initial commit

14 files changed, 2204 insertions, 0 deletions

diff --git a/files/pt-br/web/javascript/reference/global_objects/function/apply/index.html b/files/pt-br/web/javascript/reference/global_objects/function/apply/index.html
new file mode 100644
index 0000000000..a51af3db97
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/apply/index.html
@@ -0,0 +1,249 @@
+---
+title: Function.prototype.apply()
+slug: Web/JavaScript/Reference/Global_Objects/Function/apply
+tags:
+  - Funções
+  - JavaScript
+  - Métodos
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>apply()</strong></code> chama uma função com um dado valor <code>this </code>e <code>arguments </code>providos como uma array (ou um objeto parecido com um array).</p>
+
+<div class="note">
+<p><strong>Nota:</strong> A sintaxe desta função é quase idêntica a essa da {{jsxref("Function.call", "call()")}}, a diferença é que <code>call()</code> aceita uma <strong> lista de </strong><strong style="background-color: rgba(231, 228, 157, 0.247059); color: rgba(0, 0, 0, 0.65098); font-style: italic;">argumentos</strong>, enquanto <code>apply()</code> aceita um<strong> array de argumentos</strong>.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>fun</var>.apply(<var>thisArg, </var>[<var>argsArray</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>thisArg</code></dt>
+ <dd>
+ <p>O valor de <code>this</code> é fornecido para a chamada de <em>fun. </em>Note que isso talvez não seja o valor real visto pelo método:  se um método é uma função em código {{jsxref("Functions/Strict_mode", "non-strict mode", "", 1)}} , {{jsxref("null")}} e {{jsxref("undefined")}} serão substituidos com o objeto global, e os valores primitivos serão embalados.</p>
+ </dd>
+ <dt><code>argsArray</code></dt>
+ <dd>Um objeto parecido com um array (array-like), especificando os argumentos com os quais <em>fun </em>deve ser chamado, ou {{jsxref("null")}} ou {{jsxref("undefined")}} se não houverem argumentos que possam ser passados para a função. Começando com ECMAScript5 esses argumentos podem ser um objeto genérico array-like ao invés de um array. Veja abaixo a informação de {{anch("Browser_compatibility", "compatibilidade de browsers")}}.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Você pode atribuir um objeto <code>this</code><em> </em>diferente quando chamar uma função existente. <code>this</code><em> </em>refere-se ao objeto atual, o objeto da chamada. Com <code>apply</code><em>, </em>você pode escrever um método apenas uma vez e então herdá-lo em outro objeto, sem ter que reescrever o método para o novo objeto.</p>
+
+<p><code>apply </code>é muito parecido com {{jsxref("Function.call", "call()")}}, exceto pelo tipo de argumentos que ele suporta. Você pode usar um array de argumentos em vez de conjunto de parâmetros nomeados. Com <code>apply, </code>você pode usar um array literal, por exemplo, <code><em>fun</em>.apply(this, ['comer', 'bananas'])</code>, ou um objeto {{jsxref("Array")}}, por exemplo f<code><em>un</em>.apply(this, new Array('comer', 'bananas')).</code></p>
+
+<p>Você pode também usar {{jsxref("Functions/arguments", "arguments")}} para o parâmetro <code>argsArray.</code> <code>arguments </code>é uma variável local de uma função.  Ele pode ser utilizado para todos os argumentos não especificados do objeto chamado. Assim, você não tem que saber os argumentos do objeto chamado quando você usa o método <code>apply</code>. Você pode usar <code>arguments </code>para passar todos os argumentos para o objeto da chamada. O objeto chamado fica então responsável por manipular os argumentos.</p>
+
+<p>Desde a 5a versão do ECMAScript você pode utilizar qualquer tipo de objeto que é parecido com um array (array-like), então na prática isso significa que ele vai ter uma propriedade <code>length </code>e propriedades inteiras no intervalor (<code>0... length</code>). Como um exemplo, você pode agora usar um {{domxref("NodeList")}} ou um objeto personalizado como <code>{ 'length': 2, '0': 'comer', '1': 'bananas' }</code>.</p>
+
+<p>{{note("Muitos navegadores, incluindo o Chrome 14 e o Internet Explorer 9, ainda não aceitam objetos parecidos com array e irão lançar uma exceção.")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_apply_para_cadeia_de_construtores">Usando <code>apply</code> para cadeia de construtores</h3>
+
+<p>Você pode usar <code>apply </code>para encadear {{jsxref("Operators/new", "construtores", "", 1)}} em um objeto, similar ao Java. No exemplo seguinte nós iremos criar um método de {{jsxref("Global_Objects/Function", "Função")}} global chamado <code>construct, </code>que fará você capaz de usar um objeto parecido com um array com um construtor ao invés de uma lista de argumentos</p>
+
+<pre class="brush: js">Function.prototype.construct = function (aArgs) {
+  var oNew = Object.create(this.prototype);
+  this.apply(oNew, aArgs);
+  return oNew;
+};
+</pre>
+
+<div class="note">
+<p><strong>Note:</strong> O método <code>Object.create()</code>  usado acima é relativamente novo. Para um método alternativo utilizando closures, por favor considere a seguinte alternativa.</p>
+
+<pre class="brush: js">Function.prototype.construct = function(aArgs) {
+  var fConstructor = this, fNewConstr = function() { fConstructor.apply(this, aArgs); };
+  fNewConstr.prototype = fConstructor.prototype;
+  return new fNewConstr();
+};</pre>
+</div>
+
+<p>Exemplo de uso:</p>
+
+<pre class="brush: js">function MyConstructor() {
+  for (var nProp = 0; nProp &lt; arguments.length; nProp++) {
+    this['property' + nProp] = arguments[nProp];
+  }
+}
+
+var myArray = [4, 'Hello world!', false];
+var myInstance = MyConstructor.construct(myArray);
+
+console.log(myInstance.property1);                // logs 'Hello world!'
+console.log(myInstance instanceof MyConstructor); // logs 'true'
+console.log(myInstance.constructor);              // logs 'MyConstructor'
+</pre>
+
+<div class="note">
+<p><strong>Nota:</strong>  Este método não nativo <code>Function.construct </code>não irá funcionar com alguns construtores nativos (como {{jsxref("Date")}}, por exemplo). Nestes casos você tem que usar o método {{jsxref("Function.prototype.bind")}} (por exemplo, imagine ter um array como o seguinte, para ser usado com o construtor {{jsxref("Global_Objects/Date", "Date")}}: <code>[2012, 11, 4]</code>; Neste caso você tem que escrever algom como: <code>new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))() - </code>de qualquer maneira essa não é a melhor forma de fazer as coisas e provavelmente não deve ser utilizado em qualquer ambiente de produção</p>
+</div>
+
+<h3 id="Usando_apply_e_funções_embutidas">Usando <code>apply</code> e funções embutidas</h3>
+
+<p>A forma inteligente com que <code>apply</code> é utilizado permite à você usar funções nativas que de outra forma provavelmente teriam que ser escritas iterando sobre um array de valores. Aqui, como exemplo, iremos utilizar <code>Math.max</code>/<code>Math.min</code> para achar o valor máximo/mínimo value em um array.</p>
+
+<pre class="brush: js">/* número min/max em um array */
+var numbers = [5, 6, 2, 3, 7];
+
+/* utilizando Math.min/Math.max apply */
+var max = Math.max.apply(null, numbers); /* Isso está prestes a ser igual a Math.max(numbers[0], ...)
+                                            ou Math.max(5, 6, ...) */
+var min = Math.min.apply(null, numbers);
+
+/* vs. algoritmo simples baseado em loop */
+max = -Infinity, min = +Infinity;
+
+for (var i = 0; i &lt; numbers.length; i++) {
+  if (numbers[i] &gt; max) {
+    max = numbers[i];
+  }
+  if (numbers[i] &lt; min) {
+    min = numbers[i];
+  }
+}
+</pre>
+
+<p>Mas tome cuidado: ao utilizar o <code>apply</code> desta forma, você corre o risco de exceder o limite de argumentos do JavaScript. As consequências de fazer applying em uma função com muitos argumentos (pense em algo como dezenas de centenas de argumentos) varia de acordo com os engines (JavaScriptCore tem um <a class="link-https" href="https://bugs.webkit.org/show_bug.cgi?id=80797">limite de argumentos de 65536</a> hard-coded), visto que o limite (na verdade, até mesmo a natureza de qualquer comportamento de um stack excessivamente grande) não é especificado. Algumas engines irão jogar uma excessão. De uma forma mais incisiva, outras engines irão limitar de forma arbitrária o número de argumentos que poderção ser aplicados à função. (Para ilustrar esse último caso: se uma engine dessas tem um limite de quatro argumentos [obviamente, os limites atuais são significativamente maiores], isso seria como se os argumentos <code>5, 6, 2, 3</code> do exemplo anterior fossem passados ao <code>apply</code>, ao invés do array completo.) Se o valor do seu array puder crescer à casa das dezenas de centenas, use uma estratégia híbrida: aplique suas funções em cada bloco de array por vez:</p>
+
+<pre class="brush: js">function minOfArray(arr) {
+  var min = Infinity;
+  var QUANTUM = 32768;
+
+  for (var i = 0, len = arr.length; i &lt; len; i += QUANTUM) {
+    var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len)));
+    min = Math.min(submin, min);
+  }
+
+  return min;
+}
+
+var min = minOfArray([5, 6, 2, 3, 7]);
+</pre>
+
+<h3 id="Usando_apply_em_monkey-patching">Usando apply em "monkey-patching"</h3>
+
+<p>Apply pode ser a melhor forma de monkey-patch uma função nativa do Firefox, ou de bibliotecas em JS. Dada uma função <code>someobject.foo</code>, você poderá modificar a função de uma maneira hackeresca, como por exemplo:</p>
+
+<pre class="brush: js">var originalfoo = someobject.foo;
+someobject.foo = function() {
+  // Faça coisas antes de chamar a função
+  console.log(arguments);
+  // Chama a função como se ela estivesse sido chamada normalmente:
+  originalfoo.apply(this, arguments);
+  // Rode as coisas que vem depois, aqui.
+}
+</pre>
+
+<p>Esse método é especialmente útil quando você quer fazer debug de eventos, ou interagir com algo que não tem nenhuma API como os diversos eventos <code>.on([event]...</code> events, por exemplo aqueles utilizáveis no <a href="/en-US/docs/Tools/Page_Inspector#Developer_API">Devtools Inspector</a>).</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 3º Edição.</td>
+   <td>Padrão</td>
+   <td>Definição inicial, implementado no JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>ES 5.1 objetos genéricos parecidos com array como  {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop("2.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>ES 5.1 objetos genéricos parecidos com array como  {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("2.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>Objeto {{jsxref("Functions/arguments", "arguments")}}</li>
+ <li>{{jsxref("Function.prototype.bind()")}}</li>
+ <li>{{jsxref("Function.prototype.call()")}}</li>
+ <li>{{jsxref("Functions", "Funções e escopo de funções", "", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/arguments/index.html b/files/pt-br/web/javascript/reference/global_objects/function/arguments/index.html
new file mode 100644
index 0000000000..6fac474a16
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/arguments/index.html
@@ -0,0 +1,130 @@
+---
+title: Function.arguments
+slug: Web/JavaScript/Reference/Global_Objects/Function/arguments
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>A propriedade <code><strong><em>function</em>.arguments</strong></code> diz respeito a um objeto tipo array (array-like object) correspondente aos argumentos passados para uma função. Use somente a variável {{jsxref("Functions/arguments", "arguments")}} em vez disso.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A sintaxe <code><em>function</em>.arguments</code> está obsoleta. A forma recomendada de acessar o objeto  {{jsxref("Functions/arguments", "arguments")}} disponível dentro das funções, é simplesmente referenciar a variável {{jsxref("Functions/arguments", "arguments")}}.</p>
+
+<p>No caso de recursão, ou seja, uma função f aparecer várias vezes na pilha de chamadas, o valor de <code>f.arguments</code> representa os argumentos correspondentes a invocação mais recente da função.</p>
+
+<p>O valor da propriedade arguments é normalmente nulo (<code>null</code>) se não houver nenhuma invocação pendente da função em andamento (ou seja, a função foi chamada mas ainda não retornou).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">function f(n) { g(n - 1); }
+
+function g(n) {
+  console.log('before: ' + g.arguments[0]);
+  if (n &gt; 0) { f(n); }
+  console.log('after: ' + g.arguments[0]);
+}
+
+f(2);
+
+console.log('returned: ' + g.arguments);
+
+// Output
+
+// before: 1
+// before: 0
+// after: 0
+// after: 1
+// returned: null
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definiçao inicial. Implementado em JavaScript 1.0. Obsoleto em favor de {{jsxref("Functions/arguments", "arguments")}} em ES3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>{{jsxref("Functions/arguments", "arguments")}} object</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>{{jsxref("Functions/arguments", "arguments")}} object</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>{{jsxref("Functions/arguments", "arguments")}} object</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Functions/arguments", "arguments")}} object</li>
+ <li>{{jsxref("Functions", "Functions and function scope", "", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/arity/index.html b/files/pt-br/web/javascript/reference/global_objects/function/arity/index.html
new file mode 100644
index 0000000000..93e4fb75b5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/arity/index.html
@@ -0,0 +1,78 @@
+---
+title: Function.arity
+slug: Web/JavaScript/Reference/Global_Objects/Function/arity
+tags:
+  - Função
+  - JavaScript
+  - Não implementado
+  - Obsoleto
+  - Propriedade
+translation_of: Archive/Web/JavaScript/Function.arity
+---
+<div>{{JSRef("Global_Objects", "Function")}} {{obsolete_header}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p class="note">A propriedade <code><strong>arity</strong></code> é usada para retornar o número de argumentos esperados por uma função, entretanto, ela não existe mais e foi substituida pela propriedade {{jsxref("Function.prototype.length")}}.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Implementada no JavaScript 1.2. Depreciada no JavaScript 1.4.</p>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function.prototype.length")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/bind/index.html b/files/pt-br/web/javascript/reference/global_objects/function/bind/index.html
new file mode 100644
index 0000000000..10f3ea1b8c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/bind/index.html
@@ -0,0 +1,309 @@
+---
+title: Function.prototype.bind()
+slug: Web/JavaScript/Reference/Global_Objects/Function/bind
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>bind()</strong></code> cria uma nova função que, quando chamada, tem sua palavra-chave <code>this</code> definida com o valor fornecido, com uma sequência determinada de argumentos precedendo quaisquer outros que sejam fornecidos <span id="result_box" lang="pt"><span>quando</span> <span>a nova</span> <span>função é chamada</span></span>.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}}</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>function</var>.bind(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</code></pre>
+
+<h3 id="Parâmetros"><span class="short_text" id="result_box" lang="es"><span>Parâmetros</span></span></h3>
+
+<dl>
+ <dt><code>thisArg</code></dt>
+ <dd><span id="result_box" lang="pt"><span>O valor a ser</span> <span>passado como </span><span>parâmetro <code>this</code> para</span> <span>a função de destino</span> <span>quando a função</span> <span>vinculada</span> <span>é chamada.</span> <span>O</span> <span>valor é ignorado</span> <span>se a função</span> <span>ligada é</span> <span>construída usando o</span></span> operador {{jsxref("Operators/new", "new")}}.</dd>
+ <dt><code>arg1, arg2, ...</code></dt>
+ <dd><span id="result_box" lang="pt"><span>Argumentos que precedem outros</span></span><span lang="pt"> <span>argumentos fornecidos</span> <span>para a função</span> vinculada <span>ao invocar</span> <span>a função de destino</span><span>.</span></span></dd>
+</dl>
+
+<h3 id="Valor_de_retorno"><span lang="pt"><span>Valor de retorno</span></span></h3>
+
+<p><span lang="pt"><span>Uma cópia da função fornecida com o valor <code>this</code> especificado e argumentos iniciais.</span></span></p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função <code>bind()</code> cria uma nova <strong>função vinculada</strong> (<em>bound function</em>). Uma função vinculada é um <strong>objeto de função exótico</strong> (termo da <strong>ECMAScript 2015</strong>) que encapsula o objeto de função original. Chamar uma função vinculada geralmente resulta na execução de sua <strong>função encapsulada</strong>.</p>
+
+<p>Uma função vinculada tem as seguintes propriedades internas:</p>
+
+<ul>
+ <li><strong>[[BoundTargetFunction]]</strong> - o objeto de função encapsulado;</li>
+ <li><strong>[[BoundThis]]</strong> - o valor que sempre é passado como <code>this</code> quando se chama a função encapsulada;</li>
+ <li><strong>[[BoundArguments]]</strong> - uma lista de valores cujos elementos são usados como os primeiros argumentos para qualquer chamada da função encapsulada;</li>
+ <li><strong>[[Call]]</strong> - executa código associado com este objeto. Invocado através de uma expressão de chamada de função. Os argumentos para o método interno são um valor <code>this</code> e uma lista contendo os argumentos passados para a função por uma expressão de chamada.</li>
+</ul>
+
+<p>Quando a função vinculada é chamada, ela chama seu método interno <strong>[[Call]]</strong> na <strong>[[BoundTargetFunction]],</strong> na forma <code>Call(boundThis, args)</code>, onde <code>boundThis</code> é <strong>[[BoundThis]]</strong> e <code>args</code> é <strong>[[BoundArguments]]</strong> seguido pelos argumentos passados pela chamada de função.</p>
+
+<p>Uma função vinculada também pode ser construída usando-se o operador {{jsxref("Operators/new", "new")}}; ao fazê-lo, o resultado é o mesmo que seria se a função alvo tivesse sido construída. O valor de <code>this</code> fornecido é ignorado, porém os argumentos precedentes são fornecidos à função emulada.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Criando_uma_função_vinculada">Criando uma função vinculada</h3>
+
+<p><span id="result_box" lang="pt"><span>O uso</span> <span>mais simples de</span> <code><span>bind()</span></code> <span class="alt-edited">é fazer com que</span> <span>uma função que</span><span>, independentemente da</span><span> chamada,</span> <span>é chamada com</span> <span>um determinado</span> valor <code><span>this</span></code></span>.<span id="result_box" lang="pt"><span> Um erro comum</span> <span>para </span><span>programadores JavaScript</span> novatos <span>é extrair</span> <span>um método</span> <span>de um objeto e</span></span>, <span id="result_box" lang="pt"><span>em seguida, </span> <span>chamar essa função</span> <span>e esperar que ele</span> <span>use</span> <span>o objeto original</span> <span>como</span> o seu <code><span>this</span></code> <span>(por exemplo,</span> <span>usando</span> <span>esse método</span> <span>num código baseado em</span></span> <em>callback</em><span lang="pt"><span>)</span><span>.</span> <span>Sem</span> <span>a devida atenção</span><span>,</span> <span>no entanto</span><span>,</span> <span>o objeto original</span> <span>é normalmente</span> <span>perdido</span><span>.</span> <span>Criar</span> <span>uma função</span> <span class="alt-edited">vinculada</span> <span>a partir da função</span><span>,</span> <span>usando o objeto</span> <span>original,</span> <span>resolve perfeitamente</span> <span>esse</span> <span>problema:</span></span></p>
+
+<pre class="brush: js">this.x = 9; //this aqui se refere ao objeto global "window" do navegador
+var module = {
+  x: 81,
+  getX: function() { return this.x; }
+};
+
+module.getX(); // 81
+
+var retrieveX = module.getX;
+retrieveX();
+// retorna 9 - a função foi invocada no escopo global
+
+// Criando uma nova função com 'this' vinculada ao módulo
+// Programadores novatos podem confundir a variável x
+// global com a propriedade x do módulo
+var boundGetX = retrieveX.bind(module);
+boundGetX(); // 81
+</pre>
+
+<h3 id="Funções_parcialmente_aplicadas">Funções parcialmente aplicadas</h3>
+
+<p>O próximo uso mais simples de <code>bind()</code> é criar uma função com argumentos iniciais pré-especificados. Esses argumentos (caso existam) acompanham o valor <code>this</code> fornecido e então são inseridos no início dos argumentos passados para a função alvo, seguidos pelos argumentos passados para a função vinculada, sempre que a função vinculada é chamada.</p>
+
+<pre class="brush: js">function list() {
+  return Array.prototype.slice.call(arguments);
+}
+
+var list1 = list(1, 2, 3); // [1, 2, 3]
+
+// Cria uma função com um argumento principal predefinido
+var leadingThirtysevenList = list.bind(null, 37);
+
+var list2 = leadingThirtysevenList();
+// [37]
+
+var list3 = leadingThirtysevenList(1, 2, 3);
+// [37, 1, 2, 3]
+</pre>
+
+<h3 id="Com_setTimeout">Com <code>setTimeout</code></h3>
+
+<p>Por padrão, dentro de {{domxref("window.setTimeout()")}} a palavra-chave <code>this</code> vai ser definida com o objeto {{ domxref("window") }} (ou com o objeto <code>global</code>). Ao trabalhar com métodos de classes que requerem que <code>this</code> se refira à instâncias de classes, você pode vincular <code>this</code> explicitamente à função de <em>callback</em>, de modo a manter a instância.</p>
+
+<pre class="brush: js">function LateBloomer() {
+  this.petalCount = Math.ceil(Math.random() * 12) + 1;
+}
+
+// Declarar bloom depois de um intervalo de 1 segundo
+LateBloomer.prototype.bloom = function() {
+  window.setTimeout(this.declare.bind(this), 1000);
+};
+
+LateBloomer.prototype.declare = function() {
+  console.log('I am a beautiful flower with ' +
+    this.petalCount + ' petals!');
+};
+
+var flower = new LateBloomer();
+flower.bloom();
+// depois de 1 segundo, ativa o método 'declare'</pre>
+
+<h3 id="Funções_vinculadas_usadas_como_construtores">Funções vinculadas usadas como construtores</h3>
+
+<div class="warning">
+<p><strong>Aviso:</strong> Esta seção demonstra capacidades do JavaScript e documenta alguns casos de borda do método <code>bind()</code>. Os métodos mostrados abaixo não são os melhores jeitos de se fazer as coisas e provavelmente não deveriam ser usados em nenhum ambiente produtivo.</p>
+</div>
+
+<p>Funções vinculadas são automaticamente adequadas para uso com o operador {{jsxref("Operators/new", "new")}} para construir novas instâncias criadas pela função alvo. Quando uma função vinculada é usada para construir um valor, o <code>this</code> fornecido é ignorado. Porém, argumentos fornecidos ainda são prefixados à chamada do construtor:</p>
+
+<pre class="brush: js">function Point(x, y) {
+  this.x = x;
+  this.y = y;
+}
+
+Point.prototype.toString = function() {
+  return this.x + ',' + this.y;
+};
+
+var p = new Point(1, 2);
+p.toString(); // '1,2'
+
+// não suportado no polyfill abaixo,
+// funciona bem com o bind nativo:
+
+var YAxisPoint = Point.bind(null, 0/*x*/);
+
+var emptyObj = {};
+var YAxisPoint = Point.bind(emptyObj, 0/*x*/);
+
+var axisPoint = new YAxisPoint(5);
+axisPoint.toString(); // '0,5'
+
+axisPoint instanceof Point; // true
+axisPoint instanceof YAxisPoint; // true
+new Point(17, 42) instanceof YAxisPoint; // true
+</pre>
+
+<p>Note que você não precisa fazer nada de especial para criar uma função vinculada para usar com {{jsxref("Operators/new", "new")}}. O corolário é que você não precisa fazer nada de especial para criar uma função vinculada que será chamada de forma clara, mesmo que você preferisse que a função vinculada fosse somente chamada usando-se {{jsxref("Operators/new", "new")}}.</p>
+
+<pre class="brush: js">// Exemplo pode ser executado diretamente no seu console JavaScript
+// ...continuando o exemplo acima
+
+// Ainda pode ser chamada como uma função normal
+// (apesar de que isso geralmente não é desejado)
+YAxisPoint(13);
+
+emptyObj.x + ',' + emptyObj.y;
+// &gt;  '0,13'
+</pre>
+
+<p>Se você quer suportar o uso de uma função vinculada somente através de {{jsxref("Operators/new", "new")}}, ou somente a chamando, a função alvo deve impor essa restrição.</p>
+
+<h3 id="Criando_atalhos">Criando atalhos</h3>
+
+<p><code>bind()</code> itambém é útil em casos onde você quer criar um atalho para uma função que requer um valor específico de <code>this</code>.</p>
+
+<p>Tome por exemplo {{jsxref("Array.prototype.slice")}}, que você quer usar para converter um objeto <em>array-like</em> em um vetor verdadeiro. Você poderia criar um atalho assim:</p>
+
+<pre class="brush: js">var slice = Array.prototype.slice;
+
+// ...
+
+slice.apply(arguments);
+</pre>
+
+<p>Com <code>bind()</code>, isso pode ser simplificado. No seguinte trecho de código, <code>slice</code> é uma função vinculada à função {{jsxref("Function.prototype.apply()", "apply()")}} de {{jsxref("Function.prototype")}}, com o valor <code>this</code> definido com a função {{jsxref("Array.prototype.slice()", "slice()")}} de {{jsxref("Array.prototype")}}. Isso significa que chamadas adicionais de <code>apply()</code> podem ser eliminadas:</p>
+
+<pre class="brush: js">// mesmo que "slice" no exemplo anterior
+var unboundSlice = Array.prototype.slice;
+var slice = Function.prototype.apply.bind(unboundSlice);
+
+// ...
+
+slice(arguments);
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>A função <code>bind</code> é uma adição à ECMA-262, 5ª. edição; como tal, pode não estar presente em todos os navegadores. Você pode contornar isso parcialmente inserindo o seguinte código no começo de seus <em>scripts</em>, permitindo o uso de muita parte da funcionalidade de <code>bind()</code> em implementações que não a suportam nativamente.</p>
+
+<pre class="brush: js">if (!Function.prototype.bind) {
+  Function.prototype.bind = function(oThis) {
+    if (typeof this !== 'function') {
+      // mais próximo possível da função interna
+      // IsCallable da ECMAScript 5
+      throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
+    }
+
+    var aArgs   = Array.prototype.slice.call(arguments, 1),
+        fToBind = this,
+        fNOP    = function() {},
+        fBound  = function() {
+          return fToBind.apply(this instanceof fNOP
+                 ? this
+                 : oThis,
+                 aArgs.concat(Array.prototype.slice.call(arguments)));
+        };
+
+    fNOP.prototype = this.prototype;
+    fBound.prototype = new fNOP();
+
+    return fBound;
+  };
+}
+</pre>
+
+<p>Algumas das muitas diferenças (é bem possível que haja outras, já que esta lista não pretende seriamente ser completa) entre este algoritmo e o algoritmo especificado são:</p>
+
+<ul>
+ <li>Esta implementação parcial depende dos métodos internos {{jsxref("Array.prototype.slice()")}}, {{jsxref("Array.prototype.concat()")}}, {{jsxref("Function.prototype.call()")}} e {{jsxref("Function.prototype.apply()")}} possuírem seus valores originais.</li>
+ <li>Esta implementação parcial cria funções que não tem um {{jsxref("Function.caller", "caller")}} imutável como "mecanismo de defesa" e propriedades <code>arguments</code> que lançam um {{jsxref("Global_Objects/TypeError", "TypeError")}} ao usar <em>get</em>, <em>set</em>, ou ao deletar. (Isto pode ser adicionado se a implementação suporta {{jsxref("Object.defineProperty")}}, ou parcialmente implementado sem um comportamento <em>throw-on-delete</em> se a implementação suporta as extensões {{jsxref("Object.defineGetter", "__defineGetter__")}} e {{jsxref("Object.defineSetter", "__defineSetter__")}})</li>
+ <li>Esta implementação parcial cria funções que tem uma propriedade <code>prototype</code>. (Funções vinculadas apropriadas não a tem.)</li>
+ <li>Esta implementação parcial cria funções vinculadas cuja propriedade {{jsxref("Function.length", "length")}} não cumpre com a regra da ECMA-262: cria funções com comprimento zero, quando uma implementação completa, dependendo do comprimento da função alvo e do número de argumentos pre-especificados, pode retornar um comprimento não-nulo.</li>
+</ul>
+
+<p>Se você escolher utilizar esta implementação parcial, <strong>você não deve confiar em casos onde o comportamento é diferente da ECMA-262, 5ª. edição!</strong> Porém, com algum cuidado (e talvez com modificação adicional para atender necessidades específicas), esta implementação parcial pode ser uma ponte razoável para quando <code>bind()</code> for amplamente implementada de acordo com a especificação.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.4.5', 'Function.prototype.bind')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function.prototype.bind', 'Function.prototype.bind')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("7")}}</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("11.60")}}</td>
+   <td>{{CompatSafari("5.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatAndroid("4.0")}}</td>
+   <td>{{CompatChrome("1")}}</td>
+   <td>{{CompatGeckoMobile("2")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOperaMobile("11.5")}}</td>
+   <td>{{CompatSafari("6.0")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function.prototype.apply()")}}</li>
+ <li>{{jsxref("Function.prototype.call()")}}</li>
+ <li>{{jsxref("Functions", "Functions", "", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/call/index.html b/files/pt-br/web/javascript/reference/global_objects/function/call/index.html
new file mode 100644
index 0000000000..a0356bf585
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/call/index.html
@@ -0,0 +1,194 @@
+---
+title: Function.prototype.call()
+slug: Web/JavaScript/Reference/Global_Objects/Function/call
+tags:
+  - Função
+  - JavaScript
+  - Método(2)
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/call
+---
+<div>{{JSRef("Global_Objects", "Function")}}</div>
+
+<h2 id="Introdução">Introdução</h2>
+
+<p>O método <code><strong>call()</strong></code> invoca uma função com um dado valor <code>this</code>  e argumentos passados individualmente.</p>
+
+<div class="note">
+<p><strong>Nota:</strong> Apesar de a sintaxe desta função ser quase idêntica à de {{jsxref("Function.prototype.apply", "apply()")}}, a principal diferença é que <code>call()</code> aceita uma <strong>lista de argumentos</strong>, enquanto <code>apply()</code> aceita <strong>um único array de argumentos.</strong></p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>fun</var>.call(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>thisArg</code></dt>
+ <dd>O valor de  <code>this</code>  proveu a chamada para <em><code>fun</code></em>. Note que <code>this</code> pode não ser o valor atual visto pelo método: se esse método é uma função em {{jsxref("Functions_and_function_scope/Strict_mode", "non-strict mode", "", 1)}} code, {{jsxref("Global_Objects/null", "null")}} e {{jsxref("Global_Objects/undefined", "undefined")}} serão reescritos com o objeto global, e valores primitivos serão encaixados.</dd>
+ <dt><code>arg1, arg2, ...</code></dt>
+ <dd>Argumentos para  o objeto.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Você pode atribuir um objeto <code>this</code> diferente quando executar uma função existente. <code>this</code> refere-se ao objeto atual, o objeto em execução. Com <code>call</code>, você pode escrever um método uma vez e então herdá-lo em outro objeto, sem ter que reescrever o método para o novo objeto.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_Usando_call_para_encadear_construtores_para_um_objeto">Exemplo: Usando <code>call</code> para encadear construtores para um objeto</h3>
+
+<p>Você pode usar <code>call</code> para encadear construtores para um objeto, similar ao  Java. No seguinte exemplo, o construtor do  objeto <code>Product</code> é definido com dois parâmetros, <code>name</code> e <code>price</code>. Outras duas funções <code>Food</code> e <code>Toy</code> executam <code>Product</code> passando <code>this,</code> <code>name</code> e <code>price</code>. O Produto inicializa as propriedades <code>name</code> e <code>price</code>,  ambos definem o <code>category</code>.</p>
+
+<pre class="brush: js">function Product(name, price) {
+  this.name = name;
+  this.price = price;
+
+  if (price &lt; 0) {
+    throw RangeError('Cannot create product ' +
+                      this.name + ' with a negative price');
+  }
+
+  return this;
+}
+
+function Food(name, price) {
+  Product.call(this, name, price);
+  this.category = 'food';
+}
+
+Food.prototype = Object.create(Product.prototype);
+
+function Toy(name, price) {
+  Product.call(this, name, price);
+  this.category = 'toy';
+}
+
+Toy.prototype = Object.create(Product.prototype);
+
+var cheese = new Food('feta', 5);
+var fun = new Toy('robot', 40);
+</pre>
+
+<h3 id="Exemplo_Usando_o_call_para_chamar_funções_anônimas">Exemplo: Usando o <code>call</code> para chamar funções anônimas</h3>
+
+<p>Neste exemplo, criamos uma função anônima que usa o <code>call</code> para executá-lo em todos os objetos em um array(vetor). O principal propósito da função anônima aqui é adicionar uma função print para todo o objeto, que está disponível para imprimir o índice correto do objeto no array. Não foi necessário passar o valor do objeto como <code>this</code> , mas isso foi feito apenas para explicação.</p>
+
+<pre class="brush: js">var animais = [
+  { especie: 'Lion', nome: 'King' },
+  { especie: 'Whale', nome: 'Fail' }
+];
+
+for (var i = 0; i &lt; animais.length; i++) {
+  (function(i) {
+    this.print = function() {
+      console.log('#' + i + ' ' + this.especie
+                  + ': ' + this.nome);
+    }
+    this.print();
+  }).call(animais[i], i);
+}
+</pre>
+
+<h3 id="Usando_call_para_chamar_a_função_e_especificar_o_contexto_de_'this'">Usando <code>call</code> para chamar a função e especificar o contexto de 'this'</h3>
+
+<p>No exemplo abaixo, quando vamos chamar a apresentação, o valor de this será associado ao objeto i.<br>
+  </p>
+
+<pre><code>function apresentacao() {
+  var resposta = [this.pessoa, 'é um excelente', this.funcao].join(' ');
+  console.log(resposta);
+}
+
+var i = {
+  pessoa: 'Douglas Crockford', funcao: 'Desenvolvedor Javascript'
+};
+
+apresentacao.call(i); // Douglas Crockford é um excelente Desenvolvedor Javascript</code></pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.4.4', 'Function.prototype.call')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function.prototype.call', 'Function.prototype.call')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function.prototype.bind()")}}</li>
+ <li>{{jsxref("Function.prototype.apply()")}}</li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introdução à JavaScript Orientado à Objetos</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/caller/index.html b/files/pt-br/web/javascript/reference/global_objects/function/caller/index.html
new file mode 100644
index 0000000000..c380d89d7f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/caller/index.html
@@ -0,0 +1,129 @@
+---
+title: Function.caller
+slug: Web/JavaScript/Reference/Global_Objects/Function/caller
+tags:
+  - Função
+  - JavaScript
+  - Non-standard
+  - Propriedades
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>A propriedade <code><strong><em>function</em>.caller</strong></code> retorna a função que invocou a função especificada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se a função <code>f</code> foi invocada pelo codigo mais alto nível, o valor de <code>f.caller</code> é {{jsxref("null")}}, caso contrario, o valor será a função a qual invocou <code>f</code>.</p>
+
+<p>Esta propriedade substitui a propriedade obsoleta {{jsxref("Functions/arguments/caller", "arguments.caller")}} do objeto {{jsxref("Functions/arguments", "arguments")}}.</p>
+
+<p>A propriedade especial <code>__caller__</code>, a qual retornou o objeto de ativação do chamador, permitindo assin reconstruir o stack, foi removido por motivo de segurança.</p>
+
+<h3 id="Notas">Notas</h3>
+
+<p>Note que no caso de recurção, você não pode reconstruir o stack de chamadas usando esta propriedade. Considere:</p>
+
+<pre class="brush: js">function f(n) { g(n - 1); }
+function g(n) { if (n &gt; 0) { f(n); } else { stop(); } }
+f(2);
+</pre>
+
+<p>No momento em que <code>stop()</code> é chamado o stack será:</p>
+
+<pre class="brush: js">f(2) -&gt; g(1) -&gt; f(1) -&gt; g(0) -&gt; stop()
+</pre>
+
+<p>O seguinte é true:</p>
+
+<pre class="brush: js">stop.caller === g &amp;&amp; f.caller === g &amp;&amp; g.caller === f
+</pre>
+
+<p>então se você tentou recuperar o stack trace na função <code>stop()</code> assim:</p>
+
+<pre class="brush: js">var f = stop;
+var stack = 'Stack trace:';
+while (f) {
+  stack += '\n' + f.name;
+  f = f.caller;
+}
+</pre>
+
+<p>o loop nunca irá parar.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Verificando_o_valor_da_propriedade_caller_de_uma_função">Verificando o valor da propriedade <code>caller</code> de uma função</h3>
+
+<p>O código a seguir verifica o valor da propriedade <code>caller</code> de uma função.</p>
+
+<pre class="brush: js">function myFunc() {
+  if (myFunc.caller == null) {
+    return 'The function was called from the top!';
+  } else {
+    return 'This function\'s caller was ' + myFunc.caller;
+  }
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de nenhuma especificação. Implementado no JavaScript 1.5.</p>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("1.0")}}</td>
+   <td>8.0</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("1.0")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>Implementation bug for SpiderMonkey {{bug(65683)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/displayname/index.html b/files/pt-br/web/javascript/reference/global_objects/function/displayname/index.html
new file mode 100644
index 0000000000..5cf33d8080
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/displayname/index.html
@@ -0,0 +1,80 @@
+---
+title: Function.displayName
+slug: Web/JavaScript/Reference/Global_Objects/Function/displayName
+tags:
+  - Função
+  - JavaScript
+  - Non Standard
+  - Propriedade
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>A propriedade <code><strong><em>function</em>.displayName</strong></code> retorna o nome de exibição da função.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Quando definida, a propriedade <code>displayName</code> retorna o nome de exibição da função.</p>
+
+<pre class="brush: js">function doSomething() {}
+
+console.log(doSomething.displayName); // "undefined"
+
+var popup = function(content) { console.log(content); };
+
+popup.displayName = 'Show Popup';
+
+console.log(popup.displayName); // "Show Popup"
+</pre>
+
+<p>Você pode definir uma função com uma nome de exibição em um {{jsxref("Functions", "function expression", "", 1)}}:</p>
+
+<pre class="brush: js">var object = {
+  someMethod: function() {}
+};
+
+object.someMethod.displayName = 'someMethod';
+
+console.log(object.someMethod.displayName); // logs "someMethod"
+
+try { someMethod } catch(e) { console.log(e); }
+// ReferenceError: someMethod is not defined
+</pre>
+
+<p>Você pode mudar dinamicamente o<code>displayName</code> de uma função:</p>
+
+<pre class="brush: js">var object = {
+  // anonymous
+  someMethod: function(value) {
+    arguments.callee.displayName = 'someMethod (' + value + ')';
+  }
+};
+
+console.log(object.someMethod.displayName); // "undefined"
+
+object.someMethod('123')
+console.log(object.someMethod.displayName); // "someMethod (123)"
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Geralmente, é preferida por consoles e perfis em vez de  {{jsxref("Function.name", "func.name")}} mostrar o nome de uma função.</p>
+
+<p>Entrando com o seguinte em um console, isso deverá mostrar algo como  "<code>function My Function()</code>":</p>
+
+<pre class="brush: js">var a = function() {};
+a.displayName = 'My Function';
+
+a; // "function My Function()"</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de denhuma especificação.</p>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nessa página é gerada de dados estruturados. Se você gostaria de contribuir com os dados, por favor veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</div>
+
+<p>{{Compat("javascript.builtins.Function.displayName")}}</p>
+</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/index.html b/files/pt-br/web/javascript/reference/global_objects/function/index.html
new file mode 100644
index 0000000000..fa6e32e2b1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/index.html
@@ -0,0 +1,234 @@
+---
+title: Function
+slug: Web/JavaScript/Reference/Global_Objects/Function
+tags:
+  - Constructor
+  - Function
+  - JavaScript
+  - NeedsTranslation
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Global_Objects/Function
+---
+<div>{{JSRef("Global_Objects", "Function")}}</div>
+
+<h2 id="Summary" name="Summary"><span class="short_text" id="result_box" lang="pt"><span class="hps">Resumo</span></span></h2>
+
+<p>O <strong><code>construtor Function</code></strong> cria um novo objeto <code>Function</code>. Chamar o construtor diretamente pode criar funções dinamicamente, mas sofre com problemas de segurança e desempenho semelhante (mas muito menos significativo) a {{jsxref("eval")}}. No entanto, diferentemente de eval, a Função construtora cria funções que executam somente no escopo global.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>new Function ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
+ <dd>Nomes para serem usandos pela função como nomes formais de argumentos. Cada um deve ser uma string que corresponde para uma válida identidade JavaScript ou uma lista de certas strings separadas com uma <span class="short_text" id="result_box" lang="pt"><span class="hps">vírgula; por exemplo "x", "theValue". our "a,b".</span></span></dd>
+ <dt><code>functionBody</code></dt>
+ <dd>Uma string que contém as <span id="result_box" lang="pt"><span class="hps">instruções </span></span>JavaScript que <span id="result_box" lang="pt"><span class="hps">compõem </span></span><span class="short_text" id="result_box" lang="pt"><span class="hps">a definição da função.</span></span></dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Objetos <code>Function</code> criados com o construtor <code>Function</code> são <em>parseados</em> quando a função é criada. Isto é menos eficiente que criar com uma <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/function">expressão de função</a> ou um <a href="/pt-BR/docs/Web/JavaScript/Reference/Statements/function">declaração de função</a> e chamando-a dentro do seu código, porque tais funções são <em>parseadas</em> com o resto do código.</p>
+
+<p>Todos os argumentos passados para a função são tratados como os nomes dos indetificadores dos parâmetros na função a ser criada, na mesma ordem na qual eles foram passados.</p>
+
+<div class="note">
+<p><strong>Nota:</strong> Funções criadas com o construtor <code>Function não criam closures</code> para o seu contexto de criação; elas sempre são criadas no escopo global. Quando executadas, elas terão acesso apenas às suas variáveis locais ou globais, não terão acesso às variáveis do escopo na qual o construtor <code>Function</code> foi chamado. Isto é diferente de usar {{jsxref("Global_Objects/eval", "eval")}} com o código de uma expressão de função.</p>
+</div>
+
+<p>Invocar o construtor <code>Function</code> como uma função (sem usar o operador <code>new</code>) tem o mesmo efeito de chamá-la como um construtor.</p>
+
+<h2 id="Propriedades_e_Métodos_da_Function">Propriedades e Métodos da <code>Function</code></h2>
+
+<p>O objeto global <code>Function</code> não tem métodos ou propriedades próprias, no entanto, como ela é uma função, ela herda alguns métodos e propriedades através do prototype chain do {{jsxref("Function.prototype")}}.</p>
+
+<h2 id="Function_prototype_object"><code>Function</code> prototype object</h2>
+
+<h3 id="Propriedades">Propriedades</h3>
+
+<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Properties')}}</div>
+
+<h3 id="Methods" name="Methods">Métodos</h3>
+
+<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Methods')}}</div>
+
+<h2 id="Function_instances" name="Function_instances"><code>Function</code> instances</h2>
+
+<p><code>Function</code> instances inherit methods and properties from {{jsxref("Function.prototype")}}. As with all constructors, you can change the constructor's prototype object to make changes to all <code>Function</code> instances.</p>
+
+<h2 id="Examples" name="Examples">Exemplos:</h2>
+
+<h3 id="Example.3A_Specifying_arguments_with_the_Function_constructor" name="Example.3A_Specifying_arguments_with_the_Function_constructor">Exemplos: Especificando argumentos com o construtor <code>Function</code></h3>
+
+<p>O código a seguir cria um objeto <code>Function</code> que recebe dois argumentos.</p>
+
+<pre class="brush: js">// O exemplo pode ser executado direto no seu console JavaScript
+
+// Cria uma função que recebe 2 argumentos e retorna a soma entre os dois:
+var adder = new Function('a', 'b', 'return a + b');
+
+// Chamada da função
+adder(2, 6);
+// &gt; 8
+</pre>
+
+<p>Os argumentos "<code>a</code>" e "<code>b</code>" são os argumentos que serão usados no corpo da função, "<code>return a + b</code>".</p>
+
+<h3 id="Example_A_recursive_shortcut_to_massively_modify_the_DOM" name="Example:_A_recursive_shortcut_to_massively_modify_the_DOM">Exemplo: Um atalho recursivo para modificar o DOM em massa</h3>
+
+<p>Creating functions with the <code>Function</code> constructor is one of the ways to dynamically create an indeterminate number of new objects with some executable code into the global scope from a function. The following example (a recursive shortcut to massively modify the DOM) is impossible without the invocation of the <code>Function</code> constructor for each new query if you want to avoid closures.</p>
+
+<pre class="brush: html">&lt;!doctype html&gt;
+&lt;html&gt;
+&lt;head&gt;
+&lt;meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /&gt;
+&lt;title&gt;MDN Example - a recursive shortcut to massively modify the DOM&lt;/title&gt;
+&lt;script type="text/javascript"&gt;
+var domQuery = (function() {
+  var aDOMFunc = [
+    Element.prototype.removeAttribute,
+    Element.prototype.setAttribute,
+    CSSStyleDeclaration.prototype.removeProperty,
+    CSSStyleDeclaration.prototype.setProperty
+  ];
+
+  function setSomething(bStyle, sProp, sVal) {
+    var bSet = Boolean(sVal), fAction = aDOMFunc[bSet | bStyle &lt;&lt; 1],
+        aArgs = Array.prototype.slice.call(arguments, 1, bSet ? 3 : 2),
+        aNodeList = bStyle ? this.cssNodes : this.nodes;
+
+    if (bSet &amp;&amp; bStyle) { aArgs.push(''); }
+    for (
+      var nItem = 0, nLen = this.nodes.length;
+      nItem &lt; nLen;
+      fAction.apply(aNodeList[nItem++], aArgs)
+    );
+    this.follow = setSomething.caller;
+    return this;
+  }
+
+  function setStyles(sProp, sVal) { return setSomething.call(this, true, sProp, sVal); }
+  function setAttribs(sProp, sVal) { return setSomething.call(this, false, sProp, sVal); }
+  function getSelectors() { return this.selectors; };
+  function getNodes() { return this.nodes; };
+
+  return (function(sSelectors) {
+    var oQuery = new Function('return arguments.callee.follow.apply(arguments.callee, arguments);');
+    oQuery.selectors = sSelectors;
+    oQuery.nodes = document.querySelectorAll(sSelectors);
+    oQuery.cssNodes = Array.prototype.map.call(oQuery.nodes, function(oInlineCSS) { return oInlineCSS.style; });
+    oQuery.attributes = setAttribs;
+    oQuery.inlineStyle = setStyles;
+    oQuery.follow = getNodes;
+    oQuery.toString = getSelectors;
+    oQuery.valueOf = getNodes;
+    return oQuery;
+  });
+})();
+&lt;/script&gt;
+&lt;/head&gt;
+
+&lt;body&gt;
+
+&lt;div class="testClass"&gt;Lorem ipsum&lt;/div&gt;
+&lt;p&gt;Some text&lt;/p&gt;
+&lt;div class="testClass"&gt;dolor sit amet&lt;/div&gt;
+
+&lt;script type="text/javascript"&gt;
+domQuery('.testClass')
+  .attributes('lang', 'en')('title', 'Risus abundat in ore stultorum')
+  .inlineStyle('background-color', 'black')('color', 'white')('width', '100px')('height', '50px');
+&lt;/script&gt;
+&lt;/body&gt;
+
+&lt;/html&gt;
+</pre>
+
+<h2 id="Especificação">Especificação</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Operators/function", "function Expression", "", 1)}}</li>
+ <li>{{jsxref("Statements/function", "function Statement", "", 1)}}</li>
+ <li>{{jsxref("Functions_and_function_scope", "Functions and function scope", "", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/isgenerator/index.html b/files/pt-br/web/javascript/reference/global_objects/function/isgenerator/index.html
new file mode 100644
index 0000000000..b370305940
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/isgenerator/index.html
@@ -0,0 +1,55 @@
+---
+title: Function.prototype.isGenerator()
+slug: Web/JavaScript/Reference/Global_Objects/Function/isGenerator
+tags:
+  - Função
+  - Não padronizados
+  - Obsoleto
+  - metodo
+translation_of: Archive/Web/JavaScript/Function.isGenerator
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>O método não padronizado <code><strong>isGenerator()</strong></code> é usado para determinar se uma função é ou não um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">gerador</a>. Ele foi removido do Firefox a partir da versão 58.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>fun</var>.isGenerator()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um {{jsxref("Boolean")}} que indica se dada função é ou nao um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">gerador</a>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>isGenerator()</code> determina se uma função <em><code>fun</code></em> é ou não um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">gerador</a>. Fez parte de uma Proposta Inicial de Harmonia, mas não foi incluído na especificação do ECMAScript 2015.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">function f() {}
+
+function* g() {
+  yield 42;
+}
+
+console.log('f.isGenerator() = ' + f.isGenerator()); // f.isGenerator() = false
+console.log('g.isGenerator() = ' + g.isGenerator()); // g.isGenerator() = true
+</pre>
+
+<h2 id="Specificações">Specificações</h2>
+
+<p>Não faz parte de nenhuma especificação. Implementado no JavaScript 1.8.6.</p>
+
+<h2 id="Compatibilidade_do_Navegador">Compatibilidade do Navegador</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estrurados. Se você não quiser contribuir com estes dados, por favor veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um pull request.</div>
+
+<p>{{Compat("javascript.builtins.Function.isGenerator")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iteradores e geradores</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/length/index.html b/files/pt-br/web/javascript/reference/global_objects/function/length/index.html
new file mode 100644
index 0000000000..a116f07892
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/length/index.html
@@ -0,0 +1,134 @@
+---
+title: Function.length
+slug: Web/JavaScript/Reference/Global_Objects/Function/length
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/length
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code><strong>length</strong></code> especifica o número de argumentos esperados pela função.</p>
+
+<div>{{js_property_attributes(0,0,1)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>length é uma propriedade de um objeto função</code>, e indica quantos argumentos a função espera, i.e. o número de parametros formais. Este número não incluí o {{jsxref("rest_parameters", "rest parameter", "", 1)}}. <span class="short_text" id="result_box" lang="pt"><span>Por contraste,</span></span> {{jsxref("Functions_and_function_scope/arguments/length", "arguments.length")}} é local para a função e fornece o número de argumentos que foram realmente passados.</p>
+
+<h3 id="Propriedade_de_Dados_do_construtor_Function">Propriedade de Dados do construtor <code>Function</code></h3>
+
+<p>O construtor {{jsxref("Function")}} é propriamente um objeto {{jsxref("Function")}}. A proproedade de dados do seu <code>length</code> tem o valor de 1. Os atributos da propriedade são: Escrita: <code>false</code>, Enumerável: <code>false</code>, Configurável: <code>true</code>.</p>
+
+<h3 id="Propriedades_do_objeto_prototype_de_Function">Propriedades do objeto prototype de <code>Function</code></h3>
+
+<p>A propriedade length do objeto prototype {{jsxref("Function")}} tem o valor de 0.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js notranslate">console.log(Function.length); /* 1 */
+
+console.log((function()        {}).length); /* 0 */
+console.log((function(a)       {}).length); /* 1 */
+console.log((function(a, b)    {}).length); /* 2 etc. */
+console.log((function(...args) {}).length); /* 0, rest parameter is not counted */
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.5.1', 'Function.length')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>The <code>configurable</code> attribute of this property is now <code>true</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_o_Navegador">Compatibilidade com o Navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Configurable: true</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop(37)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Configurable: true</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile(37)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_tambem">Veja tambem</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/name/index.html b/files/pt-br/web/javascript/reference/global_objects/function/name/index.html
new file mode 100644
index 0000000000..2ee74e0779
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/name/index.html
@@ -0,0 +1,222 @@
+---
+title: Function.name
+slug: Web/JavaScript/Reference/Global_Objects/Function/name
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/name
+---
+<div>{{JSRef}}</div>
+
+<p><span class="seoSummary">A propriedade somente-leitura <code><strong>name</strong></code> de um objeto {{jsxref("Function")}} indica o nome da função como especificado quando esta foi criada, ou <code>"anonymous"</code> para funções criadas anonimamente.</span></p>
+
+<div>{{EmbedInteractiveExample("pages/js/function-name.html")}}</div>
+
+<p class="hidden">O código-fonte deste exemplo interativo está mantido em um repositório do GitHub. Se você gostaria de contribuir com o projeto de exemplos interativos, clone por favor <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um <em>pull request</em>.</p>
+
+<div>{{js_property_attributes(0,0,1)}}<br>
+ </div>
+
+<div class="note">
+<p>Note que em implementações não-standard anteriores à ES2015 o atributo <code>configurable</code> tinha também o valor <code>false</code>.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Nome_de_declaração_da_função">Nome de declaração da função</h3>
+
+<p>A propriedade <code>name</code> retorna o nome de uma declaração de função.</p>
+
+<pre class="brush: js">function doSomething() {}
+doSomething.name; // "doSomething"
+</pre>
+
+<h3 id="Nome_do_construtor_da_função">Nome do construtor da função</h3>
+
+<p>Funções criadas com a sintaxe <code>new Function(...)</code> ou somente <code>Function(...)</code> criam objetos {{jsxref("Function")}} com o nome "anonymous".</p>
+
+<pre>(new Function).name; // "anonymous"</pre>
+
+<h3 id="Nomes_de_função_inferidos">Nomes de função inferidos</h3>
+
+<p>Variáveis e métodos podem inferir o nome de uma função anônima a partir de sua posição sintática (novo na ECMAScript 2015).</p>
+
+<pre class="brush: js">var f = function() {};
+var object = {
+  someMethod: function() {}
+};
+
+console.log(f.name); // "f"
+console.log(object.someMethod.name); // "someMethod"
+</pre>
+
+<p>Você pode definir uma função com um nome numa {{jsxref("Operators/Function", "expressão de função", "", 1)}}:</p>
+
+<pre class="brush: js">var object = {
+  someMethod: function object_someMethod() {}
+};
+console.log(object.someMethod.name); // grava o log "object_someMethod"
+
+try { object_someMethod } catch(e) { console.log(e); }
+// ReferenceError: object_someMethod is not defined
+</pre>
+
+<p>Você não pode mudar o nome de uma função, pois a propriedade é somente-leitura:</p>
+
+<div class="hidden">
+<p>O exemplo abaixo contradiz o que é dito no começo desta seção e não funciona como descrito.</p>
+</div>
+
+<pre class="brush: js">var object = {
+  // anonymous
+  someMethod: function() {}
+};
+
+object.someMethod.name = 'otherMethod';
+console.log(object.someMethod.name); // someMethod
+</pre>
+
+<p>Para mudá-lo, você poderia no entanto usar {{jsxref("Object.defineProperty()")}}.</p>
+
+<h3 id="Nomes_curtos_de_métodos">Nomes curtos de métodos</h3>
+
+<pre class="brush: js">var o = {
+  foo(){}
+};
+o.foo.name; // "foo";</pre>
+
+<h3 id="Nomes_de_funções_vinculadas">Nomes de funções vinculadas</h3>
+
+<p>{{jsxref("Function.bind()")}} produz uma função cujo nome é "bound " seguido do nome da função.</p>
+
+<pre class="brush: js">function foo() {};
+foo.bind({}).name; // "bound foo"
+</pre>
+
+<h3 id="Nomes_de_função_para_getters_e_setters">Nomes de função para <em>getters</em> e <em>setters</em></h3>
+
+<p>Ao usar propriedades acessórias <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">get</a></code> e <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">set</a></code>, "get" ou "set" aparecerão no nome da função.</p>
+
+<pre class="brush: js">var o = {
+  get foo(){},
+  set foo(x){}
+};
+
+var descriptor = Object.getOwnPropertyDescriptor(o, "foo");
+descriptor.get.name; // "get foo"
+descriptor.set.name; // "set foo";</pre>
+
+<h3 id="Nomes_de_funções_em_classes">Nomes de funções em classes</h3>
+
+<p>Você pode usar <code>obj.constructor.name</code> para checar a "classe" de um objeto (porém leia com atenção os avisos abaixo):</p>
+
+<pre class="brush: js">function Foo() {}  // Sintaxe ES2015: class Foo {}
+
+var fooInstance = new Foo();
+console.log(fooInstance.constructor.name); // grava o log "Foo"
+</pre>
+
+<div class="warning">
+<p><strong>Aviso:</strong> O interpretador vai definir a propriedade  interna <code>Function.name</code> somente se uma função não tiver uma propriedade já com o nome <em>name</em> (veja a seção <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-setfunctionname">9.2.11 da ECMAScript2015 Language Specification</a>). Porém, a ES2015 especifica que a palavra-chave <em>static</em> de maneira que métodos estáticos serão definidos como OwnProperty da função construtora de classe (ECMAScript2015, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-runtime-semantics-classdefinitionevaluation">14.5.14.21.b</a> + <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer-runtime-semantics-propertydefinitionevaluation">12.2.6.9</a>).</p>
+</div>
+
+<p>Portanto não podemos obter o nome de virtualmente qualquer classe com um método estático <code>name()</code>:</p>
+
+<pre class="brush: js">class Foo {
+  constructor() {}
+  static name() {}
+}
+</pre>
+
+<p>Com um método <code>static name()</code>, <code>Foo.name</code> não guarda mais o nome verdadeiro da classe mas uma referência ao objeto de função <code>name()</code>. A definição de classe acima, escrita em sintaxe ES2015, se comportará de maneira similar ao seguinte trecho de código em sintaxe ES5 no Chrome ou no Firefox:</p>
+
+<pre class="brush: js">function Foo() {}
+Object.defineProperty(Foo, 'name', { writable: true });
+Foo.name = function() {};
+</pre>
+
+<p>Tentar obter a classe de <code>fooInstance</code> via <code>fooInstance.constructor.name</code> não nos dará de maneira alguma o nome da classe, mas sim uma referência ao método estático da classe. Exemplo:</p>
+
+<pre class="brush: js">var fooInstance = new Foo();
+console.log(fooInstance.constructor.name); // grava o name() da função no log
+</pre>
+
+<p>Você pode ver também, a partir do exemplo de sintaxe ES5, que, no Chrome ou no Firefox, a nossa definição estática de <code>Foo.name</code> se torna <em>writable</em>. A predefinição interna na ausência de uma definição estática customizada é somente-leitura:</p>
+
+<pre class="brush: js">Foo.name = 'Hello';
+console.log(Foo.name); // logs "Hello" if class Foo has a static name() property but "Foo" if not.
+</pre>
+
+<p>Portanto, você não pode assumir que a propriedade interna <code>Function.name</code> sempre guardará um nome de classe..</p>
+
+<h3 id="Símbolos_como_nome_de_função">Símbolos como nome de função</h3>
+
+<p>Se um {{jsxref("Symbol")}} é usado como nome de função e o símbolo tem uma descrição, o nome do método será a descrição entre colchetes.</p>
+
+<pre>var sym1 = Symbol("foo");
+var sym2 = Symbol();
+var o = {
+  [sym1]: function(){},
+  [sym2]: function(){}
+};
+
+o[sym1].name; // "[foo]"
+o[sym2].name; // ""</pre>
+
+<h2 id="Compressores_e_minificadores_JavaScript">Compressores e minificadores JavaScript</h2>
+
+<div class="warning">
+<p><strong>Aviso:</strong> Tenha cuidado ao usar <code>Function.name</code> e transformações de código-fonte, como aquelas executadas por compressores (minificadores) ou obfuscadores de JavaScript. Estas ferramentas são comumente usadas como parte de processos de <em>build  </em>de JavaScript para reduzir os tamanhos de programas antes da implementação em produção. Tais transformações frequentemente mudam nomes de função durante o <em>build</em>.</p>
+</div>
+
+<p>Código fonte do tipo:</p>
+
+<pre class="brush: js">function Foo() {};
+var foo = new Foo();
+
+if (foo.constructor.name === 'Foo') {
+  console.log("'foo' is an instance of 'Foo'");
+} else {
+  console.log('Oops!');
+}
+</pre>
+
+<p>pode ser comprimido e se tornar:</p>
+
+<pre class="brush: js">function a() {};
+var b = new a();
+if (b.constructor.name === 'Foo') {
+  console.log("'foo' is an instance of 'Foo'");
+} else {
+  console.log('Oops!');
+}
+</pre>
+
+<p>Na versão descomprimida, o programa cai no bloco-verdade e grava o log <em>'foo' is an instance of 'Foo'</em>. Todavia, na versão comprimida ele se comporta diferentemente, e cai no bloco <code>else</code>. Se você depende de <code>Function.name</code>, como no exemplo acima, tenha certeza que seu processo de <em>build</em> não mude nomes de função, ou então não assuma que uma função terá um nome determinado.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-name', 'name')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function-instances-name', 'name')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você gostaria de contribuir com os dados, confira por favor <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie uma <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Function.name")}}</p>
+</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/function/prototype/index.html
new file mode 100644
index 0000000000..285bf56281
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/prototype/index.html
@@ -0,0 +1,94 @@
+---
+title: Function.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Function/prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Function
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code><strong>Function.prototype</strong></code> representa o objeto <code>prototype</code> de {{jsxref("Function")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Objetos {{jsxref("Function")}} herdam de <code>Function.prototype</code>.  <code>Function.prototype</code> não pode ser modificado.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("Function.arguments")}} {{deprecated_inline}}</dt>
+ <dd>Um vetor correspondente aos argumentos passados a uma função. Isto é depreciado como propriedade de {{jsxref("Function")}}. Use em vez disso o objeto {{jsxref("Functions/arguments", "arguments")}} disponível dentro da função.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("Function.arity")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Usado para especificar o número de argumentos esperados pela função. Foi removido, utilize em vez disso a propriedade {{jsxref("Function.length", "length")}}.</s></dd>
+ <dt>{{jsxref("Function.caller")}} {{non-standard_inline}}</dt>
+ <dd>Especifica a função que invocou a função sendo executada.</dd>
+ <dt>{{jsxref("Function.length")}}</dt>
+ <dd>Especifica o número de argumentos esperados pela função.</dd>
+ <dt>{{jsxref("Function.name")}}</dt>
+ <dd>O nome da função.</dd>
+ <dt>{{jsxref("Function.displayName")}} {{non-standard_inline}}</dt>
+ <dd>O nome de exibição da função.</dd>
+ <dt><code>Function.prototype.constructor</code></dt>
+ <dd>Especifica a função que cria o <code>prototype</code> do objeto. Veja {{jsxref("Object.prototype.constructor")}} para mais detalhes.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Function.prototype.apply()")}}</dt>
+ <dd>Chama uma função e define seu <code>this</code> com o valor fornecido. Argumentos podem ser passados como um objeto {{jsxref("Array")}}.</dd>
+ <dt>{{jsxref("Function.prototype.bind()")}}</dt>
+ <dd>Cria uma nova função que, quando chamada, tem seu <code>this</code> definido com o valor fornecido, com uma sequência de argumentos determinada precedendo quaisquer argumentos fornecidos quando a nova função é chamada.</dd>
+ <dt>{{jsxref("Function.prototype.call()")}}</dt>
+ <dd>Chama (executa) uma função e define seu <code>this</code> com o valor fornecido. Argumentos podem ser passados como são.</dd>
+ <dt>{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}</dt>
+ <dd>Retorna <code>true</code> se a função é um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">gerador</a>; se não, retorna <code>false</code>.</dd>
+ <dt>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Retorna uma <em>string</em> representando o código-fonte da função. Sobrescreve o método {{jsxref("Object.prototype.toSource")}}.</dd>
+ <dt>{{jsxref("Function.prototype.toString()")}}</dt>
+ <dd>Retorna uma <em>string</em> representando o código-fonte da função. Sobrescreve o método {{jsxref("Object.prototype.toString")}}.</dd>
+</dl>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de compatibildiade nesta página é gerada a partir de dados estruturados. Se você gostaria de contribuir com os dados, confira por favor <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie uma <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Function.prototype")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/function/tosource/index.html
new file mode 100644
index 0000000000..4fbeaaf1c1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/tosource/index.html
@@ -0,0 +1,57 @@
+---
+title: Function.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Function/toSource
+tags:
+  - Função
+  - JavaScript
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>O método <code><strong>toSource()</strong></code> retorna uma string que representa o código-fonte do objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>function</var>.toSource();
+Function.toSource();
+</pre>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>Uma string representa o código-fonte de um objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método<code>toSource</code> retorna os seguintes valores:</p>
+
+<ul>
+ <li>Para objetos nativos {{jsxref("Function")}} , <code>toSource()</code> retorna a seguinte string indicando que o código-fonte não está disponível:
+
+  <pre class="brush: js">function Function() {
+    [native code]
+}
+</pre>
+ </li>
+ <li>Para funções personalizadas, <code>toSource()</code> retorna a fonte JavaScript que define o objeto como uma string.</li>
+</ul>
+
+<p>Esse método, normalmente é chamado internamente pelo JavaScript e não explicitamente no código. Você pode chamar <code>toSource</code> enquanto depura para examinar o conteúdo de um objeto.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de nenhum padrão. Implementado no JavaScript 1.3.</p>
+
+<h2 id="Compatibilidade_em_Navegadores">Compatibilidade em Navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de comaptibilidade nessa página é gerada por dados estruturados. Se você gostaria de contribuir para os dados, por favor, veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande um pull-request.</div>
+
+<p>{{Compat("javascript.builtins.Function.toSource")}}</p>
+</div>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/function/tostring/index.html
new file mode 100644
index 0000000000..c4d6fbbfb6
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/tostring/index.html
@@ -0,0 +1,239 @@
+---
+title: Function.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Function/toString
+tags:
+  - Função
+  - JavaScript
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>toString()</strong></code> retorna uma string representando o código fonte da função.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/function-tostring.html")}}</div>
+
+<p class="hidden">A fonte deste exemplo interativo está armazenado no repositório do GitHub. Se você gostaria de contrubuir para este exemplos de projeto interativo, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>function</var>.toString()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma string representando o código fonte da função.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O objeto da {{jsxref("Function")}} substitui o método {{jsxref("Object.prototype.toString", "toString")}} herdado de {{jsxref("Object")}}; ele não herda {{jsxref("Object.prototype.toString")}}. Para objetos {{jsxref("Function")}} definidos pelo usuário, o método <code>toString</code> retorna uma string contendo o seguimento de texto de origem que foi usado para definir a função</p>
+
+<p>O JavaScript chama o método <code>toString</code> automaticamente quando uma {{jsxref("Function")}} pode ser representada como um valor de texto. e.x. quando uma função é concatenada com uma string.</p>
+
+<p>O método <code>toString()</code> lançará uma exceção do tipo {{jsxref("TypeError")}} ("Function.prototype.toString called on incompatible object") se o valor <code>this</code> do objeto não é um objeto do tipo <code>Function.</code></p>
+
+<pre class="brush: js example-bad notranslate">Function.prototype.toString.call('foo'); // TypeError
+</pre>
+
+<p>Se o método <code>toString()</code> é chamado por objetos de funções embutidas ou por uma função criada por <code>Function.prototype.bind</code>, <code>toString()</code> retorna uma string de uma função nativa que parece</p>
+
+<pre class="brush: js notranslate">"function () {\n    [native code]\n}"
+</pre>
+
+<p>Se o método <code>toString()</code> é chamado por uma função criada pelo contrutor de <code>Function</code>, <code>toString()</code> retorna o código fonte de uma declaração de função sintetizada chamada "anonymous" usando os parâmetros passados e o corpo da função.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Função</th>
+   <th scope="col">Function.prototype.toString resultado</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>
+    <pre class="notranslate">
+function f(){}</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"function f(){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+class A { a(){} }</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"class A { a(){} }"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+function* g(){}</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"function* g(){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+a =&gt; a</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"a =&gt; a"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+({ a(){} }.a)</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"a(){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+({ *a(){} }.a)</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"*a(){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+({ [0](){} }[0])</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"[0](){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+Object.getOwnPropertyDescriptor({
+    get a(){}
+}, "a").get</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"get a(){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+Object.getOwnPropertyDescriptor({
+    set a(x){}
+}, "a").set</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"set a(x){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+Function.prototype.toString</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"function toString() { [native code] }"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+(function f(){}.bind(0))</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"function () { [native code] }"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+Function("a", "b")</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"function anonymous(a\n) {\nb\n}"</pre>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>
+    <p>Definição inicial. Implementado no JavaScript 1.1.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>
+    <p>Mais requisitos específicos foram incluídos para representação de string.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><a href="https://tc39.github.io/Function-prototype-toString-revision/#sec-introduction"><code>Function.prototype.toString</code> revisions proposal</a></td>
+   <td>Rascunho</td>
+   <td>
+    <p>Padroniza a função de string navida e fins de linha.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Function.toString")}}</p>
+</div>
+
+<h2 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h2>
+
+<ul>
+ <li>Desde o Firefox 17 a função <code>Function.prototype.toString()</code> tem sido implementada salvando o fonte da função. O descompilador foi removido o que torna o parâmetro <code>indentation</code> desnecessário. Veja {{bug("761723")}} para mais detalhes.</li>
+ <li>Do Firefox 38 para o 63 a função <code>Function.prototype.toString()</code> lançava exceções para objetos {{jsxref("Proxy")}} ({{bug(1100936)}} e {{bug(1440468)}}).</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>