From a065e04d529da1d847b5062a12c46d916408bf32 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 21:46:22 -0500 Subject: update based on https://github.com/mdn/yari/issues/2028 --- .../operators/array_comprehensions/index.html | 207 --------------------- .../operators/expression_closures/index.html | 72 ------- .../operators/generator_comprehensions/index.html | 169 ----------------- 3 files changed, 448 deletions(-) delete mode 100644 files/pt-br/web/javascript/reference/operators/array_comprehensions/index.html delete mode 100644 files/pt-br/web/javascript/reference/operators/expression_closures/index.html delete mode 100644 files/pt-br/web/javascript/reference/operators/generator_comprehensions/index.html (limited to 'files/pt-br/web/javascript/reference/operators') diff --git a/files/pt-br/web/javascript/reference/operators/array_comprehensions/index.html b/files/pt-br/web/javascript/reference/operators/array_comprehensions/index.html deleted file mode 100644 index c035f757d7..0000000000 --- a/files/pt-br/web/javascript/reference/operators/array_comprehensions/index.html +++ /dev/null @@ -1,207 +0,0 @@ ---- -title: Array comprehensions -slug: Web/JavaScript/Reference/Operators/Array_comprehensions -tags: - - Array - - ECMAScript7 - - JavaScript - - Operador -translation_of: Archive/Web/JavaScript/Array_comprehensions ---- -

{{jsSidebar("Operators")}}

- -

Sumário

- -

 

- -

A sintaxe de array comprehension trata-se de uma expressão JavaScript que lhe permite rapidamente montar um novo array com base em outro já existente. As comprehensions já existem em várias outras linguagens e estarão então presentes no padrão ECMAScript 7.

- -

Veja abaixo as diferenças para a antiga implementação no SpiderMOnkey, baseado nas propostas para o ECMAScript 4.

- -

Sintaxe

- -
[for (x of iterable) x]
-[for (x of iterable) if (condition) x]
-[for (x of iterable) for (y of iterable) x + y]
-
- -

Descrição

- -

Dentro de array comprehensions dois tipos de components são permitidos: 

- - - -

A iteração por for-of deve sempre, ser a primeira componente. Multiplos for-of ou ifs podem  também ser permitidos.

- -

Exemplos

- -

Array comprehensions simples

- -
[for (i of [ 1, 2, 3 ]) i*i ];
-// [ 1, 4, 9 ]
-
-var abc = [ "A", "B", "C" ];
-[for (letters of abc) letters.toLowerCase()];
-// [ "a", "b", "c" ]
- -

Array comprehensions com if

- -
var years = [ 1954, 1974, 1990, 2006, 2010, 2014 ];
-[for (year of years) if (year > 2000) year];
-// [ 2006, 2010, 2014 ]
-[for (year of years) if (year > 2000) if(year < 2010) year];
-// [ 2006], the same as below:
-[for (year of years) if (year > 2000 && year < 2010) year];
-// [ 2006]
-
- -

Array comprehensions comparado a map e filter

- -

Um modo fácil de entender a sintaxe de array comprehension é comparar com os métodos {{jsxref("Array.map", "map")}} e {{jsxref("Array.filter", "filter")}}:

- -
var numbers = [ 1, 2, 3 ];
-
-numbers.map(function (i) { return i * i });
-[for (i of numbers) i*i ];
-// both is [ 1, 4, 9 ]
-
-numbers.filter(function (i) { return i < 3 });
-[for (i of numbers) if (i < 3) i];
-// both is [ 1, 2 ]
-
- -

Array comprehensions com dois arrays

- -

Utilizando dois iteradores for-of, com dois arrays:

- -
var numbers = [ 1, 2, 3 ];
-var letters = [ "a", "b", "c" ];
-
-var cross = [for (i of numbers) for (j of letters) i+j];
-// [ "1a", "1b", "1c", "2a", "2b", "2c", "3a", "3b", "3c" ]
-
-var grid = [for (i of numbers) [for (j of letters) i+j]];
-// [
-//  ["1a", "1b", "1c"],
-//  ["2a", "2b", "2c"],
-//  ["3a", "3b", "3c"]
-// ]
-
-[for (i of numbers) if (i > 1) for (j of letters) if(j > "a") i+j]
-// ["2b", "2c", "3b", "3c"], the same as below:
-
-[for (i of numbers) for (j of letters) if (i > 1) if(j > "a") i+j]
-// ["2b", "2c", "3b", "3c"]
-
-[for (i of numbers) if (i > 1) [for (j of letters) if(j > "a") i+j]]
-// [["2b", "2c"], ["3b", "3c"]], not the same as below:
-
-[for (i of numbers) [for (j of letters) if (i > 1) if(j > "a") i+j]]
-// [[], ["2b", "2c"], ["3b", "3c"]]
-
- -

