From 074785cea106179cb3305637055ab0a009ca74f2 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:42:52 -0500 Subject: initial commit --- .../global_objects/function/apply/index.html | 249 +++++++++++++++++ .../global_objects/function/arguments/index.html | 130 +++++++++ .../global_objects/function/arity/index.html | 78 ++++++ .../global_objects/function/bind/index.html | 309 +++++++++++++++++++++ .../global_objects/function/call/index.html | 194 +++++++++++++ .../global_objects/function/caller/index.html | 129 +++++++++ .../global_objects/function/displayname/index.html | 80 ++++++ .../reference/global_objects/function/index.html | 234 ++++++++++++++++ .../global_objects/function/isgenerator/index.html | 55 ++++ .../global_objects/function/length/index.html | 134 +++++++++ .../global_objects/function/name/index.html | 222 +++++++++++++++ .../global_objects/function/prototype/index.html | 94 +++++++ .../global_objects/function/tosource/index.html | 57 ++++ .../global_objects/function/tostring/index.html | 239 ++++++++++++++++ 14 files changed, 2204 insertions(+) create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/apply/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/arguments/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/arity/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/bind/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/call/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/caller/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/displayname/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/isgenerator/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/length/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/name/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/prototype/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/tosource/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/function/tostring/index.html (limited to 'files/pt-br/web/javascript/reference/global_objects/function') 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 +--- +
{{JSRef}}
+ +

O método apply() chama uma função com um dado valor this e arguments providos como uma array (ou um objeto parecido com um array).

+ +
+

Nota: A sintaxe desta função é quase idêntica a essa da {{jsxref("Function.call", "call()")}}, a diferença é que call() aceita uma  lista de argumentos, enquanto apply() aceita um array de argumentos.

+
+ +

Sintaxe

+ +
fun.apply(thisArg, [argsArray])
+ +

Parâmetros

+ +
+
thisArg
+
+

O valor de this é fornecido para a chamada de fun. 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.

+
+
argsArray
+
Um objeto parecido com um array (array-like), especificando os argumentos com os quais fun 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")}}.
+
+ +

Descrição

+ +

Você pode atribuir um objeto this diferente quando chamar uma função existente. this refere-se ao objeto atual, o objeto da chamada. Com apply, 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.

+ +

apply é 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 apply, você pode usar um array literal, por exemplo, fun.apply(this, ['comer', 'bananas']), ou um objeto {{jsxref("Array")}}, por exemplo fun.apply(this, new Array('comer', 'bananas')).

+ +

Você pode também usar {{jsxref("Functions/arguments", "arguments")}} para o parâmetro argsArray. arguments é 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 apply. Você pode usar arguments para passar todos os argumentos para o objeto da chamada. O objeto chamado fica então responsável por manipular os argumentos.

+ +

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 length e propriedades inteiras no intervalor (0... length). Como um exemplo, você pode agora usar um {{domxref("NodeList")}} ou um objeto personalizado como { 'length': 2, '0': 'comer', '1': 'bananas' }.

+ +

