Resolve conflicts

Author: odsantos

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

@@ -24,19 +24,11 @@ O navegador tem um interpretador(motor) incorporado, às vezes chamado de "máqu
 
 Interpretadores diferentes têm "codinomes" diferentes. Por exemplo:
 
-<<<<<<< HEAD
-- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- no Chrome e no Opera.
+- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- no Chrome, Opera e Edge.
 - [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- no Firefox.
 - ...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.
-=======
-- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome, Opera and Edge.
-- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
-- ...There are other codenames like "Chakra" for IE, "JavaScriptCore", "Nitro" and "SquirrelFish" for Safari, etc.
-
-The terms above are good to remember because they are used in developer articles on the internet. We'll use them too. For instance, if "a feature X is supported by V8", then it probably works in Chrome, Opera and Edge.
->>>>>>> 193319c963b9ba86ac7d9590f7261a36ecdcc4d2
+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 Chrom, Opera e Edge.
 
 ```smart header="Como funcionam os interpretadores?"
 
@@ -53,7 +45,7 @@ O interpretador aplica otimizações em cada etapa do processo. Ele ainda observ
 
 JavaScript moderno é uma linguagem de programação "segura". Ele não fornece acesso de baixo nível à memória ou CPU, porque foi inicialmente criado para navegadores que não necessitam dele.
 
-As capacidades do JavaScript dependem muito do ambiente em que está sendo executado. Por exemplo, [Node.js](https://wikipedia.org/wiki/Node.js) suporta funções que permitem ao JavaScript ler/gravar arquivos arbitrários, executar solicitações de rede, etc.
+As capacidades do JavaScript dependem muito do ambiente em que está sendo executado. Por exemplo, [Node.js]https://pt.wikipedia.org/wiki/Node.js) suporta funções que permitem ao JavaScript ler/gravar arquivos arbitrários, executar solicitações de rede, etc.
 
 O JavaScript no navegador pode fazer tudo relacionado à manipulação de páginas web, interação com o usuário e o servidor web.
 

1-js/01-getting-started/3-code-editors/article.md

@@ -13,9 +13,9 @@ Uma IDE carrega o projeto (que pode ter muitos arquivos), permite navegação en
 Se você ainda não tiver selecionado uma IDE, considere as seguintes opções:
 
 - [Visual Studio Code](https://code.visualstudio.com/) (plataforma cruzada, livre).
-- [WebStorm](http://www.jetbrains.com/webstorm/) (plataforma cruzada, pago).
+- [WebStorm](https://www.jetbrains.com/pt-br/webstorm/) (plataforma cruzada, pago).
 
-Para Windows, há também "Visual Studio", que não deve ser confundido com "Visual Studio Code". "Visual Studio" é um editor pago e poderoso somente para Windows, bem adequado para a plataforma .NET . Uma versão gratuita é chamada [Visual Studio Community](https://www.visualstudio.com/vs/community/).
+Para Windows, há também "Visual Studio", que não deve ser confundido com "Visual Studio Code". "Visual Studio" é um editor pago e poderoso somente para Windows, bem adequado para a plataforma .NET . Uma versão gratuita é chamada [Visual Studio Community](https://visualstudio.microsoft.com/pt-br/vs/community/).
 
 Muitas IDEs são pagas, mas têm um período experimental. Seu custo é geralmente desprezível comparado ao salário de um desenvolvedor qualificado, então basta escolher o melhor para você.
 
@@ -31,18 +31,10 @@ Na prática, os editores leves podem ter muitos plug-ins, incluindo analisadores
 
 As seguintes opções merecem sua atenção:
 
-<<<<<<< HEAD
 - [Atom](https://atom.io/) (plataforma cruzada, livre).
-- [Visual Studio Code](https://code.visualstudio.com/) (plataforma cruzada, livre).
 - [Sublime Text](http://www.sublimetext.com) (plataforma cruzada, shareware).
 - [Notepad++](https://notepad-plus-plus.org/) (Windows, livre).
 - [Vim](http://www.vim.org/) e [Emacs](https://www.gnu.org/software/emacs/) também são legais se você sabe como usá-los.
-=======
-- [Atom](https://atom.io/) (cross-platform, free).
-- [Sublime Text](http://www.sublimetext.com) (cross-platform, shareware).
-- [Notepad++](https://notepad-plus-plus.org/) (Windows, free).
-- [Vim](http://www.vim.org/) and [Emacs](https://www.gnu.org/software/emacs/) are also cool if you know how to use them.
->>>>>>> 193319c963b9ba86ac7d9590f7261a36ecdcc4d2
 
 ## Não vamos discutir
 

1-js/03-code-quality/02-coding-style/article.md

@@ -54,7 +54,7 @@ if (condição) {
 
 Uma construção de única-linha, tal como `if (condição) doSomething()`, é um importante caso de exceção. Devemos utilizar chavetas, ou não?
 
-Aqui estão variantes com anotações, para que por si mesmo você possa avaliar a sua legíbilidade:
+Aqui estão variantes com anotações, para que por si mesmo você possa avaliar a sua legibilidade:
 
 1. 😠 Principiantes, por vezes fazem isto. É mau! As chavetas não são necessárias:
     ```js
@@ -83,11 +83,12 @@ Para código muito curto, uma única linha é aceitável, ex: `if (cond) return
 Ninguém gosta de ler uma longa linha horizontal de código. A melhor prática é a particionar.
 
 Por exemplo:
-
 ```js
 // o acento grave (*backtick*) ` permite repartir uma *string* por múltiplas linhas
 let str = `
-  O TC39 da ECMA International, é um grupo de desenvolvedores e implementadores de JavaScript, académicos, e outros, colaborando com a comunidade para manter e evoluir a definição de JavaScript.
+  O TC39 da ECMA International, é um grupo de desenvolvedores e 
+  implementadores de JavaScript, académicos, e outros, colaborando com a comunidade 
+  para manter e evoluir a definição de JavaScript.
 `;
 ```
 
@@ -148,7 +149,7 @@ Existem dois tipos de indentação:
 
 ### Pontos-e-vírgula
 
-Um ponto-e-vírgula deveria estar presente no fim de cada instrução, mesmo que possívelmente pudesse ser omitido.
+Um ponto-e-vírgula deveria estar presente no fim de cada instrução, mesmo que possivelmente pudesse ser omitido.
 
 Existem linguagens em que o ponto-e-vírgula é verdadeiramente opcional, e raramente utilizado. Contudo, em JavaScript, há casos em que uma quebra-de-linha não é interpretada como um ponto-e-vírgula, deixando o código vulnerável a erros. Veja mais sobre isto no capítulo <info:structure#semicolon>.
 
@@ -247,7 +248,6 @@ Se estiver a escrever várias funções "auxiliares" (*"helper" functions*) acom
     setHandler(elem);
     walkAround();
     ```
-
 2. O código primeiro, depois as funções:
 
     ```js
@@ -269,7 +269,6 @@ Se estiver a escrever várias funções "auxiliares" (*"helper" functions*) acom
       ...
     }
     ```
-
 3. Mista: uma função é declarada onde for empregue pela primeira vez.
 
 A maior parte da vezes, a segunda variante é a preferida.
@@ -282,7 +281,7 @@ Um guia de estilo contém regras gerais sobre "como escrever" código, ex. que a
 
 Quando todos os membros de uma equipa usam o mesmo guia de estilo, o código parece uniforme, independentemente do membro da equipa que o tenha escrito.
 
-Óbviamente, que uma equipa pode sempre escrever o seu próprio guia de estilo, mas geralmente não há necessidade. Existem muitos guias à escolha.
+Obviamente, que uma equipa pode sempre escrever o seu próprio guia de estilo, mas geralmente não há necessidade. Existem muitos guias à escolha.
 
 Algumas opções populares:
 
@@ -292,29 +291,21 @@ Algumas opções populares:
 - [StandardJS](https://standardjs.com/)
 - (e muitas mais)
 
-Se for um programador iniciante, começe pela cábula (*cheatsheet*) disponível no início deste capítulo. Depois, poderá procurar por outros guias de estilo afim de colher mais ideias e decidir qual prefere.
+Se for um programador iniciante, comece pela cábula (*cheatsheet*) disponível no início deste capítulo. Depois, poderá procurar por outros guias de estilo afim de colher mais ideias e decidir qual prefere.
 
 ## *Linters* Automatizados
 
-*Linters*, são ferramentas que automáticamente verificam o estilo do seu código e fazem sugestões para o alterar.
+*Linters*, são ferramentas que automaticamente verificam o estilo do seu código e fazem sugestões para o alterar.
 
 O seu ponto-forte reside em, à medida que verificam o estilo, poderem encontrar alguns erros (*bugs*), como nomes de variáveis ou de funções mal-escritos. Devido a esta capacidade, é recomendado que use um *linter* mesmo que não queira aderir a um certo "estilo de código".
 
 Aqui estão algumas das mais conhecidas ferramentas de *linting*:
 
-<<<<<<< HEAD
 - [JSLint](http://www.jslint.com/) -- um dos primeiros *linters*.
 - [JSHint](http://www.jshint.com/) -- mais configurações do que *JSLint*.
-- [ESLint](http://eslint.org/) -- provávelmente o mais recente.
+- [ESLint](http://eslint.org/) -- provavelmente o mais recente.
 
 Todos eles podem executar a tarefa. O autor utiliza [ESLint](http://eslint.org/).
-=======
-- [JSLint](https://www.jslint.com/) -- one of the first linters.
-- [JSHint](https://jshint.com/) -- more settings than JSLint.
-- [ESLint](https://eslint.org/) -- probably the newest one.
-
-All of them can do the job. The author uses [ESLint](https://eslint.org/).
->>>>>>> 193319c963b9ba86ac7d9590f7261a36ecdcc4d2
 
 Muitos *linters* estão integrados em editores populares: apenas ative a extensão (*plugin*) no editor e configure o estilo.
 
@@ -344,11 +335,7 @@ Aqui está um exemplo de um ficheiro `.eslintrc`:
 
 Aqui a diretiva `"extends"` denota que a configuração tem como base o conjunto de configurações em "eslint:recommended". Depois disso, podemos especificar as nossas próprias.
 
-<<<<<<< HEAD
 Também é possível descarregar conjuntos de regras de estilo da web e depois estendê-los. Veja em <http://eslint.org/docs/user-guide/getting-started> mais detalhes sobre a instalação.
-=======
-It is also possible to download style rule sets from the web and extend them instead. See <https://eslint.org/docs/user-guide/getting-started> for more details about installation.
->>>>>>> 193319c963b9ba86ac7d9590f7261a36ecdcc4d2
 
 De igual modo, certos *IDEs* (Ambientes de Desenvolvimento Integrado) têm *linting* incorporado (*built-in*), o que é conveniente mas não tão personalizável como o *ESLint*.
 

1-js/05-data-types/01-primitives-methods/article.md

@@ -1,8 +1,6 @@
 # Métodos de primitivos
 
-JavaScript nos permite trabalhar com primitivos (strings, números, etc.) como se fossem objetos.
-
-Eles também fornecem métodos para chamar como se fossem objetos. Estudaremos isso em breve, mas primeiro veremos como isso funciona, porque, é claro, os primitivos não são objetos (e aqui deixaremos isso ainda mais claro).
+JavaScript nos permite trabalhar com primitivos (strings, números, etc.) como se fossem objetos. Eles também fornecem métodos para chamar como se fossem objetos. Estudaremos isso em breve, mas primeiro veremos como isso funciona, porque, é claro, os primitivos não são objetos (e aqui deixaremos isso ainda mais claro).
 
 Vejamos as principais diferenças entre primitivos e objetos.
 
@@ -50,13 +48,9 @@ A solução parece um pouco estranha, mas aqui está:
 2. A linguagem permite acesso a métodos e propriedades de strings, números, booleanos e símbolos.
 3. Quando isso acontece, um "invólucro de objeto" especial que fornece a funcionalidade extra é criado e, em seguida, é destruído.
 
-<<<<<<< HEAD
-Os "invólucros de objeto" são diferentes para cada tipo primitivo e são chamados: `String`, `Number`, `Boolean` e `Symbol`. Assim, eles fornecem diferentes conjuntos de métodos.
-=======
-The "object wrappers" are different for each primitive type and are called: `String`, `Number`, `Boolean`, `Symbol` and `BigInt`. Thus, they provide different sets of methods.
->>>>>>> 193319c963b9ba86ac7d9590f7261a36ecdcc4d2
+Os "invólucros de objeto" são diferentes para cada tipo primitivo e são chamados: `String`, `Number`, `Boolean`, `Symbol` e `BigInt`. Assim, eles fornecem diferentes conjuntos de métodos.
 
-Por exemplo, existe um método para *strings* [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) que retorna `str` em letras maiúsculas.
+Por exemplo, existe um método para *strings* [str.toUpperCase()](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) que retorna `str` em letras maiúsculas.
 
 Veja como isso funciona:
 
@@ -76,7 +70,7 @@ Portanto, os primitivos podem fornecer métodos, mas ainda permanecem leves.
 
 O mecanismo do JavaScript otimiza muito esse processo. Pode até ignorar a criação do objeto extra. Mas ainda deve seguir a especificação e se comportar como se criasse um.
 
-Um número tem métodos próprios, por exemplo, [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) arredonda o número para a precisão dada:
+Um número tem métodos próprios, por exemplo, [toFixed(n)](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) arredonda o número para a precisão dada:
 
 ```js run
 let n = 1.23456;

1-js/06-advanced-functions/01-recursion/05-output-single-linked-list-reverse/solution.md

@@ -37,7 +37,7 @@ The loop variant is also a little bit more complicated than the direct output.
 
 There is no way to get the last value in our `list`. We also can't "go back".
 
-So what we can do is to first go through the items in the direct order and rememeber them in an array, and then output what we remembered in the reverse order:
+So what we can do is to first go through the items in the direct order and remember them in an array, and then output what we remembered in the reverse order:
 
 ```js run
 let list = {

1-js/11-async/03-promise-chaining/article.md

@@ -34,29 +34,17 @@ new Promise(function(resolve, reject) {
 
 A ideia é que o resultado seja passado através de uma cadeia de tratadores `.then`.
 
-<<<<<<< HEAD
 O fluxo é o seguinte:
 1. A promessa inicial é resolvida em 1 segundo `(*)`,
-2. Então o tratador de `.then` é chamado `(**)`.
-3. O valor retornado por ele é passado ao próximo tratador de `.then` `(***)`
+2. Então o tratador de `.then` é chamado `(**)`, que por sua vez cria uma nova promessa (resolvida com o valor `2`).
+3. O próximo tratador `.then` `(***)` recebe o valor retornado pelo anterior, o processa (o duplica) e ele é passado ao próximo tratador.
 4. ...e assim por diante.
-=======
-Here the flow is:
-1. The initial promise resolves in 1 second `(*)`,
-2. Then the `.then` handler is called `(**)`, which in turn creates a new promise (resolved with `2` value).
-3. The next `then` `(***)` gets the result of the previous one, processes it (doubles) and passes the next handler.
-4. ...and so on.
->>>>>>> 193319c963b9ba86ac7d9590f7261a36ecdcc4d2
 
 Como o resultado é passado através da cadeia de tratadores, podemos observar a sequência de chamadas `alert`: `1` -> `2` -> `4`.
 
 ![](promise-then-chain.svg)
 
-<<<<<<< HEAD
-A coisa toda funciona pois a chamada ao `promise.then` retorna uma promessa, assim podemos chamar o próximo `.then` nesse retorno.
-=======
-The whole thing works, because every call to a `.then` returns a new promise, so that we can call the next `.then` on it.
->>>>>>> 193319c963b9ba86ac7d9590f7261a36ecdcc4d2
+A coisa toda funciona, pois cada chamada ao `.then` retorna uma nova promessa, assim podemos chamar o próximo `.then` nesse retorno.
 
 Quando um tratador retorna um valor, ele se torna o resultado da promessa, então o próximo `.then` é chamado com ele.