works

iliakan · iliakan · commit b043ea701d82 · 2016-07-03T18:27:36.000+03:00
diff --git a/1-js/2-first-steps/07-types/1-string-quotes/solution.md b/1-js/2-first-steps/07-types/1-string-quotes/solution.md
@@ -0,0 +1,15 @@
+
+Backticks embed the expression inside `${...}` into the string.
+
+```js run
+let name = "Ilya";
+
+// the expression is a number 1
+alert( `hello ${1}` ); // Hello, 1
+
+// the expression is a variable, embed it
+alert( `hello ${name}` ); // Hello, Ilya
+
+// the expression is a string "name"
+alert( `hello ${"name"}` ); // Hello, name
+```
diff --git a/1-js/2-first-steps/07-types/1-string-quotes/task.md b/1-js/2-first-steps/07-types/1-string-quotes/task.md
@@ -0,0 +1,17 @@
+importance: 5
+
+---
+
+# String quotes
+
+What is the output of the script?
+
+```js
+let name = "Ilya";
+
+alert( `hello ${1}` ); // ?
+
+alert( `hello ${"name"}` ); // ?
+
+alert( `hello ${name}` ); // ?
+```
diff --git a/1-js/2-first-steps/07-types/2-hello-object/solution.md b/1-js/2-first-steps/07-types/2-hello-object/solution.md
diff --git a/1-js/2-first-steps/07-types/2-hello-object/task.md b/1-js/2-first-steps/07-types/2-hello-object/task.md
@@ -1,4 +1,4 @@
-importance: 3
+importance: 5
 
 ---
 
diff --git a/1-js/2-first-steps/07-types/3-sum-object/solution.md b/1-js/2-first-steps/07-types/3-sum-object/solution.md
@@ -0,0 +1,17 @@
+
+
+```js run
+let salaries = {
+  John: 100,
+  Ann: 160,
+  Pete: 130
+}
+
+let sum = 0;
+for(let key in salaries) {
+  sum += salaries[key];
+}
+
+alert(sum); // 390
+```
+
diff --git a/1-js/2-first-steps/07-types/3-sum-object/task.md b/1-js/2-first-steps/07-types/3-sum-object/task.md
@@ -0,0 +1,19 @@
+importance: 5
+
+---
+
+# Sum object properties
+
+We have an object storing salaries of our team:
+
+```js
+let salaries = {
+  John: 100,
+  Ann: 160,
+  Pete: 130
+}
+```
+
+Write the code to sum all salaries and store in the variable `sum`. Should be `390` in the example above.
+
+Use `for..in` loop to iterate over the object.
diff --git a/1-js/2-first-steps/07-types/4-sum-array/solution.md b/1-js/2-first-steps/07-types/4-sum-array/solution.md
@@ -0,0 +1,13 @@
+
+
+```js run
+let salaries = [ 100, 160, 130 ];
+
+let sum = 0;
+for(let salary of salaries) {
+  sum += salary;
+}
+
+alert( sum ); // 390
+```
+
diff --git a/1-js/2-first-steps/07-types/4-sum-array/task.md b/1-js/2-first-steps/07-types/4-sum-array/task.md
@@ -0,0 +1,13 @@
+importance: 5
+
+---
+
+# Sum the array
+
+Write the code to get the sum of the array using `for..of` loop and store in the variable `sum`:
+
+```js
+let salaries = [ 100, 160, 130 ];
+```
+
+Should be `390` here.
diff --git a/1-js/2-first-steps/07-types/article.md b/1-js/2-first-steps/07-types/article.md
@@ -39,7 +39,7 @@ Besides regular numbers there are so-called "special numeric values" which also
     `NaN` is sticky. Any further operation on `NaN` would give `NaN`:
 
     ```js run
-    alert( "not a number" * 2 + 5 - 9 ); // still NaN
+    alert( "not a number" * 2 + 5 - 9 ); // NaN
     ```
 
     So, in a long mathematical expression if we have `NaN` in one place, it propagates to the whole result.
@@ -66,7 +66,7 @@ In JavaScript, there are 3 types of quotes.
 
 1. Double quotes: `"Hello"`.
 2. Single quotes: `'Hello'`.
-3. Backtricks: <code>&#96;Hello&#96;</code>.
+3. Backticks: <code>&#96;Hello&#96;</code>.
 
 Double and single quotes are similar, "simple" quotes.
 
