Jun 8, 2020 · Jul 26, 2020 · Dec 11, 2020 · Dec 11, 2020 · May 29, 2021 · Jan 15, 2023
diff --git a/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md b/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md

 ```js run
 function ask(question, yes, no) {
  if (confirm(question)) yes()
  if (confirm(question)) yes();
  else no();
 }

 ask(
  "Do you agree?",
  "Você concorda?",
 *!*
  () => alert("You agreed."),
  () => alert("You canceled the execution.")
  () => alert("Você concordou."),
  () => alert("Você cancelou a execução.")
 */!*
 );
 ```

 Looks short and clean, right?
 Parece mais curto e claro, não?
diff --git a/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md b/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md

 #Rewrite witharrow functions
 #Reescreva com funções seta (*arrow functions*)

 Replace Function Expressions with arrow functions in the code below:
 Substitua as Expressões de Função por funções seta no código abaixo:

 ```js run
 function ask(question, yes, no) {
  if (confirm(question)) yes()
  if (confirm(question)) yes();
  else no();
 }

 ask(
  "Do you agree?",
  function() { alert("You agreed."); },
  function() { alert("You canceled the execution."); }
  "Você concorda?",
  function() { alert("Você concordou."); },
  function() { alert("Você cancelou a execução."); }
 );
 ```
diff --git a/1-js/02-first-steps/17-arrow-functions-basics/article.md b/1-js/02-first-steps/17-arrow-functions-basics/article.md
 #Funções seta, o básico
 #Arrow functions, o básico

 Existe outra sintaxe, muito simples econcisa, para criar funções, e quegeralmente é melhor do que Expressões de Função.
 Há outra sintaxe muito simples eabreviada para criar funções, e quefrequentemente é melhor do que Expressões de Função (*Function Expressions*).

 É chamada de "funções seta" (*"arrow functions"*), porquetem este aspeto:
 É chamada de "*arrow functions*" (funções seta), porqueé parecida com:

 ```js
 let func = (arg1, arg2, ...argN) => expression
 let func = (arg1, arg2, ...,argN) => expression;
 ```

 ...Isto, cria a função `func` com os argumentos `arg1..argN`,depoisavalia a `expression` no lado direitousando os mesmos, e retorna o seu resultado.
 ...Isto cria a função `func` com os argumentos `arg1..argN`,a seguiravalia a `expression` no lado direitocom eles, e retorna o resultado.

 Por outras palavras, é a versão mais curta de:

 ```js
 let func = function(arg1, arg2, ...argN) {
 let func = function(arg1, arg2, ...,argN) {
  return expression;
 };
 ```
 alert( sum(1, 2) ); // 3
 ```

 Como pode ver, `(a, b) => a + b` significa uma função que aceita dois argumentos, nomeadamente `a` e `b`. No momento da execução,esta avaliaa expressão `a + b`e retornao resultado.
 Comovocêpode ver `(a, b) => a + b` significa uma função que aceita dois argumentos, nomeadamente `a` e `b`. No momento da execução, a expressão `a + b`é avaliada eo resultado retornado.

 - Se tivermosapenasum argumento, então os parênteses à sua volta podem ser omitidos,tornando ela ainda mais curta.
 - Se tivermos umsóargumento, então os parênteses à sua volta podem ser omitidos,ficando ela ainda mais curta.

    Por exemplo:

    alert( double(3) ); // 6
    ```

 - Se não houver argumentos, os parêntesesirão estarvazios (mas devem estar presentes):
 - Se não houver argumentos, os parêntesesestarãovazios,mas devem estar presentes:

    ```js run
    let sayHi = () => alert("Olá!");

    sayHi();
    ```

 Funções seta podem serempregues da mesma forma queExpressões de Função.
 *Arrow functions* podem serutilizadas da mesma forma que*Function Expressions*.

 Por exemplo, para criar dinamicamente uma função:

 ```js run
 let age = prompt("Que idade tem?", 18);
 let age = prompt("Que idadevocêtem?", 18);

 let welcome = (age < 18) ?
  () => alert('Olá') :
 welcome();
 ```

 Funções seta podem parecernão familiarese não muito legíveis a princípio, mas issorápidamente muda à medida que os olhos se habituam à estrutura.
 *Funções seta* podem parecerestranhase não muito legíveis a princípio, mas issorapidamente muda à medida que os olhos se habituam à estrutura.

 Elas são muito convenientes para ações simplesnumaúnica-linha, quando estamospreguiçosos demais para escrever muitas palavras.
 Elas são muito convenientes para ações simplescom umaúnica-linha, quando estamosalgo ociosos para escrever muitas palavras.

 ## Funções seta de múltiplas linhas
 ##*Funções seta* com múltiplas linhas

 Os exemplos acimatomaram os argumentos à esquerda de `=>` e avaliarama expressão à direita com eles.
 As funções seta vistas até agora foram muito simples. Elastomaram os argumentos à esquerda de `=>`, e avaliarame retornaram o resultado da expressão à direita com eles.

 Por vezes, precisamos dealgoum pouco maiscomplexo, como demúltiplas expressõesou instruções.Isso também é possível, mas devemos colocar elas dentro dechavetas. Depois, usamos um `return`normal com elas.
 Por vezes, precisamos deuma funçãoum pouco maiscomplexa, commúltiplas expressõese instruções.Neste caso, nós as envolvemos entre chavetas. A maior diferença é que aschavetas precisam de um `return`dentro delas para retornar um valor (tal como uma função comum precisa).

 Desta forma:

 alert( sum(1, 2) ); // 3
 ```

 ```smart header="Maisà frente"
 Aqui, enaltecemos funções seta pela sua brevidade. Mas não ésó!
 ```smart header="Maisadiante"
 Aqui, enaltecemos funções seta pela sua brevidade. Mas não étudo!

 Funções seta têm outrasfuncionalidades interessantes.
 Funções seta têm outrasparticularidades interessantes.

 Para as estudarcommais detalhe, primeiro precisamos de saberalgunsoutros aspetos de JavaScript, e desta formavamos retornar a funções seta mais adiante no capitulo <info:arrow-functions>.
 Para as estudar maisemdetalhe, primeiro precisamos de saber outros aspetos de JavaScript, e desta formairemos retornar a funções seta mais adiante no capitulo <info:arrow-functions>.

 Por ora,podemosjá usar funções seta para açõesnuma única-linha e *callbacks*.
 Por ora, jápodemosusar funções seta para açõescom uma única-linha e *callbacks*.
 ```

 ## Resumo

 Funções seta sãopráticas para açõesnuma única-linha. Elas vêm em dois sabores:
 *Arrow functions* sãoapropriadas para açõessimples, especialmente com uma única-linha. Elas vêm em dois sabores:

 1. Sem chavetas: `(...args) => expression` -- o lado direito é uma expressão: a função a avalia e retorna o resultado.
 2. Com chavetas: `(...args) => { body }` -- chavetas nospermitem escrever múltiplas instruções dentro da função, mas precisamos de um explícito `return` para retornar alguma coisa.
 1. Sem chavetas: `(...args) => expression` -- o lado direito é uma expressão; a função a avalia e retorna o resultado. Parenteses podem ser omitidos, se houver só um argumento, ex `n => n*2`.
 2. Com chavetas: `(...args) => { body }` -- chavetas nospossibilitam escrever múltiplas instruções dentro da função, mas precisamos de um explícito `return` para retornar alguma coisa.
