Full translation and adaptation of learn-js.org's lessons to Brazilian Portuguese

tutorials/learn-js.org/en/Async and Await.md

@@ -1,27 +1,20 @@
 Tutorial
 --------
 
-The `async` and `await` keywords in JavaScript are used to make asynchronous programming easy,
-by introducing something called **coroutines**. A coroutine is a function which can pause
-its execution and return control to the main loop until some event occurs. It is an alternative
-approach for using callback functions, which makes it easier to write, understand and maintain.
+The `async` and `await` keywords in JavaScript are used to make asynchronous programming easy, by introducing something called **coroutines**.
+A coroutine is a function which can pause its execution and return control to the main loop until some event occurs. It is an alternative approach for using callback functions, which makes it easier to write, understand and maintain.
 
 ### The `await` keyword
 
-The `await` keyword is a special command which tells JavaScript to stop the execution of the
-current function until a Promise resolves, and then return the promise's value. It can be
-seen as an endless loop which checks if the promise has been resolved, and returns the value
-of the resolved promise when it does.
+The `await` keyword is a special command which tells JavaScript to stop the execution of the current function until a Promise resolves, and then return the promise's value.
+It can be seen as an endless loop which checks if the promise has been resolved, and returns the value of the resolved promise when it does.
 
 The `await` keyword only works inside `async` functions (which are coroutines, as explained before).
-The tricky part about `async` functions is that they return a Promise, instead of a value. This
-means that every time we need to run an `async` function, we need to `await` on it if we want
-to get the return value.
 
-Let's revisit the example of `sumAsync` from the Promises tutorial, but with using the sleep
-function instead of setTimeout, so we can implement `sumAsync` using `await` later on.
-The sleep function will return a `Promise` which resolves after `ms` milliseconds, and uses
-setTimeout to work.
+The tricky part about `async` functions is that they return a Promise, instead of a value. This means that every time we need to run an `async` function, we need to `await` on it if we want to get the return value.
+
+Let's revisit the example of `sumAsync` from the Promises tutorial, but with using the sleep function instead of setTimeout, so we can implement `sumAsync` using `await` later on.
+The sleep function will return a `Promise` which resolves after `ms` milliseconds, and uses setTimeout to work.
 
     .exec
     function sleep(ms) {
@@ -41,8 +34,7 @@ setTimeout to work.
         console.log("The result of the addition is:", result);
     });
 
-We can make our code `sumAsync` much nicer by simply using `await` on the `sleep` function and then
-returning the result.
+We can make our code `sumAsync` much nicer by simply using `await` on the `sleep` function and then returning the result.
 
     .exec
     function sleep(ms) {
@@ -61,16 +53,14 @@ returning the result.
         console.log("The result of the addition is:", result);
     });
 
-Since `sumAsync` is a an `async` function, it **implicitly** returns a `Promise`, just like
-the previous example which **explicitly** returns a `Promise`. The two `sumAsync` functions
-are completely identical in their functionality, but the one which is defined using `async`
-is much easier to understand!
+Since `sumAsync` is a an `async` function, it **implicitly** returns a `Promise`, just like the previous example which **explicitly** returns a `Promise`.
+
+The two `sumAsync` functions are completely identical in their functionality, but the one which is defined using `async` is much easier to understand!
 
 Exercise
 --------
 
-Write an async function which waits 500 milliseconds and then returns the uppercase
-of a given string. Use the `sleep` function provided.
+Write an async function which waits 500 milliseconds and then returns the uppercase of a given string. Use the `sleep` function provided.
 
 Tutorial Code
 -------------

tutorials/learn-js.org/en/Promises.md

@@ -4,11 +4,9 @@ Promises are the basics of asynchronous programming in JavaScript, and are very
 
 ### What is Asynchronous Programming?
 
-Asynchronous programming, or in short, async programming, is a method of programming which 
-enables different parts of code to run at changing times, instead of immediately.
+Asynchronous programming, or in short, async programming, is a method of programming which enables different parts of code to run at changing times, instead of immediately.
 
-This is mostly required when we want to fetch information from some remote server, and write
-code which does something with what the server returned:
+This is mostly required when we want to fetch information from some remote server, and write code which does something with what the server returned:
 
     function getServerStatus() {
         const result = fetch("/server/status");
@@ -17,13 +15,10 @@ code which does something with what the server returned:
         console.log("The status from the server is: ", result.ok);
     }
 
