fixed mistakes and simplified explanation

**In chapter 01-08-02 prototype-inheritance**

There were many mistakes.
And some of sentences were correct, but they were "unnatural" in Ukrainian and make understanding more difficult.

Author: Andrii256

1-js/08-prototypes/02-function-prototype/article.md

@@ -2,15 +2,15 @@
 
 Як відомо, ми можемо створювати нові об’єкти за допомогою функції-конструктора, ось так `new F()`.
 
-Якщо розглядати `F.prototype` як властивість об’єкта, то оператор `new` автоматично створює приховану властивість `[[Prototype]]` для новоствореного об’єкта.
+Якщо в `F.prototype` міститься об'єкт, то оператор `new` автоматично встановлює той об'єкт в `[[Prototype]]` для новоствореного об’єкта.
 
 ```smart
-JavaScript мала можливість успадкування властивостей через прототипи ще від самого початку її створення. Це було одним з головних особливостей мови.
+JavaScript використовувала прототипне наслідування з моменту своєї появи. Це одна з особливостей цієї мови.
 
-Але в ті часи, не було прямого доступу до прототипів. Тільки одна річ, яка працювала надійно, була властивість функції-конструктора `"prototype"` , яка і описана в цій главі. Ось чому ще існує багато коду де цю властивість використовують.
+Але раніше, в давні часи, прямого доступу до прототипа в об'єкта не було. Надійно працювала лише властивість "prototype" функції-конструктора, описане в цьому розділі. Тому ця властивість використовується в багатьох скриптах.
 ```
 
-Зауважте, що `F.prototype` тут означає звичайну властивість, яку назвали `"prototype"` в об’єкті `F`. Це звучить дуже співзвучно з терміном "prototype", але тут це означає всього лиш звичайне ім’я властивості.
+Зауважте, що `F.prototype` тут є звичайною властивістю, яку назвали `"prototype"` в об’єкті `F`. Це звучить дуже співзвучно з терміном "prototype", але тут це означає всього лиш звичайне ім’я властивості.
 
 Ось приклад:
 
