From 3b7521d85f749576316baa2293206b25b526c66a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nildo=20J=C3=BAnior?= <nildo.jnr@gmail.com>
Date: Mon, 4 Nov 2019 21:39:19 +0100
Subject: [PATCH 1/6] Translate Callbacks' section Introduction

---
 1-js/11-async/01-callbacks/article.md | 48 +++++++++++++--------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/1-js/11-async/01-callbacks/article.md b/1-js/11-async/01-callbacks/article.md
index 742b621b7..4f34f09a2 100644
--- a/1-js/11-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -1,10 +1,10 @@
 
 
-# Introduction: callbacks
+# Introdução: callbacks
 
-Many actions in JavaScript are *asynchronous*.
+Muitas ações em JavaScript são *assíncronas*.
 
-For instance, take a look at the function `loadScript(src)`:
+Por exemplo, veja a função `loadScript(src)`:
 
 ```js
 function loadScript(src) {
@@ -14,40 +14,40 @@ function loadScript(src) {
 }
 ```
 
-The purpose of the function is to load a new script. When it adds the `<script src="…">` to the document, the browser loads and executes it.
+O objetivo da função é carregar um novo script. Quando ela adiciona o `<script src="…">` no documento, o navegador carrega e executa esse script.
 
-We can use it like this:
+Podemos usar essa função assim:
 
 ```js
-// loads and executes the script
+// carrega e executa o script
 loadScript('/my/script.js');
 ```
 
-The function is called "asynchronously," because the action (script loading) finishes not now, but later.
+A função é chamada "assincronamente" porque a ação (carregar o script) não termina no mesmo instante. Ela termina mais tarde.
 
-The call initiates the script loading, then the execution continues. While the script is loading, the code below may finish executing, and if the loading takes time, other scripts may run meanwhile too.
+A chamada inicia o carregamento do script, e depois a execução continua. Enquanto o script está carregando, o código que está embaixo pode terminar de executar. E se o carregamento demorar, outros scripts podem executar enquanto isso.
 
 ```js
 loadScript('/my/script.js');
-// the code below loadScript doesn't wait for the script loading to finish
+// o código embaixo de loadScript não espera o carregamento do script terminar
 // ...
 ```
 
-Now let's say we want to use the new script when it loads. It probably declares new functions, so we'd like to run them.
+Agora, vamos imaginar que queremos usar o novo script quando ele terminar de carregar. Ele provavelmente declara novas funções, e queremos executar elas.
 
-But if we do that immediately after the `loadScript(…)` call, that wouldn't work:
+Mas se nós fizermos isso imediatamente depois da chamada `loadScript(…)`, não iria funcionar.
 
 ```js
-loadScript('/my/script.js'); // the script has "function newFunction() {…}"
+loadScript('/my/script.js'); // o script tem "function newFunction() {…}"
 
 *!*
-newFunction(); // no such function!
+newFunction(); // a função não existe!
 */!*
 ```
 
-Naturally, the browser probably didn't have time to load the script. So the immediate call to the new function fails. As of now, the `loadScript` function doesn't provide a way to track the load completion. The script loads and eventually runs, that's all. But we'd like to know when it happens, to use new functions and variables from that script.
+Naturalmente, o navegador provavelmente não teve tempo de carregar o script. Então a chamada imediata para a nova função falha. Do jeito que está, a função `loadScript` não provê uma maneira de saber quando o carregamento termina. O script carrega e eventualmente é executado, isso é tudo. Mas nós queremos saber quando isso acontece, para podermos usar as novas funções e variáveis daquele script.
 
-Let's add a `callback` function as a second argument to `loadScript` that should execute when the script loads:
+Vamos adicionar uma função `callback` como segundo argumento em `loadScript` que deve executar quando o script terminar de carregar:
 
 ```js
 function loadScript(src, *!*callback*/!*) {
@@ -62,19 +62,19 @@ function loadScript(src, *!*callback*/!*) {
 }
 ```
 
-Now if we want to call new functions from the script, we should write that in the callback:
+Agora se nós quisermos chamar as novas funções do script, nós podemos fazer isso no callback:
 
 ```js
 loadScript('/my/script.js', function() {
-  // the callback runs after the script is loaded
-  newFunction(); // so now it works
+  // o callback executa depois que o script termina de carregar
+  newFunction(); // então agora funciona
   ...
 });
 ```
 
-That's the idea: the second argument is a function (usually anonymous) that runs when the action is completed.
+Esta é a ideia: o segundo argumento é uma função (normalmente anônima) que executa quando a ação termina.
 
-Here's a runnable example with a real script:
+Veja um exemplo executável com um script real:
 
 ```js run
 function loadScript(src, callback) {
@@ -86,15 +86,15 @@ function loadScript(src, callback) {
 
 *!*
 loadScript('https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js', script => {
-  alert(`Cool, the ${script.src} is loaded`);
-  alert( _ ); // function declared in the loaded script
+  alert(`Legal, o ${script.src} está carregado`);
+  alert( _ ); // função declarada no script carregado
 });
 */!*
 ```
 
-That's called a "callback-based" style of asynchronous programming. A function that does something asynchronously should provide a `callback` argument where we put the function to run after it's complete.
+Isso é chamado de programação assíncrona "baseada em callbacks". A função que faz alguma coisa assincronamente deve prover um argumento `callback` onde nós colocamos a função que vai executar depois que ela terminar.
 
-Here we did it in `loadScript`, but of course, it's a general approach.
+Aqui nós fizemos isso em `loadScript`, mas é claro que isso é uma abordagem genérica.
 
 ## Callback in callback
 

From 91547eedb2d902b74229f1ca593affe2897470bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nildo=20J=C3=BAnior?= <nildo.jnr@gmail.com>
Date: Wed, 25 Dec 2019 15:21:26 +0100
Subject: [PATCH 2/6] Translate Callbacks' section Callback in callback

---
 1-js/11-async/01-callbacks/article.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/1-js/11-async/01-callbacks/article.md b/1-js/11-async/01-callbacks/article.md
index 4f34f09a2..56bb576d7 100644
--- a/1-js/11-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -96,29 +96,29 @@ Isso é chamado de programação assíncrona "baseada em callbacks". A função
 
 Aqui nós fizemos isso em `loadScript`, mas é claro que isso é uma abordagem genérica.
 
-## Callback in callback
+## Callback no callback
 
-How can we load two scripts sequentially: the first one, and then the second one after it?
+Como poderíamos carregar dois scripts sequencialmente? Carregar um primeiro, e depois o segundo?
 
