Merge pull request #184 from odsantos/conflicts-check-after-pr178

Update "1-js/02-first-steps" (04 - 10) after #178

Author: odsantos

1-js/02-first-steps/04-variables/article.md

@@ -12,11 +12,7 @@ Uma [variável](https://pt.wikipedia.org/wiki/Variável_(programação)) é um "
 
 Para criar uma variável em JavaScript, use a palavra-chave `let`.
 
-<<<<<<< HEAD
-A declaração abaixo cria (em outras palavras: * declara * ou * define *) uma variável com o nome "message":
-=======
-The statement below creates (in other words: *declares*) a variable with the name "message":
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
+A declaração abaixo cria (em outras palavras: *declara*) uma variável com o nome "message":
 
 ```js
 let message;
@@ -39,7 +35,7 @@ let message;
 message = 'Olá!';
 
 *!*
-alert(message); // mostra o conteúdo variável
+alert(message); // mostra o conteúdo da variável
 */!*
 ```
 
@@ -74,7 +70,7 @@ let user = 'John',
   message = 'Olá';
 ```
 
-... Ou até mesmo no estilo "comma-first":
+... Ou até mesmo no estilo "vírgula-primeiro":
 
 ```js no-beautify
 let user = 'John'
@@ -98,13 +94,13 @@ Existem diferenças sutis entre `let` e `var`, mas elas ainda não são importan
 
 ## Uma analogia da vida real
 
-Podemos facilmente compreender o conceito de uma "variável" se a imaginarmos como uma "box" de dados, com um adesivo de nome exclusivo.
+Podemos facilmente compreender o conceito de uma "variável" se a imaginarmos como uma "caixa" para dados, com um adesivo de nome exclusivo.
 
-Por exemplo, a variável `mensagem` pode ser imaginada como uma box chamada `"message"`com o valor `"Olá"`!:
+Por exemplo, a variável `mensagem` pode ser imaginada como uma caixa chamada `"message"`com o valor `"Olá"`!:
 
 ![](variable.svg)
 
-Podemos pôr qualquer valor na box.
+Podemos pôr qualquer valor na caixa.
 
 Também podemos mudá-lo quantas vezes quisermos:
 ```js run
@@ -133,36 +129,31 @@ let message;
 message = hello;
 */!*
 
-// agora duas variáveis mantêm os mesmos dados
+// agora duas variáveis contêm os mesmos dados
 alert(hello); // Olá Mundo!
 alert(message); // Olá Mundo!
 ```
 
-<<<<<<< HEAD
-```smart header="Linguagens funcionais"
-É interessante notar que linguagens de programação [funcional](https://en.wikipedia.org/wiki/Functional_programming), como [Scala](http://www.scala-lang.org/) or [Erlang](http://www.erlang.org/), proibem a modificação de valores de variáveis.
-=======
-````warn header="Declaring twice triggers an error"
-A variable should be declared only once.
+````warn header="Declarar duas vezes lança um erro"
+Uma variável deve ser declarada apenas uma vez.
 
-A repeated declaration of the same variable is an error:
+Uma declaração repetida da mesma variável é um erro:
 
 ```js run
-let message = "This";
+let message = "Isto";
 
-// repeated 'let' leads to an error
-let message = "That"; // SyntaxError: 'message' has already been declared
+// um 'let' repetido conduz a um erro
+let message = "Aquilo"; // SyntaxError: 'message' has already been declared (Erro-de-sintaxe: 'message' já foi declarado)
 ```
-So, we should declare a variable once and then refer to it without `let`.
+Assim, nós devemos declarar uma variável uma única vez e depois fazer referência a ela sem o `let`.
 ````
 
-```smart header="Functional languages"
-It's interesting to note that there exist [functional](https://en.wikipedia.org/wiki/Functional_programming) programming languages, like [Scala](http://www.scala-lang.org/) or [Erlang](http://www.erlang.org/) that forbid changing variable values.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
+```smart header="Linguagens funcionais"
+É interessante notar que existem linguagens de programação [funcionais](https://en.wikipedia.org/wiki/Functional_programming), como [Scala](http://www.scala-lang.org/) ou [Erlang](http://www.erlang.org/), que proíbem a modificação de valores de variáveis.
 
-Em tais linguagens, uma vez que o valor é armazenado "na box", ele está lá para sempre. Se precisarmos de armazenar algo mais, a linguagem nos obriga a criar uma nova box (declarar uma nova variável). Não podemos reutilizar a antiga.
+Em tais linguagens, uma vez que o valor é armazenado "na caixa", ele está lá para sempre. Se precisarmos de armazenar algo mais, a linguagem nos obriga a criar uma nova caixa (declarar uma nova variável). Não podemos reutilizar a antiga.
 
-Embora possa parecer um pouco estranho à primeira vista, estas línguas são bastante capazes de um desenvolvimento sério. Mais do que isso, há áreas como cálculos paralelos onde essa limitação confere certos benefícios. Estudar tal linguagem (mesmo que você não esteja planejando usá-la em breve) é recomendado para ampliar a mente.
+Embora possa parecer um pouco estranho à primeira vista, estas linguagens são bastante capazes de um desenvolvimento sério. Mais do que isso, há áreas como cálculos paralelos onde essa limitação confere certos benefícios. Estudar uma linguagem dessas (mesmo que você não esteja planejando usá-la em breve) é recomendado para ampliar a mente.
 ```
 
 ## Nomeação de variável [#variable-naming]
@@ -204,19 +195,15 @@ let my-name; // hífens '-' não são permitidos no nome
 Variáveis chamadas `apple` e `AppLE` são duas variáveis diferentes.
 ```
 
-````smart header="Letras não inglesas são permitidas, mas não são recomendadas"
-É possível usar qualquer idioma, incluindo letras cirílicas ou até hieróglifos, como este:
+````smart header="Letras não-Latin são permitidas, mas não são recomendadas"
+É possível usar qualquer idioma, incluindo letras cirílicas ou até hieróglifos, como estes:
 
 ```js
 let имя = '...';
 let 我 = '...';
 ```
 
-<<<<<<< HEAD
 Tecnicamente, não há erro aqui, tais nomes são permitidos, mas há uma tradição internacional de usar o inglês em nomes de variáveis. Mesmo que estejamos escrevendo um pequeno script, ele pode ter uma longa vida pela frente. Pessoas de outros países podem precisar lê-lo em algum momento.
-=======
-Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it some time.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 ````
 
 ````warn header="Nomes reservados"
@@ -250,7 +237,7 @@ Esta é uma má prática e causaria um erro no modo estrito:
 "use strict";
 
 *!*
-num = 5; // erro: o número não está definido
+num = 5; // erro: 'num' não está definido
 */!*
 ```
 ````
@@ -263,19 +250,15 @@ Para declarar uma variável constante (imutável), use `const` em vez de `let`:
 const myBirthday = '18.04.1982';
 ```
 
-<<<<<<< HEAD
 Variáveis declaradas usando `const` são chamadas de "constantes". Elas não podem ser alteradas. Uma tentativa de fazer isso causaria um erro:
-=======
-Variables declared using `const` are called "constants". They cannot be reassigned. An attempt to do so would cause an error:
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
 
 ```js run
 const myBirthday = '18.04.1982';
 
 myBirthday = '01.01.2001'; // erro, não é possível reatribuir a constante!
 ```
 
-Quando um programador é certo que uma variável nunca mudará, eles podem declará-la com `const` para garantir e comunicar claramente esse fato a todos.
+Quando um programador está certo que uma variável nunca mudará, ele pode declará-la com `const` para garantir e comunicar claramente esse fato a todos.
 
 
 ### Constantes maiúsculas
@@ -320,11 +303,7 @@ Em outras palavras, constantes com nomes maiúsculos são usadas apenas como pse
 
 Falando em variáveis, há mais uma coisa extremamente importante.
 
-<<<<<<< HEAD
-Por favor, nomeie as suas variáveis de forma sensata. Tome tempo para pensar sobre isso.
-=======
-A variable name should have a clean, obvious meaning, describing the data that it stores.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3
+O nome de uma variável deveria ter um significado claro e óbvio, descrevendo os dados que ela armazena.
 
 A nomenclatura variável é uma das habilidades mais importantes e complexas em programação. Uma rápida olhada em nomes de variáveis pode revelar qual código foi escrito por um iniciante versus um desenvolvedor experiente.
 
@@ -357,7 +336,7 @@ Os minificadores e navegadores JavaScript modernos otimizam o código o suficien
 
 Podemos declarar variáveis para armazenar dados usando as palavras-chave `var`, `let`, ou `const`.
 
-- `let` -- é uma declaração de variável moderna. O código deve estar em modo estrito para usar `let` no Chrome (V8).
+- `let` -- é uma declaração de variável moderna.
 - `var` -- é uma declaração de variável da velha escola. Normalmente não a usamos de todo, mas vamos cobrir diferenças sutis de `let` no capítulo <info:var>, para o caso de você precisar delas.
 - `const` -- é como `let`, mas o valor da variável não pode ser alterado.
 

1-js/02-first-steps/05-types/article.md

@@ -35,7 +35,7 @@ Além dos números regulares, existem os chamados "valores numéricos especiais"
     alert( 1 / 0 ); // Infinito
     ```
 
-     Ou apenas referi-lo directamente:
+     Ou apenas referi-lo diretamente:
 
     ```js run
     alert( Infinity ); // Infinito
@@ -178,7 +178,7 @@ O valor especial `undefined` também se diferencia. Faz um tipo próprio, tal co
 
 O significado de `undefined` é "o valor não é atribuído".
 
-Se uma variável é declarada, mas não atribuida, então seu valor é `undefined`:
+Se uma variável é declarada, mas não atribuída, então seu valor é `undefined`:
 
 ```js run
 let age;
@@ -252,7 +252,7 @@ As três últimas linhas podem precisar de explicações adicionais:
 
 1. `Math` é um objeto embutido que fornece operações matemáticas. Nós o vamos aprender no capítulo <info:number>. Aqui, ele serve apenas como um exemplo de um objeto.
 2. O resultado de `typeof null` é `"object"`. É um erro oficialmente reconhecido no comportamento de `typeof` e mantido para compatibilidade. Naturalmente, `null` não é um objeto. É um valor especial com um tipo separado próprio.
-3. O resultado de `typeof alert` é `"function"`, porque `alert` é uma função. Vamos estudar as funções nos próximos capítulos onde veremos tambémm que não há nenhum tipo especial "função" em JavaScript. As funções pertencem ao tipo objecto. Mas o `typeof` as trata de forma diferente, retornando `"function"`. Isto, também vem dos primeiros dias do JavaScript. Tecnicamente, é incorrecto, mas muito conveniente na prática.
+3. O resultado de `typeof alert` é `"function"`, porque `alert` é uma função. Vamos estudar as funções nos próximos capítulos onde veremos também que não há nenhum tipo especial "função" em JavaScript. As funções pertencem ao tipo objecto. Mas o `typeof` as trata de forma diferente, retornando `"function"`. Isto, também vem dos primeiros dias do JavaScript. Tecnicamente, é incorreto, mas muito conveniente na prática.
 
 ## Resumo
 

1-js/02-first-steps/06-alert-prompt-confirm/article.md

@@ -4,11 +4,7 @@ As we'll be using the browser as our demo environment, let's see a couple of fun
 
 ## alert
 
-<<<<<<< HEAD:1-js/02-first-steps/06-alert-prompt-confirm/article.md
-This one we've seen already. It shows a message and waits for the user to presses "OK".
-=======
 This one we've seen already. It shows a message and waits for the user to press "OK".
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3:1-js/02-first-steps/06-alert-prompt-confirm/article.md
 
 For example:
 
@@ -35,11 +31,7 @@ It shows a modal window with a text message, an input field for the visitor, and
 : An optional second parameter, the initial value for the input field.
 
 ```smart header="The square brackets in syntax `[...]`"
-<<<<<<< HEAD:1-js/02-first-steps/06-alert-prompt-confirm/article.md
-The square brackets around `default` in the syntax above denote that the parameter as optional, not required.
-=======
 The square brackets around `default` in the syntax above denote that the parameter is optional, not required.
->>>>>>> e074a5f825a3d10b0c1e5e82561162f75516d7e3:1-js/02-first-steps/06-alert-prompt-confirm/article.md
 ```
 
 The visitor can type something in the prompt input field and press OK. Then we get that text in the `result`. Or they can cancel the input by pressing Cancel or hitting the `key:Esc` key, then we get `null` as the `result`.

1-js/02-first-steps/08-operators/article.md

@@ -172,11 +172,11 @@ Why are unary pluses applied to values before the binary ones? As we're going to
 
 ## Operator precedence
 
-If an expression has more than one operator, the execution order is defined by their *precedence*, or, in other words, the implicit priority order of operators.
+If an expression has more than one operator, the execution order is defined by their *precedence*, or, in other words, the default priority order of operators.
 
 From school, we all know that the multiplication in the expression `1 + 2 * 2` should be calculated before the addition. That's exactly the precedence thing. The multiplication is said to have *a higher precedence* than the addition.
 
-Parentheses override any precedence, so if we're not satisfied with the implicit order, we can use them to change it. For example: `(1 + 2) * 2`.
+Parentheses override any precedence, so if we're not satisfied with the default order, we can use them to change it. For example, write `(1 + 2) * 2`.
 
 There are many operators in JavaScript. Every operator has a corresponding precedence number. The one with the larger number executes first. If the precedence is the same, the execution order is from left to right.
 
@@ -232,7 +232,7 @@ alert( a ); // 3
 alert( c ); // 0
 ```
 
-In the example above, the result of `(a = b + 1)` is the value which is assigned to `a` (that is `3`). It is then used for further evaluations.
+In the example above, the result of expression `(a = b + 1)` is the value which was assigned to `a` (that is `3`). It is then used for further evaluations.
 
 Funny code, isn't it? We should understand how it works, because sometimes we see it in JavaScript libraries.
 
@@ -311,14 +311,14 @@ So, there are special operators for it:
 
     ```js run no-beautify
     let counter = 2;
-    counter++;      // works the same as counter = counter + 1, but is shorter
+    counter++;        // works the same as counter = counter + 1, but is shorter
     alert( counter ); // 3
     ```
 - **Decrement** `--` decreases a variable by 1:
 
     ```js run no-beautify
     let counter = 2;
-    counter--;      // works the same as counter = counter - 1, but is shorter
+    counter--;        // works the same as counter = counter - 1, but is shorter
     alert( counter ); // 1
     ```
 
@@ -451,10 +451,10 @@ Here, the first expression `1 + 2` is evaluated and its result is thrown away. T
 ```smart header="Comma has a very low precedence"
 Please note that the comma operator has very low precedence, lower than `=`, so parentheses are important in the example above.
 
-Without them: `a = 1 + 2, 3 + 4` evaluates `+` first, summing the numbers into `a = 3, 7`, then the assignment operator `=` assigns    `a = 3`, and finally the number after the comma, `7`, is not processed so it's ignored.
+Without them: `a = 1 + 2, 3 + 4` evaluates `+` first, summing the numbers into `a = 3, 7`, then the assignment operator `=` assigns `a = 3`, and the rest is ignored. It's like `(a = 1 + 2), 3 + 4`.
 ```
 
-Why do we need an operator that throws away everything except the last part?
+Why do we need an operator that throws away everything except the last expression?
 
 Sometimes, people use it in more complex constructs to put several actions in one line.
 
@@ -467,4 +467,4 @@ for (*!*a = 1, b = 3, c = a * b*/!*; a < 10; a++) {
 }
 ```
 
-Such tricks are used in many JavaScript frameworks. That's why we're mentioning them. But, usually, they don't improve code readability so we should think well before using them.
+Such tricks are used in many JavaScript frameworks. That's why we're mentioning them. But usually they don't improve code readability so we should think well before using them.

1-js/02-first-steps/09-comparison/1-comparison-questions/task.md

@@ -15,3 +15,4 @@ undefined === null
 null == "\n0\n"
 null === +"\n0\n"
 ```
+