From 8672d85a8d2cde05395eb355211d2f70e225c222 Mon Sep 17 00:00:00 2001
From: Tetiana Hordiienko <hordiienko.tatiana@gmail.com>
Date: Mon, 2 Aug 2021 13:51:10 +0300
Subject: [PATCH 01/12] Finished article translation along with tasks and tests

---
 .../1-two-functions-one-object/solution.md    |   6 +-
 .../1-two-functions-one-object/task.md        |   6 +-
 .../2-calculator-constructor/_js.view/test.js |   8 +-
 .../2-calculator-constructor/task.md          |  12 +-
 .../3-accumulator/_js.view/solution.js        |   2 +-
 .../3-accumulator/_js.view/test.js            |   6 +-
 .../3-accumulator/solution.md                 |   2 +-
 .../06-constructor-new/3-accumulator/task.md  |  22 +--
 .../06-constructor-new/article.md             | 164 +++++++++---------
 9 files changed, 114 insertions(+), 114 deletions(-)

diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
index 7d8edd7ca..b74655228 100644
--- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
+++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/solution.md
@@ -1,8 +1,8 @@
-Yes, it's possible.
+Так, це можливо.
 
-If a function returns an object then `new` returns it instead of `this`.
+Якщо функція повертає об’єкт, тоді `new` повертає його замість `this`.
 
-So they can, for instance, return the same externally defined object `obj`:
+Так функції `A` та `B` можуть, наприклад, повертати один і той самий об’єкт `obj`, визначений незалежно від цих функцій:
 
 ```js run no-beautify
 let obj = {};
diff --git a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
index 8c1fea8eb..45f4b5823 100644
--- a/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
+++ b/1-js/04-object-basics/06-constructor-new/1-two-functions-one-object/task.md
@@ -2,9 +2,9 @@ importance: 2
 
 ---
 
-# Two functions – one object
+# Дві функції - один об’єкт
 
-Is it possible to create functions `A` and `B` such as `new A()==new B()`?
+Чи є можливим створити такі функції `A` та `B`, де `new A()==new B()`?
 
 ```js no-beautify
 function A() { ... }
@@ -16,4 +16,4 @@ let b = new B;
 alert( a == b ); // true
 ```
 
-If it is, then provide an example of their code.
+Якщо так -- наведіть приклад коду таких функцій.
diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
index bba80e5c2..8b2a1c4c6 100644
--- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
+++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
@@ -10,17 +10,17 @@ describe("calculator", function() {
     calculator = new Calculator();
     calculator.read();
   });
-  
-  it("the read method asks for two values using prompt and remembers them in object properties", function() {
+
+  it("метод read запитує два значення за допомогою prompt і запам'ятовує їх у властивостях об’єкта", function() {
     assert.equal(calculator.a, 2);
     assert.equal(calculator.b, 3);
   });
 
-  it("when 2 and 3 are entered, the sum is 5", function() {
+  it("при введенні 2 і 3 сума дорівнює 5", function() {
     assert.equal(calculator.sum(), 5);
   });
 
-  it("when 2 and 3 are entered, the product is 6", function() {
+  it("при введені 2 і 3, добуток дорівнює 6", function() {
     assert.equal(calculator.mul(), 6);
   });
 
diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
index 60e7c373e..68f5c751e 100644
--- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
+++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
@@ -2,15 +2,15 @@ importance: 5
 
 ---
 
-# Create new Calculator
+# Створити Калькулятор за допомогою конструктора
 
-Create a constructor function `Calculator` that creates objects with 3 methods:
+Створіть функцію-конструктор `Calculator`, який створює об’єкти з трьома методами:
 
-- `read()` asks for two values using `prompt` and remembers them in object properties.
-- `sum()` returns the sum of these properties.
-- `mul()` returns the multiplication product of these properties.
+- `read()` запитує два значення за допомогою `prompt` і запам'ятовує їх у властивостях об'єкта.
+- `sum()` повертає суму цих властивостей.
+- `mul()` повертає результат множення даних властивостей.
 
-For instance:
+Наприклад:
 
 ```js
 let calculator = new Calculator();
diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/solution.js b/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/solution.js
index 585287c54..a654d8d32 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/solution.js
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/solution.js
@@ -2,7 +2,7 @@ function Accumulator(startingValue) {
   this.value = startingValue;
 
   this.read = function() {
-    this.value += +prompt('How much to add?', 0);
+    this.value += +prompt('Скільки додати?', 0);
   };
 
 }
diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js b/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js
index a719cf45c..5d57a7b62 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/_js.view/test.js
@@ -8,20 +8,20 @@ describe("Accumulator", function() {
     prompt.restore();
   });
 
-  it("initial value is the argument of the constructor", function() {
+  it("початкове значення - це аргумент конструктора", function() {
     let accumulator = new Accumulator(1);
 
     assert.equal(accumulator.value, 1);
   });
 
-  it("after reading 0, the value is 1", function() {
+  it("після прочитання 0 значення дорівнює 1", function() {
     let accumulator = new Accumulator(1);
     prompt.returns("0");
     accumulator.read();
     assert.equal(accumulator.value, 1);
   });
 
-  it("after reading 1, the value is 2", function() {
+  it("після прочитання 1 значення дорівнює 2", function() {
     let accumulator = new Accumulator(1);
     prompt.returns("1");
     accumulator.read();
diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md
index eb145e79d..1130beab2 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/solution.md
@@ -5,7 +5,7 @@ function Accumulator(startingValue) {
   this.value = startingValue;
 
   this.read = function() {
-    this.value += +prompt('How much to add?', 0);
+    this.value += +prompt('Скільки додати?', 0);
   };
 
 }
diff --git a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
index c2c44881e..0d3d21dec 100644
--- a/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
+++ b/1-js/04-object-basics/06-constructor-new/3-accumulator/task.md
@@ -2,26 +2,26 @@ importance: 5
 
 ---
 
-# Create new Accumulator
+# Створити Accumulator
 
-Create a constructor function `Accumulator(startingValue)`.
+Створіть функцію-конструктор `Accumulator(startingValue)`.
 
-Object that it creates should:
+Об’єкт, який він створює повинен:
 
-- Store the "current value" in the property `value`. The starting value is set to the argument of the constructor `startingValue`.
-- The `read()` method should use `prompt` to read a new number and add it to `value`.
+- Зберігати "поточне значення" у властивості `value`. Початкове значення має значення аргументу конструктора `startingValue`.
+- Метод `read()` повинен використовувати `prompt` для зчитування нового числа та додавати його до `value`.
 
-In other words, the `value` property is the sum of all user-entered values with the initial value  `startingValue`.
+Іншими словами, властивість `value` -- це сума всіх введенних користувачем значень разом із початковим значенням `startingValue`.
 
-Here's the demo of the code:
+Нижче ви можете подивитись демонстрацію роботи коду:
 
 ```js
-let accumulator = new Accumulator(1); // initial value 1
+let accumulator = new Accumulator(1); // початкове значення 1
 
-accumulator.read(); // adds the user-entered value
-accumulator.read(); // adds the user-entered value
+accumulator.read(); // додає введене користувачем значення
+accumulator.read(); // додає введене користувачем значення
 
-alert(accumulator.value); // shows the sum of these values
+alert(accumulator.value); // показує суму цих значень
 ```
 
 [demo]
diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 184b30f86..9b5f064d5 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -1,17 +1,17 @@
-# Constructor, operator "new"
+# Конструктори, оператор "new"
 
-The regular `{...}` syntax allows to create one object. But often we need to create many similar objects, like multiple users or menu items and so on.
+Звичайний синтаксис `{...}` дозволяє створити тільки один об’єкт. Проте часто нам потрібно створити багато однотипних об’єктів, таких як, наприклад, користувачі чи елементи меню та т.п.
 
-That can be done using constructor functions and the `"new"` operator.
+Це можно зробити за допомоги функції-конструктора та оператора `"new"`.
 
-## Constructor function
+## Функція-конструктор
 
-Constructor functions technically are regular functions. There are two conventions though:
+Технічно, функції-конструктори -- це звичайні функції. Однак є дві загальні угоди:
 
-1. They are named with capital letter first.
-2. They should be executed only with `"new"` operator.
+1. Ім’я функції-конструктора повинно починатися з великої літери.
+2. Функції-конструктори повинні виконуватися лише з оператором `"new"`.
 
-For instance:
+Наприклад:
 
 ```js run
 function User(name) {
@@ -20,212 +20,212 @@ function User(name) {
 }
 
 *!*
-let user = new User("Jack");
+let user = new User("Джек");
 */!*
 
-alert(user.name); // Jack
+alert(user.name); // Джек
 alert(user.isAdmin); // false
 ```
 
-When a function is executed with `new`, it does the following steps:
+Коли функція виконується з `new`, відбуваються наступні кроки:
 
-1. A new empty object is created and assigned to `this`.
-2. The function body executes. Usually it modifies `this`, adds new properties to it.
-3. The value of `this` is returned.
+1. Створюється новий порожній об'єкт, який присвоюється `this`.
+2. Виконується тіло функції. Зазвичай воно модифікує `this`, додає до нього нові властивості.
+3. Повертається значення `this`.
 
-In other words, `new User(...)` does something like:
+Іншими словами, виклик `new User(...)` робить щось на зразок:
 
 ```js
 function User(name) {
 *!*
-  // this = {};  (implicitly)
+  // this = {};  (неявно)
 */!*
 
-  // add properties to this
+  // додає властивості до this
   this.name = name;
   this.isAdmin = false;
 
 *!*
-  // return this;  (implicitly)
+  // return this;  (неявно)
 */!*
 }
 ```
 
-So `let user = new User("Jack")` gives the same result as:
+Отже `let user = new User("Джек")` дає той самий результат, що:
 
 ```js
 let user = {
-  name: "Jack",
+  name: "Джек",
   isAdmin: false
 };
 ```
 
-Now if we want to create other users, we can call `new User("Ann")`, `new User("Alice")` and so on. Much shorter than using literals every time, and also easy to read.
+Тепер, якщо ми хочемо створити інших користувачів, ми можемо викликати `new User("Ганна")`, `new User("Аліса")` тощо. Така конструкція значно коротша, ніж використання літералів кожного разу, а також легша для читання.
 
-That's the main purpose of constructors -- to implement reusable object creation code.
+Це і є основною метою конструкторів -- зручне перевикористання коду зі створення об'єктів.
 
-Let's note once again -- technically, any function (except arrow functions, as they don't have `this`) can be used as a constructor. It can be run with `new`, and it will execute the algorithm above. The "capital letter first" is a common agreement, to make it clear that a function is to be run with `new`.
+Ще раз зауважимо -- технічно будь-яка функція (окрім стрілкових функцій, оскільки вони не мають власного `this`) може бути використана як конструктор. Вона може бути запущена через `new`, і буде виконано наведений вище алгоритм. "Ім’я з великої літери" це загальна угода, яка допомагає чітко зрозуміти, що функцію слід запускати з `new`.
 
 ````smart header="new function() { ... }"
-If we have many lines of code all about creation of a single complex object, we can wrap them in an immediately called constructor function, like this:
+Якщо у нас є багато рядків коду, які створюють єдиний складний об'єкт, ми можемо обернути їх у функцію-конструктор, яка одразу буде викликана, таким чином:
 
 ```js
-// create a function and immediately call it with new
+// створити функцію і негайно викликати її за допомогою new
 let user = new function() { 
-  this.name = "John";
+  this.name = "Джон";
   this.isAdmin = false;
 
-  // ...other code for user creation
-  // maybe complex logic and statements
-  // local variables etc
+  // ...інший код для створення користувача
+  // можливо складна логіка та інструкції
+  // локальні змінні тощо
 };
 ```
 
-This constructor can't be called again, because it is not saved anywhere, just created and called. So this trick aims to encapsulate the code that constructs the single object, without future reuse.
+Цей конструктор не можна викликати знову, оскільки він ніде не зберігається, а лише створюється і викликається. Отже, такий прийом спрямований на інкапсуляцію коду, який створює єдиний об’єкт, без подальшого повторного використання.
 ````
 
-## Constructor mode test: new.target
+## Перевірка виклику у режимі конструктора: new.target
 
-```smart header="Advanced stuff"
-The syntax from this section is rarely used, skip it unless you want to know everything.
+```smart header="Просунуті можливості"
+Синтаксис з цього розділу використовується рідко, пропустіть його, якщо наразі ви не хочете занурюватись більш детально у мову.
 ```
 
-Inside a function, we can check whether it was called with `new` or without it, using a special `new.target` property.
+Використовуючи спеціальну властивість `new.target` всередині функції, ми можемо перевірити чи була ця функція викликана за допомогою оператора `new` чи без нього.
 
-It is undefined for regular calls and equals the function if called with `new`:
+Якщо функція була викликана за допомогою `new`, то в `new.target` буде сама функція, в іншому разі отримаємо `undefined`:
 
 ```js run
 function User() {
   alert(new.target);
 }
 
-// without "new":
+// виклик без "new":
 *!*
 User(); // undefined
 */!*
 
-// with "new":
+// виклик з "new":
 *!*
 new User(); // function User { ... }
 */!*
 ```
 
-That can be used inside the function to know whether it was called with `new`, "in constructor mode", or without it, "in regular mode".
+Така можливість може бути використана всередині функції для того, щоб дізнатися чи функція була викликана за допомогою оператора `new`, "у режимі конструктора", чи без нього, "у звичайному режимі".
 
-We can also make both `new` and regular calls to do the same, like this:
+Ми також можемо зробити щоб обидва виклики, з `new` та звичайний, робили одне й те саме, таким чином:
 
 ```js run
 function User(name) {
-  if (!new.target) { // if you run me without new
-    return new User(name); // ...I will add new for you
+  if (!new.target) { // якщо ви викликали без оператора new
+    return new User(name); // ...додамо оператор new за вас
   }
 
   this.name = name;
 }
 
-let john = User("John"); // redirects call to new User
-alert(john.name); // John
+let john = User("Джон"); // перенаправляє виклик до new User
+alert(john.name); // Джон
 ```
 
-This approach is sometimes used in libraries to make the syntax more flexible. So that people may call the function with or without `new`, and it still works.
+Цей підхід іноді використовується в бібліотеках для створення більш гнучкого синтаксису, який дозволив би розробникам викликати функцію як з оператором `new`, так і без нього.
 
-Probably not a good thing to use everywhere though, because omitting `new` makes it a bit less obvious what's going on. With `new` we all know that the new object is being created.
+Проте використання такого підходу скрізь не є хорошою практикою, тому що відсутність `new` робить код менш очевидним. З оператором `new` ми усі знаємо, що буде створено новий об’єкт.
 
-## Return from constructors
+## Повернення значення з конструктора return
 
-Usually, constructors do not have a `return` statement. Their task is to write all necessary stuff into `this`, and it automatically becomes the result.
+Зазвичай конструктори не мають інструкції `return`. Їх завдання - записати усе необхідне у `this`, яке автоматично стане результатом.
 
-But if there is a `return` statement, then the rule is simple:
+Але якщо є інструкція `return`, то застосовується просте правило:
 
-- If `return` is called with an object, then the object is returned instead of `this`.
-- If `return` is called with a primitive, it's ignored.
+- Якщо `return` викликається з об’єктом, тоді замість `this` буде повернено цей об’єкт.
+- Якщо `return` викликається з примітивом, примітив ігнорується.
 
-In other words, `return` with an object returns that object, in all other cases `this` is returned.
+Іншими словами, `return` з об’єктом повертає цей об’єкт, у всіх інших випадках повертається`this`.
 
-For instance, here `return` overrides `this` by returning an object:
+У наступному прикладі `return` перезаписує `this`, повертаючи об’єкт:
 
 ```js run
 function BigUser() {
 
-  this.name = "John";
+  this.name = "Джон";
 
-  return { name: "Godzilla" };  // <-- returns this object
+  return { name: "Годзілла" };  // <-- повертає цей об’єкт
 }
 
-alert( new BigUser().name );  // Godzilla, got that object
+alert( new BigUser().name );  // Годзілла, отримали цей об’єкт
 ```
 
-And here's an example with an empty `return` (or we could place a primitive after it, doesn't matter):
+А ось приклад з порожнім `return` (або ми можемо розмістити примітив після нього, не має значення):
 
 ```js run
 function SmallUser() {
 
-  this.name = "John";
+  this.name = "Джон";
 
-  return; // <-- returns this
+  return; // <-- повертає this
 }
 
-alert( new SmallUser().name );  // John
+alert( new SmallUser().name );  // Джон
 ```
 
-Usually constructors don't have a `return` statement. Here we mention the special behavior with returning objects mainly for the sake of completeness.
+Зазвичай конструктори не мають інструкції `return`. Тут ми згадуємо особливу поведінку з поверненнями об’єктів, головним чином, для повноти вивчення мови.
 
-````smart header="Omitting parentheses"
-By the way, we can omit parentheses after `new`, if it has no arguments:
+````smart header="Відсутність дужок"
+До речі, ми можемо опустити дужки після `new`, якщо виклик конструктора відбувається без аргументів:
 
 ```js
-let user = new User; // <-- no parentheses
-// same as
+let user = new User; // <-- немає дужок
+// те саме, що
 let user = new User();
 ```
 
-Omitting parentheses here is not considered a "good style", but the syntax is permitted by specification.
+Пропуск дужок не є гарною практикою, та специфікація дозволяє такий синтакис.
 ````
 
-## Methods in constructor
+## Створення методів у конструкторі
 
-Using constructor functions to create objects gives a great deal of flexibility. The constructor function may have parameters that define how to construct the object, and what to put in it.
+Використання конструкторів для створення об’єктів дає велику гнучкість. Конструктор може мати параметри, які визначають, як побудувати об’єкт і що в нього помістити.
 
-Of course, we can add to `this` not only properties, but methods as well.
+Звичайно, ми можемо додати до `this` не лише властивості, але й методи.
 
-For instance, `new User(name)` below creates an object with the given `name` and the method `sayHi`:
+У наведеному нижче прикладі, `new User(name)` створює об’єкт із заданим `name` та методом `sayHi`:
 
 ```js run
 function User(name) {
   this.name = name;
 
   this.sayHi = function() {
-    alert( "My name is: " + this.name );
+    alert( "Моє ім’я: " + this.name );
   };
 }
 
 *!*
-let john = new User("John");
+let john = new User("Джон");
 
-john.sayHi(); // My name is: John
+john.sayHi(); // Моє ім’я: Джон
 */!*
 
 /*
 john = {
-   name: "John",
+   name: "Джон",
    sayHi: function() { ... }
 }
 */
 ```
 
-To create complex objects, there's a more advanced syntax, [classes](info:classes), that we'll cover later.
+Для створення складних об’єктів існує більш просунутий синтаксис, [класи](info:classes), про який ми поговоримо пізніше.
 
-## Summary
+## Підсумки
 
-- Constructor functions or, briefly, constructors, are regular functions, but there's a common agreement to name them with capital letter first.
-- Constructor functions should only be called using `new`. Such a call implies a creation of empty `this` at the start and returning the populated one at the end.
+- Функції-конструктори або, коротко, конструктори, є звичайними функціями, але існує загальна угода ім’я такої функції починати з великої літери.
+- Конструктори повинні викликатися тільки з використанням оператора `new`. Такий виклик передбачає створення порожнього `this` на початку та повернення заповненого у кінці.
 
-We can use constructor functions to make multiple similar objects.
+Ми можемо використовувати конструктори для створення численних подібних об’єктів.
 
-JavaScript provides constructor functions for many built-in language objects: like `Date` for dates, `Set` for sets and others that we plan to study.
+JavaScript надає функції-конструктори для багатьох вбудованих об'єктів мови: наприклад, `Date`, `Set` та інших, які ми плануємо вивчати далі.
 
-```smart header="Objects, we'll be back!"
-In this chapter we only cover the basics about objects and constructors. They are essential for learning more about data types and functions in the next chapters.
+```smart header="Об’єкти, ми ще до них повернемось!"
+У цьому розділі ми розглядаємо лише основи об’єктів та конструкторів. Вони є важливими для подальшого вивчення типів даних та функцій у наступних розділах.
 
-After we learn that, we return to objects and cover them in-depth in the chapters <info:prototypes> and <info:classes>.
+Після того, як ми це вивчемо, ми повернемося до об’єктів для більш детального їх вивчення у розділах <info:prototypes> та <info:classes>.
 ```

From 7c87d80e043fb8fe734232d8890187b10dcd27da Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:38:10 +0300
Subject: [PATCH 02/12] Update
 1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js

---
 .../2-calculator-constructor/_js.view/test.js                   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
index 8b2a1c4c6..9bff4266d 100644
--- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
+++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/_js.view/test.js
@@ -11,7 +11,7 @@ describe("calculator", function() {
     calculator.read();
   });
 
-  it("метод read запитує два значення за допомогою prompt і запам'ятовує їх у властивостях об’єкта", function() {
+  it("метод read запитує два значення за допомогою prompt і запам’ятовує їх у властивостях об’єкта", function() {
     assert.equal(calculator.a, 2);
     assert.equal(calculator.b, 3);
   });

From 77d2dc4bb3571e48ff65fc5e0c67879037ac844f Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:38:18 +0300
Subject: [PATCH 03/12] Update
 1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md

---
 .../06-constructor-new/2-calculator-constructor/task.md         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
index 68f5c751e..1d2892db0 100644
--- a/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
+++ b/1-js/04-object-basics/06-constructor-new/2-calculator-constructor/task.md
@@ -6,7 +6,7 @@ importance: 5
 
 Створіть функцію-конструктор `Calculator`, який створює об’єкти з трьома методами:
 
-- `read()` запитує два значення за допомогою `prompt` і запам'ятовує їх у властивостях об'єкта.
+- `read()` запитує два значення за допомогою `prompt` і запам'ятовує їх у властивостях об’єкта.
 - `sum()` повертає суму цих властивостей.
 - `mul()` повертає результат множення даних властивостей.
 

From 3429d09d83a6e60fb11a75938425216fa4cadbf2 Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:38:33 +0300
Subject: [PATCH 04/12] Update
 1-js/04-object-basics/06-constructor-new/article.md

---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 9b5f064d5..e8dcb6a4f 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -1,6 +1,6 @@
 # Конструктори, оператор "new"
 
-Звичайний синтаксис `{...}` дозволяє створити тільки один об’єкт. Проте часто нам потрібно створити багато однотипних об’єктів, таких як, наприклад, користувачі чи елементи меню та т.п.
+Звичайний синтаксис `{...}` дозволяє створити тільки один об’єкт. Проте часто нам потрібно створити багато однотипних об’єктів, таких як, наприклад, користувачі чи елементи меню тощо.
 
 Це можно зробити за допомоги функції-конструктора та оператора `"new"`.
 

From e9b1bf8dbd4f2458d91f3424ad43a66ce921eff6 Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:38:58 +0300
Subject: [PATCH 05/12] Update
 1-js/04-object-basics/06-constructor-new/article.md

---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index e8dcb6a4f..ecbb74f1e 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -2,7 +2,7 @@
 
 Звичайний синтаксис `{...}` дозволяє створити тільки один об’єкт. Проте часто нам потрібно створити багато однотипних об’єктів, таких як, наприклад, користувачі чи елементи меню тощо.
 
-Це можно зробити за допомоги функції-конструктора та оператора `"new"`.
+Це можна зробити за допомогою функції-конструктора та оператора `"new"`.
 
 ## Функція-конструктор
 

From 890886c76ec6838857d84faa8b1dfb58bf2c98e1 Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:39:05 +0300
Subject: [PATCH 06/12] Update
 1-js/04-object-basics/06-constructor-new/article.md

---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index ecbb74f1e..4956208b3 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -29,7 +29,7 @@ alert(user.isAdmin); // false
 
 Коли функція виконується з `new`, відбуваються наступні кроки:
 
-1. Створюється новий порожній об'єкт, який присвоюється `this`.
+1. Створюється новий порожній об’єкт, якому присвоюється `this`.
 2. Виконується тіло функції. Зазвичай воно модифікує `this`, додає до нього нові властивості.
 3. Повертається значення `this`.
 

From 7f46d44b5ad8cf2e4e8d4d0c51938ba055d7c7fd Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:39:12 +0300
Subject: [PATCH 07/12] Update
 1-js/04-object-basics/06-constructor-new/article.md

---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 4956208b3..824f53ddb 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -33,7 +33,7 @@ alert(user.isAdmin); // false
 2. Виконується тіло функції. Зазвичай воно модифікує `this`, додає до нього нові властивості.
 3. Повертається значення `this`.
 
-Іншими словами, виклик `new User(...)` робить щось на зразок:
+Інакше кажучи, виклик `new User(...)` робить щось на зразок:
 
 ```js
 function User(name) {

From 82f497c146725e7a074892433b70308d39111c41 Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:39:20 +0300
Subject: [PATCH 08/12] Update
 1-js/04-object-basics/06-constructor-new/article.md

---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 824f53ddb..fb1be25db 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -62,7 +62,7 @@ let user = {
 
 Тепер, якщо ми хочемо створити інших користувачів, ми можемо викликати `new User("Ганна")`, `new User("Аліса")` тощо. Така конструкція значно коротша, ніж використання літералів кожного разу, а також легша для читання.
 
-Це і є основною метою конструкторів -- зручне перевикористання коду зі створення об'єктів.
+Це і є основною метою конструкторів -- зручне перевикористання коду зі створення об’єктів.
 
 Ще раз зауважимо -- технічно будь-яка функція (окрім стрілкових функцій, оскільки вони не мають власного `this`) може бути використана як конструктор. Вона може бути запущена через `new`, і буде виконано наведений вище алгоритм. "Ім’я з великої літери" це загальна угода, яка допомагає чітко зрозуміти, що функцію слід запускати з `new`.
 

From 2d085d6c81750b768824ad2aec3f2985447fdadb Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:39:28 +0300
Subject: [PATCH 09/12] Update
 1-js/04-object-basics/06-constructor-new/article.md

---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index fb1be25db..4dd634156 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -67,7 +67,7 @@ let user = {
 Ще раз зауважимо -- технічно будь-яка функція (окрім стрілкових функцій, оскільки вони не мають власного `this`) може бути використана як конструктор. Вона може бути запущена через `new`, і буде виконано наведений вище алгоритм. "Ім’я з великої літери" це загальна угода, яка допомагає чітко зрозуміти, що функцію слід запускати з `new`.
 
 ````smart header="new function() { ... }"
-Якщо у нас є багато рядків коду, які створюють єдиний складний об'єкт, ми можемо обернути їх у функцію-конструктор, яка одразу буде викликана, таким чином:
+Якщо у нас є багато рядків коду, які створюють єдиний складний об’єкт, ми можемо обернути їх у функцію-конструктор, яка одразу буде викликана, таким чином:
 
 ```js
 // створити функцію і негайно викликати її за допомогою new

From 85c6685342939af3767b43a0b7036046e9b54c9a Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:39:38 +0300
Subject: [PATCH 10/12] Update
 1-js/04-object-basics/06-constructor-new/article.md

---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index 4dd634156..f32983c79 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -140,7 +140,7 @@ alert(john.name); // Джон
 - Якщо `return` викликається з об’єктом, тоді замість `this` буде повернено цей об’єкт.
 - Якщо `return` викликається з примітивом, примітив ігнорується.
 
-Іншими словами, `return` з об’єктом повертає цей об’єкт, у всіх інших випадках повертається`this`.
+Інакше кажучи, `return` з об’єктом повертає цей об’єкт, у всіх інших випадках повертається `this`.
 
 У наступному прикладі `return` перезаписує `this`, повертаючи об’єкт:
 

From b8bad3bb00729ae6cdc4e44aee9c1c54610fe297 Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:39:44 +0300
Subject: [PATCH 11/12] Update
 1-js/04-object-basics/06-constructor-new/article.md

---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index f32983c79..be4b7879d 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -149,7 +149,7 @@ function BigUser() {
 
   this.name = "Джон";
 
-  return { name: "Годзілла" };  // <-- повертає цей об’єкт
+  return { name: "Ґодзілла" };  // <-- повертає цей об’єкт
 }
 
 alert( new BigUser().name );  // Годзілла, отримали цей об’єкт

From 76cf7149cb710b88ff207085529415a8e059e280 Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Wed, 4 Aug 2021 17:39:50 +0300
Subject: [PATCH 12/12] Update
 1-js/04-object-basics/06-constructor-new/article.md

---
 1-js/04-object-basics/06-constructor-new/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/04-object-basics/06-constructor-new/article.md b/1-js/04-object-basics/06-constructor-new/article.md
index be4b7879d..6359d26cb 100644
--- a/1-js/04-object-basics/06-constructor-new/article.md
+++ b/1-js/04-object-basics/06-constructor-new/article.md
@@ -152,7 +152,7 @@ function BigUser() {
   return { name: "Ґодзілла" };  // <-- повертає цей об’єкт
 }
 
-alert( new BigUser().name );  // Годзілла, отримали цей об’єкт
+alert( new BigUser().name );  // Ґодзілла, отримали цей об’єкт
 ```
 
 А ось приклад з порожнім `return` (або ми можемо розмістити примітив після нього, не має значення):