CrazyPython
diff --git a/‎1-js/10-es-modern/6-es-object/article.md‎
Lines changed: 45 additions & 21 deletions b/‎1-js/10-es-modern/6-es-object/article.md‎
Lines changed: 45 additions & 21 deletions
@@ -76,26 +76,23 @@ alert( user["мой зелёный крокодил"] ); // Вася
 <li>`Object.getPrototypeOf(obj)`</li>
 </ul>
 
-В современной JavaScript также добавился сеттер:
+В ES-2015 также добавился сеттер:
 <ul>
 <li>`Object.setPrototypeOf(obj, newProto)`</li>
 </ul>
 
 ...А также "узаконено" свойство `__proto__`, которое даёт прямой доступ к прототипу. Его, в качестве "нестандартного", но удобного способа работы с прототипом реализовали почти все браузеры (кроме IE10-), так что было принято решение добавить его в стандарт.
 
-По стандарту оно реализовано через геттеры-сеттеры `Object.getPrototypeOf/setPrototypeOf`.
-
-
 ## Object.assign
 
+Функция `Object.assign` получает список объектов и копирует в первый `target` свойства из остальных.
+
 Синтаксис:
 ```js
 Object.assign(target, src1, src2...)
 ```
 
-Функция `Object.assign` получает список объектов и копирует в первый `target` свойства из остальных.
-
-Последующие свойства перезаписывают предыдущие.
+При этом последующие свойства перезаписывают предыдущие.
 
 Например:
 
@@ -109,14 +106,31 @@ let admin = { isAdmin: true };
 
 Object.assign(user, visitor, admin);
 
+// user <- visitor <- admin
 alert( JSON.stringify(user) ); // user: Вася, visits: true, isAdmin: true
 ```
 
+Его также можно использовать для 1-уровневого клонирования объекта:
+
+```js
+'use strict';
+
+let user = { name: "Вася", isAdmin: false };
+
+*!*
+// clone = пустой объект + все свойства user
+let clone = Object.assign({}, user);
+*/!*
+```
+
+
 ## Object.is(value1, value2)
 
-Возвращает `true`, если `value1 === value2`, иначе `false`.
+Новая функция для проверки равенства значений.
+
+Возвращает `true`, если значения `value1` и `value2` равны, иначе `false`.
 
-Есть, однако, два отличия от обычного `===`, а именно: 
+Она похожа на обычное строгое равенство `===`, но есть отличия:
 
 ```js
 //+ run
@@ -130,20 +144,20 @@ alert( Object.is(NaN, NaN) ); // true
 alert( NaN === NaN );         // false
 ```
 
-При сравнении объектов через `Object.is` успользуется алгоритм [SameValue](http://www.ecma-international.org/ecma-262/6.0/index.html#sec-samevalue), который неявно применяется во многих других местах современного стандарта.
+Отличия эти в большинстве ситуаций некритичны, так что непохоже, чтобы эта функция вытеснила обычную проверку `===`. Что интересно -- этот алгоритм сравнения, который называется [SameValue](http://www.ecma-international.org/ecma-262/6.0/index.html#sec-samevalue), применяется во внутренних реализациях различных методов современного стандарта.
 
 
 ## Методы объекта
 
 Долгое время в JavaScript термин "метод объекта" был просто альтернативным названием для свойства-функции.
 
-Теперь это уже не так, добавлены именно "методы объекта". Они, по сути, являются "свойствами-функциями, привязанными к объекту".
+Теперь это уже не так, добавлены именно "методы объекта", которые, по сути, являются свойствами-функциями, привязанными к объекту. 
 
 Их особенности:
 
 <ol>
-<li>Более короткий синтаксис.</li>
-<li>Наличие в методах специального внутреннего свойства `[[HomeObject]]` ("домашний объект"), ссылающегося на объект, которому метод принадлежит. Мы посмотрим его использование чуть дальше, в разделе про `super`.</li>
+<li>Более короткий синтаксис объявления.</li>
+<li>Наличие в методах специального внутреннего свойства `[[HomeObject]]` ("домашний объект"), ссылающегося на объект, которому метод принадлежит. Мы посмотрим его использование чуть дальше.</li>
 </ol>
 
 Для объявления метода вместо записи `"prop: function() {…}"` нужно написать просто `"prop() { … }"`.
@@ -158,7 +172,7 @@ let name = "Вася";
 let user = {
   name,
 *!*
-  /* вместо sayHi: function() { */
+  // вместо "sayHi: function() {" пишем "sayHi() {" 
   sayHi() { 
     alert(this.name);
   }
@@ -168,7 +182,7 @@ let user = {
 user.sayHi(); // Вася
 ```
 
