From 55841ee288aed8690c751fbaa1de2398579d2145 Mon Sep 17 00:00:00 2001 From: fernandoors Date: Tue, 2 Jul 2019 18:55:23 -0300 Subject: [PATCH 1/3] TRANSLETE: FROM EN TO PT-BR --- .../what-is-the-arguments-object.md | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md diff --git a/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md b/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md new file mode 100644 index 0000000000000..830f7fbe6b3d9 --- /dev/null +++ b/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md @@ -0,0 +1,51 @@ +Os objetos `arguments` são uma estrutura especial disponível dentro de todas as chamadas de função. É representada como uma lista de argumentos que são passadas quando a função é chamada. Desde que JavaScript permite chamar funções com indeterminado número de argumentos, nós precisamos de um método para descobrir e acessar esses argumentos. + +Os objetos `arguments` são um tipo de objeto array. Seu tamanho corresponde a quantidade de argumentos passados para a função e que é possível acessar seu valor através de indexação do Array. Exemplo `arguments[0]` //Captura ao primeiro argumento. Existe apenas mais uma propriedade de `arguments` chamado `callee`, que o ES5 impede o uso do `strict mode` mais informações podem ser encontradas [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee). Veja mais exemplos sobre as propriedades `arguments`. + +```js +const minhaFunc = function(primeiro) { + arguments[0] === primeiro; + arguments[1] === 2; + arguments.length === 3; +} + +minhaFunc(1, 2, 3); +``` +```js +const locais = function() { +console.log( + arguments[0] === ‘casa’, // return true + arguments[1] === ‘escritório’ , // return false + arguments.length < 4 // return true +) +} + +locais('casa', 'praia', 'fazenda'); +``` +NOTA: Para ES5 ou anteriores, o loop `for` serve para coletar os dados dos `arguments` + +Em alguns casos você ainda pode tratar o `arguments` como um Array. Você pode usar o `arguments` através de funções dinâmicas. Os métodos nativos do Array (Ex. Array.prototype.concat) serão aceitos para tratar os `arguments` dinamicamente. Essa técnica também oferece outros modos de conversão dos `arguments` para um tipo Array utilizando do método `Array.slice`. + +```js +const minhaFunc = function(primeiro) {...} +minhaFunc.apply(obj, arguments). + +// Concatena o Array com os `arguments` +Array.prototype.concat.apply([1,2,3], arguments); + +// altera os `arguments` para um tipo Array +const args = Array.prototype.slice.call(arguments); + +// remova o primeiro item de `arguments` +args = Array.prototype.slice.call(arguments, 1); +``` + +O `arrow functions` foram adicionados no ECMAScript 2015 (ES6), propondo uma sintaxe mais compacta do que em sua versão anterior. Com isso, houve um modo alternativo para tratar os `arguments` o convertendo para `arguments objects` (além das palavras chaves `this`, `super`, e `new.target`). A solução para esse caso de uso é utilizar `rest parameter`. O `rest parameter` permite que representar um indeterminado numero de argumentos como um tipo Array. Leia mais detalhes [aqui](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters). + +```js +const minhaFunc = (...args) => { + console.log('first parameter is ', args[0]); +} + +minhaFunc(1, 2, 3); +``` From ea0bc970f535066430181150623ebb3eb9f13386 Mon Sep 17 00:00:00 2001 From: fernandoors Date: Thu, 4 Jul 2019 10:45:36 -0300 Subject: [PATCH 2/3] nodejs-pt-br: Add file translated arguments-object file full name: what-is-the-arguments-object.md --- .../what-is-the-arguments-object.md | 83 ++++++++++++++----- 1 file changed, 63 insertions(+), 20 deletions(-) diff --git a/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md b/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md index 830f7fbe6b3d9..237951dc5b63f 100644 --- a/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md +++ b/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md @@ -1,51 +1,94 @@ -Os objetos `arguments` são uma estrutura especial disponível dentro de todas as chamadas de função. É representada como uma lista de argumentos que são passadas quando a função é chamada. Desde que JavaScript permite chamar funções com indeterminado número de argumentos, nós precisamos de um método para descobrir e acessar esses argumentos. +--- +date: '2011-08-26T10:08:50.000Z' +tags: + - truthy + - falsy + - types + - coercion +title: What is the arguments object? +difficulty: 4 +layout: knowledge-post.hbs +--- -Os objetos `arguments` são um tipo de objeto array. Seu tamanho corresponde a quantidade de argumentos passados para a função e que é possível acessar seu valor através de indexação do Array. Exemplo `arguments[0]` //Captura ao primeiro argumento. Existe apenas mais uma propriedade de `arguments` chamado `callee`, que o ES5 impede o uso do `strict mode` mais informações podem ser encontradas [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee). Veja mais exemplos sobre as propriedades `arguments`. +Os objetos `arguments` são uma estrutura especial disponível dentro de todas as chamadas de função e que é representada como uma lista de argumentos que são passadas quando a função é chamada. Desde que JavaScript permite chamar funções com indeterminado número de argumentos, nós precisamos de um método para descobrir e acessar esses argumentos. + +Os objetos `arguments` são um tipo de objeto array, seu tamanho corresponde a quantidade de argumentos passados para a função e que é possível acessar seu valor através de indexação do Array. Exemplo `arguments[0]` //Captura ao primeiro argumento. Existe apenas mais uma propriedade de `arguments` chamada `callee`, Nota: o ES5 impede o uso do `strict mode` mais informações podem ser encontradas [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee). Veja mais exemplos sobre as propriedades `arguments`. ```js const minhaFunc = function(primeiro) { - arguments[0] === primeiro; - arguments[1] === 2; - arguments.length === 3; + const index0 = arguments[0] === primeiro; + const index1 = arguments[1] === 2; + const argumentsLength = arguments.length === 3; + return console.log(index0, index1, argumentsLength) } - minhaFunc(1, 2, 3); +// expectativa de retorno no console: true | true | true ``` ```js const locais = function() { -console.log( - arguments[0] === ‘casa’, // return true - arguments[1] === ‘escritório’ , // return false - arguments.length < 4 // return true -) + console.log( + arguments[0] === ‘casa’, // return true + arguments[1] === ‘escritório’ , // return false + arguments.length < 4 // return true + ) } locais('casa', 'praia', 'fazenda'); +// expectativa de retorno no console: true | false | true ``` -NOTA: Para ES5 ou anteriores, o loop `for` serve para coletar os dados dos `arguments` -Em alguns casos você ainda pode tratar o `arguments` como um Array. Você pode usar o `arguments` através de funções dinâmicas. Os métodos nativos do Array (Ex. Array.prototype.concat) serão aceitos para tratar os `arguments` dinamicamente. Essa técnica também oferece outros modos de conversão dos `arguments` para um tipo Array utilizando do método `Array.slice`. +NOTA: Para ES5 ou anteriores, o loop `for` serve para coletar os dados dos `arguments` ```js -const minhaFunc = function(primeiro) {...} -minhaFunc.apply(obj, arguments). +function casa(){ + for (locais in arguments){ + console.log(arguments[locais]) + } + return arguments.length +} +casa('quarto', 'banheiro', 'sala') +// expectativa de retorno no console: quarto | banheiro | sala | 3 +``` +Em alguns casos você ainda pode tratar o `arguments` como um Array, neste caso você pode usar o `arguments` através de funções dinâmicas. Os métodos nativos do Array (Ex. Array.prototype.concat) serão aceitos para tratar os `arguments` dinamicamente. Essa técnica também oferece outros modos de conversão dos `arguments` para um tipo Array utilizando do método `Array.slice`. +```js +const minhaFunc = function(primeiro) {... + minhaFunc.apply(obj, arguments). +} // Concatena o Array com os `arguments` -Array.prototype.concat.apply([1,2,3], arguments); +const minhaFunc = function(primeiro) { + return console.log(Array.prototype.concat.apply([1, 2, 3], arguments)) +} +// expectativa de retorno no console: [ 1, 2, 3, 'PIN' ] + +minhaFunc('PIN') // altera os `arguments` para um tipo Array -const args = Array.prototype.slice.call(arguments); +const minhaFunc = function(primeiro) { + return console.log(Array.prototype.slice.call(arguments)) +} + +minhaFunc(1,2,3,'PIN',5,6,7) +// expectativa de retorno no console: [ 1, 2, 3, 'PIN', 5, 6, 7 ] // remova o primeiro item de `arguments` -args = Array.prototype.slice.call(arguments, 1); +const minhaFunc = function(primeiro) { + return console.log( Array.prototype.slice.call(arguments, 1)) +} + +minhaFunc(1,2,3,'PIN',5,6,7) +// expectativa de retorno no console: [ 2, 3, 'PIN', 5, 6, 7 ] + ``` -O `arrow functions` foram adicionados no ECMAScript 2015 (ES6), propondo uma sintaxe mais compacta do que em sua versão anterior. Com isso, houve um modo alternativo para tratar os `arguments` o convertendo para `arguments objects` (além das palavras chaves `this`, `super`, e `new.target`). A solução para esse caso de uso é utilizar `rest parameter`. O `rest parameter` permite que representar um indeterminado numero de argumentos como um tipo Array. Leia mais detalhes [aqui](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters). +O `arrow functions` foram adicionados no ECMAScript 2015 (ES6), propondo uma sintaxe mais compacta do que em sua versão anterior. Com isso, houve um modo alternativo para tratar os `arguments` o convertendo para `arguments objects` (além das palavras chaves `this`, `super`, e `new.target`). A solução para esse caso de uso é utilizar `rest parameter`. O `rest parameter` permite representar um indeterminado numero de argumentos como um tipo Array. Leia mais detalhes [aqui](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters). ```js const minhaFunc = (...args) => { - console.log('first parameter is ', args[0]); + console.log('O parâmetro é ', args[0]); } minhaFunc(1, 2, 3); +// expectativa de retorno no console: "O parâmetro é 1" + ``` From 50a8e8c3780cb070e802a640cfd3f5a6c4edcd90 Mon Sep 17 00:00:00 2001 From: fernandoors Date: Tue, 13 Aug 2019 16:29:30 -0300 Subject: [PATCH 3/3] TRANSLATE: APPLYING COMMUNITY'S SUGGESTIONS --- .../what-is-the-arguments-object.md | 90 +++++++------------ 1 file changed, 31 insertions(+), 59 deletions(-) diff --git a/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md b/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md index 237951dc5b63f..6008f1522310f 100644 --- a/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md +++ b/locale/pt-br/knowledge/javascript-conventions/what-is-the-arguments-object.md @@ -10,85 +10,57 @@ difficulty: 4 layout: knowledge-post.hbs --- -Os objetos `arguments` são uma estrutura especial disponível dentro de todas as chamadas de função e que é representada como uma lista de argumentos que são passadas quando a função é chamada. Desde que JavaScript permite chamar funções com indeterminado número de argumentos, nós precisamos de um método para descobrir e acessar esses argumentos. +O objeto `arguments` é uma estrutura especial disponível dentro de todas as chamadas de função. É representada como uma lista de argumentos que são passados quando a função é chamada. Uma vez que o JavaScript permite chamar funções com indeterminado número indeterminado de argumentos, nós precisamos de um método para descobrir e acessar esses argumentos. -Os objetos `arguments` são um tipo de objeto array, seu tamanho corresponde a quantidade de argumentos passados para a função e que é possível acessar seu valor através de indexação do Array. Exemplo `arguments[0]` //Captura ao primeiro argumento. Existe apenas mais uma propriedade de `arguments` chamada `callee`, Nota: o ES5 impede o uso do `strict mode` mais informações podem ser encontradas [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee). Veja mais exemplos sobre as propriedades `arguments`. +O objeto `arguments` é um array-like, seu tamanho corresponde a quantidade de argumentos passados para a função. É possível acessar estes valores através da indexação do Array. Exemplo: `arguments[0]` captura o primeiro argumento. A única outra propriedade de `arguments` é chamada `callee`, a qual o ES5 impede o uso no `strict mode`, mais informações podem ser encontradas [aqui](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee). +Veja mais exemplos sobre as propriedades de `arguments`. ```js -const minhaFunc = function(primeiro) { - const index0 = arguments[0] === primeiro; - const index1 = arguments[1] === 2; - const argumentsLength = arguments.length === 3; - return console.log(index0, index1, argumentsLength) -} -minhaFunc(1, 2, 3); -// expectativa de retorno no console: true | true | true -``` -```js -const locais = function() { - console.log( - arguments[0] === ‘casa’, // return true - arguments[1] === ‘escritório’ , // return false - arguments.length < 4 // return true - ) +const myfunc = function(one) { + arguments[0] === one; + arguments[1] === 2; + arguments.length === 3; } -locais('casa', 'praia', 'fazenda'); -// expectativa de retorno no console: true | false | true +myfunc(1, 2, 3); ``` -NOTA: Para ES5 ou anteriores, o loop `for` serve para coletar os dados dos `arguments` - -```js -function casa(){ - for (locais in arguments){ - console.log(arguments[locais]) - } - return arguments.length -} -casa('quarto', 'banheiro', 'sala') -// expectativa de retorno no console: quarto | banheiro | sala | 3 -``` -Em alguns casos você ainda pode tratar o `arguments` como um Array, neste caso você pode usar o `arguments` através de funções dinâmicas. Os métodos nativos do Array (Ex. Array.prototype.concat) serão aceitos para tratar os `arguments` dinamicamente. Essa técnica também oferece outros modos de conversão dos `arguments` para um tipo Array utilizando do método `Array.slice`. +Essa construção é muito útil e fornece muitas funções ao JavaScript. Mas há uma pegadinha. O objeto `arguments` se comporta como um tipo array, porém ele não é realmente um array. Ele não têm as funcionalidades que o Array herda de Array.prototype e não responde a nenhum método de array, exemplo. `arguments.sort()` gera um TypeError. Em vez disso, você precisa copiar os valores para um array verdadeiro. +Com o advento do ES6 o método `Array.from()` torna isso bastante simples. ```js -const minhaFunc = function(primeiro) {... - minhaFunc.apply(obj, arguments). +const myfunc = function(a, b, c) { + const args = Array.from(arguments); + console.log(args) // [1, 2, 3] } -// Concatena o Array com os `arguments` -const minhaFunc = function(primeiro) { - return console.log(Array.prototype.concat.apply([1, 2, 3], arguments)) -} -// expectativa de retorno no console: [ 1, 2, 3, 'PIN' ] -minhaFunc('PIN') +myfunc(1, 2, 3); +``` +NOTA: Para ES5 e anteriores, um loop `for` normal pode fazer o truque -// altera os `arguments` para um tipo Array -const minhaFunc = function(primeiro) { - return console.log(Array.prototype.slice.call(arguments)) -} +Em alguns casos você ainda pode tratar o `arguments` como um Array, você pode usar o `arguments` através de invocações de funções dinâmicas. E a maioria dos métodos nativos Array (Ex. Array.prototype.concat) aceitarão `arguments` quando invocados dinamicamente utilizando `call` ou `apply`. Essa técnica também oferece outros modos de conversão dos `arguments` para um tipo Array utilizando método `Array.slice`. -minhaFunc(1,2,3,'PIN',5,6,7) -// expectativa de retorno no console: [ 1, 2, 3, 'PIN', 5, 6, 7 ] +```js +myfunc.apply(obj, arguments). -// remova o primeiro item de `arguments` -const minhaFunc = function(primeiro) { - return console.log( Array.prototype.slice.call(arguments, 1)) -} +// concat arguments onto the +Array.prototype.concat.apply([1,2,3], arguments); -minhaFunc(1,2,3,'PIN',5,6,7) -// expectativa de retorno no console: [ 2, 3, 'PIN', 5, 6, 7 ] +// turn arguments into a true array +const args = Array.prototype.slice.call(arguments); +// cut out first argument +args = Array.prototype.slice.call(arguments, 1); ``` -O `arrow functions` foram adicionados no ECMAScript 2015 (ES6), propondo uma sintaxe mais compacta do que em sua versão anterior. Com isso, houve um modo alternativo para tratar os `arguments` o convertendo para `arguments objects` (além das palavras chaves `this`, `super`, e `new.target`). A solução para esse caso de uso é utilizar `rest parameter`. O `rest parameter` permite representar um indeterminado numero de argumentos como um tipo Array. Leia mais detalhes [aqui](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters). +### Objeto Argments em arrow function + +As `arrow functions` foram adicionadas na especificação do ECMAScript 2015 (ES6), propondo uma alternativa mais compacta do que a declaração de uma função comum. A desvantagem dessa alternativa é que não existe mais o objecto `arguments` (e também as keywords `this`, `super` ou `new.target`). A solução para esses casos é o uso dos parâmetros `rest`. Os parâmetros `rest` permitem representar um número indeterminado de argumentos como um Array. Leia mais detalhes [aqui](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters). ```js -const minhaFunc = (...args) => { - console.log('O parâmetro é ', args[0]); +const myfunc = (...args) => { + console.log('first parameter is ', args[0]); } -minhaFunc(1, 2, 3); -// expectativa de retorno no console: "O parâmetro é 1" - +myfunc(1, 2, 3); ```