@@ -178,7 +178,7 @@ let user = {
 };
 ```
 
-The `user` object can be imagined as an information shelf with two items labelled "name" and "age". 
+The `user` object can be imagined as a cabinet with two signed files labelled "name" and "age". 
 
 ![user object](object-user.png)
 
diff --git a/1-js/2-first-steps/08-type-conversions/article.md b/1-js/2-first-steps/08-type-conversions/article.md
@@ -48,6 +48,23 @@ alert(typeof a); // string
 
 The string conversion is obvious. A `false` becomes `"false"`, `null` becomes `"null"` etc.
 
+For objects it's a little bit trickier. By default, regular objects are converted like this:
+
+```js run
+alert( {} ); [object Object]
+```
+
+Although, some object subtypes have their own way of formatting, for instance, arrays turn into the comma-delimited list of items:
+
+```js run
+let arr = [1,2,3];
+
+alert( arr ); // 1,2,3
+alert( String(arr) === '1,2,3' ); // true
+```
+
+Later we'll see how to create custom rules for string conversions for our objects.
+
 ## Numeric conversion
 
 Numeric conversion happens in mathematical functions and expressions automatically.
@@ -123,7 +140,7 @@ alert( Boolean(" ") ); // any non-empty string, even whitespaces are true
 
 There exist three most widely used type conversions: to string, to number and to boolean.
 
-The conversion to string is usully obvious.
+The conversion to string is usully obvious for primitive values and depends on the object type for objects. For instance, arrays turn into a comma-delimited list of elements. 
 
 To number follows the rules:
 
diff --git a/1-js/2-first-steps/15-while-for/article.md b/1-js/2-first-steps/15-while-for/article.md
@@ -378,7 +378,7 @@ for(let key in user) {
 }
 ```
 
-Note that all "for" constructs allow to declare the looping variable inside the loop, like `let key` here. The name "key" for the variable is not mandatory, we could use any variable name here, usually "key" or "prop" names are used for such iterations.
+Note that all "for" constructs allow to declare the looping variable inside the loop, like `key` here. We could use another variable name here instead of `key`, for instance, "prop" is also widely used for iterations.
 
 
 ## The "for..of" loop
@@ -445,3 +445,5 @@ If we don't want to do anything more on this iteration and would like to forward
 
 `Break/continue` support labels before the loop. A label is the only way for `break/continue` to escape the nesting and go to the outer loop.
 
+To get an array of object property names, there is a method `Object.keys(obj)`.
+
diff --git a/1-js/2-first-steps/20-function-parameters/article.md b/1-js/2-first-steps/20-function-parameters/article.md
@@ -135,12 +135,12 @@ showName("Julius", "Caesar");
 showName("Ilya"); 
 ```
 
-The downside is that `arguments` looks like an array, but it's not. It does not support many useful array features. It only exists for backwards compatibility. The rest operator is better.
+The downside is that `arguments` looks like an array, but it's not. It does not support many useful array features. It mainly exists for backwards compatibility, usually the rest operator is better.
 ````
 
-## Destructuring in parameters
+## Destructuring parameters
 
-There are times when a function may have many parameters. Imagine a function that creates a menu. It may have a width, a height, a title, items list and so on.
+There are times when a function may have many parameters, most of which are optional. That's especially true for user interfaces. Imagine a function that creates a menu. It may have a width, a height, a title, items list and so on.
 
 Here's a bad way to write such function:
 
@@ -158,7 +158,7 @@ Like this?
 showMenu("My Menu", undefined, undefined, ["Item1", "Item2"])
 ```
 
-That's ugly. And becomes unreadable if we have not 4 but 10 parameters.
+That's ugly. And becomes unreadable if we deal with more parameters.
 
 Destructuring comes to the rescue!
 
@@ -221,7 +221,7 @@ showMenu({});
 showMenu();
 ```
 
-We can fix this of course, by making an empty object a value by default for the whole destructuring thing:
+We can fix this of course, by making `{}` a value by default for the whole destructuring thing:
 
 
 ```js run
@@ -281,8 +281,7 @@ In short:
 Together they help to travel between a list and an array of parameters with ease.
 
 
-
-## Итого
+## Summary TODO
 
 Основные улучшения в функциях:
 
diff --git a/1-js/4-data-structures/2-number/article.md b/1-js/4-data-structures/2-number/article.md
@@ -267,6 +267,16 @@ The reason is the same: loss of precision. There are 64 bits for the number, 52
 JavaScript doesn't trigger an error in such case. It does the best to fit the number into the format. Unfortunately, the format is not big enough.
 ````
 