-Как видно, создание такого метода -- чуть короче, а обращение -- не отличается от обычной функции.
+Как видно, для создания метода нужно писать меньше букв. Что же касается вызова -- он ничем не отличается от обычной функции. На данном этапе можно считать, что "метод" -- это просто сокращённый синтаксис для свойства-функции. Дополнительные возможности, которые даёт такое объявление, мы рассмотрим позже.
 
 Также методами станут объявления геттеров `get prop()` и сеттеров `set prop()`:
 
@@ -207,11 +221,17 @@ let user = {
 alert( user.getFirstName() ); // Вася
 ```
 
+Итак, мы рассмотрели синтаксические улучшения. Если коротко, то не надо писать слово "function". Теперь перейдём к другим отличиям.
+
 ## super
 
+В ES-2015 появилось новое ключевое слово `super`. Оно предназначено только для использования в методах объекта.
+
 Вызов `super.parentProperty` позволяет из метода объекта получить свойство его прототипа.
 
-Например, в коде ниже `rabbit` наследует от `animal`. Вызов `super.walk` из метода объекта `rabbit` обращается к `animal.walk`:
+Например, в коде ниже `rabbit` наследует от `animal`. 
+
+Вызов `super.walk()` из метода объекта `rabbit` обращается к `animal.walk()`:
 
 ```js
 //+ run
@@ -236,9 +256,11 @@ let rabbit = {
 rabbit.walk();
 ```
 
+Как правило, это используется в [классах](/class), которые мы рассмотрим в следующем разделе, но важно понимать, что "классы" здесь на самом деле не при чём. Свойство `super` работает через прототип, на уровне методов объекта.
+
 При обращении через `super` используется `[[HomeObject]]` текущего метода, и от него берётся `__proto__`. Поэтому `super` работает только внутри методов.
 
-Например, если переписать этот код, оформив `rabbit.walk` как обычное свойство-функцию, то будет ошибка:
+В частности, если переписать этот код, оформив `rabbit.walk` как обычное свойство-функцию, то будет ошибка:
 
 ```js
 //+ run
@@ -253,7 +275,7 @@ let animal = {
 let rabbit = { 
   __proto__: animal,
 *!*
-  walk: function() {
+  walk: function() { // Надо: walk() {
     super.walk(); // Будет ошибка!
   }
 */!*
@@ -289,9 +311,11 @@ let rabbit = {
 rabbit.walk();
 ```
 
+Ранее мы говорили о том, что у функций-стрелок нет своего `this`, `arguments`: они используют те, которые во внешней функции. Теперь к этому списку добавился ещё и `super`.
+
 [smart header="Свойство `[[HomeObject]]` -- не изменяемое"]
 
-При создании метода -- он привязан к своему объекту навсегда. Технически можно даже скопировать его и запустить независимо:
+При создании метода -- он привязан к своему объекту навсегда. Технически можно даже скопировать его и запустить отдельно, и `super` продолжит работать:
 
 ```js
 //+ run
@@ -310,14 +334,14 @@ let rabbit = {
 
 let walk = rabbit.walk; // скопируем метод в переменную
 *!*
-walk(); 
+walk(); // вызовет animal.walk()
 // I'm walking
 */!*
 ```
 
 В примере выше метод `walk()` запускается отдельно от объекта, но всё равно сохраняется через `super` доступ к его прототипу, благодаря `[[HomeObject]]`. 
 
-Это относится именно к `super`. Правила `this` для методов те же, что и для обычных функций. В примере выше при вызове `walk()` без объекта `this` будет `undefined`.
+Это -- скорее технический момент, так как методы объекта, всё же, предназначены для вызова в контексте этого объекта. В частности, правила для `this` в методах -- те же, что и для обычных функций. В примере выше при вызове `walk()` без объекта `this` будет `undefined`. 
 [/smart]
 
 ## Итого