From 8ae9a4cb38efd2e4050b21d470ad6c7fc8c3ab1e Mon Sep 17 00:00:00 2001 From: odsantos Date: Fri, 20 Sep 2019 04:18:29 +0100 Subject: [PATCH 1/3] Update article.md --- 1-js/02-first-steps/13-switch/article.md | 113 ++++++++++++----------- 1 file changed, 57 insertions(+), 56 deletions(-) diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md index 258f24068..c5ad4c0fa 100644 --- a/1-js/02-first-steps/13-switch/article.md +++ b/1-js/02-first-steps/13-switch/article.md @@ -1,22 +1,22 @@ -# The "switch" statement +# A instrução "switch" -A `switch` statement can replace multiple `if` checks. +Uma instrução `switch` pode substituir muitas comparações `se`. -It gives a more descriptive way to compare a value with multiple variants. +Ela dá uma forma mais descritiva de comparar um valor com múltiplas variantes. -## The syntax +## A sintaxe -The `switch` has one or more `case` blocks and an optional default. +O `switch` tem um ou mais blocos `caso` e um `defeito` opcional. -It looks like this: +Tem uma apresentação similar a: ```js no-beautify switch(x) { - case 'value1': // if (x === 'value1') + case 'valor1': // if (x === 'valor1') ... [break] - case 'value2': // if (x === 'value2') + case 'valor2': // if (x === 'valor2') ... [break] @@ -26,71 +26,71 @@ switch(x) { } ``` -- The value of `x` is checked for a strict equality to the value from the first `case` (that is, `value1`) then to the second (`value2`) and so on. -- If the equality is found, `switch` starts to execute the code starting from the corresponding `case`, until the nearest `break` (or until the end of `switch`). -- If no case is matched then the `default` code is executed (if it exists). +- O valor de `x` é comparado por meio de uma igualdade exata ao valor do primeiro `caso` (isto é, ao `valor1`), a seguir ao segundo (`valor2`) e assim sucessivamente. +- Se uma igualdade é encontrada, o `switch` começa a executar o código a partir do início do `caso` correspondente, até ao próximo `break` (ou até ao fim do `switch`). +- Se nenhum caso é equiparado então o código em `defeito` é executado (se existir). -## An example +## Um examplo -An example of `switch` (the executed code is highlighted): +Um examplo de `switch` (o código executado code está em destaque): ```js run let a = 2 + 2; switch (a) { case 3: - alert( 'Too small' ); + alert( 'Muito baixo' ); break; *!* case 4: - alert( 'Exactly!' ); + alert( 'Exacto!' ); break; */!* case 5: - alert( 'Too large' ); + alert( 'Muito alto' ); break; default: - alert( "I don't know such values" ); + alert( "Não conheço tais valores" ); } ``` -Here the `switch` starts to compare `a` from the first `case` variant that is `3`. The match fails. +Aqui o `switch` começa por comparar `a` à variante no primeiro `caso`, que é `3`. A equiparação falha. -Then `4`. That's a match, so the execution starts from `case 4` until the nearest `break`. +Então a `4`. Existe uma equiparação, e assim a execução começa a partir do `caso 4` até ao próximo `break`. -**If there is no `break` then the execution continues with the next `case` without any checks.** +**Se não existir um `break` então a execução continua pelo próximo `caso` sem quaisquer verificações.** -An example without `break`: +Um examplo sem `break`: ```js run let a = 2 + 2; switch (a) { case 3: - alert( 'Too small' ); + alert( 'Muito baixo' ); *!* case 4: - alert( 'Exactly!' ); + alert( 'Exacto!' ); case 5: - alert( 'Too big' ); + alert( 'Muito alto' ); default: - alert( "I don't know such values" ); + alert( "Não conheço tais valores" ); */!* } ``` -In the example above we'll see sequential execution of three `alert`s: +No examplo acima, vemos uma execução sequential de três `alert`s: ```js -alert( 'Exactly!' ); -alert( 'Too big' ); -alert( "I don't know such values" ); +alert( 'Exacto!' ); +alert( 'Muito alto' ); +alert( "Não conheço tais valores" ); ``` -````smart header="Any expression can be a `switch/case` argument" -Both `switch` and `case` allow arbitrary expressions. +````smart header="Qualquer expressão pode servir de argumento para `switch/case` " +Ambos `switch` e `case` permitem expressões arbitrárias. -For example: +Por examplo: ```js run let a = "1"; @@ -99,74 +99,75 @@ let b = 0; switch (+a) { *!* case b + 1: - alert("this runs, because +a is 1, exactly equals b+1"); + alert("isto executa, porque +a é 1, e é exatamente igual a b+1"); break; */!* default: - alert("this doesn't run"); + alert("isto não executa"); } ``` -Here `+a` gives `1`, that's compared with `b + 1` in `case`, and the corresponding code is executed. +Aqui `+a` dá `1`, o que é comparado a `b + 1` no `caso`, e o código correspondente é executado. ```` -## Grouping of "case" +## Grupos de "caso" -Several variants of `case` which share the same code can be grouped. +Múltiplas variantes de `caso` que partihem o mesmo código podem ser agrupadas. -For example, if we want the same code to run for `case 3` and `case 5`: +Por examplo, se quisermos que o mesmo código corra por `caso 3` e `caso 5`: ```js run no-beautify let a = 2 + 2; switch (a) { case 4: - alert('Right!'); + alert('Certo!'); break; *!* - case 3: // (*) grouped two cases + case 3: // (*) dois casos agrupados case 5: - alert('Wrong!'); - alert("Why don't you take a math class?"); + alert('Errado!'); + alert("Porque não tem aulas de matemática?"); break; */!* default: - alert('The result is strange. Really.'); + alert('O resultado é stranho. Realmente.'); } ``` -Now both `3` and `5` show the same message. +Agora ambos `3` e `5` mostram a mesma mensagem. -The ability to "group" cases is a side-effect of how `switch/case` works without `break`. Here the execution of `case 3` starts from the line `(*)` and goes through `case 5`, because there's no `break`. +A habilidade para "agrupar" casos é um efeito secundário de como `switch/case` funciona sem `break`. Aqui a execução do `caso 3` começa pela linha `(*)` e prossegue pelo `caso 5`, por não existir `break`. -## Type matters +## O tipo importa -Let's emphasize that the equality check is always strict. The values must be of the same type to match. +Vamos emfatizar que a verificação da igualdade é sempre exata. Os valores devem também ser do mesmo tipo para existir equiparação. -For example, let's consider the code: +Por examplo, consideremos o código: ```js run -let arg = prompt("Enter a value?"); +let arg = prompt("Insira um valor?"); switch (arg) { case '0': case '1': - alert( 'One or zero' ); + alert( 'Um ou zero' ); break; case '2': - alert( 'Two' ); + alert( 'Dois' ); break; case 3: - alert( 'Never executes!' ); + alert( 'Nunca executa!' ); break; default: - alert( 'An unknown value' ); + alert( 'Um valor desconhecido' ); } ``` -1. For `0`, `1`, the first `alert` runs. -2. For `2` the second `alert` runs. -3. But for `3`, the result of the `prompt` is a string `"3"`, which is not strictly equal `===` to the number `3`. So we've got a dead code in `case 3`! The `default` variant will execute. +1. Para `0`, `1`, o primeiro `alert` executa. +2. Para `2` o segundo `alert` corre. +3. Mas para `3`, o resultado do `prompt` á a string `"3"`, que não é estritamente igual `===` ao número `3`. Assim temos código não +executável em `case 3`! A variante `default` será executada. From 2d5fe865f0c8a7a80f5ebd1b9b3030e0ee18707d Mon Sep 17 00:00:00 2001 From: odsantos Date: Sat, 21 Sep 2019 04:01:45 +0100 Subject: [PATCH 2/3] switch article fomatting and typos fix; function expressions translate --- 1-js/02-first-steps/13-switch/article.md | 34 +- .../15-function-expressions-arrows/article.md | 307 +++++++++--------- 2 files changed, 170 insertions(+), 171 deletions(-) diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md index c5ad4c0fa..933d8297a 100644 --- a/1-js/02-first-steps/13-switch/article.md +++ b/1-js/02-first-steps/13-switch/article.md @@ -2,7 +2,7 @@ Uma instrução `switch` pode substituir muitas comparações `se`. -Ela dá uma forma mais descritiva de comparar um valor com múltiplas variantes. +Ela é uma forma mais descritiva de comparar um valor com múltiplas variantes. ## A sintaxe @@ -26,13 +26,13 @@ switch(x) { } ``` -- O valor de `x` é comparado por meio de uma igualdade exata ao valor do primeiro `caso` (isto é, ao `valor1`), a seguir ao segundo (`valor2`) e assim sucessivamente. +- O valor de `x` é comparado por meio de uma igualdade exata ao valor do primeiro `caso` (isto é, ao `valor1`), a seguir ao do segundo (`valor2`) e assim sucessivamente. - Se uma igualdade é encontrada, o `switch` começa a executar o código a partir do início do `caso` correspondente, até ao próximo `break` (ou até ao fim do `switch`). - Se nenhum caso é equiparado então o código em `defeito` é executado (se existir). -## Um examplo +## Um exemplo -Um examplo de `switch` (o código executado code está em destaque): +Um exemplo de `switch` (o código executado está em destaque): ```js run let a = 2 + 2; @@ -54,13 +54,13 @@ switch (a) { } ``` -Aqui o `switch` começa por comparar `a` à variante no primeiro `caso`, que é `3`. A equiparação falha. +Aqui o `switch` começa por comparar `a` à variante no primeiro `case`, que é `3`. A correspondência falha. -Então a `4`. Existe uma equiparação, e assim a execução começa a partir do `caso 4` até ao próximo `break`. +Então a `4`. Existe uma correspondência, e assim a execução começa a partir do `case 4` até ao próximo `break`. -**Se não existir um `break` então a execução continua pelo próximo `caso` sem quaisquer verificações.** +**Se não existir um `break` então a execução continua pelo próximo `case` sem quaisquer verificações.** -Um examplo sem `break`: +Um exemplo sem `break`: ```js run let a = 2 + 2; @@ -79,7 +79,7 @@ switch (a) { } ``` -No examplo acima, vemos uma execução sequential de três `alert`s: +No exemplo acima, vemos uma execução sequential de três `alert`'s: ```js alert( 'Exacto!' ); @@ -87,10 +87,10 @@ alert( 'Muito alto' ); alert( "Não conheço tais valores" ); ``` -````smart header="Qualquer expressão pode servir de argumento para `switch/case` " +````smart header="Any expression can be a switch/case argument" Ambos `switch` e `case` permitem expressões arbitrárias. -Por examplo: +Por exemplo: ```js run let a = "1"; @@ -107,14 +107,14 @@ switch (+a) { alert("isto não executa"); } ``` -Aqui `+a` dá `1`, o que é comparado a `b + 1` no `caso`, e o código correspondente é executado. +Aqui `+a` dá `1`, o que é comparado a `b + 1` no `case`, e o código correspondente é executado. ```` -## Grupos de "caso" +## Grupos de "case" -Múltiplas variantes de `caso` que partihem o mesmo código podem ser agrupadas. +Múltiplas variantes de `case` que partihem o mesmo código podem ser agrupadas. -Por examplo, se quisermos que o mesmo código corra por `caso 3` e `caso 5`: +Por exemplo, se quisermos que o mesmo código corra por `caso 3` e `caso 5`: ```js run no-beautify let a = 2 + 2; @@ -143,9 +143,9 @@ A habilidade para "agrupar" casos é um efeito secundário de como `switch/case` ## O tipo importa -Vamos emfatizar que a verificação da igualdade é sempre exata. Os valores devem também ser do mesmo tipo para existir equiparação. +Vamos emfatizar que a verificação da igualdade é sempre exata. Os valores devem também ser do mesmo tipo para existir correspondência. -Por examplo, consideremos o código: +Por exemplo, consideremos o código: ```js run let arg = prompt("Insira um valor?"); diff --git a/1-js/02-first-steps/15-function-expressions-arrows/article.md b/1-js/02-first-steps/15-function-expressions-arrows/article.md index b4ea19bac..7e03a028e 100644 --- a/1-js/02-first-steps/15-function-expressions-arrows/article.md +++ b/1-js/02-first-steps/15-function-expressions-arrows/article.md @@ -1,72 +1,71 @@ -# Function expressions and arrows +# Expressões de função e Arrow functions -In JavaScript, a function is not a "magical language structure", but a special kind of value. +Em JavaScript, uma função não é uma "estrutura mágica da linguagem", mas um tipo especial de valor. -The syntax that we used before is called a *Function Declaration*: +A sintaxe que usámos antes é chamada de *Declaração de Função* (*Function Declaration*): ```js function sayHi() { - alert( "Hello" ); + alert( "Olá" ); } ``` -There is another syntax for creating a function that is called a *Function Expression*. +Existe outra sintaxe para criar uma função que é chamada de *Expressão de Função* (*Function Expression*). -It looks like this: +É similar a: ```js let sayHi = function() { - alert( "Hello" ); + alert( "Olá" ); }; ``` -Here, the function is created and assigned to the variable explicitly, like any other value. No matter how the function is defined, it's just a value stored in the variable `sayHi`. +Aqui, a função é criada e atribuida explícitamente à variável, como qualquer outro valor. Não importa como a função é definida, é apenas um valor atribuido a uma variável `sayHi`. +O significado destas amostras de código é o mesmo: "crie uma função e a coloque na variável `sayHi`". -The meaning of these code samples is the same: "create a function and put it into the variable `sayHi`". - -We can even print out that value using `alert`: +Podemos até exibir esse valor usando `alert`: ```js run function sayHi() { - alert( "Hello" ); + alert( "Olá" ); } *!* -alert( sayHi ); // shows the function code +alert( sayHi ); // mostra o código da função */!* ``` -Please note that the last line does not run the function, because there are no parentheses after `sayHi`. There are programming languages where any mention of a function name causes its execution, but JavaScript is not like that. +Por favor, note que a última linha não executa a função, porque não existem parênteses depois de `sayHi`. Existem linguagens de programação onde qualquer menção ao nome de uma função provoca a sua execução, mas em JavaScript não é assim. -In JavaScript, a function is a value, so we can deal with it as a value. The code above shows its string representation, which is the source code. +Em JavaScript, uma função é um valor, então podemos lidar com ela como com um valor. O código acima mostra a sua representação em formato de texto (string), que é o código fonte. -It is a special value of course, in the sense that we can call it like `sayHi()`. +Óbviamente que é um valor especial, porque podemos invocá-lo usando `sayHi()`. -But it's still a value. So we can work with it like with other kinds of values. +Mas ainda assim é um valor. Então, podemos manuseá-lo como com outros tipos de valores. -We can copy a function to another variable: +Podemos copiar uma função para outra variável: ```js run no-beautify -function sayHi() { // (1) create - alert( "Hello" ); +function sayHi() { // (1) crie + alert( "Olá" ); } -let func = sayHi; // (2) copy +let func = sayHi; // (2) copie -func(); // Hello // (3) run the copy (it works)! -sayHi(); // Hello // this still works too (why wouldn't it) +func(); // Olá // (3) execute a cópia (funciona)! +sayHi(); // Olá // isto também ainda funciona (porque não?) ``` -Here's what happens above in detail: +Aqui está o que acima acontece, em detalhe: -1. The Function Declaration `(1)` creates the function and puts it into the variable named `sayHi`. -2. Line `(2)` copies it into the variable `func`. +1. A Declaração de Função `(1)` cria uma função e a coloca na variável chamada `sayHi`. +2. Na linha em `(2)` é copiada para a variável `func`. - Please note again: there are no parentheses after `sayHi`. If there were, then `func = sayHi()` would write *the result of the call* `sayHi()` into `func`, not *the function* `sayHi` itself. -3. Now the function can be called as both `sayHi()` and `func()`. + Por favor, note outra vez: não existem parênteses depois de `sayHi`. Se os houvessem, então `func = sayHi()` escreveria *o resultado da chamada* `sayHi()` em `func`, não a própria *função* `sayHi`. +3. Agora, a função pode ser invocada tanto como `sayHi()` como `func()`. -Note that we could also have used a Function Expression to declare `sayHi`, in the first line: +Note que poderíamos também ter uma Expressão de Função para declarar `sayHi`, na primeira linha: ```js let sayHi = function() { ... }; @@ -75,11 +74,11 @@ let func = sayHi; // ... ``` -Everything would work the same. Even more obvious what's going on, right? +Tudo funcionaria do mesmo modo. Seria ainda mais óbvio o que se passa, não? ````smart header="Why is there a semicolon at the end?" -You might wonder, why does Function Expression have a semicolon `;` at the end, but Function Declaration does not: +Poderá perguntar-se, porque terá uma Expressão de Função um ponto-e-vírgula `;` no final, mas a Declaração de Função não: ```js function sayHi() { @@ -91,27 +90,27 @@ let sayHi = function() { }*!*;*/!* ``` -The answer is simple: -- There's no need for `;` at the end of code blocks and syntax structures that use them like `if { ... }`, `for { }`, `function f { }` etc. -- A Function Expression is used inside the statement: `let sayHi = ...;`, as a value. It's not a code block. The semicolon `;` is recommended at the end of statements, no matter what is the value. So the semicolon here is not related to the Function Expression itself in any way, it just terminates the statement. +A resposta é simples: +- Não há necessidade para um `;` no fim de blocos de código e estruturas sintáticas que os usem como `if { ... }`, `for { }`, `function f { }` etc. +- Uma Expressão de Função é usada dentro de uma instrução: `let sayHi = ...;`, tal como o é um valor. Não é um bloco de código. O ponto-e-vírgula é recomendado no final de instruções, independentemente do seu valor. Assim, o ponto-e-vírgula aqui não está relacionado à Função de Expressão em si, mas simplesmente termina a instrução. ```` ## Callback functions -Let's look at more examples of passing functions as values and using function expressions. +Vejamos mais exemplos de passagem de funções como valores e de uso de expressões de função. -We'll write a function `ask(question, yes, no)` with three parameters: +Escreveremos uma função `ask(question, yes, no)` com três parametros: `question` -: Text of the question +: Texto da questão `yes` -: Function to run if the answer is "Yes" +: Função a executar se a resposta for "Sim" `no` -: Function to run if the answer is "No" +: Função a executar se a resposta for "Não" -The function should ask the `question` and, depending on the user's answer, call `yes()` or `no()`: +A função deverá efetuar a `question` e, dependendo da resposta do utilizador, chamar `yes()` ou `no()`: ```js run *!* @@ -122,24 +121,24 @@ function ask(question, yes, no) { */!* function showOk() { - alert( "You agreed." ); + alert( "Você concordou." ); } function showCancel() { - alert( "You canceled the execution." ); + alert( "Você cancelou a execução." ); } -// usage: functions showOk, showCancel are passed as arguments to ask -ask("Do you agree?", showOk, showCancel); +// uso: as funções showOk, showCancel são passadas como argumentos a ask +ask("Você concorda?", showOk, showCancel); ``` -Before we explore how we can write it in a much shorter way, let's note that in the browser (and on the server-side in some cases) such functions are quite popular. The major difference between a real-life implementation and the example above is that real-life functions use more complex ways to interact with the user than a simple `confirm`. In the browser, such a function usually draws a nice-looking question window. But that's another story. +Antes de explorarmos em como poderemos escrevê-lo de uma forma mais curta, convém notar que no navegador [browser] (e em certos casos do lado do servidor [server-side]) tais funções são muito populares. A maior difereça entre uma implementação em tempo-real [real-life] e o exemplo acima, é que funções em tempo-real usam formas mais complexas de interagir com o utilizador do que um simples `confirm`. No navegador, geralmente tal função desenha uma agradável janela contendo a questão a formular. Mas isso é outra história. -**The arguments of `ask` are called *callback functions* or just *callbacks*.** +**Os argumentos de `ask` são chamados de *funções de retorno de chamada* (callback functions) ou apenas *callbacks*.** -The idea is that we pass a function and expect it to be "called back" later if necessary. In our case, `showOk` becomes the callback for the "yes" answer, and `showCancel` for the "no" answer. +A ideia é que nós passamos uma função e esperamos que ela seja "chamada" mais tarde se necessário. No nosso caso, `showOk` se torna na função de retorno de chamada (callback) para a resposta "yes", e `showCancel` para a resposta "no". -We can use Function Expressions to write the same function much shorter: +Podemos utilizar Expressões de Funções para escrever uma versão mais curta da mesma função: ```js run no-beautify function ask(question, yes, no) { @@ -149,228 +148,228 @@ 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."); } ); */!* ``` +Aqui, as funções são declaradas justamente dentro da chamada a `ask(...)`. Elas não têm nome, e por isso são chamadas de *anónimas*. Tais funções não podem ser acedidas fora de `ask` (porque não estão atribuidas a variáveis), mas é apenas o que queremos para aqui. -Here, functions are declared right inside the `ask(...)` call. They have no name, and so are called *anonymous*. Such functions are not accessible outside of `ask` (because they are not assigned to variables), but that's just what we want here. - -Such code appears in our scripts very naturally, it's in the spirit of JavaScript. +Código semelhante aparece nos nossos programas (scripts) muito naturalmente, está no espírito de JavaScript. ```smart header="A function is a value representing an \"action\"" -Regular values like strings or numbers represent the *data*. +Valores comuns como cadeias-de-caráteres (strings) ou números representam os *dados*. -A function can be perceived as an *action*. +Uma função pode ser tida como uma *ação*. -We can pass it between variables and run when we want. +Podemos passá-la entre variáveis e executá-la quando pretendermos. ``` -## Function Expression vs Function Declaration +## Expressões de função vs Declarações de função -Let's formulate the key differences between Function Declarations and Expressions. +Vamos formular diferenças chave entre Declarações de Função e Expressões. -First, the syntax: how to see what is what in the code. +Primeiro, a sintaxe: como verificar qual é qual no código. -- *Function Declaration:* a function, declared as a separate statement, in the main code flow. +- *Declaração de Função:* uma função, declarada como uma instrução em separado, no fluxo do código principal. ```js - // Function Declaration + // Declaração de Função function sum(a, b) { return a + b; } ``` -- *Function Expression:* a function, created inside an expression or inside another syntax construct. Here, the function is created at the right side of the "assignment expression" `=`: +- *Expressão de Função:* uma função, criada dentro de uma expressão ou dentro de outra construção sintática. Aqui, a função é criada no lado direito da "expressão de atribuição" `=`: ```js - // Function Expression + // Expressão de Função let sum = function(a, b) { return a + b; }; ``` -The more subtle difference is *when* a function is created by the JavaScript engine. +A mais subtil diferença é *quando* uma função é criada pelo interpretador de JavaScript [JavaScript engine]. -**A Function Expression is created when the execution reaches it and is usable from then on.** +**Uma Expressão de Função é criada quando a execução chega até si, e é utilizável a partir daí.** -Once the execution flow passes to the right side of the assignment `let sum = function…` -- here we go, the function is created and can be used (assigned, called, etc. ) from now on. +Ao passar o fluxo de execução para o lado direito da atribuição `let sum = function…` -- aí é que é, a função é criada e pode ser utilizada (atribuida, chamada, etc.) a partir daí. -Function Declarations are different. +Declarações de Função sao diferentes. -**A Function Declaration is usable in the whole script/code block.** +**Uma Declaração de Função é utilizável ao longo de todo o script/bloco de código.** -In other words, when JavaScript *prepares* to run the script or a code block, it first looks for Function Declarations in it and creates the functions. We can think of it as an "initialization stage". +Por outras palavras, quando JavaScript se *prepara* para correr o programa (script) ou bloco de código, primeiro procura nele por Declarações de Função e cria as funções. Podemos pensar nisto como um "estágio de inicialização". -And after all of the Function Declarations are processed, the execution goes on. +Após o processamento de todas as Declarações de Função, a execução prossegue. -As a result, a function declared as a Function Declaration can be called earlier than it is defined. +Como resultado, a função declarada como Declaração de Função pode ser chamada antes da sua definição no programa. -For example, this works: +Por exemplo, isto funciona: ```js run refresh untrusted *!* -sayHi("John"); // Hello, John +sayHi("John"); // Olá, John */!* function sayHi(name) { - alert( `Hello, ${name}` ); + alert( `Olá, ${name}` ); } ``` -The Function Declaration `sayHi` is created when JavaScript is preparing to start the script and is visible everywhere in it. +A Declaração de Função `sayHi` é criada quando JavaScript se prepara para iniciar o script e é visível em todo o lugar nele. -...If it was a Function Expression, then it wouldn't work: +...Se fosse uma Expressão de Função, então não funcionaria: ```js run refresh untrusted *!* -sayHi("John"); // error! +sayHi("John"); // erro! */!* -let sayHi = function(name) { // (*) no magic any more - alert( `Hello, ${name}` ); +let sayHi = function(name) { // (*) nenhuma mágica mais + alert( `Olá, ${name}` ); }; ``` -Function Expressions are created when the execution reaches them. That would happen only in the line `(*)`. Too late. +As Expressões de Função são criadas quando a execução as alcança. O que aconteceria apenas na linha `(*)`. Tarde demais. -**When a Function Declaration is made within a code block, it is visible everywhere inside that block. But not outside of it.** +**Quando uma Declaração de Função é feita dentro de um bloco de código, ela é visível em todo o lugar dentro desse bloco. Mas não fora dele.** -Sometimes that's handy to declare a local function only needed in that block alone. But that feature may also cause problems. +Por vezes, é prático declarar uma função local apenas necessária num dado bloco. Mas essa possibilidade também pode causar problemas. -For instance, let's imagine that we need to declare a function `welcome()` depending on the `age` variable that we get during runtime. And then we plan to use it some time later. +Por exemplo, imaginemos que precisamos de declarar uma função `welcome()` que dependa da variável `age` que obtemos durante o tempo de execução (runtime). E que planejamos utilizá-la algures mais tarde. -The code below doesn't work: +O código abaixo não funciona: ```js run -let age = prompt("What is your age?", 18); +let age = prompt("Que idade tem?", 18); -// conditionally declare a function +// condicionalmente declare uma função if (age < 18) { function welcome() { - alert("Hello!"); + alert("Olá!"); } } else { function welcome() { - alert("Greetings!"); + alert("Saudações!"); } } -// ...use it later +// ...utilize-a mais tarde *!* -welcome(); // Error: welcome is not defined +welcome(); // Erro: welcome não está definida */!* ``` -That's because a Function Declaration is only visible inside the code block in which it resides. +Isto porque uma Declaração de Função apenas é visível dentro do bloco de código onde reside. -Here's another example: +Aqui está outro exemplo: ```js run -let age = 16; // take 16 as an example +let age = 16; // tenha 16 como um exemplo if (age < 18) { *!* - welcome(); // \ (runs) + welcome(); // \ (executa) */!* // | function welcome() { // | - alert("Hello!"); // | Function Declaration is available - } // | everywhere in the block where it's declared + alert("Olá!"); // | Declaração de Função está disponível + } // | em todo o lugar no bloco onde é feita // | *!* - welcome(); // / (runs) + welcome(); // / (executa) */!* } else { - function welcome() { // for age = 16, this "welcome" is never created - alert("Greetings!"); + function welcome() { // para age = 16, esta "welcome" nunca é criada + alert("Saudações!"); } } -// Here we're out of curly braces, -// so we can not see Function Declarations made inside of them. +// Aqui estamos fora das chavetas, portanto não é +// possível ver-se uma Declaração de Função feita dentro delas. *!* -welcome(); // Error: welcome is not defined +welcome(); // Erro: welcome não está definida */!* ``` -What can we do to make `welcome` visible outside of `if`? +O que poderemos fazer para tonar `welcome` visível fora do `if`? -The correct approach would be to use a Function Expression and assign `welcome` to the variable that is declared outside of `if` and has the proper visibility. +O correto seria empregar uma Função de Expressão e atribuir `welcome` a uma variável declarada fora do `if` e que tenha uma visibilidade adequada. -Now it works as intended: +Agora funciona como pretendido: ```js run -let age = prompt("What is your age?", 18); +let age = prompt("Que idade tem?", 18); let welcome; if (age < 18) { welcome = function() { - alert("Hello!"); + alert("Olá!"); }; } else { welcome = function() { - alert("Greetings!"); + alert("Saudações!"); }; } *!* -welcome(); // ok now +welcome(); // bem, agora */!* ``` -Or we could simplify it even further using a question mark operator `?`: +Ou poderíamos simplificar mais ainda utilizando o operador ponto-de-interrogação `?`: ```js run -let age = prompt("What is your age?", 18); +let age = prompt("Que idade tem?", 18); let welcome = (age < 18) ? - function() { alert("Hello!"); } : - function() { alert("Greetings!"); }; + function() { alert("Olá!"); } : + function() { alert("Saudações!"); }; *!* -welcome(); // ok now +welcome(); // bem, agora */!* ``` ```smart header="When should you choose Function Declaration versus Function Expression?" -As a rule of thumb, when we need to declare a function, the first to consider is Function Declaration syntax, the one we used before. It gives more freedom in how to organize our code, because we can call such functions before they are declared. +Como uma regra do polegar, quando precisarmos de declarar uma função, o primeiro a considerar é uma sintaxe de Declaração de Função, como utilizámos acima. Ela providencia mais liberdade para organizar o código, porque podemos chamar tais funções antes de serem declaradas. + -It's also a little bit easier to look up `function f(…) {…}` in the code than `let f = function(…) {…}`. Function Declarations are more "eye-catching". +Também é um pouco mais fácil procurar por `function f(…) {…}` no código do que `let f = function(…) {…}`. Declarações de Função "sobressaem" mais à vista. -...But if a Function Declaration does not suit us for some reason (we've seen an example above), then Function Expression should be used. +...Mas se por alguma razão uma Declaração de Função não nos for útil, (vimos um exemplo acima), então uma Expressão de Função será a escolha. ``` ## Arrow functions [#arrow-functions] -There's one more very simple and concise syntax for creating functions, that's often better than Function Expressions. It's called "arrow functions", because it looks like this: +Existe mais uma sintaxe muito simples e concisa para criar funções, e que frequentemente é melhor do que Expressões de Funções. É chamada de "Arrow functions", porque se assemelha a: ```js let func = (arg1, arg2, ...argN) => expression ``` -...This creates a function `func` that has arguments `arg1..argN`, 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`, evalua a `expression` no lado direito utilizando os mesmos e retorna o seu resultado. -In other words, it's roughly the same as: +Por outras palavras, é aproximadamente o mesmo que: ```js let func = function(arg1, arg2, ...argN) { @@ -378,14 +377,14 @@ let func = function(arg1, arg2, ...argN) { }; ``` -...But much more concise. +...Mas muito mais concisa. -Let's see an example: +Vejamos um exemplo: ```js run let sum = (a, b) => a + b; -/* The arrow function is a shorter form of: +/* A função seta é uma forma mais curta de: let sum = function(a, b) { return a + b; @@ -396,10 +395,10 @@ alert( sum(1, 2) ); // 3 ``` -If we have only one argument, then parentheses can be omitted, making that even shorter: +Se tivermos apenas um argumento, então os parênteses podem ser omitidos, tornando-a ainda mais curta: ```js run -// same as +// o mesmo que // let double = function(n) { return n * 2 } *!* let double = n => n * 2; @@ -408,45 +407,45 @@ let double = n => n * 2; alert( double(3) ); // 6 ``` -If there are no arguments, parentheses should be empty (but they should be present): +Se não houver argumentos, devem existir parênteses 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. +Arrow functions podem ser empregues da mesma forma que Expressões de Função. -For instance, here's the rewritten example with `welcome()`: +A exemplo, aqui re-escrito está o código com `welcome()`: ```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(); // ok now +welcome(); // bem, agora ``` -Arrow functions may appear unfamiliar and not very readable at first, but that quickly changes as the eyes get used to the structure. +Arrow functions podem parecer não familiares e não muito legíveis a princípio, mas isso rápidamente muda à medida que os olhos habituam-se à 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 simples ações numa única-linha, quando estamos preguiçosos demais para escrever muitas palavras. ```smart header="Multiline arrow functions" -The examples above took arguments from the left of `=>` and evaluated the right-side expression with them. +Os exemplos acima tomaram argumentos à esqerda de `=>` e evaluaram 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 e instruções. Também é possível, mas deveríamos envolvê-las em chavetas. Aí, 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, use return to get results + return result; // ao utilizarmos chavetas, usamos `return` para obter o resultado */!* }; @@ -454,25 +453,25 @@ alert( sum(1, 2) ); // 3 ``` ```smart header="More to come" -Here we praised arrow functions for brevity. But that's not all! Arrow functions have other interesting features. We'll return to them later in the chapter . +Aqui enaltecemos Arrow functions pela brevidade. Mas não é tudo! Arrow functions têm outras particulariedades interessantes. Voltaremos a elas mais adiante no capitulo . -For now, we can already use them for one-line actions and callbacks. +Por ora, podemos já usá-las para ações de única-linha e callbacks. ``` -## Summary +## Sumário -- Functions are values. They can be assigned, copied or declared in any place of the code. -- If the function is declared as a separate statement in the main code flow, that's called a "Function Declaration". -- If the function is created as a part of an expression, it's called a "Function Expression". -- Function Declarations are processed before the code block is executed. They are visible everywhere in the block. -- Function Expressions are created when the execution flow reaches them. +- Funções são valores. Elas podem ser atribuidas, copiadas ou declaradas em qualquer parte do código. +- Se a função for declarada como uma instrução separada no fluxo do código principal, é chamada de "Declaração de Função". +- Se a função for criada como parte de uma expressão, é chamada de "Expressão de função". +- Declarações de Função são processadas antes de um bloco de código ser executado. Elas são visíveis em qualquer lugar dentro do bloco. +- Expressões de função são criadas quando o fluxo de execução as alcança. -In most cases when we need to declare a function, a Function Declaration is preferable, because it is visible prior to the declaration itself. That gives us more flexibility in code organization, and is usually more readable. +Na maior parte dos casos, quando precisarmos de declarar uma função, uma Declaração de Função é preferível, porque é visível antes da própria definição. Isso dá-nos mais flexibilidade para a organização do código, e geralmente é mais legível. -So we should use a Function Expression only when a Function Declaration is not fit for the task. We've seen a couple of examples of that in this chapter, and will see more in the future. +Assim, deveríamos empregar uma Expressão de Função apenas quando a Declaração de Função não se adequasse à tarefa. Vimos alguns exemplos disso no capítulo, e veremos mais no futuro. -Arrow functions are handy for one-liners. They come in two flavors: +Arrow functions 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 evalua 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 d63363a95d4a1e1d70dd08b46e079371e53d3d1e Mon Sep 17 00:00:00 2001 From: odsantos Date: Sat, 21 Sep 2019 04:28:30 +0100 Subject: [PATCH 3/3] remove general translations of 'case' and default' --- 1-js/02-first-steps/13-switch/article.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/1-js/02-first-steps/13-switch/article.md b/1-js/02-first-steps/13-switch/article.md index 933d8297a..873699feb 100644 --- a/1-js/02-first-steps/13-switch/article.md +++ b/1-js/02-first-steps/13-switch/article.md @@ -6,7 +6,7 @@ Ela é uma forma mais descritiva de comparar um valor com múltiplas variantes. ## A sintaxe -O `switch` tem um ou mais blocos `caso` e um `defeito` opcional. +O `switch` tem um ou mais blocos `case` (caso) e um `default` (padrão) opcional. Tem uma apresentação similar a: @@ -26,9 +26,9 @@ switch(x) { } ``` -- O valor de `x` é comparado por meio de uma igualdade exata ao valor do primeiro `caso` (isto é, ao `valor1`), a seguir ao do segundo (`valor2`) e assim sucessivamente. -- Se uma igualdade é encontrada, o `switch` começa a executar o código a partir do início do `caso` correspondente, até ao próximo `break` (ou até ao fim do `switch`). -- Se nenhum caso é equiparado então o código em `defeito` é executado (se existir). +- O valor de `x` é comparado por meio de uma igualdade exata ao valor do primeiro `case` (isto é, ao `valor1`), a seguir ao do segundo (`valor2`) e assim sucessivamente. +- Se uma igualdade é encontrada, o `switch` começa a executar o código a partir do início do `case` correspondente, até ao próximo `break` (ou até ao fim do `switch`). +- Se nenhum `case` é equiparado então o código em `default` é executado (se existir). ## Um exemplo @@ -114,7 +114,7 @@ Aqui `+a` dá `1`, o que é comparado a `b + 1` no `case`, e o código correspon Múltiplas variantes de `case` que partihem o mesmo código podem ser agrupadas. -Por exemplo, se quisermos que o mesmo código corra por `caso 3` e `caso 5`: +Por exemplo, se quisermos que o mesmo código corra por `case 3` e `case 5`: ```js run no-beautify let a = 2 + 2; @@ -125,7 +125,7 @@ switch (a) { break; *!* - case 3: // (*) dois casos agrupados + case 3: // (*) dois cases agrupados case 5: alert('Errado!'); alert("Porque não tem aulas de matemática?"); @@ -139,7 +139,7 @@ switch (a) { Agora ambos `3` e `5` mostram a mesma mensagem. -A habilidade para "agrupar" casos é um efeito secundário de como `switch/case` funciona sem `break`. Aqui a execução do `caso 3` começa pela linha `(*)` e prossegue pelo `caso 5`, por não existir `break`. +A habilidade para "agrupar" cases é um efeito secundário de como `switch/case` funciona sem `break`. Aqui a execução do `case 3` começa pela linha `(*)` e prossegue pelo `case 5`, por não existir `break`. ## O tipo importa