{{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.")}}.

+ +

Exemplos

+ +

Usando apply para cadeia de construtores

+ +

Você pode usar apply 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 construct, que fará você capaz de usar um objeto parecido com um array com um construtor ao invés de uma lista de argumentos

+ +
Function.prototype.construct = function (aArgs) {
+  var oNew = Object.create(this.prototype);
+  this.apply(oNew, aArgs);
+  return oNew;
+};
+
+ +
+

Note: O método Object.create()  usado acima é relativamente novo. Para um método alternativo utilizando closures, por favor considere a seguinte alternativa.

+ +
Function.prototype.construct = function(aArgs) {
+  var fConstructor = this, fNewConstr = function() { fConstructor.apply(this, aArgs); };
+  fNewConstr.prototype = fConstructor.prototype;
+  return new fNewConstr();
+};
+
+ +

Exemplo de uso:

+ +
function MyConstructor() {
+  for (var nProp = 0; nProp < 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'
+
+ +
+

Nota:  Este método não nativo Function.construct 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")}}: [2012, 11, 4]; Neste caso você tem que escrever algom como: new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))() - 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

+
+ +

Usando apply e funções embutidas

+ +

A forma inteligente com que apply é 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 Math.max/Math.min para achar o valor máximo/mínimo value em um array.

+ +
/* 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 < numbers.length; i++) {
+  if (numbers[i] > max) {
+    max = numbers[i];
+  }
+  if (numbers[i] < min) {
+    min = numbers[i];
+  }
+}
+
+ +

Mas tome cuidado: ao utilizar o apply 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 limite de argumentos de 65536 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 5, 6, 2, 3 do exemplo anterior fossem passados ao apply, 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:

+ +
function minOfArray(arr) {
+  var min = Infinity;
+  var QUANTUM = 32768;
+
+  for (var i = 0, len = arr.length; i < 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]);
+
+ +

Usando apply em "monkey-patching"

+ +

Apply pode ser a melhor forma de monkey-patch uma função nativa do Firefox, ou de bibliotecas em JS. Dada uma função someobject.foo, você poderá modificar a função de uma maneira hackeresca, como por exemplo:

+ +
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.
+}
+
+ +

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 .on([event]... events, por exemplo aqueles utilizáveis no Devtools Inspector).

+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
ECMAScript 3º Edição.PadrãoDefinição inicial, implementado no JavaScript 1.3.
{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}{{Spec2('ES6')}} 
+ +

Compatibilidade de navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
FuncionalidadeChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
ES 5.1 objetos genéricos parecidos com array como  {{jsxref("Functions_and_function_scope/arguments", "arguments")}}{{CompatUnknown}}{{CompatGeckoDesktop("2.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FuncionalidadeAndroidChrome para AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
ES 5.1 objetos genéricos parecidos com array como  {{jsxref("Functions_and_function_scope/arguments", "arguments")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile("2.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Veja também

+ + 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 +--- +
{{JSRef}} {{deprecated_header}}
+ +

A propriedade function.arguments 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.

+ +

Descrição

+ +

A sintaxe function.arguments 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")}}.

+ +

No caso de recursão, ou seja, uma função f aparecer várias vezes na pilha de chamadas, o valor de f.arguments representa os argumentos correspondentes a invocação mais recente da função.

+ +

O valor da propriedade arguments é normalmente nulo (null) 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).

+ +

Exemplos

+ +
function f(n) { g(n - 1); }
+
+function g(n) {
+  console.log('before: ' + g.arguments[0]);
+  if (n > 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
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definiçao inicial. Implementado em JavaScript 1.0. Obsoleto em favor de {{jsxref("Functions/arguments", "arguments")}} em ES3.
{{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}{{Spec2('ES5.1')}}{{jsxref("Functions/arguments", "arguments")}} object
{{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}{{Spec2('ES6')}}{{jsxref("Functions/arguments", "arguments")}} object
{{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}}{{Spec2('ESDraft')}}{{jsxref("Functions/arguments", "arguments")}} object
+ +

Compatibilidade com navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + 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 +--- +
{{JSRef("Global_Objects", "Function")}} {{obsolete_header}}
+ +

Resumo

+ +

A propriedade arity é 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")}}.

+ +

Especificações

+ +

Implementada no JavaScript 1.2. Depreciada no JavaScript 1.4.

+ +

Compatibilidade com navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Veja também

+ + 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 +--- +
{{JSRef}}
+ +

O método bind() cria uma nova função que, quando chamada, tem sua palavra-chave this definida com o valor fornecido, com uma sequência determinada de argumentos precedendo quaisquer outros que sejam fornecidos quando a nova função é chamada.

+ +

{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}}

+ +

Sintaxe

+ +
function.bind(thisArg[, arg1[, arg2[, ...]]])
+ +

Parâmetros

+ +
+
thisArg
+
O valor a ser passado como parâmetro this para a função de destino quando a função vinculada é chamada. O valor é ignorado se a função ligada é construída usando o operador {{jsxref("Operators/new", "new")}}.
+
arg1, arg2, ...
+
Argumentos que precedem outros argumentos fornecidos para a função vinculada ao invocar a função de destino.
+
+ +

Valor de retorno

+ +

Uma cópia da função fornecida com o valor this especificado e argumentos iniciais.

+ +

Descrição

+ +

A função bind() cria uma nova função vinculada (bound function). Uma função vinculada é um objeto de função exótico (termo da ECMAScript 2015) que encapsula o objeto de função original. Chamar uma função vinculada geralmente resulta na execução de sua função encapsulada.

+ +

Uma função vinculada tem as seguintes propriedades internas:

+ + + +

Quando a função vinculada é chamada, ela chama seu método interno [[Call]] na [[BoundTargetFunction]], na forma Call(boundThis, args), onde boundThis é [[BoundThis]] e args é [[BoundArguments]] seguido pelos argumentos passados pela chamada de função.

+ +

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 this fornecido é ignorado, porém os argumentos precedentes são fornecidos à função emulada.

+ +

Exemplos

+ +

Criando uma função vinculada

+ +

O uso mais simples de bind() é fazer com que uma função que, independentemente da chamada, é chamada com um determinado valor this. Um erro comum para programadores JavaScript novatos é extrair um método de um objeto e, em seguida, chamar essa função e esperar que ele use o objeto original como o seu this (por exemplo, usando esse método num código baseado em callback). Sem a devida atenção, no entanto, o objeto original é normalmente perdido. Criar uma função vinculada a partir da função, usando o objeto original, resolve perfeitamente esse problema:

+ +
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
+
+ +

Funções parcialmente aplicadas

+ +

O próximo uso mais simples de bind() é criar uma função com argumentos iniciais pré-especificados. Esses argumentos (caso existam) acompanham o valor this 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.

+ +
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]
+
+ +

Com setTimeout

+ +

Por padrão, dentro de {{domxref("window.setTimeout()")}} a palavra-chave this vai ser definida com o objeto {{ domxref("window") }} (ou com o objeto global). Ao trabalhar com métodos de classes que requerem que this se refira à instâncias de classes, você pode vincular this explicitamente à função de callback, de modo a manter a instância.

+ +
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'
+ +

Funções vinculadas usadas como construtores

+ +
+

Aviso: Esta seção demonstra capacidades do JavaScript e documenta alguns casos de borda do método bind(). 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.

+
+ +

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 this fornecido é ignorado. Porém, argumentos fornecidos ainda são prefixados à chamada do construtor:

+ +
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
+
+ +

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")}}.

+ +
// 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;
+// >  '0,13'
+
+ +

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.

+ +

Criando atalhos

+ +

bind() itambém é útil em casos onde você quer criar um atalho para uma função que requer um valor específico de this.

+ +

Tome por exemplo {{jsxref("Array.prototype.slice")}}, que você quer usar para converter um objeto array-like em um vetor verdadeiro. Você poderia criar um atalho assim:

+ +
var slice = Array.prototype.slice;
+
+// ...
+
+slice.apply(arguments);
+
+ +

Com bind(), isso pode ser simplificado. No seguinte trecho de código, slice é uma função vinculada à função {{jsxref("Function.prototype.apply()", "apply()")}} de {{jsxref("Function.prototype")}}, com o valor this definido com a função {{jsxref("Array.prototype.slice()", "slice()")}} de {{jsxref("Array.prototype")}}. Isso significa que chamadas adicionais de apply() podem ser eliminadas:

+ +
// mesmo que "slice" no exemplo anterior
+var unboundSlice = Array.prototype.slice;
+var slice = Function.prototype.apply.bind(unboundSlice);
+
+// ...
+
+slice(arguments);
+
+ +

Polyfill

+ +

A função bind é 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 scripts, permitindo o uso de muita parte da funcionalidade de bind() em implementações que não a suportam nativamente.

+ +
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;
+  };
+}
+
+ +

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:

+ + + +

Se você escolher utilizar esta implementação parcial, você não deve confiar em casos onde o comportamento é diferente da ECMA-262, 5ª. edição! 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 bind() for amplamente implementada de acordo com a especificação.

+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES5.1', '#sec-15.3.4.5', 'Function.prototype.bind')}}{{Spec2('ES5.1')}}Definição inicial. Implementada no JavaScript 1.8.5.
{{SpecName('ES6', '#sec-function.prototype.bind', 'Function.prototype.bind')}}{{Spec2('ES6')}}
+ +

Compatibilidade de navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome("7")}}{{CompatGeckoDesktop("2")}}{{CompatIE("9")}}{{CompatOpera("11.60")}}{{CompatSafari("5.1")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatAndroid("4.0")}}{{CompatChrome("1")}}{{CompatGeckoMobile("2")}}{{CompatUnknown}}{{CompatOperaMobile("11.5")}}{{CompatSafari("6.0")}}
+
+ +

Veja também

+ + 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 +--- +
{{JSRef("Global_Objects", "Function")}}
+ +

Introdução

+ +

O método call() invoca uma função com um dado valor this  e argumentos passados individualmente.

+ +
+

Nota: Apesar de a sintaxe desta função ser quase idêntica à de {{jsxref("Function.prototype.apply", "apply()")}}, a principal diferença é que call() aceita uma lista de argumentos, enquanto apply() aceita um único array de argumentos.

+
+ +

Sintaxe

+ +
fun.call(thisArg[, arg1[, arg2[, ...]]])
+ +

Parâmetros

+ +
+
thisArg
+
O valor de  this  proveu a chamada para fun. Note que this 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.
+
arg1, arg2, ...
+
Argumentos para  o objeto.
+
+ +

Descrição

+ +

Você pode atribuir um objeto this diferente quando executar uma função existente. this refere-se ao objeto atual, o objeto em execução. Com call, 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.

+ +

Exemplos

+ +

Exemplo: Usando call para encadear construtores para um objeto

+ +

Você pode usar call para encadear construtores para um objeto, similar ao  Java. No seguinte exemplo, o construtor do  objeto Product é definido com dois parâmetros, name e price. Outras duas funções Food e Toy executam Product passando this, name e price. O Produto inicializa as propriedades name e price,  ambos definem o category.

+ +
function Product(name, price) {
+  this.name = name;
+  this.price = price;
+
+  if (price < 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);
+
+ +

Exemplo: Usando o call para chamar funções anônimas

+ +

Neste exemplo, criamos uma função anônima que usa o call 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 this , mas isso foi feito apenas para explicação.

+ +
var animais = [
+  { especie: 'Lion', nome: 'King' },
+  { especie: 'Whale', nome: 'Fail' }
+];
+
+for (var i = 0; i < animais.length; i++) {
+  (function(i) {
+    this.print = function() {
+      console.log('#' + i + ' ' + this.especie
+                  + ': ' + this.nome);
+    }
+    this.print();
+  }).call(animais[i], i);
+}
+
+ +

Usando call para chamar a função e especificar o contexto de 'this'

+ +

No exemplo abaixo, quando vamos chamar a apresentação, o valor de this será associado ao objeto i.
+  

+ +
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
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçõesStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial. Implementado no JavaScript 1.3.
{{SpecName('ES5.1', '#sec-15.3.4.4', 'Function.prototype.call')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function.prototype.call', 'Function.prototype.call')}}{{Spec2('ES6')}} 
+ +

Compatibilidade de Browser

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FuncionalidadeChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FuncionalidadeAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + 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 +--- +
{{JSRef}} {{non-standard_header}}
+ +

A propriedade function.caller retorna a função que invocou a função especificada.

+ +

Descrição

+ +

Se a função f foi invocada pelo codigo mais alto nível, o valor de f.caller é {{jsxref("null")}}, caso contrario, o valor será a função a qual invocou f.

+ +

Esta propriedade substitui a propriedade obsoleta {{jsxref("Functions/arguments/caller", "arguments.caller")}} do objeto {{jsxref("Functions/arguments", "arguments")}}.

+ +

A propriedade especial __caller__, a qual retornou o objeto de ativação do chamador, permitindo assin reconstruir o stack, foi removido por motivo de segurança.

+ +

Notas

+ +

Note que no caso de recurção, você não pode reconstruir o stack de chamadas usando esta propriedade. Considere:

+ +
function f(n) { g(n - 1); }
+function g(n) { if (n > 0) { f(n); } else { stop(); } }
+f(2);
+
+ +

No momento em que stop() é chamado o stack será:

+ +
f(2) -> g(1) -> f(1) -> g(0) -> stop()
+
+ +

O seguinte é true:

+ +
stop.caller === g && f.caller === g && g.caller === f
+
+ +

então se você tentou recuperar o stack trace na função stop() assim:

+ +
var f = stop;
+var stack = 'Stack trace:';
+while (f) {
+  stack += '\n' + f.name;
+  f = f.caller;
+}
+
+ +

o loop nunca irá parar.

+ +

Exemplos

+ +

Verificando o valor da propriedade caller de uma função

+ +

O código a seguir verifica o valor da propriedade caller de uma função.

+ +
function myFunc() {
+  if (myFunc.caller == null) {
+    return 'The function was called from the top!';
+  } else {
+    return 'This function\'s caller was ' + myFunc.caller;
+  }
+}
+
+ +

Especificações

+ +

Não faz parte de nenhuma especificação. Implementado no JavaScript 1.5.

+ +

Compatibilidade com os navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.0")}}8.0{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("1.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Ver também

+ + 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 +--- +
{{JSRef}} {{non-standard_header}}
+ +

A propriedade function.displayName retorna o nome de exibição da função.

+ +

Descrição

+ +

Quando definida, a propriedade displayName retorna o nome de exibição da função.

+ +
function doSomething() {}
+
+console.log(doSomething.displayName); // "undefined"
+
+var popup = function(content) { console.log(content); };
+
+popup.displayName = 'Show Popup';
+
+console.log(popup.displayName); // "Show Popup"
+
+ +

Você pode definir uma função com uma nome de exibição em um {{jsxref("Functions", "function expression", "", 1)}}:

+ +
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
+
+ +

Você pode mudar dinamicamente odisplayName de uma função:

+ +
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)"
+
+ +

Exemplos

+ +

Geralmente, é preferida por consoles e perfis em vez de  {{jsxref("Function.name", "func.name")}} mostrar o nome de uma função.

+ +

Entrando com o seguinte em um console, isso deverá mostrar algo como  "function My Function()":

+ +
var a = function() {};
+a.displayName = 'My Function';
+
+a; // "function My Function()"
+ +

Especificações

+ +

Não faz parte de denhuma especificação.

+ +

Compatibilidade de Navegadores

+ +
+ + +

{{Compat("javascript.builtins.Function.displayName")}}

+
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 +--- +
{{JSRef("Global_Objects", "Function")}}
+ +

Resumo

+ +

O construtor Function cria um novo objeto Function. 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.

+ +

Sintaxe

+ +
new Function ([arg1[, arg2[, ...argN]],] functionBody)
+ +

Parâmetros

+ +
+
arg1, arg2, ... argN
+
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 vírgula; por exemplo "x", "theValue". our "a,b".
+
functionBody
+
Uma string que contém as instruções JavaScript que compõem a definição da função.
+
+ +

Descrição

+ +

Objetos Function criados com o construtor Function são parseados quando a função é criada. Isto é menos eficiente que criar com uma expressão de função ou um declaração de função e chamando-a dentro do seu código, porque tais funções são parseadas com o resto do código.

+ +

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.

+ +
+

Nota: Funções criadas com o construtor Function não criam closures 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 Function foi chamado. Isto é diferente de usar {{jsxref("Global_Objects/eval", "eval")}} com o código de uma expressão de função.

+
+ +

Invocar o construtor Function como uma função (sem usar o operador new) tem o mesmo efeito de chamá-la como um construtor.

+ +

Propriedades e Métodos da Function

+ +

O objeto global Function 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")}}.

+ +

Function prototype object

+ +

Propriedades

+ +
{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Properties')}}
+ +

Métodos

+ +
{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Methods')}}
+ +

Function instances

+ +

Function 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 Function instances.

+ +

Exemplos:

+ +

Exemplos: Especificando argumentos com o construtor Function

+ +

O código a seguir cria um objeto Function que recebe dois argumentos.

+ +
// 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);
+// > 8
+
+ +

Os argumentos "a" e "b" são os argumentos que serão usados no corpo da função, "return a + b".

+ +

Exemplo: Um atalho recursivo para modificar o DOM em massa

+ +

Creating functions with the Function 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 Function constructor for each new query if you want to avoid closures.

+ +
<!doctype html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+<title>MDN Example - a recursive shortcut to massively modify the DOM</title>
+<script type="text/javascript">
+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 << 1],
+        aArgs = Array.prototype.slice.call(arguments, 1, bSet ? 3 : 2),
+        aNodeList = bStyle ? this.cssNodes : this.nodes;
+
+    if (bSet && bStyle) { aArgs.push(''); }
+    for (
+      var nItem = 0, nLen = this.nodes.length;
+      nItem < 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;
+  });
+})();
+</script>
+</head>
+
+<body>
+
+<div class="testClass">Lorem ipsum</div>
+<p>Some text</p>
+<div class="testClass">dolor sit amet</div>
+
+<script type="text/javascript">
+domQuery('.testClass')
+  .attributes('lang', 'en')('title', 'Risus abundat in ore stultorum')
+  .inlineStyle('background-color', 'black')('color', 'white')('width', '100px')('height', '50px');
+</script>
+</body>
+
+</html>
+
+ +

Especificação

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
ECMAScript 1st Edition.StandardDefinição inicial. Implementado no JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.3', 'Function')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-function-objects', 'Function')}}{{Spec2('ES6')}}
+ +

Compatibilidade

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

See also

+ + 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 +--- +
{{JSRef}} {{non-standard_header}}
+ +

O método não padronizado isGenerator() é usado para determinar se uma função é ou não um gerador. Ele foi removido do Firefox a partir da versão 58.

+ +

Sintaxe

+ +
fun.isGenerator()
+ +

Valor de retorno

+ +

Um {{jsxref("Boolean")}} que indica se dada função é ou nao um gerador.

+ +

Descrição

+ +

O método isGenerator() determina se uma função fun é ou não um gerador. Fez parte de uma Proposta Inicial de Harmonia, mas não foi incluído na especificação do ECMAScript 2015.

+ +

Exemplos

+ +
function f() {}
+
+function* g() {
+  yield 42;
+}
+
+console.log('f.isGenerator() = ' + f.isGenerator()); // f.isGenerator() = false
+console.log('g.isGenerator() = ' + g.isGenerator()); // g.isGenerator() = true
+
+ +

Specificações

+ +

Não faz parte de nenhuma especificação. Implementado no JavaScript 1.8.6.

+ +

Compatibilidade do Navegador

+ +
+ + +

{{Compat("javascript.builtins.Function.isGenerator")}}

+
+ +

Veja também

+ + 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 +--- +
{{JSRef}}
+ +

A propriedade length especifica o número de argumentos esperados pela função.

+ +
{{js_property_attributes(0,0,1)}}
+ +

Descrição

+ +

length é uma propriedade de um objeto função, 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)}}. Por contraste, {{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.

+ +

Propriedade de Dados do construtor Function

+ +

O construtor {{jsxref("Function")}} é propriamente um objeto {{jsxref("Function")}}. A proproedade de dados do seu length tem o valor de 1. Os atributos da propriedade são: Escrita: false, Enumerável: false, Configurável: true.

+ +

Propriedades do objeto prototype de Function

+ +

A propriedade length do objeto prototype {{jsxref("Function")}} tem o valor de 0.

+ +

Exemplos

+ +
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 */
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.3.5.1', 'Function.length')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}{{Spec2('ES6')}}The configurable attribute of this property is now true.
+ +

Compatibilidade com o Navegador

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Configurable: true{{CompatUnknown}}{{CompatGeckoDesktop(37)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Configurable: true{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile(37)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Veja tambem

+ + 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 +--- +
{{JSRef}}
+ +

A propriedade somente-leitura name de um objeto {{jsxref("Function")}} indica o nome da função como especificado quando esta foi criada, ou "anonymous" para funções criadas anonimamente.

+ +
{{EmbedInteractiveExample("pages/js/function-name.html")}}
+ + + +
{{js_property_attributes(0,0,1)}}
+ 
+ +
+

Note que em implementações não-standard anteriores à ES2015 o atributo configurable tinha também o valor false.

+
+ +

Exemplos

+ +

Nome de declaração da função

+ +

A propriedade name retorna o nome de uma declaração de função.

+ +
function doSomething() {}
+doSomething.name; // "doSomething"
+
+ +

Nome do construtor da função

+ +

Funções criadas com a sintaxe new Function(...) ou somente Function(...) criam objetos {{jsxref("Function")}} com o nome "anonymous".

+ +
(new Function).name; // "anonymous"
+ +

Nomes de função inferidos

+ +

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).

+ +
var f = function() {};
+var object = {
+  someMethod: function() {}
+};
+
+console.log(f.name); // "f"
+console.log(object.someMethod.name); // "someMethod"
+
+ +

Você pode definir uma função com um nome numa {{jsxref("Operators/Function", "expressão de função", "", 1)}}:

+ +
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
+
+ +

Você não pode mudar o nome de uma função, pois a propriedade é somente-leitura:

+ + + +
var object = {
+  // anonymous
+  someMethod: function() {}
+};
+
+object.someMethod.name = 'otherMethod';
+console.log(object.someMethod.name); // someMethod
+
+ +

Para mudá-lo, você poderia no entanto usar {{jsxref("Object.defineProperty()")}}.

+ +

Nomes curtos de métodos

+ +
var o = {
+  foo(){}
+};
+o.foo.name; // "foo";
+ +

Nomes de funções vinculadas

+ +

{{jsxref("Function.bind()")}} produz uma função cujo nome é "bound " seguido do nome da função.

+ +
function foo() {};
+foo.bind({}).name; // "bound foo"
+
+ +

Nomes de função para getters e setters

+ +

Ao usar propriedades acessórias get e set, "get" ou "set" aparecerão no nome da função.

+ +
var o = {
+  get foo(){},
+  set foo(x){}
+};
+
+var descriptor = Object.getOwnPropertyDescriptor(o, "foo");
+descriptor.get.name; // "get foo"
+descriptor.set.name; // "set foo";
+ +

Nomes de funções em classes

+ +

Você pode usar obj.constructor.name para checar a "classe" de um objeto (porém leia com atenção os avisos abaixo):

+ +
function Foo() {}  // Sintaxe ES2015: class Foo {}
+
+var fooInstance = new Foo();
+console.log(fooInstance.constructor.name); // grava o log "Foo"
+
+ +
+

Aviso: O interpretador vai definir a propriedade  interna Function.name somente se uma função não tiver uma propriedade já com o nome name (veja a seção 9.2.11 da ECMAScript2015 Language Specification). Porém, a ES2015 especifica que a palavra-chave static de maneira que métodos estáticos serão definidos como OwnProperty da função construtora de classe (ECMAScript2015, 14.5.14.21.b + 12.2.6.9).

+
+ +

Portanto não podemos obter o nome de virtualmente qualquer classe com um método estático name():

+ +
class Foo {
+  constructor() {}
+  static name() {}
+}
+
+ +

Com um método static name(), Foo.name não guarda mais o nome verdadeiro da classe mas uma referência ao objeto de função name(). 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:

+ +
function Foo() {}
+Object.defineProperty(Foo, 'name', { writable: true });
+Foo.name = function() {};
+
+ +

Tentar obter a classe de fooInstance via fooInstance.constructor.name não nos dará de maneira alguma o nome da classe, mas sim uma referência ao método estático da classe. Exemplo:

+ +
var fooInstance = new Foo();
+console.log(fooInstance.constructor.name); // grava o name() da função no log
+
+ +

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 Foo.name se torna writable. A predefinição interna na ausência de uma definição estática customizada é somente-leitura:

+ +
Foo.name = 'Hello';
+console.log(Foo.name); // logs "Hello" if class Foo has a static name() property but "Foo" if not.
+
+ +

Portanto, você não pode assumir que a propriedade interna Function.name sempre guardará um nome de classe..

+ +

Símbolos como nome de função

+ +

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.

+ +
var sym1 = Symbol("foo");
+var sym2 = Symbol();
+var o = {
+  [sym1]: function(){},
+  [sym2]: function(){}
+};
+
+o[sym1].name; // "[foo]"
+o[sym2].name; // ""
+ +

Compressores e minificadores JavaScript

+ +
+

Aviso: Tenha cuidado ao usar Function.name 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 build  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 build.

+
+ +

Código fonte do tipo:

+ +
function Foo() {};
+var foo = new Foo();
+
+if (foo.constructor.name === 'Foo') {
+  console.log("'foo' is an instance of 'Foo'");
+} else {
+  console.log('Oops!');
+}
+
+ +

pode ser comprimido e se tornar:

+ +
function a() {};
+var b = new a();
+if (b.constructor.name === 'Foo') {
+  console.log("'foo' is an instance of 'Foo'");
+} else {
+  console.log('Oops!');
+}
+
+ +

Na versão descomprimida, o programa cai no bloco-verdade e grava o log 'foo' is an instance of 'Foo'. Todavia, na versão comprimida ele se comporta diferentemente, e cai no bloco else. Se você depende de Function.name, como no exemplo acima, tenha certeza que seu processo de build não mude nomes de função, ou então não assuma que uma função terá um nome determinado.

+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES2015', '#sec-name', 'name')}}{{Spec2('ES2015')}}Definição inicial.
{{SpecName('ESDraft', '#sec-function-instances-name', 'name')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade de navegadores

+ +
+ + +

{{Compat("javascript.builtins.Function.name")}}

+
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 +--- +
{{JSRef}}
+ +

A propriedade Function.prototype representa o objeto prototype de {{jsxref("Function")}}.

+ +

Descrição

+ +

Objetos {{jsxref("Function")}} herdam de Function.prototype.  Function.prototype não pode ser modificado.

+ +

Propriedades

+ +
+
{{jsxref("Function.arguments")}} {{deprecated_inline}}
+
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.
+
{{jsxref("Function.arity")}} {{obsolete_inline}}
+
Usado para especificar o número de argumentos esperados pela função. Foi removido, utilize em vez disso a propriedade {{jsxref("Function.length", "length")}}.
+
{{jsxref("Function.caller")}} {{non-standard_inline}}
+
Especifica a função que invocou a função sendo executada.
+
{{jsxref("Function.length")}}
+
Especifica o número de argumentos esperados pela função.
+
{{jsxref("Function.name")}}
+
O nome da função.
+
{{jsxref("Function.displayName")}} {{non-standard_inline}}
+
O nome de exibição da função.
+
Function.prototype.constructor
+
Especifica a função que cria o prototype do objeto. Veja {{jsxref("Object.prototype.constructor")}} para mais detalhes.
+
+ +

Métodos

+ +
+
{{jsxref("Function.prototype.apply()")}}
+
Chama uma função e define seu this com o valor fornecido. Argumentos podem ser passados como um objeto {{jsxref("Array")}}.
+
{{jsxref("Function.prototype.bind()")}}
+
Cria uma nova função que, quando chamada, tem seu this definido com o valor fornecido, com uma sequência de argumentos determinada precedendo quaisquer argumentos fornecidos quando a nova função é chamada.
+
{{jsxref("Function.prototype.call()")}}
+
Chama (executa) uma função e define seu this com o valor fornecido. Argumentos podem ser passados como são.
+
{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}
+
Retorna true se a função é um gerador; se não, retorna false.
+
{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}
+
Retorna uma string representando o código-fonte da função. Sobrescreve o método {{jsxref("Object.prototype.toSource")}}.
+
{{jsxref("Function.prototype.toString()")}}
+
Retorna uma string representando o código-fonte da função. Sobrescreve o método {{jsxref("Object.prototype.toString")}}.
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial. Implementada no JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}{{Spec2('ESDraft')}}
+ +

Compatibilidade de navegadores

+ +
+ + +

{{Compat("javascript.builtins.Function.prototype")}}

+
+ +

Veja também

+ + 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 +--- +
{{JSRef}} {{non-standard_header}}
+ +

O método toSource() retorna uma string que representa o código-fonte do objeto.

+ +

Sintaxe

+ +
function.toSource();
+Function.toSource();
+
+ +

Valor de Retorno

+ +

Uma string representa o código-fonte de um objeto.

+ +

Descrição

+ +

O métodotoSource retorna os seguintes valores:

+ + + +

Esse método, normalmente é chamado internamente pelo JavaScript e não explicitamente no código. Você pode chamar toSource enquanto depura para examinar o conteúdo de um objeto.

+ +

Especificações

+ +

Não faz parte de nenhum padrão. Implementado no JavaScript 1.3.

+ +

Compatibilidade em Navegadores

+ +
+ + +

{{Compat("javascript.builtins.Function.toSource")}}

+
+ +

Veja Também

+ + 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 +--- +
{{JSRef}}
+ +

O método toString() retorna uma string representando o código fonte da função.

+ +
{{EmbedInteractiveExample("pages/js/function-tostring.html")}}
+ + + +

Sintaxe

+ +
function.toString()
+ +

Valor de retorno

+ +

Uma string representando o código fonte da função.

+ +

Descrição

+ +

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 toString retorna uma string contendo o seguimento de texto de origem que foi usado para definir a função

+ +

O JavaScript chama o método toString automaticamente quando uma {{jsxref("Function")}} pode ser representada como um valor de texto. e.x. quando uma função é concatenada com uma string.

+ +

O método toString() lançará uma exceção do tipo {{jsxref("TypeError")}} ("Function.prototype.toString called on incompatible object") se o valor this do objeto não é um objeto do tipo Function.

+ +
Function.prototype.toString.call('foo'); // TypeError
+
+ +

Se o método toString() é chamado por objetos de funções embutidas ou por uma função criada por Function.prototype.bind, toString() retorna uma string de uma função nativa que parece

+ +
"function () {\n    [native code]\n}"
+
+ +

Se o método toString() é chamado por uma função criada pelo contrutor de Function, toString() 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.

+ +

Exemplos

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunçãoFunction.prototype.toString resultado
+ 
+function f(){}
+ 		+ 
+"function f(){}"
+
+ 
+class A { a(){} }
+ 		+ 
+"class A { a(){} }"
+
+ 
+function* g(){}
+ 		+ 
+"function* g(){}"
+
+ 
+a => a
+ 		+ 
+"a => a"
+
+ 
+({ a(){} }.a)
+ 		+ 
+"a(){}"
+
+ 
+({ *a(){} }.a)
+ 		+ 
+"*a(){}"
+
+ 
+({ [0](){} }[0])
+ 		+ 
+"[0](){}"
+
+ 
+Object.getOwnPropertyDescriptor({
+    get a(){}
+}, "a").get
+ 		+ 
+"get a(){}"
+
+ 
+Object.getOwnPropertyDescriptor({
+    set a(x){}
+}, "a").set
+ 		+ 
+"set a(x){}"
+
+ 
+Function.prototype.toString
+ 		+ 
+"function toString() { [native code] }"
+
+ 
+(function f(){}.bind(0))
+ 		+ 
+"function () { [native code] }"
+
+ 
+Function("a", "b")
+ 		+ 
+"function anonymous(a\n) {\nb\n}"
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}} +

Definição inicial. Implementado no JavaScript 1.1.

+
{{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}{{Spec2('ES6')}} +

Mais requisitos específicos foram incluídos para representação de string.

+
Function.prototype.toString revisions proposalRascunho +

Padroniza a função de string navida e fins de linha.

+
{{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}{{Spec2('ESDraft')}}
+ +

Compatibilidade de navegador

+ +
+ + +

{{Compat("javascript.builtins.Function.toString")}}

+
+ +

Notas específicas do Firefox

+ + + +

Veja também

+ + -- cgit v1.2.3-54-g00ecf