Update base con respecto a Repositorio Inglés

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

@@ -6,7 +6,7 @@ The first thing we'll study is the building blocks of code.
 
 Statements are syntax constructs and commands that perform actions.
 
-We've already seen a statement, `alert('Hello, world!')`, which shows the message "Hello world!".
+We've already seen a statement, `alert('Hello, world!')`, which shows the message "Hello, world!".
 
 We can have as many statements in our code as we want. Statements can be separated with a semicolon.
 

1-js/02-first-steps/13-switch/article.md

@@ -148,7 +148,7 @@ Let's emphasize that the equality check is always strict. The values must be of
 For example, let's consider the code:
 
 ```js run
-let arg = prompt("Enter a value?")
+let arg = prompt("Enter a value?");
 switch (arg) {
   case '0':
   case '1':

1-js/02-first-steps/14-function-basics/article.md

@@ -128,7 +128,7 @@ Variables declared outside of any function, such as the outer `userName` in the
 
 Global variables are visible from any function (unless shadowed by locals).
 
-Usually, a function declares all variables specific to its task. Global variables only store project-level data, so when it's important that these variables are accesible from anywhere. Modern code has few or no globals. Most variables reside in their functions.
+Usually, a function declares all variables specific to its task. Global variables only store project-level data, and it's important that these variables are accessible from anywhere. Modern code has few or no globals. Most variables reside in their functions.
 ```
 
 ## Parameters

1-js/03-code-quality/04-ninja-code/article.md

@@ -83,7 +83,7 @@ While choosing a name try to use the most abstract word. Like `obj`, `data`, `va
 
     Give them a try. A young initiate may wonder -- are such names really useful for a ninja? Indeed, they are!
 
-    Sure, the variable name still means something. It says what's inside the variable: a string, a number or something else. But when an outsider tries to understand the code, he'll be surprised to see that there's actually no information at all! And will ultimately fail to alter your well-thought code.
+    Sure, the variable name still means something. It says what's inside the variable: a string, a number or something else. But when an outsider tries to understand the code, they'll be surprised to see that there's actually no information at all! And will ultimately fail to alter your well-thought code.
 
     The value type is easy to find out by debugging. But what's the meaning of the variable? Which string/number does it store?
 
@@ -153,7 +153,7 @@ function ninjaFunction(elem) {
 }
 ```
 
-A fellow programmer who wants to work with `elem` in the second half of the function will be surprised... Only during the debugging, after examining the code they will find out that he's working with a clone!
+A fellow programmer who wants to work with `elem` in the second half of the function will be surprised... Only during the debugging, after examining the code they will find out that they're working with a clone!
 
 Seen in code regularly. Deadly effective even against an experienced ninja. 
 
@@ -197,7 +197,7 @@ function render() {
 
 A programmer who jumps inside the `render` will probably fail to notice that there's a local `user` shadowing the outer one.
 
-Then he'll try to work with `user` assuming that it's the external variable, the result of `authenticateUser()`... The trap is sprung! Hello, debugger...
+Then they'll try to work with `user` assuming that it's the external variable, the result of `authenticateUser()`... The trap is sprung! Hello, debugger...
 
 
 ## Side-effects everywhere!

1-js/04-object-basics/01-object/3-is-empty/_js.view/solution.js

@@ -1,7 +1,7 @@
 function isEmpty(obj) {
   for (let key in obj) {
-    // if the loop has started, there is a prorty
+    // if the loop has started, there is a property
     return false;
   }
   return true;
-}
+}

1-js/04-object-basics/01-object/3-is-empty/solution.md

@@ -1,10 +1 @@
 Just loop over the object and `return false` immediately if there's at least one property.
-
-```js
-function isEmpty(obj) {
-  for (let key in obj) {
-    return false;
-  }
-  return true;
-}
-```

1-js/04-object-basics/01-object/8-multiply-numeric/solution.md

