Merge branch 'conflicts-check-after-pr178' of https://github.com/odsantos/pt.javascript.info into conflicts-check-after-pr178

Author: odsantos

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

@@ -35,7 +35,7 @@ let message;
 message = 'Olá!';
 
 *!*
-alert(message); // mostra o conteúdo variável
+alert(message); // mostra o conteúdo da variável
 */!*
 ```
 
@@ -94,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
@@ -129,7 +129,7 @@ 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!
 ```
@@ -151,7 +151,7 @@ Assim, devemos declarar uma variável apenas uma vez e depois fazer referência
 ```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 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 alguma dessas linguagens (mesmo que você não esteja planejando usá-la em breve) é recomendado para ampliar a mente.
 ```
@@ -195,8 +195,8 @@ 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 de alfabeto 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 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 имя = '...';
@@ -237,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
 */!*
 ```
 ````
@@ -303,7 +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.
 
-O nome de uma variável deve ter um significado claro e óbvio, descrevendo os dados que ela armazena.
+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 que código foi escrito por um iniciante versus um desenvolvedor experiente.
 
@@ -336,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/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"
 ```
+

1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.svg

@@ -2,11 +2,11 @@
 
 Sometimes, we need to perform different actions based on different conditions.
 
-To do that, we use the `if` statement and the conditional (ternary) operator which we will be referring to as the “question mark” operator `?` for simplicity.
+To do that, we can use the `if` statement and the conditional operator `?`, that's also called a "question mark" operator.
 
 ## The "if" statement
 
-The `if` statement evaluates a condition and, if the condition's result is `true`, executes a block of code.
+The `if(...)` statement evaluates a condition in parentheses and, if the result is `true`, executes a block of code.
 
 For example:
 
@@ -103,7 +103,7 @@ In the code above, JavaScript first checks `year < 2015`. If that is falsy, it g
 
 There can be more `else if` blocks. The final `else` is optional.
 
-## Ternary operator '?'
+## Conditional operator '?'
 
 Sometimes, we need to assign a variable depending on a condition.
 
@@ -124,9 +124,9 @@ if (age > 18) {
 alert(accessAllowed);
 ```
 
-The so-called "ternary" or "question mark" operator lets us do that in a shorter and simpler way.
+The so-called "conditional" or "question mark" operator lets us do that in a shorter and simpler way.
 
-The operator is represented by a question mark `?`.  The formal term "ternary" means that the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
+The operator is represented by a question mark `?`. Sometimes it's called "ternary", because the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
 
 The syntax is:
 ```js
@@ -141,7 +141,7 @@ For example:
 let accessAllowed = (age > 18) ? true : false;
 ```
 
-Technically, we can omit the parentheses around `age > 18`. The question mark operator has a low precedence, so it executes after the comparison `>`. 
+Technically, we can omit the parentheses around `age > 18`. The question mark operator has a low precedence, so it executes after the comparison `>`.
 
 This example will do the same thing as the previous one:
 
@@ -216,7 +216,7 @@ Depending on the condition `company == 'Netscape'`, either the first or the seco
 
 We don't assign a result to a variable here. Instead, we execute different code depending on the condition.
 
-**We don't recommend using the question mark operator in this way.**
+**It's not recommended to use the question mark operator in this way.**
 
 The notation is shorter than the equivalent `if` statement, which appeals to some programmers. But it is less readable.