+```smart header="Two zeroes"
+Another funny consequence of the internal representation is there are actually two zeroes: `0` and `-0`.
+
+That's because a sign is represented by a single bit, so every number can be positive or negative, including the zero. 
+
+In most cases the distinction is unnoticeable, because operators are suited to treat them as the same.
+```
+
+
+
 ## Tests: isFinite and isNaN
 
 Remember the two special numeric values?
@@ -310,6 +320,17 @@ alert( isFinite(num) );
 
 Please note that an empty or a space-only string is treated as `0` in all numeric functions. If it's not what's needed, then additional checks are required. 
 
+```smart header="Compare with `Object.is`"
+
+There is a special built-in method [Object.is](mdn:js/Object/is) to compare values in "even stricter way" than `===`. 
+
+The call `Object.is(value1, value2)` returns the same result as `value1 === value2` with two exceptions:
+
+1. It can compare with `NaN`, e.g. `Object.is(NaN, NaN) === true`.
+2. Values `0` and `-0` are different: `Object.is(0, -0) === false`.
+```
+
+
 ## parseInt and parseFloat
 
 The numeric conversion using a plus `+` or `Number()` is strict. If a value is not exactly a number, it fails:
diff --git a/1-js/4-data-structures/3-string/article.md b/1-js/4-data-structures/3-string/article.md
@@ -49,29 +49,8 @@ let guestList = "Guests:  // Error: Unexpected token ILLEGAL
 
 Single and double quotes come from ancient times of language creation, and the need for multiline strings was not taken into account. Backticks appeared much later and thus are more versatile.
 
-Backticks also allow to specify a "template function" at the beginning. 
+Backticks also allow to specify a "template function" before the first backtick, the syntax is: <code>func&#96;string&#96;</code>. The function `func` is called automatically, receives the string and embedded expressions and can process them. You can read more in the [docs](mdn:JavaScript/Reference/Template_literals#Tagged_template_literals). That is called "tagged templates". This feature makes it easier to wrap strings into custom templating or other functionality, but is rarely used.
 
-Its name is put before the first backtick. Then it receives the string and embedded expressions can can process them.
-
-The syntax is: 
-```js run
-function love(string, value1, value2) {
-    alert( string[0] ); // Hello 
-    alert( string[1] ); //  and 
-    alert( value1 ); // Ilya
-    alert( value2 ); // Julia
-    return value1 + ' ♥ ' + value2;
-}
-
-let mom = "Julia";
-let dad = "Ilya";
-
-let str = love`Hello ${mom} and ${dad}`;
-
-alert(str); // 'Julia ♥ Ilya'
-```
-
-In the example above, `love` is the name for the function. It is called with an array 
 
 ## Special characters
 
