merging all conflicts

Author: iliakan

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

@@ -46,13 +46,23 @@ Além dos números regulares, existem os chamados "valores numéricos especiais"
     alert( "not a number" / 2 ); // NaN, tal divisão é errônea
     ```
 
+<<<<<<< HEAD
     `NaN` é pegajoso. Qualquer outra operação em `NaN` retorna `NaN`:
+=======
+    `NaN` is sticky. Any further mathematical operation on `NaN` returns `NaN`:
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
     ```js run
-    alert( "not a number" / 2 + 5 ); // NaN
+    alert( NaN + 1 ); // NaN
+    alert( 3 * NaN ); // NaN
+    alert( "not a number" / 2 - 1 ); // NaN
     ```
 
+<<<<<<< HEAD
      Então, se há um `NaN` em algum lugar em uma expressão matemática, ele se propaga para o resultado inteiro.
+=======
+    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result (there's only one exception to that: `NaN ** 0` is `1`).
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 ```smart header="As operações matemáticas são seguras"
 Fazer matemática é "seguro" em JavaScript. Podemos fazer qualquer coisa: dividir por zero, tratar strings não-numéricas como números, etc.

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -106,7 +106,7 @@ In practice, the zero height is often a valid value, that shouldn't be replaced
 
 ## Precedence
 
-The precedence of the `??` operator is about the same as `||`, just a bit lower. It equals `5` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table), while `||` is `6`.
+The precedence of the `??` operator is the same as `||`. They both equal `4` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
 
 That means that, just like `||`, the nullish coalescing operator `??` is evaluated before `=` and `?`, but after most other operations, such as `+`, `*`.
 

1-js/02-first-steps/16-function-expressions/article.md

@@ -12,7 +12,7 @@ function sayHi() {
 
 There is another syntax for creating a function that is called a *Function Expression*.
 
-It allows to create a new function in the middle of any expression.
+It allows us to create a new function in the middle of any expression.
 
 For example:
 

1-js/02-first-steps/17-arrow-functions-basics/article.md

@@ -33,7 +33,11 @@ let sum = function(a, b) {
 alert( sum(1, 2) ); // 3
 ```
 
+<<<<<<< HEAD
 Como pode ver, `(a, b) => a + b` significa uma função que aceita dois argumentos, nomeadamente `a` e `b`. No momento da execução, esta avalia a expressão `a + b` e retorna o resultado.
+=======
+As you can see, `(a, b) => a + b` means a function that accepts two arguments named `a` and `b`. Upon the execution, it evaluates the expression `a + b` and returns the result.
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 - Se tivermos apenas um argumento, então os parênteses à sua volta podem ser omitidos, tornando ela ainda mais curta.
 
@@ -86,7 +90,11 @@ Desta forma:
 let sum = (a, b) => {  // a chaveta abre uma função multi-linha
   let result = a + b;
 *!*
+<<<<<<< HEAD
   return result; // se usarmos chavetas, então precisamos de um "return" explícito
+=======
+  return result; // if we use curly braces, then we need an explicit "return"
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 */!*
 };
 

1-js/04-object-basics/04-object-methods/8-chain-calls/_js.view/solution.js

@@ -11,5 +11,6 @@ let ladder = {
   },
   showStep: function() { 
     alert(this.step);
+    return this;
   }
 };

1-js/04-object-basics/04-object-methods/8-chain-calls/_js.view/test.js

@@ -32,6 +32,14 @@ describe('Ladder', function() {
   it('down().up().up().up() ', function() {
     assert.equal(ladder.down().up().up().up().step, 2);
   });
+
+  it('showStep() should return this', function() {
+    assert.equal(ladder.showStep(), ladder);
+  });
+ 
+  it('up().up().down().showStep().down().showStep()', function () {
+    assert.equal(ladder.up().up().down().showStep().down().showStep().step, 0)
+  });
 
   after(function() {
     ladder.step = 0;

1-js/04-object-basics/07-optional-chaining/article.md

@@ -25,7 +25,7 @@ That's the expected result. JavaScript works like this. As `user.address` is `un
 
 In many practical cases we'd prefer to get `undefined` instead of an error here (meaning "no street").
 
-...And another example. In the web development, we can get an object that corresponds to a web page element using a special method call, such as `document.querySelector('.elem')`, and it returns `null` when there's no such element.
+...and another example. In Web development, we can get an object that corresponds to a web page element using a special method call, such as `document.querySelector('.elem')`, and it returns `null` when there's no such element.
 
 ```js run
 // document.querySelector('.elem') is null if there's no element

1-js/05-data-types/10-destructuring-assignment/article.md

@@ -5,7 +5,7 @@ The two most used data structures in JavaScript are `Object` and `Array`.
 - Objects allow us to create a single entity that stores data items by key. 
 - Arrays allow us to gather data items into an ordered list.
 
-Although, when we pass those to a function, it may need not an object/array as a whole. It may need individual pieces.
+Although, when we pass those to a function, it may need not be an object/array as a whole. It may need individual pieces.
 
 *Destructuring assignment* is a special syntax that allows us to "unpack" arrays or objects into a bunch of variables, as sometimes that's more convenient. 
 

1-js/11-async/01-callbacks/article.md

@@ -195,9 +195,9 @@ So the single `callback` function is used both for reporting errors and passing
 
 ## Pyramid of Doom
 
-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.
+At first glance, it looks like a viable approach to asynchronous coding. And indeed it is. For one or maybe two nested calls it looks fine.
 
-But for multiple asynchronous actions that follow one after another we'll have code like this:
+But for multiple asynchronous actions that follow one after another, we'll have code like this:
 
 ```js
 loadScript('1.js', function(error, script) {
@@ -228,8 +228,8 @@ 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.
+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 `(*)`.
 
 As calls become more nested, the code becomes deeper and increasingly more difficult to manage, especially if we have real code instead of `...` that may include more loops, conditional statements and so on.
@@ -298,7 +298,7 @@ function step3(error, script) {
 }
 ```
 
-See? It does the same, and there's no deep nesting now because we made every action a separate top-level function.
+See? It does the same thing, and there's no deep nesting now because we made every action a separate top-level function.
 
 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.
 

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

@@ -120,7 +120,11 @@ new Promise(function(resolve, reject) {
 });
 ```
 
+<<<<<<< HEAD
 Aqui o primeiro `.then` exibe `1` e retorna `new Promise(…)` na linha `(*)`. Após 1 segundo ele é resolvido, e o resultado (o argumento de `resolve`, no caso é `result * 2`) é passado ao tratador do segundo `.then`. O tratador está na linha `(**)`, ele exibe `2` e faz a mesma coisa.
+=======
+Here the first `.then` shows `1` and returns `new Promise(…)` in the line `(*)`. After one second it resolves, and the result (the argument of `resolve`, here it's `result * 2`) is passed on to the handler of the second `.then`. That handler is in the line `(**)`, it shows `2` and does the same thing.
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 Então a saída é a mesma que no exemplo anterior: 1 -> 2 -> 4, mas agora com 1 segundo de atraso entre as chamadas `alert`.