fixes

Author: iliakan

1-js/06-advanced-functions/12-arrow-functions/article.md

@@ -1,4 +1,4 @@
-# И ещё про стрелочные функции
+# Повторяем стрелочные функции
 
 Давайте вернёмся к стрелочным функциям.
 

1-js/07-object-properties/01-property-descriptors/article.md

@@ -3,13 +3,13 @@
 
 Как мы знаем, объекты могут содержать свойства.
 
-До этого момента мы рассматривали свойство только как пару "ключ-значение". Но на самом деле свойство объекта - это гораздо более гибкое и мощное средство.
+До этого момента мы рассматривали свойство только как пару "ключ-значение". Но на самом деле свойство объекта гораздо мощнее и гибче.
 
-В этой главе мы изучим дополнительные опции конфигурации для свойств, а в следующей увидим, как можно незаметно превратить их в специальные функции - геттеры и сеттеры.
+В этой главе мы изучим дополнительные флаги конфигурации для свойств, а в следующей увидим, как можно незаметно превратить их в специальные функции - геттеры и сеттеры.
 
 ## Флаги свойств
 
-Помимо **`значения`**, свойства объекта имеют три специальных атрибута (так называемые "флаги").
+Помимо значения **`value`**, свойства объекта имеют три специальных атрибута (так называемые "флаги").
 
 - **`writable`** -- если `true`, свойство можно изменить, иначе оно только для чтения.
 - **`enumerable`** -- если `true`, свойство перечисляется в циклах, в противном случае циклы его игнорируют.
@@ -63,14 +63,14 @@ Object.defineProperty(obj, propertyName, descriptor)
 ```
 
 `obj`, `propertyName`
-: Объект и свойство, с которыми мы будем работать.
+: Объект и его свойство, для которого нужно применить дескриптор.
 
 `descriptor`
 : Применяемый дескриптор.
 
 Если свойство существует, `defineProperty` обновит его флаги. В противном случае метод создает новое свойство с указанным значением и флагами; если какой-либо флаг не указан явно, ему присваивается значение `false`.
 
-Например, все флаги свойства `name` в коде ниже создаются со значением `false`: 
+Например, здесь создаётся свойство `name`, все флаги которого имеют значение `false`:
 
 ```js run
 let user = {};
@@ -116,40 +116,39 @@ Object.defineProperty(user, "name", {
 });
 
 *!*
-user.name = "Pete"; // Ошибка: Невозможно изменить доступное только для чтения свойство 'name'...
+user.name = "Pete"; // Ошибка: Невозможно изменить доступное только для чтения свойство 'name'
 */!*
 ```
 
 Теперь никто не сможет изменить имя пользователя, если только не обновит соответствующий флаг новым вызовом `defineProperty`.
 
 ```smart header="Ошибки появляются только в строгом режиме"
-В нестрогом режиме, без `use strict`, мы не увидим никаких ошибок при записи в свойства "только для чтения" и т.п. Эти операции всё равно не будут выполнены успешно. Действия, нарушающие ограничения флагов, в нестрогом режиме просто молча игнорируются.
+В нестрогом режиме, без `use strict`, мы не увидим никаких ошибок при записи в свойства "только для чтения" и т.п. Но эти операции всё равно не будут выполнены успешно. Действия, нарушающие ограничения флагов, в нестрогом режиме просто молча игнорируются.
 ```
 
-Вот та же самая операция, но в ситуации, когда свойства не существует:
+Вот тот же пример, но свойство создано "с нуля":
 
 ```js run
 let user = { };
 
 Object.defineProperty(user, "name", {
 *!*
-  value: "Pete",
+  value: "John",
   // для нового свойства необходимо явно указывать все флаги, для которых значение true
   enumerable: true,
   configurable: true
 */!*
 });
 