-In many programming languages such as Python, this approach would work, because functions
-are by default synchronous functions.
+In many programming languages such as Python, this approach would work, because functions are by default synchronous functions.
+
+In JavaScript, most APIs which require waiting for a function to do something, are **asynchronous** by default which means that this code will not do what we think it will do, since the `fetch` function is asynchronous, and therefore will return something which is not exactly the result, but will _eventually_ be the result.
 
-In JavaScript, most APIs which require waiting for a function to do something, 
-are **asynchronous** by default which means that this code will not 
-do what we think it will do, since the `fetch` function is asynchronous, and therefore will 
-return something which is not exactly the result, but will _eventually_ be the result. 
 This "thing" which is returned from the `fetch` function is called a **Promise** in JavaScript.
 
 To make the code above work, we will need to write the function in the following manner:
@@ -47,12 +42,10 @@ to use one of these two functions.
 2. It can be waited on using the `then` method (and other similar methods), or the `await` 
 statement. (The async/await statements have a separate tutorial).
 
-An asynchronous function is defined by a function, which instead of returning the value
-it was supposed to return, it returns a `Promise` object, which will eventually resolve and
+An asynchronous function is defined by a function, which instead of returning the value it was supposed to return, it returns a `Promise` object, which will eventually resolve and
 give the user the answer.
 
-For example, let's say that we would like to calculate the sum of two numbers, but by
-writing a function which returns a `Promise` and not the value.
+For example, let's say that we would like to calculate the sum of two numbers, but by writing a function which returns a `Promise` and not the value.
 
     .exec
     function sumAsync(x, y) {
@@ -70,9 +63,7 @@ writing a function which returns a `Promise` and not the value.
         console.log("The result of the addition is:", result);
     });
 
-When can this be very useful? When the calculation needs to happen indirectly, for example
-after waiting a while or when retrieving information from the server using the `fetch`
-command for example.
+When can this be very useful? When the calculation needs to happen indirectly, for example after waiting a while or when retrieving information from the server using the `fetch` command, for example.
 
 Let's modify the example to resolve the solution only after a half a second:
 
@@ -100,8 +91,7 @@ Let's modify the example to resolve the solution only after a half a second:
 
 ### Rejecting promises
 
-In a synchronous flow, if we want to tell the user that something went wrong so he can
-catch an exception, we throw an exception using the `throw` argument. When using promises,
+In a synchronous flow, if we want to tell the user that something went wrong so he can catch an exception, we throw an exception using the `throw` argument. When using promises,
 we need to trigger the `reject` function instead.
 
 Let's say we want to write the same function, but with a rejection if a value is negative:

tutorials/learn-js.org/pt/Async e Await.md