@@ -27,37 +27,37 @@ function Rabbit(name) {
 Rabbit.prototype = animal;
 */!*
 
-let rabbit = new Rabbit("White Rabbit"); //  rabbit.__proto__ == animal
+let rabbit = new Rabbit("Білий кролик"); //  rabbit.__proto__ == animal
 
 alert( rabbit.eats ); // true
 ```
 
-Вираз `Rabbit.prototype = animal` дослівно означає наступне: "коли `new Rabbit` створено, його властивість `[[Prototype]]` посилається на об’єкт `animal`".
+Вираз `Rabbit.prototype = animal` дослівно означає наступне: "коли буде створено `new Rabbit`, його властивість `[[Prototype]]` має посилатись на об'єкт `animal`".
 
 Ось кінцева картинка:
 
 ![](proto-constructor-animal-rabbit.svg)
 
-На картинці, `"prototype"` що показана горизонтальною стрілкою, це звичайна властивість, а `[[Prototype]]`показана вертикальною, що означає `rabbit` успадковує властивості від свого прототипа `animal`.
+На картинці, `"prototype"` що зображена біля горизонтальної стрілки - це звичайна властивість, а `[[Prototype]]`, що зображена біля вертикальної стрілки - вказує на те, що `rabbit` успадковує властивості від свого прототипа `animal`.
 
-```smart header="`F.prototype` використовується тільки у разі використання функції-конструктора `new F`"
-Властивість `F.prototype` використовується коли буде викликано `new F`, і створює властивість `[[Prototype]]` для нового об’єкта.
+```smart header="`F.prototype` використовується тільки у в момент виклику функції-конструктора `new F`"
+`F.prototype` використовується тільки при виклику `new F` і присвоюється в якості властивості `[[Prototype]]` нового об'єкта.
 
-Якщо властивість `F.prototype` після створення змінюється (`F.prototype = <another object>`), тоді і новий об’єкт який створюється функцією-конструктором `new F` буде мати посилання `[[Prototype]]` на інший об’єкт, а в раніше створених об’єктах є свої прототипи які були визначені ще  при їх створенні.
+Якщо після створення властивість `F.prototype` зміниться (`F.prototype = <інший об'єкт>`), то нові об'єкти, створені з допомогою `new F`, будуть мати в якості `[[Prototype]]` інший об'єкт, а вже існуючі об'єкти будуть посилатись на старий.
 ```
 
 ## Типове значення F.prototype, властивості конструктора
 
-Кожна функція має властивість `"prototype"` навіть якщо ми цю властивість самі не прописуємо. Тобто вона існує за замовчуванням, або ця властивість є типовою.
+Кожна функція за замовчуванням має властивість `"prototype"`, навіть якщо ми цю властивість самі не прописуємо.
 
-В свою чергу, така типова властивість `"prototype"` представляє собою об’єкт, який має єдину властивість з назвою `constructor`, що зворотньо посилається на назву самої функції-конструктора.
+За замовчуванням "prototype" є об'єктом з однією єдиною властивістю `constructor`, яка посилається на саму ж функцію.
 
 Ось як тут:
 
 ```js
 function Rabbit() {}
 
-/* властивість створена за замовчуванням
+/* значення prototype, яке призначається за замовченням
 Rabbit.prototype = { constructor: Rabbit };
 */
 ```
@@ -74,7 +74,7 @@ function Rabbit() {}
 alert( Rabbit.prototype.constructor == Rabbit ); // true
 ```
 
-Отже, якщо ми нічого не робимо з властивістю `constructor` то вона є доступна для всіх об’єктів rabbits через `[[Prototype]]`:
+Ну й логічно, якщо ми самі нічого з властивістю `constructor` не робимо, то вона є доступна для всіх об’єктів `rabbit` через `[[Prototype]]`:
 
 ```js run
 function Rabbit() {}
@@ -88,7 +88,7 @@ alert(rabbit.constructor == Rabbit); // true (від прототипу)
 
 ![](rabbit-prototype-constructor.svg)
 
-Ми можемо використовувати властивість `constructor` для створення нових об’єктів використовуючи той самий конструктор, який вже існує.
+Ми можемо використовувати властивість `constructor` для створення нових об’єктів використовуючи ту саму функцію-конструктор, як і для вже існуючих.
 
 Як тут:
 
@@ -98,22 +98,22 @@ function Rabbit(name) {
   alert(name);
 }
 
-let rabbit = new Rabbit("White Rabbit");
+let rabbit = new Rabbit("Білий кролик");
 
 *!*
-let rabbit2 = new rabbit.constructor("Black Rabbit");
+let rabbit2 = new rabbit.constructor("Чорний кролик");
 */!*
 ```
 
-Це дуже практично у випадку наявності об’єкта, але не знаємо за допомогою якого саме конструктора той об’єкт був створений (для прикладу який був імпортований з якоїсь бібліотеки), а нам потрібно створити новий об’єкт по типу того, що вже існує.
+Це дуже практично у випадку якщо ми маємо об'єкт, не знаємо за допомогою якого саме конструктора той об’єкт був створений (до прикладу якщо він був імпортований з якоїсь бібліотеки), а нам потрібно створити новий об’єкт по типу того, що вже існує.
 
-Але самим важливим моментом щодо `"constructor"` є те, що...
+Але найважливішим моментом щодо `"constructor"` є те, що...
 
 **...Сама мова JavaScript не забезпечує правильного значення `"constructor"`.**
 
-Так, воно існує за замовчуванням у властивостях `"prototype"` для функцій, але це все, що є. Те, що стається з `"constructor"` пізніше, цілковито залежить від нас самих.
+Так, `constructor` існує за замовчуванням у властивостях `"prototype"` для функцій, але це й усе. Подальша доля `"constructor"` повністю в наших руках.
 
-А саме, якщо ми замінимо типове значення на якесь інше, тоді в ньому не буде ніякого `"constructor"`.
+А саме, якщо ми замінимо дефолтне значення `prototype` на якесь інше, тоді в `prototype` не буде ніякого `"constructor"`.
 
 Наприклад:
 
@@ -129,7 +129,7 @@ alert(rabbit.constructor === Rabbit); // false
 */!*
 ```
 
-Отже, щоб мати правильний `"constructor"` ми можемо чи додавати, чи видаляти властивості у дефолтному `"prototype"` замість того, щоб її цілковито заміняти:
+Отже, щоб мати правильний `"constructor"`, замість цілком заміняти дефолтний `prototype` якимось нашим іншим об'єктом, ми можемо просто додавати або видаляти властивості до уже наявного дефолтного `"prototype"`:
 
 ```js
 function Rabbit() {}
@@ -140,7 +140,7 @@ Rabbit.prototype.jumps = true
 // а тому дефолтне Rabbit.prototype.constructor зберігається
 ```
 
-чи по іншому, відновлюємо `constructor` вручну:
+чи ось інший варіант, відновлюємо `constructor` вручну:
 
 ```js
 Rabbit.prototype = {
@@ -161,7 +161,7 @@ Rabbit.prototype = {
 Все досить просто, тільки треба додати кілька деталей щоб усе було зрозуміло:
 
 - Властивість об’єкта `F.prototype` (ні в якому разі не `[[Prototype]]`) встановлює приховану властивість `[[Prototype]]` нового об’єкта, тільки тоді, коли буде викликана через `new F()`.
-- Значення властивості `F.prototype` може бути, або посиланням на об’єкт, або `null`: інші значення не працюють.
+- Значення властивості `F.prototype` може бути або посиланням на об’єкт, або `null`: значення інших типів не спрацюють.
 - Тільки властивість `"prototype"` має такий спеціальний ефект: може встановлюватись в конструкторі та може викликатись через оператор `new`.
 
 У звичайних об’єктах властивість `prototype` не є чимось спеціальним: