Merge branch 'master' into switch

Author: odsantos

1-js/01-getting-started/1-intro/article.md

@@ -109,8 +109,9 @@ Exemplos de tais linguagens:
 - [CoffeeScript](http://coffeescript.org/) é um "açúcar sintático" para JavaScript. Ele introduz uma sintaxe mais curta, permitindo-nos escrever um código mais claro e preciso. Normalmente, Ruby devs gostam dele.
 - [TypeScript](http://www.typescriptlang.org/) está concentrado em adicionar "estritos tipos de dados" para simplificar o desenvolvimento e suporte de sistemas complexos. É desenvolvido pela Microsoft.
 - [Flow](http://flow.org/) também adiciona tipos de dados, mas de uma forma diferente. Desenvolvido pela Facebook.
-- [Dart](https://www.dartlang.org/) é uma linguagem autônoma que tem seu próprio interpretador que roda em ambientes fora do navegador (como aplicativos móveis), mas também pode ser transpilada para JavaScript. Desenvolvido pela Google.
+- [Dart](https://www.dartlang.org/) é uma linguagem autônoma que tem seu próprio interpretador que roda em ambientes fora do navegador (como aplicativos móveis), mas também pode ser transpilada para JavaScript. Desenvolvida pela Google.
 - [Brython](https://brython.info/) é um transpilador de Python para JavaScript que permite escrever aplicativos em puro Python, sem JavaScript.
+- [Kotlin](https://kotlinlang.org/docs/js-overview.html) é uma linguagem de programação moderna, concisa e segura, que pode ser usada no navegador ou no Node.
 
 Há mais. Claro que, mesmo que usemos uma dessas linguagens transpiladas, também devemos saber JavaScript para entender o que estamos fazendo.
 

1-js/01-getting-started/2-manuals-specifications/article.md

@@ -17,16 +17,12 @@ E mais, se você está desenvolvendo para browsers, há outras especificações
 
 ## Manuais
 
-- **MDN (Mozilla) JavaScript Reference**  é um manual com exemplos e outras informações. É ótimo para um entendimento sobre funções, métodos da linguagem, etc.
+- **MDN (Mozilla) JavaScript Reference**  é um manual com exemplos e outras informações. É ótimo para um entendimento sobre funções da linguagem, métodos , etc.
 
 	Pode ser encontrado em <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference>.
 
 	Porém, às vezes é melhor fazer uma busca na internet. Apenas use "MDN [termo]" na busca, por exemplo: <https://google.com/search?q=MDN+parseInt> para procurar pela função `parseInt`.
 
-- **MSDN** - Manual da Microsoft com muitas informações, incluindo JavaScript (frequentemente referido como JScript). Se precisar de algo específico para o Internet Explorer, é melhor ir por aqui: <http://msdn.microsoft.com/>.
-
-	Assim como para o manual da Mozilla, também podemos fazer uma busca na internet com frases do tipo "RegExp MSDN" ou "RegExp MSDN jscript".
-
 ## Tabelas de compatibilidade
 
 JavaScript é uma linguagem em desenvolvimento, novas funcionalidades são adicionadas regularmente.

1-js/02-first-steps/04-variables/2-declare-variables/solution.md

@@ -1,21 +1,21 @@
-Primeiro, a variável para o nome do nosso planeta.
+## A variável para o nosso planeta
 
 Isso é simples:
 
 ```js
 let ourPlanetName = "Earth";
 ```
 
-Note que poderíamos usar um nome mais curto, `planet`, mas pode não ser óbvio a que planeta se refere. É bom ser mais detalhado. Pelo menos até a variável isNotTooLong.
+Note que poderíamos usar um nome mais curto, `planet`, mas pode não ser óbvio a que planeta se refere. É bom ser mais detalhado. Pelo menos até a variável naoForDemasiadoLonga.
 
-Em segundo lugar, o nome do visitante atual:
+## O nome do visitante atual
 
 ```js
 let currentUserName = "John";
 ```
 
-Novamente, nós poderíamos encurtar isso para `userName` se tivermos certeza que o usuário é atual.
+Novamente, nós poderíamos encurtar isso para `userName` se tivermos a certeza de que o usuário é o atual.
 
 Os editores modernos e o autocomplete facilitam a escrita de nomes longos de variáveis. Não salve neles. Um nome com 3 palavras é o suficiente.
 
-E se o seu editor não possui autocompletar corretamente, obtenha [um novo](/code-editors).
+E se o seu editor não possui autocompletar corretamente, obtenha [um novo](/code-editors).

1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/solution.md

@@ -1,24 +1,24 @@
-JavaScript-code:
+Código Javascript:
 
 ```js demo run
-let name = prompt("What is your name?", "");
+let name = prompt("Qual o seu nome?", "");
 alert(name);
 ```
 
-The full page:
+Página completa:
 
 ```html
 <!DOCTYPE html>
 <html>
 <body>
 
-  <script>
-    'use strict';
+    <script>
+      'use strict';
 
-    let name = prompt("What is your name?", "");
-    alert(name);
-  </script>
+      let name = prompt("Qual o seu nome?", "");
+      alert(name);
+    </script>
 
-</body>
+ </body>
 </html>
 ```

1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/task.md

@@ -2,8 +2,8 @@ importance: 4
 
 ---
 
-# A simple page
+# Uma página simples
 
-Create a web-page that asks for a name and outputs it.
+Crie uma página web que solicite um nome e o exiba.
 
 [demo]

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

@@ -1,105 +1,105 @@
-# Interaction: alert, prompt, confirm
+# Interação: alert, prompt, confirm
 
-As we'll be using the browser as our demo environment, let's see a couple of functions to interact with the user: `alert`, `prompt` and `confirm`.
+Como usuaremos o navegador como nosso ambiente de demonstração, vamos ver algumas funções para interagir com o usuário: `alert`, `prompt` e `confirm`.
 
 ## alert
 
-This one we've seen already. It shows a message and waits for the user to press "OK".
+Esta já vimos. Ela mostra uma mensagem e aguarda o usuário pressionar "OK".
 
-For example:
+Por exemplo:
 
 ```js run
-alert("Hello");
+alert('Olá');
 ```
 
-The mini-window with the message is called a *modal window*. The word "modal" means that the visitor can't interact with the rest of the page, press other buttons, etc, until they have dealt with the window. In this case -- until they press "OK".
+A mini-janela com a mensagem é chamada de _modal window_. A palavra "modal" significa que o visitante não pode interagir com o resto da página, pressionar outros botões, etc, até que ele tenha lidado com a janela. Nesse caso -- até pressionar "OK".
 
 ## prompt
 
-The function `prompt` accepts two arguments:
+A função `prompt` aceita dois argumentos:
 
 ```js no-beautify
 result = prompt(title, [default]);
 ```
 
-It shows a modal window with a text message, an input field for the visitor, and the buttons OK/Cancel.
+Mostra uma janela modal com uma mensagem de texto, um campo de entrada para o visitante, e os botões OK/Cancel.
 
 `title`
-: The text to show the visitor.
+: Texto para ser mostrado ao visitante.
 
 `default`
-: An optional second parameter, the initial value for the input field.
+: Um parâmetro opcional, o valor inicial para o campo de entrada.
 
-```smart header="The square brackets in syntax `[...]`"
-The square brackets around `default` in the syntax above denote that the parameter is optional, not required.
-```
+```smart header="Os colchetes na sintaxe `[...]`"
+ Os colchetes ao redor de `default` na sintaxe acima denotam que o parâmetro é opcional, não é obrigatório.
+````
 
-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`.
+O visitante pode digitar algo no campo de entrada do prompt e pressionar OK. Então nós temos esse texto no `result`.  Ou ele pode cancelar a entrada pressionando Cancelar ou `key:Esc`, então nos temos `null` como o `result`.
 
-The call to `prompt` returns the text from the input field or `null` if the input was canceled.
+A chamada do `prompt` retorna o texto do campo de entrada ou `null` se a entrada for cancelada.
 
-For instance:
+Por exemplo:
 
 ```js run
-let age = prompt('How old are you?', 100);
+let age = prompt('Qual a sua idade?', 100);
 
-alert(`You are ${age} years old!`); // You are 100 years old!
-```
+alert(`Você tem ${age} anos!`); //Você tem 100 anos!
+````
 
-````warn header="In IE: always supply a `default`"
-The second parameter is optional, but if we don't supply it, Internet Explorer will insert the text `"undefined"` into the prompt.
+````warn header="No IE: sempre forneça um `default`"
+O segundo parâmetro é opcional, mas se não o fornecermos, o Internet Explorer irá inserir o texto `"undefined"` no prompt.
 
-Run this code in Internet Explorer to see:
+Execute este código no Internet Explorer para visualizar:
 
 ```js run
-let test = prompt("Test");
+let test = prompt('Teste');
 ```
 
-So, for prompts to look good in IE, we recommend always providing the second argument:
+Portanto, para que os prompts tenham boa aparência no IE, recomendamos que sempre forneça o segundo argumento:
 
 ```js run
-let test = prompt("Test", ''); // <-- for IE
+let test = prompt('Teste', ''); // <-- para o IE
 ```
 ````
 
 ## confirm
 
-The syntax:
+A sintaxe:
 
 ```js
 result = confirm(question);
 ```
 
-The function `confirm` shows a modal window with a `question` and two buttons: OK and Cancel.
+A função `confirm` mostra uma janela modal com uma `question` e dois botões: OK e Cancelar.
 
-The result is `true` if OK is pressed and `false` otherwise.
+O resultado é `true` se OK for pressionado e `false` caso contrário.
 
-For example:
+Por exemplo:
 
 ```js run
-let isBoss = confirm("Are you the boss?");
+let isBoss = confirm("Você é o chefe?");
 
-alert( isBoss ); // true if OK is pressed
+alert( isBoss ); // true se OK for pressionado
 ```
 
-## Summary
+## Sumário
 
-We covered 3 browser-specific functions to interact with visitors:
+Cobrimos 3 funções específicas do navegador para interagir com o visitante:
 
 `alert`
-: shows a message.
+: mostra uma mensagem.
 
 `prompt`
-: shows a message asking the user to input text. It returns the text or, if Cancel button or `key:Esc` is clicked, `null`.
+: mostra uma mensagem pedindo para o usuário inserir texto. Ela retorna o texto ou, se CANCEL ou `key:Esc` for clicado, `null`.
 
 `confirm`
-: shows a message and waits for the user to press "OK" or "Cancel". It returns `true` for OK and `false` for Cancel/`key:Esc`.
+: mostra uma mensagem e espera que o usuário pressione  "OK" ou "Cancel". Ela retorna `true` para OK e `false` para Cancel/`key:Esc`.
 
-All these methods are modal: they pause script execution and don't allow the visitor to interact with the rest of the page until the window has been dismissed.
+Todos esse métodos são modais: eles pausam a execução do script e não permitem ao visitante interagir com o resto da página até que a janela seja descartada.
 
-There are two limitations shared by all the methods above:
+Existem duas limitações compartilhadas entre esses metódos acima:
 
-1. The exact location of the modal window is determined by the browser. Usually, it's in the center.
-2. The exact look of the window also depends on the browser. We can't modify it.
+1. A localização exata da janela modal é determinada pelo navegador. Geralmente, está no centro.
+2. A aparência exata da janela também depende do navegador. Nós não podemos modificá-la.
 
-That is the price for simplicity. There are other ways to show nicer windows and richer interaction with the visitor, but if "bells and whistles" do not matter much, these methods work just fine.
+Este é o preço da simplicidade. Existem outras maneiras de mostrar janelas mais agradáveis e interações mais ricas aos visitantes, mas se "sinos e assobios" não importam muito, esses métodos funcionam bem.

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

@@ -104,7 +104,12 @@ Here's a more complex example:
 alert(2 + 2 + '1' ); // "41" and not "221"
 ```
 
-Here, operators work one after another. The first `+` sums two numbers, so it returns `4`, then the next `+` adds the string `1` to it, so it's like `4 + '1' = 41`.
+Here, operators work one after another. The first `+` sums two numbers, so it returns `4`, then the next `+` adds the string `1` to it, so it's like `4 + '1' = '41'`.
+
+```js run
+alert('1' + 2 + 2); // "122" and not "14"
+```
+Here, the first operand is a string, the compiler treats the other two operands as strings too. The `2` gets concatenated to `'1'`, so it's like `'1' + 2 = "12"` and `"12" + 2 = "122"`.
 
 The binary `+` is the only operator that supports strings in such a way. Other arithmetic operators work only with numbers and always convert their operands to numbers.
 
@@ -214,7 +219,7 @@ alert( x ); // 5
 
 The fact of `=` being an operator, not a "magical" language construct has an interesting implication.
 
-Most operators in JavaScript return a value. That's obvious for `+` and `-`, but also true for `=`.
+All operators in JavaScript return a value. That's obvious for `+` and `-`, but also true for `=`.
 
 The call `x = value` writes the `value` into `x` *and then returns it*.
 

1-js/02-first-steps/10-ifelse/article.md

@@ -68,7 +68,7 @@ if (cond) {
 
 ## The "else" clause
 
-The `if` statement may contain an optional "else" block. It executes when the condition is false.
+The `if` statement may contain an optional "else" block. It executes when the condition is falsy.
 
 For example:
 ```js run

1-js/02-first-steps/18-javascript-specials/article.md

@@ -273,7 +273,7 @@ We covered three ways to create a function in JavaScript:
     ```
 
 
-- Functions may have local variables: those declared inside its body. Such variables are only visible inside the function.
+- Functions may have local variables: those declared inside its body or its parameter list. Such variables are only visible inside the function.
 - Parameters can have default values: `function sum(a = 1, b = 2) {...}`.
 - Functions always return something. If there's no `return` statement, then the result is `undefined`.
 

1-js/03-code-quality/01-debugging-chrome/article.md

@@ -135,7 +135,7 @@ Existem botões para isso no topo do painel direito. Vamos interagir com eles.
     Continuando a clicar nele, passará por todas as instruções do programa, uma por uma.
 
 <span class="devtools" style="background-position:-62px -192px"></span> -- "Step over": execute o próximo comando, mas *mas não vá para dentro de uma função*, atalho `key:F10`.
-: Similar ao comando "Step" anterior, mas com um comportamento diferente se a próxima instrução for uma chamada de função. Isto é: não uma incorporada (*built-in*), como `alert`, mas uma função sua.
+: Similar ao comando "Step" anterior, mas com um comportamento diferente se a próxima instrução for uma chamada de função. Isto é: não uma incorporada (*built-in*), como `alert`, mas uma função nossa.
 
     O comando "Step", vai para dentro dela e suspende a execução na sua primeira linha, ao contrário de "Step over" que executa essa chamada de função aninhada invisívelmente, saltando sobre o funcionamento interno da função.