up

Author: iliakan

1-js/2-first-steps/21-object-tostring-valueof/article.md

@@ -40,7 +40,7 @@ The `ToPrimitive(obj, "number")` is the same, but `valueOf()` and `toString()` a
 4. If the result is a primitive, return it.
 5. Otherwise `TypeError` (conversion failed)
 
-```smart header="ToPrimitive returns a primitive"
+```smart header="ToPrimitive returns a primitive, but its type is not guaranteed"
 As we can see, the result of `ToPrimitive` is always a primitive, because even if `toString/valueOf` return a non-primitive value, it is ignored.
 
 But it can be any primitive. There's no control whether `toString()` returns exactly a string or, say a boolean.
@@ -96,7 +96,7 @@ If only `toString()` is implemented, then both string and numeric conversions us
 
 ## Array example
 
-Let's check a few examples to finally get the whole picture.
+Let's see few more examples with arrays to get the better picture.
 
 ```js run
 alert( [] + 1 ); // '1'
@@ -108,7 +108,7 @@ The array from the left side of `+` is first converted to primitive using `toPri
 
 For arrays (and most other built-in objects) only `toString` is implemented, and it returns a list of items.
 
-So we'll have:
+So we'll have the following results of conversion:
 
 ```js 
 alert( '' + 1 ); // '1'

1-js/5-deeper/1-recursion/9-output-single-linked-list/task.md

@@ -5,6 +5,7 @@ importance: 5
 # Вывести односвязный список
 
 TODO: определение списка есть в статье, убрать отсюда.
+TODO: разбить на две задачи - прямой и обратный вывод.
 
 [Односвязный список](http://ru.wikipedia.org/wiki/Связный_список) -- это структура данных, которая состоит из *элементов*, каждый из которых хранит ссылку на следующий. Последний элемент может не иметь ссылки, либо она равна `null`.
 

1-js/5-deeper/2-closure/1-counter-independent/solution.md

@@ -0,0 +1,5 @@
+The answer: **0,1.**
+
+Functions `counter` and `counter2` are created by different invocations of `makeCounter`.
+
+So they have independent outer Lexical Environments, each one has it's own `count`.

1-js/5-deeper/2-closure/1-counter-independent/task.md

@@ -0,0 +1,29 @@
+importance: 5
+
+---
+
+# Are counters independent?
+
+What is the second counter going to show? `0,1` or `2,3` or something else?
+
+```js
+function makeCounter() {
+  let count = 0;
+
+  return function() {
+    return count++;
+  };
+}
+
+var counter = makeCounter();
+var counter2 = makeCounter();
+
+alert( counter() ); // 0
+alert( counter() ); // 1
+
+*!*
+alert( counter2() ); // ?
+alert( counter2() ); // ?
+*/!*
+```
+

1-js/5-deeper/2-closure/2-counter-inc-dec/_js.view/solution.js

@@ -0,0 +1,13 @@
+function makeCounter() {
+  let count = 0;
+
+  function counter() {
+    return count++;
+  }
+
+  counter.set = value => count = value;
+
+  counter.decrease = () => count--;
+
+  return counter;
+}

1-js/5-deeper/2-closure/2-counter-inc-dec/_js.view/source.js

@@ -0,0 +1,18 @@
+function makeCounter() {
+  let count = 0;
+
+  // ... your code ...
+}
+
+let counter = makeCounter();
+
+alert( counter() ); // 0
+alert( counter() ); // 1
+
+counter.set(10); // set the new count
+
+alert( counter() ); // 10
+
+counter.decrease(); // decrease the count by 1
+
+alert( counter() ); // 10 (instead of 11)

1-js/5-deeper/2-closure/2-counter-inc-dec/_js.view/test.js

@@ -0,0 +1,41 @@
+describe("counter", function() {
+
+  it("increases from call to call", function() {
+
+    let counter = makeCounter();
+
+    assert.equal( counter(), 0 ); 
+    assert.equal( counter(), 1 ); 
+    assert.equal( counter(), 2 ); 
+  });
+
+  
+  describe("counter.set", function() {
+    it("sets the count", function() {
+
+      let counter = makeCounter();
+
+      counter.set(10);
+
+      assert.equal( counter(), 10 ); 
+      assert.equal( counter(), 11 ); 
+    });
+  });
+  
+  describe("counter.decrease", function() {
+    it("decreases the count", function() {
+
+      let counter = makeCounter();
+
+      counter.set(10);
+
+      assert.equal( counter(), 10 ); 
+
+      counter.decrease();
+
+      assert.equal( counter(), 10 ); 
+
+    });
+  });
+
+});

1-js/5-deeper/2-closure/2-counter-inc-dec/solution.md

@@ -0,0 +1,6 @@
+
+The solution is to write addition methods right into the `counter`. They share the same outer lexical environment and also can access the current `count`.
+
+This trick is often used for Javascript libraries like lodash, jQuery and others. They provide a function that has other functions as properties.
+
+Actually, they do it to less pollute the global space, so that a single library gives only one global variable. That lowers the chance of possible naming conflicts.

1-js/5-deeper/2-closure/2-counter-inc-dec/task.md

@@ -0,0 +1,13 @@
+importance: 5
+
+---
+
+# Set and decrease for counter
+
+Modify the code of `makeCounter()` so that the counter can also decrease and set the number:
+
+- `counter()` should return the next number (as before).
+- `counter.set(value)` should set the `count` to `value`.
+- `counter.decrease(value)` should decrease the `count` by 1.
+
+See the sandbox code for the complete usage example.

1-js/5-deeper/2-closure/3-function-in-if/solution.md

@@ -0,0 +1,3 @@
+The result is **an error**.
+
+The function `sayHi` is declared inside the `if`, so it only lives inside it. There is no `sayHi` outside.