Especificações

- - - - - - - - - - - - - - -
SpecificationStatusComment
Proposed for ECMAScript 7No draft available yetEstava inicialmente no rascunho para o ES6, porém foi removido na revisão 27 (Agosto, 2014). Veja as revisões antigas do ES6 para especificações de semântica. Uma versão atualizada estará de volta em um novo rascunho do ES7.
- -

Compatibilidade

- -

{{ CompatibilityTable() }}

- -
- - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{ CompatNo() }}{{ CompatGeckoDesktop("30") }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
-
- -
- - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{ CompatNo() }}{{ CompatNo() }}{{ CompatGeckoMobile("30") }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
-
- -

Notas sobre implementações para o SpiderMonkey

- - - -

Diferenças para as antiga JS1.7/JS1.8 comprehensions

- - - -

Veja Também

- - diff --git a/files/pt-br/web/javascript/reference/operators/expression_closures/index.html b/files/pt-br/web/javascript/reference/operators/expression_closures/index.html deleted file mode 100644 index afae2c0459..0000000000 --- a/files/pt-br/web/javascript/reference/operators/expression_closures/index.html +++ /dev/null @@ -1,72 +0,0 @@ ---- -title: Expression closures -slug: Web/JavaScript/Reference/Operators/Expression_closures -translation_of: Archive/Web/JavaScript/Expression_closures ---- -
{{JSSidebar("Operators")}}{{Non-standard_Header}}{{Obsolete_Header("gecko60")}} -
Não padronizado. Não use!
-A síntaxe expressão closure syntax é uma feature especifica ao Firefox que foi deprecada e foi removida a partir do Firefox 60. Para usos futuros considere usar arrow functions.
-
- -

Expressões fechamentos são uma  forma curta de sintaxe de função para escrever funções simples.

- -

Síntaxe

- -
function [nome]([param1[, param2[, ..., paramN]]])
-   expressão
-
- -

Parâmetros

- -
-
nome
-
O nome da função. Pode ser omitido, passando a ser nesse caso uma função anónima. O nome só é local ao corpo da função.
-
paramN
-
Nome do parâmetro a ser passado à função. Uma função pode receber até 255 argumentos.
-
expressão
-
A expressão pela qual o corpo da função é composta
-
- -

Descrição

- -

Esta adição é nada mais que uma maneira reduzida de escreve funções simples, dando à linguagem algo semelhante a Notação Lambda.

- -

JavaScript 1.7 e anterior:

- -
function(x) { return x * x; }
- -

JavaScript 1.8:

- -
function(x) x * x
- -

Esta Síntaxe permite omitir as chavetas e o 'return' - fazendo-os implícitos. Não benifício adicional em escrever código desta forma para além de ser sintáticamente reduzido.

- -

Exemplos

- -

Uma maneira reduzida de fazer bind de EventListeners:

- -
 document.addEventListener('click', function() false, true);
-
- -

Usando esta função com algumas funções de array do JavaScript 1.6:

- -
elems.some(function(elem) elem.type == 'text');
-
- -

Compatibilidade do Browser

- - - -

{{Compat("javascript.operators.expression_closures")}}

- -

Ver também

- - diff --git a/files/pt-br/web/javascript/reference/operators/generator_comprehensions/index.html b/files/pt-br/web/javascript/reference/operators/generator_comprehensions/index.html deleted file mode 100644 index 1cbfb286f4..0000000000 --- a/files/pt-br/web/javascript/reference/operators/generator_comprehensions/index.html +++ /dev/null @@ -1,169 +0,0 @@ ---- -title: Generator comprehensions -slug: Web/JavaScript/Reference/Operators/Generator_comprehensions -translation_of: Archive/Web/JavaScript/Generator_comprehensions ---- -
{{JSSidebar("Operators")}}{{Non-standard_Header}}{{Obsolete_Header("gecko58")}} -
-

Não padronizado. Não use!
- A sintaxe de generator comprehensions não é padronizada e foi removida a partir do Firefox 58. Para usos futuros, considere o uso de {{JSxRef ("Statements / function *", "generator", "", 1)}}.

-
-
- -

A sintaxe de generator comprehension foi uma expressão em JavaScript que permitia montar rapidamente um nova função geradora baseada em um objeto iterável existente. Porém, ela foi removida do padrão e da implementação Firefox. Não a use!

- -

Sintaxe

- -
(for (x of iterable) x)
-(for (x of iterable) if (condition) x)
-(for (x of iterable) for (y of iterable) x + y)
-
- -

Descrição

- -

Dentro de generator comprehensions, são permitidos dois tipos de componentes:

- - - -

A iteração for-of é sempre o primeiro componente. Várias iterações for-of or declarações if são permitidas.

- -

Uma desvantagem significativa das {{JSxRef("Operators/Array_comprehensions","array comprehensions","","true")}} é que elas causam a construção de um array inteiro na memória. Quando a entrada para a comprehension é em si um pequeno array ,a sobrecarga envolvida é insignificante — mas quando a entrada é um grande array ou um generator custoso (ou mesmo infinito), a criação de um novo array pode ser problemática.

- -

Geradores permitem o cálculo lento de sequências, com items calculados sob demanda conforme a necessidade. Generator comprehensions são sintaticamente quase idênticos aos array comprehensions — elas usam parênteses invés de chaves — mas invés de construir um array, criam um gerador que pode executar lentamente. Eles podem ser considerados como uma sintaxe abreviada para criar geradores

- -

Suponha que temos um interador it que itera sobre uma grande sequência de inteiros. Queremos criar um novo iterador que irá iterar sobre seus dobros. Um array comprehension criaria na memória um array completo contendo os valores dobrados:

- -
var doubles = [for (i in it) i * 2];
-
- -

Um generator comprehension por outro lado criaria um novo iterador que criaria valores dobrados sob demanda conforme a necessidade:

- -
var it2 = (for (i in it) i * 2);
-console.log(it2.next()); // O primeiro valor, duplicado
-console.log(it2.next()); // O segundo valor, duplicado
-
- -

Quando um generator comprehension é usado como um argumento para uma função, os parênteses usados para a chamada da função significam que os parênteses externos podem ser omitidos:

- -
var result = doSomething(for (i in it) i * 2);
-
- -

A diferença significativa entre os dois exemplos começam pelo uso da generator comprehension, você teria apenas que fazer um loop sobre a estrutura 'obj' uma vez, total, ao invés de uma vez ao compreender o array, e mais uma vez ao iterar sobre ele.

- -

Exemplos

- -

Simples generator comprehensions

- -
(for (i of [1, 2, 3]) i * i );
-// generator function which yields 1, 4, and 9
-
-[...(for (i of [1, 2, 3]) i * i )];
-// [1, 4, 9]
-
-var abc = ['A', 'B', 'C'];
-(for (letters of abc) letters.toLowerCase());
-// generator function which yields "a", "b", and "c"
-
- -

Generator comprehensions com declaração if

- -
var years = [1954, 1974, 1990, 2006, 2010, 2014];
-
-(for (year of years) if (year > 2000) year);
-// generator function which yields 2006, 2010, and 2014
-
-(for (year of years) if (year > 2000) if (year < 2010) year);
-// generator function which yields 2006, the same as below:
-
-(for (year of years) if (year > 2000 && year < 2010) year);
-// generator function which yields 2006
-
- -

Generator comprehensions comparadas à função geradora

- -

Um maneira fácil de entender a sintaxe de generator comprehension, é compará-la com a função geradora.

- -

Exemplo 1: Gerador simples.

- -
var numbers = [1, 2, 3];
-
-// Generator function
-(function*() {
-  for (let i of numbers) {
-    yield i * i;
-  }
-})();
-
-// Generator comprehension
-(for (i of numbers) i * i );
-
-// Result: both return a generator which yields [1, 4, 9]
-
- -

Exemplo 2: Usando if no gerador.

- -
var numbers = [1, 2, 3];
-
-// Generator function
-(function*() {
-  for (let i of numbers) {
-    if (i < 3) {
-      yield i * 1;
-    }
-  }
-})();
-
-// Generator comprehension
-(for (i of numbers) if (i < 3) i);
-
-// Result: both return a generator which yields [1, 2]
- -

Especificações

- -

As generator comprehensions estavam inicialmente no rascunho do ECMAScript 2015, mas foram removidas na revisão 27 (agosto de 2014). Por favor, veja as revisões mais antigas do ES2015 para a semântica de especificação.

- -

Compatibilidade do navegador

- - - -

{{Compat("javascript.operators.generator_comprehensions")}}

- -

Diferenças para as antigas JS1.7/JS1.8 comprehensions

- -
Comprehensions das versões JS1.7/JS1.8 foram removidas da Gecko 46 ({{bug(1220564)}}).
- -

Sintaxe antiga das comprehensions (não use mais!):

- -
(X for (Y in Z))
-(X for each (Y in Z))
-(X for (Y of Z))
-
- -

Diferenças:

- - - -

Veja também

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