-alert(user.name); // Pete
-user.name = "Alice"; // Ошибка
+alert(user.name); // John
+user.name = "Pete"; // Ошибка
 ```
 
-
 ## Неперечислимое свойство
 
 Теперь добавим собственный метод `toString` к объекту `user`.
 
-Обычно встроенный метод `toString` в объектах - неперечислимый, его не видно в цикле `for..in`. Но если мы напишем свой собственный метод `toString`, цикл `for..in` будет выводить его по умолчанию:
+Встроенный метод `toString` в объектах - неперечислимый, его не видно в цикле `for..in`. Но если мы напишем свой собственный метод `toString`, цикл `for..in` будет выводить его по умолчанию:
 
 ```js run
 let user = {
@@ -185,7 +184,7 @@ Object.defineProperty(user, "toString", {
 for (let key in user) alert(key); // name
 ```
 
-Неперечислимые свойства также исключаются из `Object.keys`:
+Неперечислимые свойства также не возвращаются `Object.keys`:
 
 ```js
 alert(Object.keys(user)); // name

1-js/07-object-properties/02-property-accessors/article.md

@@ -9,23 +9,23 @@
 
 ## Геттеры и сеттеры
 
-Свойства-аксессоры записываются как методы: так называемый "геттер" - для чтения и "сеттер" - для записи. При литеральном объявлении объекта они обозначены `get` и `set`:
+Свойства-аксессоры представлены методами: "геттер" - для чтения и "сеттер" - для записи. При литеральном объявлении объекта они обозначаются `get` и `set`:
 
 ```js
 let obj = {
   *!*get propName()*/!* {
-    // геттер, код получения obj.propName
+    // геттер, срабатывает при чтении obj.propName
   },
 
   *!*set propName(value)*/!* {
-    // сеттер, код присвоения obj.propName = value
+    // сеттер, срабатывает при записи obj.propName = value
   }
 };
 ```
 
 Геттер срабатывает, когда `obj.propName` читается, сеттер -- когда значение назначается.
 
-Для примера, у нас есть объект `user` со свойствами `name` и `surname`:
+Например, у нас есть объект `user` со свойствами `name` и `surname`:
 
 ```js run
 let user = {
@@ -34,7 +34,7 @@ let user = {
 };
 ```
 
-А теперь добавим свойство объекта "fullName" для полного имени, которое в нашем случае: "John Smith". Само собой, мы не хотим дублировать уже имеющуюся информацию, так что реализуем его при помощи аксессора:
+А теперь добавим свойство объекта `fullName` для полного имени, которое в нашем случае: `"John Smith"`. Само собой, мы не хотим дублировать уже имеющуюся информацию, так что реализуем его при помощи аксессора:
 
 ```js run
 let user = {
@@ -55,7 +55,19 @@ alert(user.fullName); // John Smith
 
 Снаружи свойство-аксессор выглядит как обычное свойство. В этом и заключается смысл свойств-аксессоров. Мы не *вызываем* `user.fullName` как функцию, а *читаем* как обычное свойство: геттер выполнит всю работу за кулисами.
 
-На данный момент `fullName` имеет только геттер. Если попытаться присвоить значение свойству `user.fullName`, то это вызовет ошибку.
+На данный момент `fullName` имеет только геттер. Если попытаться присвоить значение свойству `user.fullName`, то это вызовет ошибку:
+
+```js run
+let user = {
+  get fullName() {
+    return `...`;
+  }
+};
+
+*!*
+user.fullName = "Тест"; // Ошибка (у свойства есть только геттер)
+*/!*
+```
 
 Давайте исправим это, добавив сеттер для `user.fullName`:
 
@@ -82,15 +94,10 @@ alert(user.name); // Alice
 alert(user.surname); // Cooper
 ```
 
-В итоге мы получили "виртуальное" свойство fullName. Его можно прочитать и изменить, но по факту его не существует.
-
-```smart header="Accessor properties are only accessible with get/set"
-Как только свойство определено с помощью `get prop()` или `set prop()`, оно становится свойством-аксессором, а не свойством-данных.
+В итоге мы получили "виртуальное" свойство `fullName`. Его можно прочитать и изменить, но по факту его не существует.
 
-- Если определен геттер -- мы можем прочитать свойство `object.prop`, иначе нет.
-- Если определен сеттер -- мы можем установить свойство `object.prop=...`, иначе нет.
-
-В обоих случаях мы не можем удалить свойство-аксессор.
+```smart header="Нет поддержки для `delete`"
+При попытке удалить свойство-аксессор оператором `delete` будет ошибка.
 ```
 
 
@@ -100,14 +107,14 @@ alert(user.surname); // Cooper
 
 Свойства-аксессоры не имеют `value` и `writable`, но взамен предлагают функции `get` и `set`.
 
-Таким образом, дескриптор аксессора может иметь:
+То есть, дескриптор аксессора может иметь:
 
 - **`get`** -- функция без аргументов, которая сработает при чтении свойства,
 - **`set`** -- функция, принимающая один аргумент, вызываемая при присвоении свойства,
 - **`enumerable`** -- то же самое, что и для свойств-данных,
 - **`configurable`** -- то же самое, что и для свойств-данных.
 
-Например, для создания аксессора `fullName` при помощи `defineProperty`, мы можем передать дескриптор с использованием `get` и `set`:
+Например, для создания аксессора `fullName` при помощи `defineProperty` мы можем передать дескриптор с использованием `get` и `set`:
 
 ```js run
 let user = {
@@ -132,7 +139,7 @@ alert(user.fullName); // John Smith
 for(let key in user) alert(key); // name, surname
 ```
 
-Обратите внимание, что свойство объекта может быть только свойством-аксессора или свойством-данных.
+Ещё раз заметим, что свойство объекта может быть только свойством-аксессором (с методами `get/set`) или свойством-данных (со значением `value`).
 
 При попытке указать и `get` и `value` в одном дескрипторе будет ошибка:
 
@@ -151,9 +158,9 @@ Object.defineProperty({}, 'prop', {
 
 ## Умные геттеры/сеттеры
 
-Геттеры/сеттеры можно использовать как обёртки над "реальными" значениями свойств, чтобы получить больше контроля над ними.
+Геттеры/сеттеры можно использовать как обёртки над "реальными" значениями свойств, чтобы получить больше контроля над операциями с ними.
 
-Например, если мы хотим запретить устанавливать короткое имя для `user`, мы можем хранить `name` в специальном свойстве `_name`, отфильтровав значение в сеттере:
+Например, если мы хотим запретить устанавливать короткое имя для `user`, мы можем использовать сеттер `name` для проверки, а само значение хранить в отдельном свойстве `_name`:
 
 ```js run
 let user = {
@@ -176,14 +183,16 @@ alert(user.name); // Pete
 user.name = ""; // Имя слишком короткое...
 ```
 
+Таким образом, само имя хранится в `_name`, доступ к которому производится через геттер и сеттер.
+
 Технически, внешний код всё ещё может получить доступ к имени напрямую с помощью `user._name`, но существует широко известное соглашение о том, что свойства, которые начинаются с символа `"_"`, являются внутренними, и к ним не следует обращаться извне пределов объекта.
 
 
 ## Использование для совместимости
 
-Одна из хороших идей, стоящих за геттерами и сеттерами -- они позволяют в любой момент взять "обычное" свойство и изменить его поведение, поменяв на геттер и сеттер.
+У аксессоров есть интересная область применения - они позволяют в любой момент взять "обычное" свойство и изменить его поведение, поменяв на геттер и сеттер.
 
-Например, мы начали реализовывать объект `user`, используя свойства-данные `name` и `age`:
+Например, представим, что мы начали реализовывать объект `user`, используя свойства-данные имя `name` и возраст `age`:
 
 ```js
 function User(name, age) {
@@ -196,7 +205,7 @@ let john = new User("John", 25);
 alert( john.age ); // 25
 ```
 
-...Но рано или поздно всё может измениться. Взамен `age` мы можем решить хранить `birthday`, потому что так более точно и удобно:
+...Но рано или поздно всё может измениться. Взамен возраста `age` мы можем решить хранить дату рождения `birthday`, потому что так более точно и удобно:
 
 ```js
 function User(name, birthday) {
@@ -209,7 +218,9 @@ let john = new User("John", new Date(1992, 6, 1));
 
 Что нам делать со старым кодом, который использует свойство `age`?
 
-Мы можем попытаться найти все такие места и изменить их, но это отнимает время и может быть выполнимо, если код был написан/используется многими другими людьми. И кроме того, `age` -- это отличное свойство для `user`, верно? В некоторых ситуациях это то, что нам нужно.
+Мы можем попытаться найти все такие места и изменить их, но это отнимает время и может быть невыполнимо, если код был используется многими другими людьми. И кроме того, `age` -- это отличное свойство для `user`, верно?
+
+Давайте его сохраним.
 
 Добавление геттера для `age` решит проблему: