From d93973f2edbcbe8a41534918e404f98d7af14bbf Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Mon, 8 Jun 2020 20:52:36 +0100 Subject: [PATCH 1/6] Update arrow-functions files. --- .../1-rewrite-arrow/solution.md | 8 +-- .../1-rewrite-arrow/task.md | 10 +-- .../17-arrow-functions-basics/article.md | 70 +++++++++---------- 3 files changed, 43 insertions(+), 45 deletions(-) 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 index 3ea112473..b5880321e 100644 --- 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 @@ -6,12 +6,12 @@ function ask(question, yes, 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 index 2f44db27e..ba28d504a 100644 --- 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 @@ -1,7 +1,7 @@ -# Rewrite with arrow 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) { @@ -10,8 +10,8 @@ function ask(question, yes, 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 index e0fb5bda5..b28e42d3b 100644 --- a/1-js/02-first-steps/17-arrow-functions-basics/article.md +++ b/1-js/02-first-steps/17-arrow-functions-basics/article.md @@ -1,16 +1,16 @@ -# Arrow functions, the basics +# Funções seta, o básico -There's another very simple and concise syntax for creating functions, that's often better than Function Expressions. +Existe outra sintaxe, muito simples e concisa, para criar funções, e que frequentemente é melhor do que Expressões de Funções. -It's called "arrow functions", because it looks like this: +É chamada de "funções seta" (*"arrow functions"*), porque se assemelha a: ```js let func = (arg1, arg2, ...argN) => expression ``` -...This creates a function `func` that accepts arguments `arg1..argN`, then evaluates the `expression` on the right side with their use and returns its result. +...Isto, cria a função `func` com os argumentos `arg1..argN`, depois avalia a `expression` no lado direito utilizando os mesmos, e retorna o seu resultado. -In other words, it's the shorter version of: +Por outras palavras, é a versão mais curta de: ```js let func = function(arg1, arg2, ...argN) { @@ -18,12 +18,12 @@ let func = function(arg1, arg2, ...argN) { }; ``` -Let's see a concrete example: +Vejamos um exemplo concreto: ```js run let sum = (a, b) => a + b; -/* This arrow function is a shorter form of: +/* Esta função seta é uma forma mais curta de: let sum = function(a, b) { return a + b; @@ -33,79 +33,77 @@ let sum = function(a, b) { alert( sum(1, 2) ); // 3 ``` -As you can, see `(a, b) => a + b` means a function that accepts two arguments named `a` and `b`. Upon the execution, it evaluates the expression `a + b` and returns the result. +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 avalia a expressão `a + b` e retorna o resultado. -- If we have only one argument, then parentheses around parameters can be omitted, making that even shorter. +- Se tivermos apenas um argumento, então os parênteses à sua volta podem ser omitidos, tornando-a ainda mais curta. - For example: + Por examplo: ```js run *!* let double = n => n * 2; - // roughly the same as: let double = function(n) { return n * 2 } + // aproximadamente o mesmo que: let double = function(n) { return n * 2 } */!* alert( double(3) ); // 6 ``` -- If there are no arguments, parentheses will be empty (but they should be present): +- Se não houver argumentos, os parênteses estarão vazios (mas devem estar presentes): ```js run - let sayHi = () => alert("Hello!"); + let sayHi = () => alert("Olá!"); sayHi(); ``` -Arrow functions can be used in the same way as Function Expressions. +Funções seta podem ser empregues da mesma forma que Expressões de Função. -For instance, to dynamically create a function: +Por exemplo, para criar dinamicamente uma função: ```js run -let age = prompt("What is your age?", 18); +let age = prompt("Que idade tem?", 18); let welcome = (age < 18) ? - () => alert('Hello') : - () => alert("Greetings!"); + () => alert('Olá') : + () => alert("Saudações!"); welcome(); ``` -Arrow functions may appear unfamiliar and not very readable at first, but that quickly changes as the eyes get used to the structure. +Funções seta podem parecer não familiares e não muito legíveis a princípio, mas isso rápidamente muda à medida que os olhos se habituam à estrutura. -They are very convenient for simple one-line actions, when we're just too lazy to write many words. +Elas são muito convenientes para ações simples numa única-linha, quando estamos preguiçosos demais para escrever muitas palavras. -## Multiline arrow functions +## Funções seta de múltiplas linhas -The examples above took arguments from the left of `=>` and evaluated the right-side expression with them. +Os exemplos acima tomaram os argumentos à esqerda de `=>` e avaliaram a expressão à direita com eles. -Sometimes we need something a little bit more complex, like multiple expressions or statements. It is also possible, but we should enclose them in curly braces. Then use a normal `return` within them. +Por vezes, precisamos de algo um pouco mais complexo, como múltiplas expressões ou instruções. Isso também é possível, mas deveríamos envolvê-las em chavetas. Depois, usamos um `return` normal com elas. -Like this: +Desta forma: ```js run -let sum = (a, b) => { // the curly brace opens a multiline function +let sum = (a, b) => { // a chaveta abre uma função multi-linha let result = a + b; *!* - return result; // if we use curly braces, then we need an explicit "return" + return result; // se usarmos chavetas, então precisamos de um "return" explícito */!* }; alert( sum(1, 2) ); // 3 ``` -```smart header="More to come" -Here we praised arrow functions for brevity. But that's not all! +```smart header="Mais adiante" +Aqui, enaltecemos funções seta pela sua brevidade. Mas não é tudo! -Arrow functions have other interesting features. +Para as estudar mais detalhadamente, primeiro precisamos de saber alguns outros aspetos de JavaScript, e desta forma retornaremos a funções seta mais adiante no capitulo . -To study them in-depth, we first need to get to know some other aspects of JavaScript, so we'll return to arrow functions later in the chapter . - -For now, we can already use arrow functions for one-line actions and callbacks. +Por ora, podemos já usar funções seta para ações numa única-linha e *callbacks*. ``` -## Summary +## Resumo -Arrow functions are handy for one-liners. They come in two flavors: +Funções seta são apropriadas para ações única-linha. Elas vêm em dois sabores: -1. Without curly braces: `(...args) => expression` -- the right side is an expression: the function evaluates it and returns the result. -2. With curly braces: `(...args) => { body }` -- brackets allow us to write multiple statements inside the function, but we need an explicit `return` to return something. +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 permitem-nos escrever múltiplas instruções dentro da função, mas precisamos de um explícito `return` para retornar alguma coisa. From 6d0181989aff79b09cf304528791d45e6cf5b692 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Sun, 26 Jul 2020 15:10:01 +0100 Subject: [PATCH 2/6] Update arrow-functions --- 1-js/02-first-steps/17-arrow-functions-basics/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index b28e42d3b..cfb7527ca 100644 --- a/1-js/02-first-steps/17-arrow-functions-basics/article.md +++ b/1-js/02-first-steps/17-arrow-functions-basics/article.md @@ -78,7 +78,7 @@ Elas são muito convenientes para ações simples numa única-linha, quando esta Os exemplos acima tomaram os argumentos à esqerda de `=>` e avaliaram a expressão à direita com eles. -Por vezes, precisamos de algo um pouco mais complexo, como múltiplas expressões ou instruções. Isso também é possível, mas deveríamos envolvê-las em chavetas. Depois, usamos um `return` normal com elas. +Por vezes, precisamos de algo um pouco mais complexo, como múltiplas expressões ou instruções. Isso também é possível, mas deveríamos envolvê-las em chavetas. A seguir, usamos um `return` normal com elas. Desta forma: From 83f30d3736e8dfc107672216483839a70414576f Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Fri, 11 Dec 2020 23:40:37 +0100 Subject: [PATCH 3/6] Update "Arrow functions" translation. --- .../17-arrow-functions-basics/article.md | 40 ++++++++++--------- 1 file changed, 21 insertions(+), 19 deletions(-) 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 index cfb7527ca..e52fbc998 100644 --- a/1-js/02-first-steps/17-arrow-functions-basics/article.md +++ b/1-js/02-first-steps/17-arrow-functions-basics/article.md @@ -1,14 +1,14 @@ -# Funções seta, o básico +# Arrow functions, o básico -Existe outra sintaxe, muito simples e concisa, para criar funções, e que frequentemente é melhor do que Expressões de Funções. +Há outra sintaxe muito simples e abreviada para criar funções, e que frequentemente é melhor do que Function Expressions (Expressões de Função). -É chamada de "funções seta" (*"arrow functions"*), porque se assemelha a: +É chamada de "*arrow functions*" (funções seta), porque é parecida com: ```js let func = (arg1, arg2, ...argN) => expression ``` -...Isto, cria a função `func` com os argumentos `arg1..argN`, depois avalia a `expression` no lado direito utilizando os mesmos, e retorna o seu resultado. +...Isto cria a função `func` com os argumentos `arg1..argN`, a seguir avalia a `expression` no lado direito com eles, e retorna o resultado. Por outras palavras, é a versão mais curta de: @@ -33,11 +33,11 @@ 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 avalia a expressão `a + b` e retorna o resultado. +Como 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 e o resultado retornado. -- Se tivermos apenas um argumento, então os parênteses à sua volta podem ser omitidos, tornando-a ainda mais curta. +- Se tivermos um só argumento, então os parênteses à sua volta podem ser omitidos, ficando ela ainda mais curta. - Por examplo: + Por exemplo: ```js run *!* @@ -48,7 +48,7 @@ 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ênteses estarão vazios (mas devem estar presentes): +- Se não houver argumentos, os parênteses estão vazios (mas devem estar presentes): ```js run let sayHi = () => alert("Olá!"); @@ -56,7 +56,7 @@ Como pode ver, `(a, b) => a + b` significa uma função que aceita dois argument sayHi(); ``` -Funções seta podem ser empregues da mesma forma que Expressões de Função. +*Arrow functions* podem ser utilizadas da mesma forma que *Function Expressions*. Por exemplo, para criar dinamicamente uma função: @@ -70,15 +70,15 @@ let welcome = (age < 18) ? welcome(); ``` -Funções seta podem parecer não familiares e não muito legíveis a princípio, mas isso rápidamente muda à medida que os olhos se habituam à estrutura. +*Arrow functions* podem parecer estranhas e não muito legíveis a princípio, mas isso rápidamente muda à medida que os olhos se habituam à estrutura. -Elas são muito convenientes para ações simples numa única-linha, quando estamos preguiçosos demais para escrever muitas palavras. +Elas são muito convenientes para ações simples com uma única-linha, quando estamos algo ociosos para escrever muitas palavras. -## Funções seta de múltiplas linhas +## *Arrow functions* com múltiplas linhas -Os exemplos acima tomaram os argumentos à esqerda de `=>` e avaliaram a expressão à direita com eles. +Os exemplos acima tomaram os argumentos à esquerda de `=>` e avaliaram a expressão à direita com eles. -Por vezes, precisamos de algo um pouco mais complexo, como múltiplas expressões ou instruções. Isso também é possível, mas deveríamos envolvê-las em chavetas. A seguir, usamos um `return` normal com elas. +Por vezes, precisamos de algo um pouco mais complexo, como múltiplas expressões ou instruções. Isso também é possível, mas temos de as envolver em chavetas. Depois, usamos um `return` normal com elas. Desta forma: @@ -94,16 +94,18 @@ alert( sum(1, 2) ); // 3 ``` ```smart header="Mais adiante" -Aqui, enaltecemos funções seta pela sua brevidade. Mas não é tudo! +Aqui, enaltecemos arrow functions pela sua brevidade. Mas não é tudo! -Para as estudar mais detalhadamente, primeiro precisamos de saber alguns outros aspetos de JavaScript, e desta forma retornaremos a funções seta mais adiante no capitulo . +Arrow functions têm outras particularidades interessantes. -Por ora, podemos já usar funções seta para ações numa única-linha e *callbacks*. +Para as estudar mais em detalhe, primeiro precisamos de saber alguns outros aspetos de JavaScript, e desta forma iremos retornar a funções seta mais adiante no capitulo . + +Por ora, já podemos usar arrow functions para ações com uma única-linha e *callbacks*. ``` ## Resumo -Funções seta são apropriadas para ações única-linha. Elas vêm em dois sabores: +*Arrow functions* são apropriadas para ações 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 permitem-nos escrever múltiplas instruções dentro da função, mas precisamos de um explícito `return` para retornar alguma coisa. +2. Com chavetas: `(...args) => { body }` -- chavetas nos possibilitam escrever múltiplas instruções dentro da função, mas precisamos de um explícito `return` para retornar alguma coisa. From d3265f44b30738089c1f0fc45fc0273325ad4e1d Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Sat, 29 May 2021 16:31:15 +0100 Subject: [PATCH 4/6] Update translation. --- 1-js/02-first-steps/17-arrow-functions-basics/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 index e52fbc998..0d471d7e5 100644 --- a/1-js/02-first-steps/17-arrow-functions-basics/article.md +++ b/1-js/02-first-steps/17-arrow-functions-basics/article.md @@ -33,7 +33,7 @@ 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, a expressão `a + b` é avaliada e o resultado retornado. +Como você 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 e o resultado retornado. - Se tivermos um só argumento, então os parênteses à sua volta podem ser omitidos, ficando ela ainda mais curta. @@ -48,7 +48,7 @@ Como pode ver `(a, b) => a + b` significa uma função que aceita dois argumento alert( double(3) ); // 6 ``` -- Se não houver argumentos, os parênteses estão vazios (mas devem estar presentes): +- Se não houver argumentos, os parênteses estarão vazios (mas devem estar presentes): ```js run let sayHi = () => alert("Olá!"); From c8a49eb8e310e4229d3c2cefcfe249f7d26f4d44 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Sun, 15 Jan 2023 22:57:09 +0100 Subject: [PATCH 5/6] Update "Arrow functions" (1) --- .../1-rewrite-arrow/solution.md | 2 +- .../17-arrow-functions-basics/1-rewrite-arrow/task.md | 2 +- .../17-arrow-functions-basics/article.md | 10 +++++----- 3 files changed, 7 insertions(+), 7 deletions(-) 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 index b5880321e..428315298 100644 --- 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 @@ -1,7 +1,7 @@ ```js run function ask(question, yes, no) { - if (confirm(question)) yes() + if (confirm(question)) yes(); else no(); } 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 index ba28d504a..284252a09 100644 --- 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 @@ -5,7 +5,7 @@ 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(); } 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 index 0d471d7e5..11f8fc86b 100644 --- a/1-js/02-first-steps/17-arrow-functions-basics/article.md +++ b/1-js/02-first-steps/17-arrow-functions-basics/article.md @@ -5,7 +5,7 @@ Há outra sintaxe muito simples e abreviada para criar funções, e que frequent É 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`, a seguir avalia a `expression` no lado direito com eles, e retorna o resultado. @@ -13,7 +13,7 @@ let func = (arg1, arg2, ...argN) => expression Por outras palavras, é a versão mais curta de: ```js -let func = function(arg1, arg2, ...argN) { +let func = function(arg1, arg2, ..., argN) { return expression; }; ``` @@ -48,7 +48,7 @@ Como você pode ver `(a, b) => a + b` significa uma função que aceita dois arg alert( double(3) ); // 6 ``` -- Se não houver argumentos, os parênteses estarão vazios (mas devem estar presentes): +- Se não houver argumentos, os parênteses estarão vazios, mas devem estar presentes: ```js run let sayHi = () => alert("Olá!"); @@ -61,7 +61,7 @@ Como você pode ver `(a, b) => a + b` significa uma função que aceita dois arg Por exemplo, para criar dinamicamente uma função: ```js run -let age = prompt("Que idade tem?", 18); +let age = prompt("Que idade você tem?", 18); let welcome = (age < 18) ? () => alert('Olá') : @@ -70,7 +70,7 @@ let welcome = (age < 18) ? welcome(); ``` -*Arrow functions* podem parecer estranhas e não muito legíveis a princípio, mas isso rápidamente muda à medida que os olhos se habituam à estrutura. +*Arrow functions* podem parecer estranhas e não muito legíveis a princípio, mas isso rapidamente muda à medida que os olhos se habituam à estrutura. Elas são muito convenientes para ações simples com uma única-linha, quando estamos algo ociosos para escrever muitas palavras. From e4f2418945071204bf999f11184a4646573bda3b Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Mon, 16 Jan 2023 21:56:50 +0100 Subject: [PATCH 6/6] Update "Arrow functions" (2) --- .../17-arrow-functions-basics/article.md | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) 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 index 11f8fc86b..2c29ba90c 100644 --- a/1-js/02-first-steps/17-arrow-functions-basics/article.md +++ b/1-js/02-first-steps/17-arrow-functions-basics/article.md @@ -1,6 +1,6 @@ # Arrow functions, o básico -Há outra sintaxe muito simples e abreviada para criar funções, e que frequentemente é melhor do que Function Expressions (Expressões de Função). +Há outra sintaxe muito simples e abreviada para criar funções, e que frequentemente é melhor do que Expressões de Função (*Function Expressions*). É chamada de "*arrow functions*" (funções seta), porque é parecida com: @@ -70,15 +70,15 @@ let welcome = (age < 18) ? welcome(); ``` -*Arrow functions* podem parecer estranhas e não muito legíveis a princípio, mas isso rapidamente muda à medida que os olhos se habituam à estrutura. +*Funções seta* podem parecer estranhas e não muito legíveis a princípio, mas isso rapidamente muda à medida que os olhos se habituam à estrutura. Elas são muito convenientes para ações simples com uma única-linha, quando estamos algo ociosos para escrever muitas palavras. -## *Arrow functions* com múltiplas linhas +## *Funções seta* com múltiplas linhas -Os exemplos acima tomaram os argumentos à esquerda de `=>` e avaliaram a expressão à direita com eles. +As funções seta vistas até agora foram muito simples. Elas tomaram os argumentos à esquerda de `=>`, e avaliaram e retornaram o resultado da expressão à direita com eles. -Por vezes, precisamos de algo um pouco mais complexo, como múltiplas expressões ou instruções. Isso também é possível, mas temos de as envolver em chavetas. Depois, usamos um `return` normal com elas. +Por vezes, precisamos de uma função um pouco mais complexa, com múltiplas expressões e instruções. Neste caso, nós as envolvemos entre chavetas. A maior diferença é que as chavetas precisam de um `return` dentro delas para retornar um valor (tal como uma função comum precisa). Desta forma: @@ -94,18 +94,18 @@ alert( sum(1, 2) ); // 3 ``` ```smart header="Mais adiante" -Aqui, enaltecemos arrow functions pela sua brevidade. Mas não é tudo! +Aqui, enaltecemos funções seta pela sua brevidade. Mas não é tudo! -Arrow functions têm outras particularidades interessantes. +Funções seta têm outras particularidades interessantes. -Para as estudar mais em detalhe, primeiro precisamos de saber alguns outros aspetos de JavaScript, e desta forma iremos retornar a funções seta mais adiante no capitulo . +Para as estudar mais em detalhe, primeiro precisamos de saber outros aspetos de JavaScript, e desta forma iremos retornar a funções seta mais adiante no capitulo . -Por ora, já podemos usar arrow functions para ações com uma única-linha e *callbacks*. +Por ora, já podemos usar funções seta para ações com uma única-linha e *callbacks*. ``` ## Resumo -*Arrow functions* são apropriadas para ações com uma única-linha. Elas vêm em dois sabores: +*Arrow functions* são apropriadas para ações simples, 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. +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 nos possibilitam escrever múltiplas instruções dentro da função, mas precisamos de um explícito `return` para retornar alguma coisa.