Merge branch 'master' into master

Author: odsantos

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

@@ -26,7 +26,7 @@ Interpretadores diferentes têm "codinomes" diferentes. Por exemplo:
 
 - [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- no Chrome e no Opera.
 - [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- no Firefox.
-- ...Há outros codinomes como "Chakra" para o IE, "ChakraCore" para Microsoft Edge, "Nitro" e "SquirrelFish" para Safari, etc.
+- ...Há outros codinomes como "Chakra" para o IE, "JavaScriptCore", "Nitro" e "SquirrelFish" para Safari, etc.
 
 Os termos acima são bons para lembrar, pois são usados em artigos de desenvolvedores na internet. Vamos usá-los também. Por exemplo, se "um recurso X é suportado pelo V8", então ele provavelmente funciona no Chrome e no Opera.
 
@@ -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/02-structure/article.md

@@ -46,7 +46,7 @@ alert(3 +
 + 2);
 ```
 
-O código produz `6` porque o Javascript não insere pontos e virgulas aqui. É intuitivamente óbvio que se a linha termina com um sinal de mais `"+"`, então é uma "expressão incompleta", logo o ponto e vírgula não é necessário. E neste caso isso funciona como pretendido.
+O código produz `6` porque o Javascript não insere pontos e virgulas aqui. É intuitivamente óbvio que se a linha termina com um sinal de mais `"+"`, então é uma "expressão incompleta", logo o ponto e vírgula aí seria incorreto. E neste caso isso funciona como pretendido.
 
 **Mas há situações em que o JavaScript "falha" em assumir um ponto e vírgula onde ele é realmente necessário.**
 
@@ -56,40 +56,36 @@ Erros que ocorrem em tais casos são bastante difíceis de encontrar e corrigir.
 Se você está curioso para ver um exemplo concreto de tal erro, verifique este código:
 
 ```js run
-[1, 2].forEach(alert)
+alert("Hello");
+
+[1, 2].forEach(alert);
 ```
 
-Não há necessidade de pensar sobre o significado dos parênteses `[]` e `forEach` ainda. Nós vamos estudá-los mais tarde. Por enquanto, apenas lembre-se que o resultado do código: mostra `1` e depois` 2`.
+Não há necessidade de pensar sobre o significado dos parênteses `[]` e também do `forEach`. Nós vamos estudá-los mais tarde. Por enquanto, apenas lembre-se do resultado da execução do código: ele mostra `Hello`, depois `1`, e depois` 2`.
 
-Agora, vamos adicionar um `alert` antes do código e * não * terminá-lo com um ponto e vírgula:
+Agora, vamos remover o ponto e vírgula depois do `alert`:
 
 ```js run no-beautify
-alert("Haverá um erro")
+alert("Hello")
 
-[1, 2].forEach(alert)
+[1, 2].forEach(alert);
 ```
 
-Agora, se nós executarmos o código, apenas o primeiro `alert` é mostrado e então temos um erro!
-
-Mas tudo está bem novamente se adicionarmos um ponto e vírgula após `alert`:
-```js run
-alert("Tudo bem agora");
+A diferença em comparação com o código acima é de apenas um caractere: o ponto e vírgula da primeira linha se foi.
 
-[1, 2].forEach(alert)  
-```
+Se nós executarmos esse código, apenas o primeiro `Hello` é mostrado (e então há um erro, você pode precisar de abrir a consola para o ver). Já não existem mais números.
 
-Agora temos a mensagem "Tudo bem agora" seguida por "1" e "2".
+Isso ocorre porque o JavaScript não assume um ponto e vírgula antes dos colchetes `[...]`. Portanto, o código no último exemplo é tratado como uma única instrução. 
 
-
-O erro na variante sem ponto e vírgula ocorre porque o JavaScript não assume um ponto e vírgula antes dos colchetes `[...]`.
-
-Portanto, como o ponto e vírgula não é inserido automaticamente, o código no primeiro exemplo é tratado como uma única instrução. Veja como o mecanismo vê isso:
+Veja como o mecanismo vê isso:
 
 ```js run no-beautify
-alert("Haverá um erro")[1, 2].forEach(alert)
+alert("Hello")[1, 2].forEach(alert);
 ```
 
-Mas devem ser duas declarações separadas, não uma. Tal fusão neste caso é completamente errado, daí o erro. Isso pode acontecer em outras situações.
+Parece estranho, não? Tal fusão neste caso é completamente errada. Nós precisamos de colocar um ponto e vírgula depois de `alert` para o código funcionar corretamente.
+
+Isso também pode acontecer em outras situações.
 ````
 
 Recomendamos colocar ponto e vírgula entre as frases, mesmo que estejam separadas por novas linhas. Esta regra é amplamente adotada pela comunidade. Vamos notar mais uma vez -- *é possível* deixar de fora os pontos e vírgulas na maior parte do tempo. Mas é mais seguro -- especialmente para um iniciante -- usá-los.

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

@@ -24,7 +24,7 @@ Agora, podemos colocar alguns dados usando o operador de atribuição `=`:
 let message;
 
 *!*
-message = 'Olá'; // armazenar a string
+message = 'Olá'; // armazene a string 'Olá' na variável chamada message
 */!*
 ```
 

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

@@ -64,7 +64,7 @@ Os valores numéricos especiais pertencem formalmente ao tipo "número". Claro q
 
 Veremos mais sobre como trabalhar com números no capítulo <info:number>.
 
-## BigInt
+## BigInt [#bigint-type]
 
 In JavaScript, the "number" type cannot represent integer values larger than <code>(2<sup>53</sup>-1)</code> (that's `9007199254740991`), or less than <code>-(2<sup>53</sup>-1)</code> for negatives. It's a technical limitation caused by their internal representation.
 

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/3-primitive-conversions-questions/solution.md

@@ -9,7 +9,6 @@ true + false = 1
 "$" + 4 + 5 = "$45"
 "4" - 2 = 2
 "4px" - 2 = NaN
-7 / 0 = Infinity
 "  -9  " + 5 = "  -9  5" // (3)
 "  -9  " - 5 = -14 // (4)
 null + 1 = 1 // (5)

1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md

@@ -16,7 +16,6 @@ true + false
 "$" + 4 + 5
 "4" - 2
 "4px" - 2
-7 / 0
 "  -9  " + 5
 "  -9  " - 5
 null + 1