-The natural solution would be to put the second `loadScript` call inside the callback, like this:
+A solução natural seria colocar a segunda chamada de `loadScript` dentro do callback, assim:
 
 ```js
 loadScript('/my/script.js', function(script) {
 
-  alert(`Cool, the ${script.src} is loaded, let's load one more`);
+  alert(`Legal, ${script.src} foi carregado, vamos carregar mais um`);
 
 *!*
   loadScript('/my/script2.js', function(script) {
-    alert(`Cool, the second script is loaded`);
+    alert(`Legal, o segundo script foi carregado`);
   });
 */!*
 
 });
 ```
 
-After the outer `loadScript` is complete, the callback initiates the inner one.
+Depois que o `loadScript` de fora termina, o callback inicia o `loadScript` de dentro.
 
-What if we want one more script...?
+E se nós quisermos mais um script...?
 
 ```js
 loadScript('/my/script.js', function(script) {
@@ -127,7 +127,7 @@ loadScript('/my/script.js', function(script) {
 
 *!*
     loadScript('/my/script3.js', function(script) {
-      // ...continue after all scripts are loaded
+      // ...continua depois que todo os scripts forem carregados
     });
 */!*
 
@@ -136,7 +136,7 @@ loadScript('/my/script.js', function(script) {
 });
 ```
 
-So, every new action is inside a callback. That's fine for few actions, but not good for many, so we'll see other variants soon.
+Então, toda ação nova fica dentro de um callback. Tudo bem para poucas ações, mas não é bom para muitas ações. Por isso nós vamos ver outras variantes em breve.
 
 ## Handling errors
 

From dc9cc8045ce3d98597d5809aedf87008085084d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nildo=20J=C3=BAnior?= <nildo.jnr@gmail.com>
Date: Fri, 3 Jan 2020 01:17:19 +0100
Subject: [PATCH 3/6] Translate Callbacks' section Handling errors

---
 1-js/11-async/01-callbacks/article.md | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/1-js/11-async/01-callbacks/article.md b/1-js/11-async/01-callbacks/article.md
index 56bb576d7..db6c680ce 100644
--- a/1-js/11-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -138,11 +138,11 @@ loadScript('/my/script.js', function(script) {
 
 Então, toda ação nova fica dentro de um callback. Tudo bem para poucas ações, mas não é bom para muitas ações. Por isso nós vamos ver outras variantes em breve.
 
-## Handling errors
+## Tratando erros
 
-In the above examples we didn't consider errors. What if the script loading fails? Our callback should be able to react on that.
+No exemplo acima nós não consideramos erros. E se o carregamento do script falhar? Nosso callback deveria ser capaz de reagir a isso.
 
-Here's an improved version of `loadScript` that tracks loading errors:
+Abaixo temos uma versão melhorada do `loadScript` que pega os erros de carregamento:
 
 ```js run
 function loadScript(src, callback) {
@@ -151,33 +151,33 @@ function loadScript(src, callback) {
 
 *!*
   script.onload = () => callback(null, script);
-  script.onerror = () => callback(new Error(`Script load error for ${src}`));
+  script.onerror = () => callback(new Error(`Erro no carregamento do script ${src}`));
 */!*
 
   document.head.append(script);
 }
 ```
 
-It calls `callback(null, script)` for successful load and `callback(error)` otherwise.
+O código acima chama `callback(null, script)` quando o carregamento é feito com sucesso e `callback(error)` caso contrário.
 
-The usage:
+Usando a função:
 ```js
 loadScript('/my/script.js', function(error, script) {
   if (error) {
-    // handle error
+    // tratar o erro
   } else {
-    // script loaded successfully
+    // script carregado com sucesso
   }
 });
 ```
 
-Once again, the recipe that we used for `loadScript` is actually quite common. It's called the "error-first callback" style.
+De novo, o padrão que nós usamos para o `loadScript` é bem comum. É chamado de estilo "error-first callback".
 
-The convention is:
-1. The first argument of the `callback` is reserved for an error if it occurs. Then `callback(err)` is called.
-2. The second argument (and the next ones if needed) are for the successful result. Then `callback(null, result1, result2…)` is called.
+A convenção é:
+1. O primeiro argumento do `callback` é reservado para um erro, se algum ocorrer. Então `callback(err)` é chamado.
+2. O segundo argumento (e o próximo se for necessário) são para quando houver sucesso. Então `callback(null, result1, result2…)` é chamado.
 
-So the single `callback` function is used both for reporting errors and passing back results.
+Assim uma única função `callback` é usada tanto para reportar erros quanto para retornar os resultados.
 
 ## Pyramid of Doom
 

From 0aa5cb27381d10086ffec43b2c4623907f710b9d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nildo=20J=C3=BAnior?= <nildo.junior@cognite.com>
Date: Mon, 18 May 2020 18:11:57 +0200
Subject: [PATCH 4/6] Translate Callbacks' section Pyramid of Doom

---
 1-js/11-async/01-callbacks/article.md | 38 +++++++++++++--------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/1-js/11-async/01-callbacks/article.md b/1-js/11-async/01-callbacks/article.md
index db6c680ce..d68304e21 100644
--- a/1-js/11-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -179,11 +179,11 @@ A convenção é:
 
 Assim uma única função `callback` é usada tanto para reportar erros quanto para retornar os resultados.
 
-## Pyramid of Doom
+## Pirâmide da Perdição
 
-From the first look, it's a viable way of asynchronous coding. And indeed it is. For one or maybe two nested calls it looks fine.
+À primeira vista parece uma maneira viável de programação assíncrona. E realmente é. Para uma ou duas chamadas aninhadas está ok.
 
-But for multiple asynchronous actions that follow one after another we'll have code like this:
+Mas para múltiplas ações assíncronas que seguem uma depois da outra, vamos ter um código como esse:
 
 ```js
 loadScript('1.js', function(error, script) {
@@ -202,7 +202,7 @@ loadScript('1.js', function(error, script) {
             handleError(error);
           } else {
   *!*
-            // ...continue after all scripts are loaded (*)
+            // ...continua depois que todos os scripts são carregados (*)
   */!*
           }
         });
@@ -213,14 +213,14 @@ loadScript('1.js', function(error, script) {
 });
 ```
 
-In the code above:
-1. We load `1.js`, then if there's no error.
-2. We load `2.js`, then if there's no error.
-3. We load `3.js`, then if there's no error -- do something else `(*)`.
+No código acima:
+1. Carregamos `1.js`, e depois, se não tiver nenhum erro.
+2. Carregamos `2.js`, e depois, se não tiver nenhum erro.
+3. Carregamos `3.js`, e depois, se não tiver nenhum erro -- faz outra coisa `(*)`.
 
-As calls become more nested, the code becomes deeper and increasingly more difficult to manage, especially if we have a real code instead of `...`, that may include more loops, conditional statements and so on.
+À medida em que as chamadas ficam mais aninhadas, o código vai ficando mais profundo e cada vez mais difícil de gerenciar, especialmente se nós tivermos um código real em vez de `...`, que pode incluir mais laços, condicionais e assim por diante.
 
-That's sometimes called "callback hell" or "pyramid of doom."
+Isso é às vezes chamado de "callback hell (inferno dos callbacks)" ou "pyramid of doom (pirâmide da perdição)."
 
 <!--
 loadScript('1.js', function(error, script) {
@@ -248,11 +248,11 @@ loadScript('1.js', function(error, script) {
 
 ![](callback-hell.svg)
 
-The "pyramid" of nested calls grows to the right with every asynchronous action. Soon it spirals out of control.
+A "pirâmide" de chamadas aninhadas cresce para a direita a cada ação assíncrona e rapidamente sai de controle.
 
-So this way of coding isn't very good.
+Então esse jeito de programar não é muito bom.
 
-We can try to alleviate the problem by making every action a standalone function, like this:
+Nós podemos tentar diminuir o problema fazendo cada ação ser uma função separada, assim:
 
 ```js
 loadScript('1.js', step1);
@@ -279,17 +279,17 @@ function step3(error, script) {
   if (error) {
     handleError(error);
   } else {
-    // ...continue after all scripts are loaded (*)
+    // ...continua depois que todos os scripts são carregados (*)
   }
 };
 ```
 
-See? It does the same, and there's no deep nesting now because we made every action a separate top-level function.
+Viu? Isso faz a mesma coisa, e não tem um aninhamento profundo agora porque nós fizemos cada ação em uma função separada no mesmo nível.
 
-It works, but the code looks like a torn apart spreadsheet. It's difficult to read, and you probably noticed that one needs to eye-jump between pieces while reading it. That's inconvenient, especially if the reader is not familiar with the code and doesn't know where to eye-jump.
+funciona, porém o código parece uma planilha dividida. É difícil de ler, e você provavelmente percebeu que precisamos pular entre as partes do código enquanto estamos lendo ele. Isso é inconveniente, especialmente se o leitor não estiver familiarizado com o código e não souber para onde pular.
 
-Also, the functions named `step*` are all of single use, they are created only to avoid the "pyramid of doom." No one is going to reuse them outside of the action chain. So there's a bit of a namespace cluttering here.
+Além disso, as funções chamadas `step*` são todas utilizadas apenas uma vez. Elas são criadas apenas pra evitar a "pirâmide da perdição." Ninguém vai reutilizá-las fora da cadeia de ações. Então tem um pouco de bagunça aqui.
 
-We'd like to have something better.
+Gostaríamos de ter algo melhor.
 
-Luckily, there are other ways to avoid such pyramids. One of the best ways is to use "promises," described in the next chapter.
+Felizmente, existem outras maneiras de evitar essas pirâmides. Uma das melhores maneiras é usar "promises (promessas)", descritas no próximo capítulo.

From f954d7a7ca1b27caa533f88a1aa9a649317eff21 Mon Sep 17 00:00:00 2001
From: Nildo Junior <nildo.jnr@gmail.com>
Date: Sat, 6 Aug 2022 10:53:43 +0200
Subject: [PATCH 5/6] Add suggested changes

---
 1-js/11-async/01-callbacks/article.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/1-js/11-async/01-callbacks/article.md b/1-js/11-async/01-callbacks/article.md
index cf9d728d9..98e291b1d 100644
--- a/1-js/11-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -10,7 +10,7 @@ Se você não está familiarizado com esses métodos, e o uso deles nos exemplos
 Mas nós vamos tentar deixar as coisas claras de qualquer jeito. Não vai ter nada muito complexo em relação ao navegador.
 ```
 
-Muitas funções providas pelo JavaScript permitem que você agende ações *assíncronas*. Em outras palavras, ações que nós iniciamos agora, mas elas terminam mais tarde.
+Muitas funções providas pelo JavaScript permitem que você agende ações *assíncronas*. Em outras palavras, ações que nós iniciamos agora, mas que terminam mais tarde.
 
 Por exemplo, uma dessas funções é a função `setTimeout`.
 
@@ -49,7 +49,7 @@ loadScript('/my/script.js');
 
 Agora, vamos imaginar que queremos usar o novo script assim que ele terminar de carregar. Ele provavelmente declara novas funções, e queremos executar elas.
 
-Mas se nós fizermos isso imediatamente depois da chamada `loadScript(…)`, não iria funcionar.
+Mas se nós fizéssemos isso imediatamente depois da chamada `loadScript(…)`, não iria funcionar.
 
 ```js
 loadScript('/my/script.js'); // o script tem "function newFunction() {…}"
@@ -106,7 +106,7 @@ loadScript('https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js', s
 */!*
 ```
 
-Isso é chamado de programação assíncrona "baseada em callbacks". A função que faz alguma coisa assincronamente deve prover um argumento `callback` onde nós colocamos a função que vai executar depois que ela terminar.
+Isso é chamado de programação assíncrona "baseada em callbacks". A função que faz alguma coisa assincronamente deve prover um argumento `callback` onde nós colocamos a função que vai executar depois que ela estiver completa.
 
 Aqui nós fizemos isso em `loadScript`, mas é claro que isso é uma abordagem genérica.
 
@@ -156,7 +156,7 @@ Então, toda ação nova fica dentro de um callback. Tudo bem para poucas açõe
 
 No exemplo acima nós não consideramos erros. E se o carregamento do script falhar? Nosso callback deveria ser capaz de reagir a isso.
 
-Abaixo temos uma versão melhorada do `loadScript` que pega os erros de carregamento:
+Abaixo temos uma versão melhorada do `loadScript` que rastreia os erros de carregamento:
 
 ```js
 function loadScript(src, callback) {
@@ -185,7 +185,7 @@ loadScript('/my/script.js', function(error, script) {
 });
 ```
 
-De novo, o padrão que nós usamos para o `loadScript` é bem comum. É chamado de estilo "error-first callback".
+De novo, o padrão que nós usamos para o `loadScript` é bem comum. É chamado de estilo "callback com erro primeiro".
 
 A convenção é:
 1. O primeiro argumento do `callback` é reservado para um erro, se algum ocorrer. Então `callback(err)` é chamado.
@@ -262,7 +262,7 @@ loadScript('1.js', function(error, script) {
 
 ![](callback-hell.svg)
 
-A "pirâmide" de chamadas aninhadas cresce para a direita a cada ação assíncrona e rapidamente sai de controle.
+A "pirâmide" de chamadas aninhadas cresce para a direita a cada ação assíncrona e rapidamente sai do controle.
 
 Então esse jeito de programar não é muito bom.
 
@@ -300,7 +300,7 @@ function step3(error, script) {
 
 Viu? Isso faz a mesma coisa, e não tem um aninhamento profundo agora porque nós fizemos cada ação em uma função separada no mesmo nível.
 
-funciona, porém o código parece uma planilha dividida. É difícil de ler, e você provavelmente percebeu que precisamos pular entre as partes do código enquanto estamos lendo ele. Isso é inconveniente, especialmente se o leitor não estiver familiarizado com o código e não souber para onde pular.
+Funciona, porém o código parece uma planilha dividida. É difícil de ler, e você provavelmente percebeu que precisamos de pular entre as partes do código enquanto estamos lendo ele. Isso é inconveniente, especialmente se o leitor não estiver familiarizado com o código e não souber para onde pular.
 
 Além disso, as funções chamadas `step*` são todas utilizadas apenas uma vez. Elas são criadas apenas pra evitar a "pirâmide da perdição." Ninguém vai reutilizá-las fora da cadeia de ações. Então tem um pouco de bagunça aqui.
 

From 89747adae2cfb377c8a3a922fa5a24912e0be40c Mon Sep 17 00:00:00 2001
From: Nildo Junior <nildo.jnr@gmail.com>
Date: Sat, 6 Aug 2022 10:59:09 +0200
Subject: [PATCH 6/6] Translate comment

---
 1-js/11-async/01-callbacks/article.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1-js/11-async/01-callbacks/article.md b/1-js/11-async/01-callbacks/article.md
index 98e291b1d..e28b60993 100644
--- a/1-js/11-async/01-callbacks/article.md
+++ b/1-js/11-async/01-callbacks/article.md
@@ -20,8 +20,8 @@ Veja a função `loadScript(src)`, que carrega um script com um dado `src`:
 
 ```js
 function loadScript(src) {
-  // creates a <script> tag and append it to the page
-  // this causes the script with given src to start loading and run when complete
+  // cria uma tag <script> e a anexa à página
+  // isso faz com que o script com o determinado src comece a carregar e seja executado quando concluído
   let script = document.createElement('script');
   script.src = src;
   document.head.append(script);