From 68fc8e96a9629e73469ed457abd955e548ec670c Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:49:58 +0100 Subject: unslug pt-br: move --- .../functions/default_parameters/index.html | 210 +++++++++++++++++++++ .../functions/definicoes_metodos/index.html | 200 -------------------- .../functions/method_definitions/index.html | 200 ++++++++++++++++++++ .../functions/parametros_predefinidos/index.html | 210 --------------------- 4 files changed, 410 insertions(+), 410 deletions(-) create mode 100644 files/pt-br/web/javascript/reference/functions/default_parameters/index.html delete mode 100644 files/pt-br/web/javascript/reference/functions/definicoes_metodos/index.html create mode 100644 files/pt-br/web/javascript/reference/functions/method_definitions/index.html delete mode 100644 files/pt-br/web/javascript/reference/functions/parametros_predefinidos/index.html (limited to 'files/pt-br/web/javascript/reference/functions') diff --git a/files/pt-br/web/javascript/reference/functions/default_parameters/index.html b/files/pt-br/web/javascript/reference/functions/default_parameters/index.html new file mode 100644 index 0000000000..82dc54abd8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/functions/default_parameters/index.html @@ -0,0 +1,210 @@ +--- +title: Parâmetros Predefinidos +slug: Web/JavaScript/Reference/Functions/Parametros_Predefinidos +tags: + - ECMA2015 + - ECMAScript6 + - Function + - Functions + - Função + - Funções + - JavaScript +translation_of: Web/JavaScript/Reference/Functions/Default_parameters +--- +
{{jsSidebar("Functions")}}
+ +

Os parâmetros predefinidos de uma função permitem que parâmetros regulares sejam inicializados com com valores iniciais caso undefined ou nenhum valor seja passado.

+ +

Sintaxe

+ +
function [nome]([param1[ = valorPredefinido1 ][, ..., paramN[ = valorPredefinidoN ]]]) {
+   instruções
+}
+
+ +

Descrição

+ +

Em JavaScript, os parâmetros de funções tem {{jsxref("undefined")}} como valor predefinido. Contudo, em alguns casos pode ser útil utilizar algum outro valor. É nesta situação em que os parâmetros predefinidos podem ser úteis.

+ +

No passado, a estratégia de definir valores padrão para parâmetros era testar os valores do parâmetros no corpo da função e atribuir um valor se este for undefined. No exemplo a seguir, se nenhum valor for fornecido para b na chamada, este valor será undefined, quando a*b for calculado resultaria em NaN. No entanto, isto é capturado na segunda linha definindo um valor padrão para b:

+ +
function multiply(a, b) {
+  b = (typeof b !== 'undefined') ? b : 1;
+
+  return a * b;
+}
+
+multiply(5, 2); // 10
+multiply(5, 1); // 5
+multiply(5);    // 5
+
+ +

Com o parâmetros predefinidos a checagem no corpo da função nao é mais necessária. Agora você pode simplesmente colocar 1 como valor padrão para b na declaração da função:

+ +
function multiply(a, b = 1) {
+  return a * b;
+}
+
+multiply(5, 2); // 10
+multiply(5, 1); // 5
+multiply(5);    // 5
+ +

Exemplos

+ +

Passando undefined vs. outros valores "falsy"

+ +

Na segunda chamada aqui, mesmo se o segundo argumento é definido explicitamente como undefined (com exceção de null) quando chamado, o valor para o argumento num será o padrão.

+ +
function test(num = 1) {
+  console.log(typeof num);
+}
+
+test();          // 'number' (num é definido para 1)
+test(undefined); // 'number' (num é definido para 1 também)
+
+// teste com outros values "falsy":
+test('');        // 'string' (num é definido para '')
+test(null);      // 'object' (num é definido para null)
+ +

Avaliado em tempo de chamada

+ +

Os parâmetros predefinidos são avaliados no momento da chamada da função, então diferente de ex.: Python, um novo objeto é criado cada vez que a funçao é chamada.