@@ -1,19 +0,0 @@
-``` js run
-
-// before the call
-let menu = {
-  width: 200,
-  height: 300,
-  title: "My menu"
-};
-
-function multiplyNumeric(obj) {
-  for (let key in obj) {
-    if (typeof obj[key] == 'number') {
-      obj[key] *= 2;
-    }
-  }
-}
-
-alert(menu); 
-```

1-js/04-object-basics/04-object-methods/7-calculator/solution.md

@@ -1,6 +1,5 @@
 
-
-```js run demo
+```js run demo solution
 let calculator = {
   sum() {
     return this.a + this.b;
@@ -20,4 +19,3 @@ calculator.read();
 alert( calculator.sum() );
 alert( calculator.mul() );
 ```
-

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

@@ -1,6 +1,6 @@
 The solution is to return the object itself from every call.
 
-```js run
+```js run demo
 let ladder = {
   step: 0,
   up() {
@@ -28,7 +28,7 @@ ladder.up().up().down().up().down().showStep(); // 1
 
 We also can write a single call per line. For long chains it's more readable:
 
-```js 
+```js
 ladder
   .up()
   .up()
@@ -37,4 +37,3 @@ ladder
   .down()
   .showStep(); // 1
 ```
-

1-js/04-object-basics/04-object-methods/article.md

@@ -214,7 +214,7 @@ sayHi(); // undefined
 
 In this case `this` is `undefined` in strict mode. If we try to access `this.name`, there will be an error.
 
-In non-strict mode (if one forgets `use strict`) the value of `this` in such case will be the *global object* (`window` in a browser, we'll get to it later). This is a historical behavior that `"use strict"` fixes.
+In non-strict mode the value of `this` in such case will be the *global object* (`window` in a browser, we'll get to it later in the chapter [](info:global-object)). This is a historical behavior that `"use strict"` fixes.
 
 Please note that usually a call of a function that uses `this` without an object is not normal, but rather a programming mistake. If a function has `this`, then it is usually meant to be called in the context of an object.
 

1-js/04-object-basics/06-constructor-new/2-calculator-constructor/solution.md

@@ -1,5 +1,3 @@
-
-
 ```js run demo
 function Calculator() {
 

1-js/05-data-types/03-string/3-truncate/solution.md

@@ -2,10 +2,9 @@ The maximal length must be `maxlength`, so we need to cut it a little shorter, t
 
 Note that there is actually a single unicode character for an ellipsis. That's not three dots.
 
-```js run
+```js run demo
 function truncate(str, maxlength) {
-  return (str.length > maxlength) ? 
+  return (str.length > maxlength) ?
     str.slice(0, maxlength - 1) + '…' : str;
 }
 ```
-

1-js/05-data-types/03-string/4-extract-currency/solution.md

@@ -1,5 +0,0 @@
-```js run
-    function extractCurrencyValue(str) {
-      return +str.slice(1);
-    }
-```

1-js/05-data-types/04-array/10-maximal-subarray/solution.md

@@ -1,4 +1,4 @@
-# The slow solution
+# Slow solution
 
 We can calculate all possible subsums.
 
@@ -67,7 +67,7 @@ Let's walk the array and keep the current partial sum of elements in the variabl
 
 If the description is too vague, please see the code, it's short enough:
 
-```js run
+```js run demo
 function getMaxSubSum(arr) {
   let maxSum = 0;
   let partialSum = 0;

1-js/05-data-types/04-array/article.md

@@ -104,7 +104,7 @@ A [queue](https://en.wikipedia.org/wiki/Queue_(abstract_data_type)) is one of mo
 
 Arrays support both operations.
 
-In practice we meet it very often. For example, a queue of messages that need to be shown on-screen.
+In practice we need it very often. For example, a queue of messages that need to be shown on-screen.
 
 There's another use case for arrays -- the data structure named [stack](https://en.wikipedia.org/wiki/Stack_(abstract_data_type)). 
 

1-js/05-data-types/05-array-methods/1-camelcase/_js.view/solution.js

@@ -1,8 +1,10 @@
 function camelize(str) {
   return str
-    .split('-') // my-long-word -> ['my', 'long', 'word']
-    .map( 
+    .split('-') // splits 'my-long-word' into array ['my', 'long', 'word']
+    .map(
+      // capitalizes first letters of all array items except the first one
+      // converts ['my', 'long', 'word'] into ['my', 'Long', 'Word']
       (word, index) => index == 0 ? word : word[0].toUpperCase() + word.slice(1)
-    ) // ['my', 'long', 'word'] -> ['my', 'Long', 'Word']
-    .join(''); // ['my', 'Long', 'Word'] -> myLongWord
+    )
+    .join(''); // joins ['my', 'Long', 'Word'] into 'myLongWord'
 }

1-js/05-data-types/05-array-methods/11-array-unique/solution.md

@@ -2,7 +2,7 @@ Let's walk the array items:
 - For each item we'll check if the resulting array already has that item.
 - If it is so, then ignore, otherwise add to results.
 
-```js run
+```js run demo
 function unique(arr) {
   let result = [];
 

1-js/05-data-types/05-array-methods/2-filter-range/solution.md

@@ -0,0 +1,14 @@
+```js run demo
+function filterRange(arr, a, b) {
+  // added brackets around the expression for better readability
+  return arr.filter(item => (a <= item && item <= b));
+}
+
+let arr = [5, 3, 8, 1];
+
+let filtered = filterRange(arr, 1, 4);
+
+alert( filtered ); // 3,1 (matching values)
+
+alert( arr ); // 5,3,8,1 (not modified)
+```

1-js/05-data-types/05-array-methods/3-filter-range-in-place/_js.view/solution.js

@@ -1,5 +1,4 @@
 
-
 function filterRangeInPlace(arr, a, b) {
 
   for (let i = 0; i < arr.length; i++) {
@@ -12,4 +11,4 @@ function filterRangeInPlace(arr, a, b) {
     }
   }
 
-}
+}

1-js/05-data-types/05-array-methods/3-filter-range-in-place/solution.md

@@ -0,0 +1,21 @@
+```js run demo
+function filterRangeInPlace(arr, a, b) {
+
+  for (let i = 0; i < arr.length; i++) {
+    let val = arr[i];
+
+    // remove if outside of the interval
+    if (val < a || val > b) {
+      arr.splice(i, 1);
+      i--;
+    }
+  }
+
+}
+
+let arr = [5, 3, 8, 1];
+
+filterRangeInPlace(arr, 1, 4); // removed the numbers except from 1 to 4
+
+alert( arr ); // [3, 1]
+```

1-js/05-data-types/05-array-methods/8-sort-objects/solution.md

@@ -1,6 +1,6 @@
 ```js run no-beautify
 function sortByName(arr) {
-  arr.sort((a, b) => b.name > a.name ? 1 : -1);
+  arr.sort((a, b) => a.age > b.age ? 1 : -1);
 }
 
 let john = { name: "John", age: 25 };
@@ -12,6 +12,6 @@ let arr = [ john, pete, mary ];
 sortByName(arr);
 
 // now sorted is: [john, mary, pete]
-alert(arr[1].name); // Mary
+alert(arr[0].name); // John
+alert(arr[2].name); // Pete
 ```
-

1-js/05-data-types/05-array-methods/8-sort-objects/task.md

@@ -4,7 +4,7 @@ importance: 5
 
 # Sort objects
 
-Write the function `sortByName(users)` that gets an array of objects with property `name` and sorts it.
+Write the function `sortByName(users)` that gets an array of objects with the `age` property and sorts them by `age`.
 
 For instance:
 
@@ -18,6 +18,6 @@ let arr = [ john, pete, mary ];
 sortByName(arr);
 
 // now: [john, mary, pete]
-alert(arr[1].name); // Mary
+alert(arr[0].name); // Mary
+alert(arr[2].name); // Pete
 ```
-

1-js/05-data-types/05-array-methods/article.md

@@ -275,7 +275,8 @@ Here the [arr.find](mdn:js/Array/find) method comes in handy.
 The syntax is:
 ```js
 let result = arr.find(function(item, index, array) {
-  // should return true if the item is what we are looking for
+  // if true is returned, item is returned and iteration is stopped
+  // for falsy scenario returns undefined
 });
 ```
 
@@ -313,11 +314,12 @@ The `find` method looks for a single (first) element that makes the function ret
 
 If there may be many, we can use [arr.filter(fn)](mdn:js/Array/filter).
 
-The syntax is roughly the same as `find`, but it returns an array of matching elements:
+The syntax is similar to `find`, but filter continues to iterate for all array elements even if `true` is already returned:
 
 ```js
 let results = arr.filter(function(item, index, array) {
-  // should return true if the item passes the filter
+  // if true item is pushed to results and iteration continues
+  // returns empty array for complete falsy scenario
 });
 ```
 
@@ -568,7 +570,7 @@ The calculation flow:
 
 ![](reduce.png)
 
-Or in the form of a table, where each row represents is a function call on the next array element:
+Or in the form of a table, where each row represents a function call on the next array element:
 
 |   |`sum`|`current`|`result`|
 |---|-----|---------|---------|

1-js/05-data-types/07-map-set-weakmap-weakset/02-filter-anagrams/solution.md

@@ -59,7 +59,7 @@ Here we could also use a plain object instead of the `Map`, because keys are str
 
 That's how the solution can look:
 
-```js run
+```js run demo
 function aclean(arr) {
   let obj = {};
 

1-js/05-data-types/07-map-set-weakmap-weakset/03-iterable-keys/task.md

@@ -16,7 +16,7 @@ map.set("name", "John");
 let keys = map.keys();
 
 *!*
-// Error: numbers.push is not a function
+// Error: keys.push is not a function
 keys.push("more");
 */!*
 ```

1-js/05-data-types/07-map-set-weakmap-weakset/article.md

@@ -328,7 +328,7 @@ Compare it with the regular `Map` example above. Now if `john` only exists as th
 
 - `weakMap.get(key)`
 - `weakMap.set(key, value)`
-- `weakMap.delete(key, value)`
+- `weakMap.delete(key)`
 - `weakMap.has(key)`
 
 Why such a limitation? That's for technical reasons. If an object has lost all other references (like `john` in the code above), then it is to be garbage-collected automatically. But technically it's not exactly specified *when the cleanup happens*.

1-js/05-data-types/08-keys-values-entries/01-sum-salaries/solution.md

@@ -0,0 +1,29 @@
+```js run demo
+function sumSalaries(salaries) {
+
+  let sum = 0;
+  for (let salary of Object.values(salaries)) {
+    sum += salary;
+  }
+
+  return sum; // 650
+}
+
+let salaries = {
+  "John": 100,
+  "Pete": 300,
+  "Mary": 250
+};
+
+alert( sumSalaries(salaries) ); // 650
+```
+Or, optionally, we could also get the sum using `Object.values` and `reduce`:
+
+```js
+// reduce loops over array of salaries,
+// adding them up
+// and returns the result
+function sumSalaries(salaries) {
+  return Object.values(salaries).reduce((a, b) => a + b, 0) // 650
+}
+```

1-js/05-data-types/09-destructuring-assignment/6-max-salary/_js.view/solution.js

@@ -3,7 +3,7 @@ function topSalary(salaries) {
   let max = 0;
   let maxName = null;
 
-  for(let [name, salary] of Object.entries(salaries)) {
+  for(const [name, salary] of Object.entries(salaries)) {
     if (max < salary) {
       max = salary;
       maxName = name;