Merge pull request #1548 from Rnbsov/patch-33

update article

Author: Alexandre887

1-js/04-object-basics/04-object-methods/4-object-property-this/solution.md

@@ -4,41 +4,52 @@
 ```js run
 function makeUser() {
   return {
-    name: "Джон",
+    name: "John",
     ref: this
   };
-};
+}
 
 let user = makeUser();
 
 alert( user.ref.name ); // Error: Cannot read property 'name' of undefined
 ```
 
-Это потому, что правила, которые определяют значение `this`, никак не смотрят на объявление объекта. Важен лишь момент вызова метода.
+Это потому, что правила, которые определяют значение `this`, никак не смотрят на объявление объекта. Важен лишь момент вызова.
 
-Здесь значение `this` внутри `makeUser()` является `undefined`, потому что `makeUser()` вызвана как функция, не через "точку" как метод.
+Здесь значение `this` внутри `makeUser()` равно `undefined`, потому что оно вызывается как функция, а не через "точечный" синтаксис как метод.
 
-Литерал объекта сам по себе не влияет на `this`. Значение `this` одно для всей функции и блоков кода в ней, литеральные объекты не меняют его.
+Значение `this` одно для всей функции, блоки кода и объектные литералы на него не влияют.
 
-Таким образом, при создании объекта `ref: this` берёт текущее значение `this` функции `makeUser()`.
+Таким образом, `ref: this` фактически принимает текущее `this` функции `makeUser()`.
 
-А вот противоположный случай:
+Мы можем переписать функцию и вернуть то же самое `this` со значением `undefined`:
+
+```js run
+function makeUser(){
+  return this; // на этот раз нет литерала объекта
+}
+
+alert( makeUser().name ); // Error: Cannot read property 'name' of undefined
+```
+Как вы можете видеть, результат `alert( makeUser().name )` совпадает с результатом `alert( user.ref.name )` из предыдущего примера.
+
+Вот противоположный случай:
 
 ```js run
 function makeUser() {
   return {
-    name: "Джон",
+    name: "John",
 *!*
     ref() {
       return this;
     }
 */!*
   };
-};
+}
 
 let user = makeUser();
 
-alert( user.ref().name ); // Джон
+alert( user.ref().name ); // John
 ```
 
-Теперь это работает, поскольку `user.ref()` вызывается как метод. И значением `this` становится объект перед точкой `.`.
+Теперь это работает, поскольку `user.ref()` - это метод. И значением `this` становится объект перед точкой `.`.

1-js/04-object-basics/04-object-methods/4-object-property-this/task.md

@@ -11,10 +11,10 @@ importance: 5
 ```js
 function makeUser() {
   return {
-    name: "Джон",
+    name: "John",
     ref: this
   };
-};
+}
 
 let user = makeUser();
 

1-js/04-object-basics/04-object-methods/7-calculator/_js.view/test.js

@@ -2,7 +2,7 @@
 
 describe("калькулятор", function() {
 
-  context("Когда 2 и 3 введены", function() {
+  context("когда 2 и 3 введены", function() {
     beforeEach(function() {
       sinon.stub(window, "prompt");
 
@@ -15,12 +15,17 @@ describe("калькулятор", function() {
     afterEach(function() {
       prompt.restore();
     });
+    
+    it('read получает два значения и сохраняет их как свойства объекта', function () {
+      assert.equal(calculator.a, 2);
+      assert.equal(calculator.b, 3);
+    });
 
-    it("Сумма равна 5", function() {
+    it("сумма равна 5", function() {
       assert.equal(calculator.sum(), 5);
     });
 
-    it("Произведение равно 6", function() {
+    it("произведение равно 6", function() {
       assert.equal(calculator.mul(), 6);
     });
   });

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

@@ -21,17 +21,25 @@ describe('Лестница', function() {
     assert(alert.called);
   });
 
-  it('up() должен увеличивать ступеньки', function() {
+  it('up() должен увеличивать ступеньку', function() {
     assert.equal(ladder.up().up().step, 2);
   });
 
-  it('down() должен уменьшать ступеньки', function() {
+  it('down() должен уменьшать ступеньку', function() {
     assert.equal(ladder.down().step, -1);
   });
 
   it('down().up().up().up() ', function() {
     assert.equal(ladder.down().up().up().up().step, 2);
   });
+
+  it('showStep() должен возвращать 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/04-object-methods/8-chain-calls/solution.md

@@ -1,4 +1,4 @@
-Решением является возврат самого объекта в каждом методе.
+Решение состоит в том, чтобы возвращать сам объект из каждого вызова.
 
 ```js run demo
 let ladder = {
@@ -21,19 +21,19 @@ let ladder = {
     return this;
 */!*
   }
-}
+};
 
-ladder.up().up().down().up().down().showStep(); // 1
+ladder.up().up().down().showStep().down().showStep(); // показывает 1 затем 0
 ```
 
-Мы также можем писать один вызов на одной строке. Для длинной цепи вызовов это более читабельно:
+Мы также можем записать один вызов на одной строке. Для длинных цепей вызовов это более читабельно:
 
 ```js
 ladder
   .up()
   .up()
   .down()
-  .up()
+  .showStep() // 1
   .down()
-  .showStep(); // 1
+  .showStep(); // 0
 ```

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

@@ -4,7 +4,7 @@ importance: 2
 
 # Цепь вызовов
 
-Это `ladder` (лестница) - объект, который позволяет подниматься вверх и спускаться:
+У нас есть объект `ladder` (лестница), который позволяет подниматься и спускаться:
 
 ```js
 let ladder = {
@@ -21,19 +21,21 @@ let ladder = {
 };
 ```
 
-Теперь, если нам нужно сделать несколько последовательных вызовов, мы можем выполнить это так:
+Теперь, если нам нужно выполнить несколько последовательных вызовов, мы можем сделать это так:
 
 ```js
 ladder.up();
 ladder.up();
 ladder.down();
 ladder.showStep(); // 1
+ladder.down();
+ladder.showStep(); // 0
 ```
 
 Измените код методов `up`, `down` и `showStep` таким образом, чтобы их вызов можно было сделать по цепочке, например так:
 
 ```js
-ladder.up().up().down().showStep(); // 1
+ladder.up().up().down().showStep().down().showStep(); // показывает 1 затем 0
 ```
 
 Такой подход широко используется в библиотеках JavaScript.