@@ -554,7 +533,7 @@ For instance:
 alert( 'Österreich'.localeCompare('Zealand') ); // -1
 ```
 
-The method actually has two additional arguments specified in [the documentation](mdn:js/String/localeCompare), that allow to specify the language (by default taken from the environment) and setup additional rules like case sensivity or should `a` and `á` be treated as the same etc. 
+The method actually has two additional arguments specified in [the documentation](mdn:js/String/localeCompare), that allow to specify the language (by default taken from the environment) and setup additional rules like case sensivity or should `"a"` and `"á"` be treated as the same etc. 
 
 ## Internal encoding
 
diff --git a/1-js/4-data-structures/4-object/3-sum-salaries/_js.view/solution.js b/1-js/4-data-structures/4-object/3-sum-salaries/_js.view/solution.js
@@ -1,8 +1,8 @@
 function sumSalaries(salaries) {
 
   let sum = 0;
-  for (let name in salaries) {
-    sum += salaries[name];
+  for (let salary of Object.values(salaries)) {
+    sum += salary;
   }
 
   return sum;
diff --git a/1-js/4-data-structures/4-object/3-sum-salaries/task.md b/1-js/4-data-structures/4-object/3-sum-salaries/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 There is a `salaries` object with arbitrary number of salaries. 
 
-Write the function `sumSalaries(salaries)` that returns the sum of all salaries.
+Write the function `sumSalaries(salaries)` that returns the sum of all salaries using `Object.values` and the `for..of` loop.
 
 If `salaries` is empty, then the result must be `0`.
 
diff --git a/1-js/4-data-structures/4-object/4-max-salary/_js.view/solution.js b/1-js/4-data-structures/4-object/4-max-salary/_js.view/solution.js
@@ -3,9 +3,9 @@ function topSalary(salaries) {
   let max = 0;
   let maxName = null;
 
-  for (let name in salaries) {
-    if (max < salaries[name]) {
-      max = salaries[name];
+  for(let [name, salary] of Object.entries(salaries)) {
+    if (max < salary) {
+      max = salary;
       maxName = name;
     }
   }
diff --git a/1-js/4-data-structures/4-object/4-max-salary/task.md b/1-js/4-data-structures/4-object/4-max-salary/task.md
@@ -19,3 +19,4 @@ Create the function `topSalary(salaries)` that returns the name of the top-paid
 - If `salaries` is empty, it shoul return `null`.
 - If there are multiple top-paid persons, return any of them.
 
+P.S. Use `Object.entries` and destructuring to iterate over key/value pairs.
diff --git a/1-js/4-data-structures/4-object/5-count-properties/_js.view/solution.js b/1-js/4-data-structures/4-object/5-count-properties/_js.view/solution.js
@@ -0,0 +1,4 @@
+function count(obj) { 
+  return Object.keys(obj).length;
+}
+
diff --git a/1-js/4-data-structures/4-object/5-count-properties/_js.view/test.js b/1-js/4-data-structures/4-object/5-count-properties/_js.view/test.js
@@ -0,0 +1,13 @@
+describe("count", function() {
+  it("counts the number of properties", function() {
+    assert.equal( count({a: 1, b: 2}), 2 );
+  });
+
+  it("returns 0 for an empty object", function() {
+    assert.equal( count({}), 0 );
+  });
+
+  it("ignores symbolic properties", function() {
+    assert.equal( count({ [Symbol('id')]: 1 }), 0 );
+  });
+});
diff --git a/1-js/4-data-structures/4-object/5-count-properties/solution.md b/1-js/4-data-structures/4-object/5-count-properties/solution.md
diff --git a/1-js/4-data-structures/4-object/5-count-properties/task.md b/1-js/4-data-structures/4-object/5-count-properties/task.md
@@ -0,0 +1,21 @@
+importance: 5
+
+---
+
+# Count properties
+
+Write a function `count(obj)` that returns the number of properties in the object:
+
+```js
+let user = {
+  name: 'John',
+  age: 30
+};
+
+alert( count(user) ); // 2
+```
+
+Try to make the code as short as possible.
+
+P.S. Ignore symbolic properties, count only "regular" ones.
+
diff --git a/1-js/4-data-structures/4-object/6-multiply-numeric/_js.view/solution.js b/1-js/4-data-structures/4-object/6-multiply-numeric/_js.view/solution.js
diff --git a/1-js/4-data-structures/4-object/6-multiply-numeric/_js.view/source.js b/1-js/4-data-structures/4-object/6-multiply-numeric/_js.view/source.js
diff --git a/1-js/4-data-structures/4-object/6-multiply-numeric/_js.view/test.js b/1-js/4-data-structures/4-object/6-multiply-numeric/_js.view/test.js
@@ -5,9 +5,14 @@ describe("multiplyNumeric", function() {
       height: 300,
       title: "My menu"
     };
-    multiplyNumeric(menu);
+    let result = multiplyNumeric(menu);
     assert.equal(menu.width, 400);
     assert.equal(menu.height, 600);
     assert.equal(menu.title, "My menu");
   });
+
+  it("returns nothing", function() {
+    assert.isUndefined( multiplyNumeric({}) );
+  });
+  
 });
diff --git a/1-js/4-data-structures/4-object/6-multiply-numeric/solution.md b/1-js/4-data-structures/4-object/6-multiply-numeric/solution.md
diff --git a/1-js/4-data-structures/4-object/6-multiply-numeric/task.md b/1-js/4-data-structures/4-object/6-multiply-numeric/task.md
diff --git a/1-js/4-data-structures/4-object/article.md b/1-js/4-data-structures/4-object/article.md
diff --git a/1-js/4-data-structures/7-array/article.md b/1-js/4-data-structures/7-array/article.md
diff --git a/1-js/4-data-structures/8-array-methods/article.md b/1-js/4-data-structures/8-array-methods/article.md
diff --git a/1-js/4-data-structures/9-map-set-weakmap-weakset/article.md b/1-js/4-data-structures/9-map-set-weakmap-weakset/article.md

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-importance: 3`
	`1`	`+importance: 5`
`2`	`2`
`3`	`3`	`---`
`4`	`4`