Original file line number	Diff line number	Diff line change
		@@ -1,17 +1,17 @@

		```js run
		function ask(question, yes, no) {
		if (confirm(question)) yes()
		if (confirm(question)) yes();
		else no();
		}

		ask(
		"Do you agree?",
		"Você concorda?",
		!
		() => alert("You agreed."),
		() => alert("You canceled the execution.")
		() => alert("Você concordou."),
		() => alert("Você cancelou a execução.")
		/!
		);
		```

		Looks short and clean, right?
		Parece mais curto e claro, não?
Original file line number	Diff line number	Diff line change
		@@ -1,17 +1,17 @@

		#Rewrite witharrow functions
		#Reescreva com funções seta (arrow functions)

		Replace Function Expressions with arrow functions in the code below:
		Substitua as Expressões de Função por funções seta no código abaixo:

		```js run
		function ask(question, yes, no) {
		if (confirm(question)) yes()
		if (confirm(question)) yes();
		else no();
		}

		ask(
		"Do you agree?",
		function() { alert("You agreed."); },
		function() { alert("You canceled the execution."); }
		"Você concorda?",
		function() { alert("Você concordou."); },
		function() { alert("Você cancelou a execução."); }
		);
		```
Original file line number	Diff line number	Diff line change
		@@ -1,19 +1,19 @@
		#Funções seta, o básico
		#Arrow functions, o básico

		Existe outra sintaxe, muito simples econcisa, para criar funções, e quegeralmente é melhor do que Expressões de Função.
		Há outra sintaxe muito simples eabreviada para criar funções, e quefrequentemente é melhor do que Expressões de Função (Function Expressions).

		É chamada de "funções seta" ("arrow functions"), porquetem este aspeto:
		É chamada de "arrow functions" (funções seta), porqueé parecida com:

		```js
		let func = (arg1, arg2, ...argN) => expression
		let func = (arg1, arg2, ...,argN) => expression;
		```

		...Isto, cria a função `func` com os argumentos `arg1..argN`,depoisavalia a `expression` no lado direitousando os mesmos, e retorna o seu resultado.
		...Isto cria a função `func` com os argumentos `arg1..argN`,a seguiravalia a `expression` no lado direitocom eles, e retorna o resultado.

		Por outras palavras, é a versão mais curta de:

		```js
		let func = function(arg1, arg2, ...argN) {
		let func = function(arg1, arg2, ...,argN) {
		return expression;
		};
		```
Expand All		@@ -33,9 +33,9 @@ let sum = function(a, b) {
		alert( sum(1, 2) ); // 3
		```

		Como pode ver, `(a, b) => a + b` significa uma função que aceita dois argumentos, nomeadamente `a` e `b`. No momento da execução,esta avaliaa expressão `a + b`e retornao resultado.
		Comovocêpode ver `(a, b) => a + b` significa uma função que aceita dois argumentos, nomeadamente `a` e `b`. No momento da execução, a expressão `a + b`é avaliada eo resultado retornado.

		- Se tivermosapenasum argumento, então os parênteses à sua volta podem ser omitidos,tornando ela ainda mais curta.
		- Se tivermos umsóargumento, então os parênteses à sua volta podem ser omitidos,ficando ela ainda mais curta.

		Por exemplo:

Expand All		@@ -48,20 +48,20 @@ Como pode ver, `(a, b) => a + b` significa uma função que aceita dois argument
		alert( double(3) ); // 6
		```

		- Se não houver argumentos, os parêntesesirão estarvazios (mas devem estar presentes):
		- Se não houver argumentos, os parêntesesestarãovazios,mas devem estar presentes:

		```js run
		let sayHi = () => alert("Olá!");

		sayHi();
		```

		Funções seta podem serempregues da mesma forma queExpressões de Função.
		Arrow functions podem serutilizadas da mesma forma queFunction Expressions.

		Por exemplo, para criar dinamicamente uma função:

		```js run
		let age = prompt("Que idade tem?", 18);
		let age = prompt("Que idadevocêtem?", 18);

		let welcome = (age < 18) ?
		() => alert('Olá') :
Expand All		@@ -70,15 +70,15 @@ let welcome = (age < 18) ?
		welcome();
		```

		Funções seta podem parecernão familiarese não muito legíveis a princípio, mas issorápidamente muda à medida que os olhos se habituam à estrutura.
		Funções seta podem parecerestranhase não muito legíveis a princípio, mas issorapidamente muda à medida que os olhos se habituam à estrutura.

		Elas são muito convenientes para ações simplesnumaúnica-linha, quando estamospreguiçosos demais para escrever muitas palavras.
		Elas são muito convenientes para ações simplescom umaúnica-linha, quando estamosalgo ociosos para escrever muitas palavras.

		## Funções seta de múltiplas linhas
		##Funções seta com múltiplas linhas

		Os exemplos acimatomaram os argumentos à esquerda de `=>` e avaliarama expressão à direita com eles.
		As funções seta vistas até agora foram muito simples. Elastomaram os argumentos à esquerda de `=>`, e avaliarame retornaram o resultado da expressão à direita com eles.

		Por vezes, precisamos dealgoum pouco maiscomplexo, como demúltiplas expressõesou instruções.Isso também é possível, mas devemos colocar elas dentro dechavetas. Depois, usamos um `return`normal com elas.
		Por vezes, precisamos deuma funçãoum pouco maiscomplexa, commúltiplas expressõese instruções.Neste caso, nós as envolvemos entre chavetas. A maior diferença é que aschavetas precisam de um `return`dentro delas para retornar um valor (tal como uma função comum precisa).

		Desta forma:

Expand All		@@ -93,19 +93,19 @@ let sum = (a, b) => { // a chaveta abre uma função multi-linha
		alert( sum(1, 2) ); // 3
		```

		```smart header="Maisà frente"
		Aqui, enaltecemos funções seta pela sua brevidade. Mas não ésó!
		```smart header="Maisadiante"
		Aqui, enaltecemos funções seta pela sua brevidade. Mas não étudo!

		Funções seta têm outrasfuncionalidades interessantes.
		Funções seta têm outrasparticularidades interessantes.

		Para as estudarcommais detalhe, primeiro precisamos de saberalgunsoutros aspetos de JavaScript, e desta formavamos retornar a funções seta mais adiante no capitulo <info:arrow-functions>.
		Para as estudar maisemdetalhe, primeiro precisamos de saber outros aspetos de JavaScript, e desta formairemos retornar a funções seta mais adiante no capitulo <info:arrow-functions>.

		Por ora,podemosjá usar funções seta para açõesnuma única-linha e callbacks.
		Por ora, jápodemosusar funções seta para açõescom uma única-linha e callbacks.
		```

		## Resumo

		Funções seta sãopráticas para açõesnuma única-linha. Elas vêm em dois sabores:
		Arrow functions sãoapropriadas para açõessimples, especialmente com uma única-linha. Elas vêm em dois sabores:

		1. Sem chavetas: `(...args) => expression` -- o lado direito é uma expressão: a função a avalia e retorna o resultado.
		2. Com chavetas: `(...args) => { body }` -- chavetas nospermitem escrever múltiplas instruções dentro da função, mas precisamos de um explícito `return` para retornar alguma coisa.
		1. Sem chavetas: `(...args) => expression` -- o lado direito é uma expressão; a função a avalia e retorna o resultado. Parenteses podem ser omitidos, se houver só um argumento, ex `n => n*2`.
		2. Com chavetas: `(...args) => { body }` -- chavetas nospossibilitam escrever múltiplas instruções dentro da função, mas precisamos de um explícito `return` para retornar alguma coisa.