Resolve conflicts.

Author: odsantos

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

@@ -24,15 +24,9 @@ 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.
 - [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.
-=======
-- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome and Opera.
-- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
-- ...There are other codenames like "Chakra" for IE, "JavaScriptCore", "Nitro" and "SquirrelFish" for Safari, etc.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
+- ...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.
 

1-js/01-getting-started/4-devtools/article.md

@@ -8,11 +8,7 @@ Para que possamos visualizar erros e obter muitas outras informações úteis so
 
 A maioria dos desenvolvedores escolhem o Chrome ou o Firefox para o desenvolvimento porque esses navegadores têm as melhores ferramentas de desenvolvedor. Outros navegadores também fornecem ferramentas de desenvolvedor, às vezes com recursos especiais, mas geralmente estão jogando "catch-up" no Chrome ou Firefox. Assim, a maioria dos desenvolvedores tem um navegador "favorito" e muda para outros se um problema é específico do navegador.
 
-<<<<<<< HEAD
 As ferramentas do desenvolvedor são potentes; elas têm muitos recursos. Para começar, vamos aprender como as abrir, olhar para erros e executar comandos JavaScript.
-=======
-Developer tools are potent; they have many features. To start, we'll learn how to open them, look at errors, and run JavaScript commands.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 ## Google Chrome
 

1-js/02-first-steps/02-structure/article.md

@@ -46,11 +46,7 @@ alert(3 +
 + 2);
 ```
 
-<<<<<<< HEAD
-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.
-=======
-The code outputs `6` because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression", so a semicolon there would be incorrect. And in this case, that works as intended.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
+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.**
 
@@ -65,63 +61,31 @@ alert("Hello");
 [1, 2].forEach(alert);
 ```
 
-<<<<<<< HEAD
-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:
-
-```js run no-beautify
-alert("Haverá um erro")
-=======
-No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of running the code: it shows `Hello`, then `1`, then `2`.
-
-Now let's remove the semicolon after the `alert`:
+Agora, vamos remover o ponto e vírgula depois do `alert`:
 
 ```js run no-beautify
 alert("Hello")
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 [1, 2].forEach(alert);
 ```
 
-<<<<<<< HEAD
-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");
-=======
-The difference compared to the code above is only one character: the semicolon at the end of the first line is gone.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
-
-If we run this code, only the first `Hello` shows (and there's an error, you may need to open the console to see it). There are no numbers any more.
+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.
 
-<<<<<<< HEAD
-Agora temos a mensagem "Tudo bem agora" seguida por "1" e "2".
-
-
-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:
-
-```js run no-beautify
-alert("Haverá um erro")[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.
 
-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.
-=======
-That's because JavaScript does not assume a semicolon before square brackets `[...]`. So, the code in the last example is treated as a single statement.
+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. 
 
-Here's how the engine sees it:
+Veja como o mecanismo vê isso:
 
 ```js run no-beautify
 alert("Hello")[1, 2].forEach(alert);
 ```
 
-Looks weird, right? Such merging in this case is just wrong. We need to put a semicolon after `alert` for the code to work correctly.
+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.
 
-This can happen in other situations also.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
+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/15-function-basics/article.md

@@ -20,19 +20,11 @@ function showMessage() {
 }
 ```
 
-<<<<<<< HEAD
-A palavra-chave `function` vem primeiro, depois vem o *nome da função*, e uma lista de *parâmetros* entre os parêntesis (vazio no exemplo acima) e finalmente o código da função, também chamado de "o corpo da função", entre chaves.
-
-```js
-function name(parameters) {
-  ...corpo...
-=======
-The `function` keyword goes first, then goes the *name of the function*, then a list of *parameters* between the parentheses (comma-separated, empty in the example above, we'll see examples later) and finally the code of the function, also named "the function body", between curly braces.
+A palavra-chave `function` vem primeiro, depois vem o *nome da função*, e uma lista de *parâmetros* entre os parêntesis (separados por vírgulas, vazia no exemplo acima, veremos exemplos mais tarde) e finalmente o código da função, também chamado de "o corpo da função", entre chaves.
 
 ```js
 function name(parameter1, parameter2, ... parameterN) {
-  ...body...
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
+  ...corpo...
 }
 ```
 
@@ -202,11 +194,7 @@ For instance, the aforementioned function `showMessage(from, text)` can be calle
 showMessage("Ann");
 ```
 
-<<<<<<< HEAD
-That's not an error. Such a call would output `"Ann: undefined"`. There's no `text`, so it's assumed that `text === undefined`.
-=======
 That's not an error. Such a call would output `"*Ann*: undefined"`. As the value for `text` isn't passed, it becomes `undefined`.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 We can specify the so-called "default" (to use if omitted) value for a parameter in the function declaration, using `=`:
 

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

@@ -1,8 +1,4 @@
-<<<<<<< HEAD
-# Depuração de erros no Chrome
-=======
-# Debugging in the browser
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
+# Depuração de erros no navegador
 
 Antes de escrevermos código mais complexo, vamos falar de debugging (depuração de erros).
 

1-js/03-code-quality/05-testing-mocha/article.md

@@ -2,11 +2,7 @@
 
 Teste automatizado será utilizado nos exercícios seguintes, e também é amplamente usado em projetos reais.
 
-<<<<<<< HEAD
 ## Porque precisamos de testes?
-=======
-## Why do we need tests?
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 Quando escrevemos uma função, nós geralmente podemos imaginar o que ela deveria fazer: que parâmetros dariam que resultados.
 

1-js/04-object-basics/09-object-toprimitive/article.md

@@ -3,9 +3,6 @@
 
 What happens when objects are added `obj1 + obj2`, subtracted `obj1 - obj2` or printed using `alert(obj)`?
 
-<<<<<<< HEAD
-There are special methods in objects that do the conversion.
-=======
 JavaScript doesn't exactly allow to customize how operators work on objects. Unlike some other programming languages, such as Ruby or C++, we can't implement a special object method to handle an addition (or other operators).
 
 In case of such operations, objects are auto-converted to primitives, and then the operation is carried out over these primitives and results in a primitive value.
@@ -24,7 +21,6 @@ We have two purposes:
 2. There are exceptions, where such operations are possible and look good. E.g. subtracting or comparing dates (`Date` objects). We'll come across them later.
 
 ## Conversion rules
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 In the chapter <info:type-conversions> we've seen the rules for numeric, string and boolean conversions of primitives. But we left a gap for objects. Now, as we know about methods and symbols it becomes possible to close it.
 
@@ -34,23 +30,11 @@ The numeric conversion happens when we subtract objects or apply mathematical fu
 
 As for the string conversion -- it usually happens when we output an object like `alert(obj)` and in similar contexts.
 
-<<<<<<< HEAD
-## ToPrimitive
-
-When an object is used in the context where a primitive is required, for instance, in an `alert` or mathematical operations, it's converted to a primitive value using the `ToPrimitive` algorithm ([specification](https://tc39.github.io/ecma262/#sec-toprimitive)).
-
-That algorithm allows us to customize the conversion using a special object method.
-
-Depending on the context, the conversion has a so-called "hint".
-
-There are three variants:
-=======
 We can fine-tune string and numeric conversion, using special object methods.
 
 There are three variants of type conversion, that happen in various situations.
 
 They're called "hints", as described in the [specification](https://tc39.github.io/ecma262/#sec-toprimitive):
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 `"string"`
 : When an operation expects a string, for object-to-string conversions, like `alert`:
@@ -117,12 +101,8 @@ Let's start from the first method. There's a built-in symbol named `Symbol.toPri
 
 ```js
 obj[Symbol.toPrimitive] = function(hint) {
-<<<<<<< HEAD
-  // return a primitive value
-=======
   // here goes the code to convert this object to a primitive
   // it must return a primitive value
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
   // hint = one of "string", "number", "default"
 }
 ```
@@ -223,12 +203,7 @@ alert(user + 500); // toString -> John500
 
 In the absence of `Symbol.toPrimitive` and `valueOf`, `toString` will handle all primitive conversions.
 
-<<<<<<< HEAD
-
-## ToPrimitive and ToString/ToNumber
-=======
 ### A conversion can return any primitive type
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 The important thing to know about all primitive-conversion methods is that they do not necessarily return the "hinted" primitive.
 

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

@@ -41,13 +41,8 @@ Objetos são "mais pesados" que primitivos. Eles exigem recursos adicionais para
 
 Aqui está o paradoxo enfrentado pelo criador do JavaScript:
 
-<<<<<<< HEAD
-- Há muitas coisas que alguém poderia querer fazer com um primitivo como uma string ou um número. Seria ótimo acessá-los como métodos.
-- Primitivos devem ser o mais rápido e leve possível.
-=======
-- There are many things one would want to do with a primitive like a string or a number. It would be great to access them using methods.
-- Primitives must be as fast and lightweight as possible.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
+- Há muitas coisas que alguém poderia querer fazer com um primitivo como uma string ou um número. Seria ótimo acessá-los usando métodos.
+- Primitivos devem ser o mais rápidos e leves possível.
 
 A solução parece um pouco estranha, mas aqui está:
 

1-js/13-modules/01-modules-intro/article.md

@@ -69,11 +69,7 @@ There are core features, valid both for browser and server-side JavaScript.
 
 ### Always "use strict"
 
-<<<<<<< HEAD
-Modules always `use strict`. E.g. assigning to an undeclared variable will give an error.
-=======
 Modules always work in strict mode. E.g. assigning to an undeclared variable will give an error.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 ```html run
 <script type="module">
@@ -93,26 +89,18 @@ In the example below, two scripts are imported, and `hello.js` tries to use `use
 
 Modules should `export` what they want to be accessible from outside and `import` what they need.
 
-<<<<<<< HEAD
-So we should import `user.js` directly into `hello.js` instead of `index.html`.
-=======
 - `user.js` should export the `user` variable.
 - `hello.js` should import it from `user.js` module.
 
 In other words, with modules we use import/export instead of relying on global variables.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 This is the correct variant:
 
 [codetabs src="scopes-working" height="140" current="hello.js"]
 
-<<<<<<< HEAD
-In the browser, independant top-level scope also exists for each `<script type="module">`:
-=======
 In the browser, if we talk about HTML pages, independent top-level scope also exists for each `<script type="module">`.
 
 Here are two scripts on the same page, both `type="module"`. They don't see each other's top-level variables:
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 ```html run
 <script type="module">
@@ -127,17 +115,13 @@ Here are two scripts on the same page, both `type="module"`. They don't see each
 </script>
 ```
 
-<<<<<<< HEAD
-If we really need to make a "global" in-browser variable, we can explicitly assign it to `window` and access as `window.user`. But that's an exception requiring a good reason.
-=======
 ```smart
 In the browser, we can make a variable window-level global by explicitly assigning it to a `window` property, e.g. `window.user = "John"`. 
 
 Then all scripts will see it, both with `type="module"` and without it. 
 
 That said, making such global variables is frowned upon. Please try to avoid them.
 ```
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 ### A module code is evaluated only the first time when imported
 
@@ -164,11 +148,7 @@ import `./alert.js`; // Module is evaluated!
 import `./alert.js`; // (nothing)
 ```
 
-<<<<<<< HEAD
-In practice, top-level module code is mostly used for initialization. We create data structures, pre-fill them, and if we want something to be reusable -- export it.
-=======
 The second import shows nothing, because the module has already been evaluated.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 There's a rule: top-level module code should be used for initialization, creation of module-specific internal data structures. If we need to make something callable multiple times - we should export it as a function, like we did with `sayHi` above.
 
@@ -202,13 +182,9 @@ alert(admin.name); // Pete
 */!*
 ```
 
-<<<<<<< HEAD
-So, let's reiterate -- the module is executed only once. Exports are generated, and then they are shared between importers, so if something changes the `admin` object, other modules will see that .
-=======
 As you can see, when `1.js` changes the `name` property in the imported `admin`, then `2.js` can see the new `admin.name`.
 
 That's exactly because the module is executed only once. Exports are generated, and then they are shared between importers, so if something changes the `admin` object, other modules will see that.
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 **Such behavior is actually very convenient, because it allows us to *configure* modules.**
 
@@ -230,29 +206,19 @@ export function sayHi() {
 }
 ```
 
-<<<<<<< HEAD
-Now, in `init.js`, the first script of our app, we set `admin.name`. Then everyone will see it, including calls made from inside `admin.js` itself:
-=======
 Here, `admin.js` exports the `config` object (initially empty, but may have default properties too).
 
 Then in `init.js`, the first script of our app, we import `config` from it and set `config.user`:
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 ```js
 // 📁 init.js
 import {config} from './admin.js';
 config.user = "Pete";
 ```
 
-<<<<<<< HEAD
-```js
-// 📁 other.js
-import {admin, sayHi} from './admin.js';
-=======
 ...Now the module `admin.js` is configured. 
 
 Further importers can call it, and it correctly shows the current user:
->>>>>>> fb4fc33a2234445808100ddc9f5e4dcec8b3d24c
 
 ```js
 // 📁 another.js