@@ -0,0 +1,94 @@
+Tutorial
+--------
+
+Estas duas palavras reservadas do JavaScript, "`async`" e "`await`", facilitam um bocado a programação assíncrona, por serem a porta de entrada das chamadas **corrotinas**.
+
+Uma corrotina é uma função que pode pausar sua execução e passar o controle ao fluxo principal até que algum evento ocorra. É uma abordagem alternativa ao uso de funções callback que deixa o código mais fácil de escrever, ler e manter.
+
+### A Palavra Reservada "`await`"
+
+A palavra reservada "`await`" é um comando especial que diz ao JavaScript em que ponto da função atual deve parar até que o objeto de tipo Promise seja concluído, para só então retornar o valor dessa promessa. Pode-se pensar em um laço infinito que verifica se a promessa concluiu, retornando o valor obtido assim que possível.
+
+A palavra reservada "`await`" só funciona dentro de funções declaradas com "`async`" (que são corrotinas, como já explicado).
+
+O desafio das funções com "`async`" é que elas sempre retornam promessas em vez de valores. Quer dizer que sempre que formos executar uma função com "`async`", precisamos usar o "`await`" se quisermos fazer operações com o valor retornado.
+
+Revisitemos o exemplo da função `somaAssincrona` do tutorial de promessas, mas definindo a função `dormir` em vez de usando a "`setTimeout`", para que possamos implementar a função `somaAssincrona` usando o "`await`" depois.
+
+A função `dormir` retornará um objeto do tipo `Promise` que concluirá após `ms` milissegundos e usará setTimeout para tal.
+
+    .exec
+    function dormir(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
+    function somaAssincrona(x, y) {
+        return new Promise((resolve, reject) => {
+            dormir(500).then(() => {
+                resolve(x + y);
+            });
+        });
+    }
+
+    // agora, abriremos a promessa
+    somaAssincrona(5, 7).then((resultado) => {
+        console.log(`O resultado da adição é ${resultado}.`);
+    });
+
+Podemos deixar o código da função `somaAssincrona` bem melhor simplesmente por usar o "`await`" na função `dormir` e retornando o resultado.
+
+    .exec
+    function dormir(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
+    async function somaAssincrona(x, y) {
+        // a função pausa por 500 milissegundos
+        await dormir(500);
+
+        // terminou. calculemos e retornemos o valor
+        return x+y;
+    }
+
+    // somaAssincrona é uma função assíncrona, quer dizer que retorna uma promessa.
+    somaAssincrona(5, 7).then((resultado) => {
+        console.log(`O resultado da adição é ${resultado}.`);
+    });
+
+Já que `somaAssincrona` é uma função declarada com "`async`", ela retorna **implicitamente** um objeto do tipo `Promise`, tal qual o exemplo mais acima, que retorna **explicitamente** uma promessa.
+
+Ambas as funções `somaAssincrona` têm funcionalidade idêntica, mas essa última, criada com o "`async`", ficou bem mais fácil de entender!
+
+Exercise
+--------
+
+Escreva uma função assíncrona via `"async"` e `"await"` que receba uma string como parâmetro e espere 500 milissegundos para retornar essa string toda em letras maiúsculas. Use a função "`sleep`" já disponibilizada.
+
+Tutorial Code
+-------------
+    function sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
+    async function uppercaseString(s) {
+        // your code goes here
+    }
+
+    uppercaseString("edward").then(console.log);
+
+Expected Output
+---------------
+EDWARD
+
+Solution
+--------
+    function sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
+    async function uppercaseString(s) {
+        await sleep(500);
+        return s.toUpperCase();
+    }
+
+    uppercaseString("edward").then(console.log);

tutorials/learn-js.org/pt/Caixas Pop-up.md

@@ -0,0 +1,34 @@
+Tutorial
+--------
+Dispomos de três tipos de caixas pop-up no JavaScript: "`alert`", "`confirm`"  e "`prompt`". Para usar qualquer uma, basta chamá-las:
+
+
+    alert("Olá.");
+    confirm("Você quer faturar uma grana?");
+    prompt("Qual o seu nome?");
+
+As caixas do tipo "`alert`" não retornam coisa alguma.
+As caixas do tipo "`confirm`" retornarão "`true`" se o usuário clicar em "OK" e retornarão "`false`" se ele clicar em "Cancelar".
+As caixas do tipo "`prompt`" retornarão qualquer coisa que o usuário escrever.
+
+Todas as caixas exibirão o argumento de seu chamamento ao usuário, no entanto as caixas do "`prompt`" têm um outro parâmetro opcional: o texto que já estará dentro da caixa por padrão.
+
+Exercise
+--------
+Crie uma variável ```test```, defina-a como o retorno de uma caixa do tipo `prompt` e escreva "Hi!" nela (sem aspas) quando ela aparecer. A propósito: seu bloqueador de pop-ups precisa estar desativado.
+
+Tutorial Code
+-------------
+// Make your prompt box below!
+
+console.log(test);
+
+Expected Output
+---------------
+Hi!
+
+Solution
+--------
+// Make your prompt box below!
+var test = prompt("Type Hi!");
+console.log(test);

tutorials/learn-js.org/pt/Contexto de Função.md

@@ -0,0 +1,122 @@
+Tutorial
+--------
+
+No JavaScript, as funções rodam em um determinado contexto o qual pode ser acessado pela palavra reservada "`this`". 
+
+Todas as funções padrão do navegador rodam sob o contexto "`Window`". As funções definidas sob um objeto ou uma classe (que é outra função) usarão o contexto do objeto em que foram criadas. No entanto, também podemos mudar o contexto de uma função a qualquer momento antes, durante ou depois da sua execução.
+
+### Atrelando um Método a um Objeto
+
+Para atrelar uma função a um objeto e fazer dela um método dele, podemos usar a função "`bind`". Aqui vai um exemplo simples:
+
+    var pessoa = {
+        nome : "Derek"
+    };
+
+    function mostraNome() {
+        console.log(this.nome);
+    }
+
+Tá na cara que a gente não vai conseguir chamar a função `mostraNome()` sem associar ela ao objeto `pessoa`, e para fazer isso, nós precisamos criar outra função que, por transitividade, associe a função ao objeto da seguinte forma:
+
+    var mostraNomeAssociado = mostraNome.bind(pessoa);
+    mostraNomeAssociado();
+>exibe "Derek"
+
+### Chamando uma Função de um Contexto Diferente
+
+Podemos usar as funções "`call`" e "`apply`" para chamar uma função como se estivesse atrelada a um objeto. A diferença entre ambas é apenas a ordem dos argumentos: a função `call` recebe o parâmetro `this` primeiro e depois a função a ser atrelada, enquanto a função "`apply`" recebe como primeiro parâmetro o `this` e um vetor de parâmetros para passar à função como o segundo.
+
+Por exemplo, chamemos `mostraNome` sob o contexto `pessoa` usando a função "`call`":
+
+    mostraNome.call(pessoa);
+>retorna "Derek"
+
+### "`Call`" e "`Apply`" vs. "`Bind`"
+
+A diferença entre "`call`", "`apply`" e "`bind`" é que o "`bind`" retorna uma nova função idêntica à antiga, com a diferença de que o valor de "`this`" da nova função corresponde ao objeto que lhe foi atrelado. Já "`call`" e "`apply`" chamam a função com o "`this`" já sendo o objeto atrelado, mas sem o retorno de uma nova função ou mudanças na original, apenas a chamam com um valor diferente para o "`this`".
+
+For example:
+
+    var mostraNomeAssociado = mostraNome.call(pessoa);    // mostraNomeAssociado pega o valor retornado pela função mostraNome (null)
+    mostraNomeAssociado();                               // não funciona porque não é uma função, é um Null
+
+    mostraNome.bind(pessoa);                         // retorna uma função, mas já que nada a está usando, é inútil
+    mostraNome();                                    // dá um erro porque "this.nome" não foi definido no contexto puro de mostraNome 
+
+Pense no "`call`" como a execução do valor **retornado** pelo "`bind`".
+
+Por exemplo:
+
+    mostraNome.call(pessoa);     // é o mesmo que
+    mostraNome.bind(pessoa)();   // executa a função retornada pelo bind
+
+Ou pense no "`bind`" como um atalho para o "`call`".
+
+Por exemplo:
+
+    var mostraNomeAssociado = mostraNome.bind(pessoa); // é o mesmo que
+
+    var mostraNomeAssociado = function() {
+        mostraNome.call(pessoa);
+    }
+
+
+Exercise
+--------
+
+Crie cópias das funções "`printFullName`" e "`printDetails`" atreladas ao objeto "`person`", chamando-as "`boundPrintFullName`" e `"boundPrintDetails"`.
+
+Tutorial Code
+-------------
+
+var person = {
+    firstName : "John",
+    lastName : "Smith",
+    age : 23
+};
+
+function printFullName() {
+    console.log(this.firstName + " " + this.lastName);
+}
+
+function printDetails() {
+    console.log(this.firstName + " is " + this.age + " years old");
+}
+
+// TODO: create bound copies of printFullName and printDetails.
+var boundPrintFullName;
+var boundPrintDetails;
+
+boundPrintFullName();
+boundPrintDetails();
+
+Expected Output
+---------------
+
+John Smith
+John is 23 years old
+
+Solution
+--------
+
+var person = {
+    firstName : "John",
+    lastName : "Smith",
+    age : 23
+};
+
+function printFullName() {
+    console.log(this.firstName + " " + this.lastName);
+}
+
+function printDetails() {
+    console.log(this.firstName + " is " + this.age + " years old");
+}
+
+// TODO: create bound copies of printFullName and printDetails.
+var boundPrintFullName = printFullName.bind(person);
+var boundPrintDetails = printDetails.bind(person);
+
+boundPrintFullName();
+boundPrintDetails();