+ +
function append(value, array = []) {
+  array.push(value);
+  return array;
+}
+
+append(1); //[1]
+append(2); //[2], not [1, 2]
+
+
+ +

Este mesmo comportamento é aplicado para funções e variáveis:

+ +
function callSomething(thing = something()) { return thing }
+
+function something(){
+  return "sth";
+}
+
+callSomething();  //sth
+ +

Parâmetros predefinidos estão disponíveis para os parâmetros seguintes à sua definição

+ +

Parâmetros que já foram avaliados ficam disponíveis para uso para os parâmetros seguintes:

+ +
function singularAutoPlural(singular, plural = singular+"s",
+                            rallyingCry = plural + " ATTACK!!!") {
+  return [singular, plural, rallyingCry ];
+}
+
+//["Gecko","Geckos", "Geckos ATTACK!!!"]
+singularAutoPlural("Gecko");
+
+//["Fox","Foxes", "Foxes ATTACK!!!"]
+singularAutoPlural("Fox","Foxes");
+
+//["Deer", "Deer", "Deer ... change."]
+singularAutoPlural("Deer", "Deer", "Deer peaceably and respectfully
+   petition the government for positive change.")
+
+ +

Esta funcionalidade torna-se uma maneira direta e demonstra quantos casos extremos são manipulados.

+ +
function go() {
+  return ":P"
+}
+
+function withDefaults(a, b = 5, c = b, d = go(), e = this,
+                      f = arguments, g = this.value) {
+  return [a,b,c,d,e,f,g];
+}
+function withoutDefaults(a, b, c, d, e, f, g){
+  switch(arguments.length){
+    case 0:
+      a
+    case 1:
+      b = 5
+    case 2:
+      c = b
+    case 3:
+      d = go();
+    case 4:
+      e = this
+    case 5:
+      f = arguments
+    case 6:
+      g = this.value;
+    default:
+  }
+  return [a,b,c,d,e,f,g];
+}
+
+withDefaults.call({value:"=^_^="});
+// [undefined, 5, 5, ":P", window, arguments, "=^_^="]
+
+
+withoutDefaults.call({value:"=^_^="});
+// [undefined, 5, 5, ":P", window, arguments, "=^_^="]
+
+ +

Funções definidadas dentro do corpo da função

+ +

Introduzido no Gecko 33 {{geckoRelease(33)}}. Funções declaradas no corpo da função não podem ser referenciada dentro de parâmetos padrão e lançará um {{jsxref("ReferenceError")}} (atualmente um {{jsxref("TypeError")}} no SpiderMonkey, veja {{bug(1022967)}}). Parâmetros padrão são sempre executados primeiro, declarações de funções dentro do corpo de outra função são avaliadas depois.

+ +
// Não funciona! Throws ReferenceError.
+function f(a = go()) {
+  function go(){return ":P"}
+}
+
+ +

Parâmetros sem valor padrão depois de parâmetros com valores padrão

+ +

Antes do Gecko 26 {{geckoRelease(26)}}, o seguinte código resultaria em um {{jsxref("SyntaxError")}}. Isto foi corrigido no {{bug(777060)}} e funciona como esperado em versões posteriores:

+ +
function f(x=1, y) {
+  return [x, y];
+}
+
+f(); // [1, undefined]
+
+ +

Parâmetro desestruturado com valores padrões

+ +

É possível definir valores padrões com a notação destructuring assignment:

+ +
function f([x, y] = [1, 2], {z: z} = {z: 3}) {
+  return x + y + z;
+}
+
+f(); // 6
+ +

Especificações

+ + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-function-definitions', 'Function Definitions')}}{{Spec2('ES6')}}Definição Inicial.
+ +

Compatibilidade nos navegadores

+ +
+

{{Compat("javascript.functions.default_parameters")}}

+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/functions/definicoes_metodos/index.html b/files/pt-br/web/javascript/reference/functions/definicoes_metodos/index.html deleted file mode 100644 index ac02cb9deb..0000000000 --- a/files/pt-br/web/javascript/reference/functions/definicoes_metodos/index.html +++ /dev/null @@ -1,200 +0,0 @@ ---- -title: Definições de Método -slug: Web/JavaScript/Reference/Functions/Definicoes_metodos -tags: - - ECMAScript 2015 - - Funções - - JavaScript - - Objeto - - Sintaxe -translation_of: Web/JavaScript/Reference/Functions/Method_definitions ---- -
{{JsSidebar("Functions")}}
- -

No ECMAScript 2015 foi introduzida uma sintaxe reduzida para definição de métodos em inicializadores de objetos. É uma abreviação para uma função atribuída ao nome do método.

- -

{{EmbedInteractiveExample("pages/js/functions-definitions.html")}}

- - - -

Sintaxe

- -
var obj = {
-  propriedade( parametros… ) {},
-  *generator( parametros… ) {},
-// também com chaves computadas:
-  [propriedade]( parameters… ) {},
-  *[generator]( parametros… ) {},
-// compare ES5 sintaxe para getter/setter:
-  get propriedade() {},
-  set propriedade(valor) {}
-};
-
- -

Descrição

- -

A sintaxe reduzida é similar à da getter e setter  introduzida no ECMAScript 5.

- -

Dado o seguinte código:

- -
var obj = {
-  foo: function() {},
-  bar: function() {}
-};
- -

Agora você pode reduzi-lo para isto:

- -
var obj = {
-  foo() {},
-  bar() {}
-};
- -

Generator methods

- -

Os generator methods também podem ser definidos utilizando a sintaxe reduzida.

- - - -
// Utilizando a propriedade com nome (pre-ES6)
-var obj2 = {
-  g: function*() {
-    var indice = 0;
-    while(true)
-      yield indice++;
-  }
-};
-
-// O mesmo objeto utilizando a sintaxe reduzida
-var obj2 = {
-  * g() {
-    var indice = 0;
-    while(true)
-      yield indice++;
-  }
-};
-
-var coisa = obj2.g();
-console.log(coisa.next().value); // 0
-console.log(coisa.next().value); // 1
- -

Métodos assíncronos

- -

{{jsxref("Statements/funcoes_assincronas", "Funções assíncronas", "", 1)}} também podem ser definidas usando a sintaxe reduzida.

- -
// Utilizando a propriedade com nome (pre-ES6)
-var obj3 = {
-  f: async function () {
-    await alguma_promise;
-  }
-};
-
-// O mesmo objeto com a sintaxe reduzida
-var obj3 = {
-  async f() {
-    await alguma_promise;
-  }
-};
- -

Generator methods assíncronos

- -

  Os generator methods também podem ser {{jsxref("Statements/funcoes_assincronas", "assíncronos", "", 1)}}

- -
var obj4 = {
-  f: async function* () {
-    yield 1;
-    yield 2;
-    yield 3;
-  }
-};
-
-// O mesmo objeto com a sintaxe reduzida
-var obj4 = {
-  async* f() {
-   yield 1;
-   yield 2;
-   yield 3;
-  }
-};
- -

Métodos reduzidos não são construíveis

- -

Métodos assim definidos não são construtores e lançarão um {{jsxref("TypeError")}} se você tentar instanciá-los.

- -
var obj = {
-  metodo() {},
-};
-new obj.metodo; // TypeError: obj.method is not a constructor
-
-var obj = {
-  * g() {}
-};
-new obj.g; // TypeError: obj.g is not a constructor (modificado no ES2016)
-
- -

Exemplos

- -

Caso de teste simples

- -
var obj = {
-  a : "foo",
-  b(){ return this.a; }
-};
-console.log(obj.b()); // "foo"
-
- -

Nome de propriedades computados

- -

A sintaxe reduzida também suporta nome de propriedades computados.

- -
var bar = {
-  foo0 : function (){return 0;},
-  foo1(){return 1;},
-  ["foo" + 2](){return 2;},
-};
-
-console.log(bar.foo0()); // 0
-console.log(bar.foo1()); // 1
-console.log(bar.foo2()); // 2
- -

Especificações

- - - - - - - - - - - - - - - - - - - -
EspecificaçõesEstadoComentário
{{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}{{Spec2('ES6')}}Initial definition.
{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}{{Spec2('ESDraft')}} 
- -

Compatibilidade de browser

- - - -

{{Compat("javascript.functions.method_definitions")}}

- -

Veja também

- - diff --git a/files/pt-br/web/javascript/reference/functions/method_definitions/index.html b/files/pt-br/web/javascript/reference/functions/method_definitions/index.html new file mode 100644 index 0000000000..ac02cb9deb --- /dev/null +++ b/files/pt-br/web/javascript/reference/functions/method_definitions/index.html @@ -0,0 +1,200 @@ +--- +title: Definições de Método +slug: Web/JavaScript/Reference/Functions/Definicoes_metodos +tags: + - ECMAScript 2015 + - Funções + - JavaScript + - Objeto + - Sintaxe +translation_of: Web/JavaScript/Reference/Functions/Method_definitions +--- +
{{JsSidebar("Functions")}}
+ +

No ECMAScript 2015 foi introduzida uma sintaxe reduzida para definição de métodos em inicializadores de objetos. É uma abreviação para uma função atribuída ao nome do método.

+ +

{{EmbedInteractiveExample("pages/js/functions-definitions.html")}}

+ + + +

Sintaxe

+ +
var obj = {
+  propriedade( parametros… ) {},
+  *generator( parametros… ) {},
+// também com chaves computadas:
+  [propriedade]( parameters… ) {},
+  *[generator]( parametros… ) {},
+// compare ES5 sintaxe para getter/setter:
+  get propriedade() {},
+  set propriedade(valor) {}
+};
+
+ +

Descrição

+ +

A sintaxe reduzida é similar à da getter e setter  introduzida no ECMAScript 5.

+ +

Dado o seguinte código:

+ +
var obj = {
+  foo: function() {},
+  bar: function() {}
+};
+ +

Agora você pode reduzi-lo para isto:

+ +
var obj = {
+  foo() {},
+  bar() {}
+};
+ +

Generator methods

+ +

Os generator methods também podem ser definidos utilizando a sintaxe reduzida.

+ + + +
// Utilizando a propriedade com nome (pre-ES6)
+var obj2 = {
+  g: function*() {
+    var indice = 0;
+    while(true)
+      yield indice++;
+  }
+};
+
+// O mesmo objeto utilizando a sintaxe reduzida
+var obj2 = {
+  * g() {
+    var indice = 0;
+    while(true)
+      yield indice++;
+  }
+};
+
+var coisa = obj2.g();
+console.log(coisa.next().value); // 0
+console.log(coisa.next().value); // 1
+ +

Métodos assíncronos

+ +

{{jsxref("Statements/funcoes_assincronas", "Funções assíncronas", "", 1)}} também podem ser definidas usando a sintaxe reduzida.

+ +
// Utilizando a propriedade com nome (pre-ES6)
+var obj3 = {
+  f: async function () {
+    await alguma_promise;
+  }
+};
+
+// O mesmo objeto com a sintaxe reduzida
+var obj3 = {
+  async f() {
+    await alguma_promise;
+  }
+};
+ +

Generator methods assíncronos

+ +

  Os generator methods também podem ser {{jsxref("Statements/funcoes_assincronas", "assíncronos", "", 1)}}

+ +
var obj4 = {
+  f: async function* () {
+    yield 1;
+    yield 2;
+    yield 3;
+  }
+};
+
+// O mesmo objeto com a sintaxe reduzida
+var obj4 = {
+  async* f() {
+   yield 1;
+   yield 2;
+   yield 3;
+  }
+};
+ +

Métodos reduzidos não são construíveis

+ +

Métodos assim definidos não são construtores e lançarão um {{jsxref("TypeError")}} se você tentar instanciá-los.

+ +
var obj = {
+  metodo() {},
+};
+new obj.metodo; // TypeError: obj.method is not a constructor
+
+var obj = {
+  * g() {}
+};
+new obj.g; // TypeError: obj.g is not a constructor (modificado no ES2016)
+
+ +

Exemplos

+ +

Caso de teste simples

+ +
var obj = {
+  a : "foo",
+  b(){ return this.a; }
+};
+console.log(obj.b()); // "foo"
+
+ +

Nome de propriedades computados

+ +

A sintaxe reduzida também suporta nome de propriedades computados.

+ +
var bar = {
+  foo0 : function (){return 0;},
+  foo1(){return 1;},
+  ["foo" + 2](){return 2;},
+};
+
+console.log(bar.foo0()); // 0
+console.log(bar.foo1()); // 1
+console.log(bar.foo2()); // 2
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçõesEstadoComentário
{{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}{{Spec2('ES6')}}Initial definition.
{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade de browser

+ + + +

{{Compat("javascript.functions.method_definitions")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/functions/parametros_predefinidos/index.html b/files/pt-br/web/javascript/reference/functions/parametros_predefinidos/index.html deleted file mode 100644 index 82dc54abd8..0000000000 --- a/files/pt-br/web/javascript/reference/functions/parametros_predefinidos/index.html +++ /dev/null @@ -1,210 +0,0 @@ ---- -title: Parâmetros Predefinidos -slug: Web/JavaScript/Reference/Functions/Parametros_Predefinidos -tags: - - ECMA2015 - - ECMAScript6 - - Function - - Functions - - Função - - Funções - - JavaScript -translation_of: Web/JavaScript/Reference/Functions/Default_parameters ---- -
{{jsSidebar("Functions")}}
- -

Os parâmetros predefinidos de uma função permitem que parâmetros regulares sejam inicializados com com valores iniciais caso undefined ou nenhum valor seja passado.

- -

Sintaxe

- -
function [nome]([param1[ = valorPredefinido1 ][, ..., paramN[ = valorPredefinidoN ]]]) {
-   instruções
-}
-
- -

Descrição

- -

Em JavaScript, os parâmetros de funções tem {{jsxref("undefined")}} como valor predefinido. Contudo, em alguns casos pode ser útil utilizar algum outro valor. É nesta situação em que os parâmetros predefinidos podem ser úteis.

- -

No passado, a estratégia de definir valores padrão para parâmetros era testar os valores do parâmetros no corpo da função e atribuir um valor se este for undefined. No exemplo a seguir, se nenhum valor for fornecido para b na chamada, este valor será undefined, quando a*b for calculado resultaria em NaN. No entanto, isto é capturado na segunda linha definindo um valor padrão para b:

- -
function multiply(a, b) {
-  b = (typeof b !== 'undefined') ? b : 1;
-
-  return a * b;
-}
-
-multiply(5, 2); // 10
-multiply(5, 1); // 5
-multiply(5);    // 5
-
- -

Com o parâmetros predefinidos a checagem no corpo da função nao é mais necessária. Agora você pode simplesmente colocar 1 como valor padrão para b na declaração da função:

- -
function multiply(a, b = 1) {
-  return a * b;
-}
-
-multiply(5, 2); // 10
-multiply(5, 1); // 5
-multiply(5);    // 5
- -

Exemplos

- -

Passando undefined vs. outros valores "falsy"

- -

Na segunda chamada aqui, mesmo se o segundo argumento é definido explicitamente como undefined (com exceção de null) quando chamado, o valor para o argumento num será o padrão.

- -
function test(num = 1) {
-  console.log(typeof num);
-}
-
-test();          // 'number' (num é definido para 1)
-test(undefined); // 'number' (num é definido para 1 também)
-
-// teste com outros values "falsy":
-test('');        // 'string' (num é definido para '')
-test(null);      // 'object' (num é definido para null)
- -

Avaliado em tempo de chamada

- -

Os parâmetros predefinidos são avaliados no momento da chamada da função, então diferente de ex.: Python, um novo objeto é criado cada vez que a funçao é chamada.

- -
function append(value, array = []) {
-  array.push(value);
-  return array;
-}
-
-append(1); //[1]
-append(2); //[2], not [1, 2]
-
-
- -

Este mesmo comportamento é aplicado para funções e variáveis:

- -
function callSomething(thing = something()) { return thing }
-
-function something(){
-  return "sth";
-}
-
-callSomething();  //sth
- -

Parâmetros predefinidos estão disponíveis para os parâmetros seguintes à sua definição

- -

Parâmetros que já foram avaliados ficam disponíveis para uso para os parâmetros seguintes:

- -
function singularAutoPlural(singular, plural = singular+"s",
-                            rallyingCry = plural + " ATTACK!!!") {
-  return [singular, plural, rallyingCry ];
-}
-
-//["Gecko","Geckos", "Geckos ATTACK!!!"]
-singularAutoPlural("Gecko");
-
-//["Fox","Foxes", "Foxes ATTACK!!!"]
-singularAutoPlural("Fox","Foxes");
-
-//["Deer", "Deer", "Deer ... change."]
-singularAutoPlural("Deer", "Deer", "Deer peaceably and respectfully
-   petition the government for positive change.")
-
- -

Esta funcionalidade torna-se uma maneira direta e demonstra quantos casos extremos são manipulados.

- -
function go() {
-  return ":P"
-}
-
-function withDefaults(a, b = 5, c = b, d = go(), e = this,
-                      f = arguments, g = this.value) {
-  return [a,b,c,d,e,f,g];
-}
-function withoutDefaults(a, b, c, d, e, f, g){
-  switch(arguments.length){
-    case 0:
-      a
-    case 1:
-      b = 5
-    case 2:
-      c = b
-    case 3:
-      d = go();
-    case 4:
-      e = this
-    case 5:
-      f = arguments
-    case 6:
-      g = this.value;
-    default:
-  }
-  return [a,b,c,d,e,f,g];
-}
-
-withDefaults.call({value:"=^_^="});
-// [undefined, 5, 5, ":P", window, arguments, "=^_^="]
-
-
-withoutDefaults.call({value:"=^_^="});
-// [undefined, 5, 5, ":P", window, arguments, "=^_^="]
-
- -

Funções definidadas dentro do corpo da função

- -

Introduzido no Gecko 33 {{geckoRelease(33)}}. Funções declaradas no corpo da função não podem ser referenciada dentro de parâmetos padrão e lançará um {{jsxref("ReferenceError")}} (atualmente um {{jsxref("TypeError")}} no SpiderMonkey, veja {{bug(1022967)}}). Parâmetros padrão são sempre executados primeiro, declarações de funções dentro do corpo de outra função são avaliadas depois.

- -
// Não funciona! Throws ReferenceError.
-function f(a = go()) {
-  function go(){return ":P"}
-}
-
- -

Parâmetros sem valor padrão depois de parâmetros com valores padrão

- -

Antes do Gecko 26 {{geckoRelease(26)}}, o seguinte código resultaria em um {{jsxref("SyntaxError")}}. Isto foi corrigido no {{bug(777060)}} e funciona como esperado em versões posteriores:

- -
function f(x=1, y) {
-  return [x, y];
-}
-
-f(); // [1, undefined]
-
- -

Parâmetro desestruturado com valores padrões

- -

É possível definir valores padrões com a notação destructuring assignment:

- -
function f([x, y] = [1, 2], {z: z} = {z: 3}) {
-  return x + y + z;
-}
-
-f(); // 6
- -

Especificações

- - - - - - - - - - - - - - -
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-function-definitions', 'Function Definitions')}}{{Spec2('ES6')}}Definição Inicial.
- -

Compatibilidade nos navegadores

- -
-

{{Compat("javascript.functions.default_parameters")}}

-
- -

Veja também

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