From fe7b56124c123b4aa4c8d3dcc894c04b39323511 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Thu, 16 May 2019 23:58:09 +0300
Subject: [PATCH 01/10] translation in progress

---
 1-js/02-first-steps/07-operators/article.md | 22 ++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index 74b27e871..c7e4d4506 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -1,15 +1,15 @@
-# Operators
+# Оператори
 
-We know many operators from school. They are things like addition `+`, multiplication `*`, subtraction `-`, and so on.
+Ми знаємо багато операторів зі школи. Це такі речі, як додавання `+`, множення `*`, віднімання `-`, тощо.
 
-In this chapter, we'll concentrate on aspects of operators that are not covered by school arithmetic.
+У цьому розділі ми зупинимося на аспектах операторів, які не охоплені шкільною арифметикою.
 
-## Terms: "unary", "binary", "operand"
+## Тарміни: "унарний", "бінарний", "операнд"
 
-Before we move on, let's grasp some common terminology.
+Перш ніж ми почнемо, давайте розберемо певну загальну термінологію.
 
-- *An operand* -- is what operators are applied to. For instance, in the multiplication of `5 * 2` there are two operands: the left operand is `5` and the right operand is `2`. Sometimes, people call these "arguments" instead of "operands".
-- An operator is *unary* if it has a single operand. For example, the unary negation `-` reverses the sign of a number:
+- *Операнд* -- це те, до чого затосовуються оператори. Наприклад, у множенні `5 * 2` є два операнди: лівий операнд `5` і правий операнд `2`. Іноді, люди називають їх "аргументами", а не "операндами".
+- Опреатор є *унарним*, якщо він має один операнд. Наприклад, унарне заперечення `-` змінює знак числа:
 
     ```js run
     let x = 1;
@@ -17,16 +17,16 @@ Before we move on, let's grasp some common terminology.
     *!*
     x = -x;
     */!*
-    alert( x ); // -1, unary negation was applied
+    alert( x ); // -1, було застосоване унарне заперечення
     ```
-- An operator is *binary* if it has two operands. The same minus exists in binary form as well:
+- Оператор є *бінарним*, якщо він має два операнди. Цей мінус існує також в бінарній формі:
 
     ```js run no-beautify
     let x = 1, y = 3;
-    alert( y - x ); // 2, binary minus subtracts values
+    alert( y - x ); // 2, бінарний мінус віднімає значення
     ```
 
-    Formally, we're talking about two different operators here: the unary negation (single operand: reverses the sign) and the binary subtraction (two operands: subtracts).
+    Формально, ми говоримо про двох різних операторів: унарне заперечення (єдиний операнд: змінює знак) та бінарне віднімання (два опернди: віднімає).
 
 ## String concatenation, binary +
 

From b3f1fea7162179b33a9ba5a446d9ec7ca439c618 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Sun, 19 May 2019 20:19:47 +0300
Subject: [PATCH 02/10] saving translation progress

---
 1-js/02-first-steps/07-operators/article.md | 60 ++++++++++-----------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index c7e4d4506..934e78ac3 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -28,56 +28,56 @@
 
     Формально, ми говоримо про двох різних операторів: унарне заперечення (єдиний операнд: змінює знак) та бінарне віднімання (два опернди: віднімає).
 
-## String concatenation, binary +
+## Об'єднаяння рядків, бінарний +
 
-Now, let's see special features of JavaScript operators that are beyond school arithmetics.
+Тепер розглянемо особливості JavaScript операторів, які виходять за межі шкільної арифметики.
 
-Usually, the plus operator `+` sums numbers.
+Зазвичай оператор плюс `+` підсумовує числа.
 
-But, if the binary `+` is applied to strings, it merges (concatenates) them:
+Але, якщо бінарний `+` застосовується до рядків, він об'єднує їх:
 
 ```js
-let s = "my" + "string";
-alert(s); // mystring
+let s = "мій" + "рядок";
+alert(s); // мійрядок
 ```
 
-Note that if one of the operands is a string, the other one is converted to a string too.
+Зверніть увагу, якщо один з операндів є рядком, то інший також перетворюється на рядок.
 
-For example:
+Наприклад:
 
 ```js run
 alert( '1' + 2 ); // "12"
 alert( 2 + '1' ); // "21"
 ```
 
-See, it doesn't matter whether the first operand is a string or the second one. The rule is simple: if either operand is a string, the other one is converted into a string as well.
+Бачите, на має значення, чи перший операнд є рядком або другий. Правило просте: якщо будь-який операнд є радком, інший також перетворюється на рядок.
 
-However, note that operations run from left to right. If there are two numbers followed by a string, the numbers will be added before being converted to a string:
+Однак зверніть увагу, що операції виконуються зліва направо. Якщо є два числа, за якими йде рядок, числа будуть додані перед перетворенням на рядок:
 
 
 ```js run
-alert(2 + 2 + '1' ); // "41" and not "221"
+alert(2 + 2 + '1' ); // "41" а не "221"
 ```
 
-String concatenation and conversion is a special feature of the binary plus `+`. Other arithmetic operators work only with numbers and always convert their operands to numbers.
+Об'єднання рядків і перетворення є особливою ознакою бінарного плюса `+`. Інші арифметичні оператори працюють тільки з числами і завжди перетворюють свої операнди в числа.
 
-For instance, subtraction and division:
+Наприклад, віднімання і ділення:
 
 ```js run
 alert( 2 - '1' ); // 1
 alert( '6' / '2' ); // 3
 ```
 
-## Numeric conversion, unary +
+## Числове перетворення, унарний +
 
-The plus `+` exists in two forms: the binary form that we used above and the unary form.
+Плюс `+` існує у двох формах: бінарна форма, яку ми використовували вище та унарна форма.
 
-The unary plus or, in other words, the plus operator `+` applied to a single value, doesn't do anything to numbers. But if the operand is not a number, the unary plus converts it into a number.
+Унарний плюс або, іншими словами, оператор плюс `+`, застосований до єдиного операнда, нічого не зробить, якщо операнд є числом. Але якщо операнд не є числом, унарний плюс перетворить його в число.
 
-For example:
+Наприклад:
 
 ```js run
-// No effect on numbers
+// Нема ніякого впилу на числа
 let x = 1;
 alert( +x ); // 1
 
@@ -85,47 +85,47 @@ let y = -2;
 alert( +y ); // -2
 
 *!*
-// Converts non-numbers
+// Перетворює не числові значення
 alert( +true ); // 1
 alert( +"" );   // 0
 */!*
 ```
 
-It actually does the same thing as `Number(...)`, but is shorter.
+Він насправді працює як і `Number(...)`, але виглядає коротше.
 
-The need to convert strings to numbers arises very often. For example, if we are getting values from HTML form fields, they are usually strings.
+Необхідність перетворення рядків на числа виникає дуже часто. Наприклад, якщо ми отримуємо значення з полів HTML форми, вони зазвичай є рядками.
 
-What if we want to sum them?
+Що робити, якщо ми хочемо їх підсумувати?
 
-The binary plus would add them as strings:
+Бінарний плюс додав би їх як рядки:
 
 ```js run
 let apples = "2";
 let oranges = "3";
 
-alert( apples + oranges ); // "23", the binary plus concatenates strings
+alert( apples + oranges ); // "23", бінарний плюс об'єднує рядки
 ```
 
-If we want to treat them as numbers, we need to convert and then sum them:
+Якщо ми хочемо розглядати їх як числа, нам потрібно конвертувати, а потім підсумувати їх:
 
 ```js run
 let apples = "2";
 let oranges = "3";
 
 *!*
-// both values converted to numbers before the binary plus
+// обидва значення перетворюються на числа перед застосування бінарного плюса
 alert( +apples + +oranges ); // 5
 */!*
 
-// the longer variant
+// довший варіант
 // alert( Number(apples) + Number(oranges) ); // 5
 ```
 
-From a mathematician's standpoint, the abundance of pluses may seem strange. But from a programmer's standpoint, there's nothing special: unary pluses are applied first, they convert strings to numbers, and then the binary plus sums them up.
+З точки зору математика, надмір плюсів може здатися дивним. Але з точки зору програміста, немає нічого особливого: спочатку застосовується унарні плюси, вони перетворюють рядки на числа, а потім бінарний плюс підсумовує їх.
 
-Why are unary pluses applied to values before the binary ones? As we're going to see, that's because of their *higher precedence*.
+Чому унарні плюси застосовуються до значень перед бінарними плюсами? Як ми побичмо далі, це пов'язано з їх *більш високим пріоритетом*.
 
-## Operator precedence
+## Пріоритет оператора
 
 If an expression has more than one operator, the execution order is defined by their *precedence*, or, in other words, the implicit priority order of operators.
 

From 398d9116cc0e1241293be9c89f8ebe8e0cd36e0e Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Tue, 21 May 2019 22:35:28 +0300
Subject: [PATCH 03/10] saving translation progress

---
 1-js/02-first-steps/07-operators/article.md | 30 ++++++++++-----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index 934e78ac3..e01fa6ab0 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -127,32 +127,32 @@ alert( +apples + +oranges ); // 5
 
 ## Пріоритет оператора
 
-If an expression has more than one operator, the execution order is defined by their *precedence*, or, in other words, the implicit priority order of operators.
+Ящо вираз має більше одного оператора, порядок виконання визначається їх *пріоритетом*, або, іншими словами, неявним порядком пріоритетів операторів.
 
-From school, we all know that the multiplication in the expression `1 + 2 * 2` should be calculated before the addition. That's exactly the precedence thing. The multiplication is said to have *a higher precedence* than the addition.
+Зі школи ми всі знаємо, що множення у виразі `1 + 2 * 2` повинно бути вираховано перед додаванням. Саме це і є пріоритетом. Кажуть, що множення має *більш високий пріоритет*, ніж додавання.
 
-Parentheses override any precedence, so if we're not satisfied with the implicit order, we can use them to change it. For example: `(1 + 2) * 2`.
+Дужки перевизначають будь-який пріоритет, тому, якщо ми не задоволенні неявним приорітетом, ми можемо використовувати дужки, щоб змінити його. Наприклад: `(1 + 2) * 2`.
 
-There are many operators in JavaScript. Every operator has a corresponding precedence number. The one with the larger number executes first. If the precedence is the same, the execution order is from left to right.
+У JavaScript є багато операторів. Кожен оператор має відповідний номер пріоритету. Першим виконується той оператор, який має найбільший номер. Якщо пріоритет є одниковим, порядок виконання — зліва направо.
 
-Here's an extract from the [precedence table](https://developer.mozilla.org/en/JavaScript/Reference/operators/operator_precedence) (you don't need to remember this, but note that unary operators are higher than corresponding binary ones):
+Ось витяг із [таблиці пріоритетів](https://developer.mozilla.org/en/JavaScript/Reference/operators/operator_precedence) (вам не потрібно запам'ятовувати це, але зверніть увагу, що унарні оператори вище за відповідні бінарні):
 
-| Precedence | Name | Sign |
+| Приорітет | Ім'я | Знак |
 |------------|------|------|
 | ... | ... | ... |
-| 16 | unary plus | `+` |
-| 16 | unary negation | `-` |
-| 14 | multiplication | `*` |
-| 14 | division | `/` |
-| 13 | addition | `+` |
-| 13 | subtraction | `-` |
+| 16 | унарний плюс | `+` |
+| 16 | унарне заперечення | `-` |
+| 14 | множення | `*` |
+| 14 | ділення | `/` |
+| 13 | додавання | `+` |
+| 13 | віднімання | `-` |
 | ... | ... | ... |
-| 3 | assignment | `=` |
+| 3 | призначення | `=` |
 | ... | ... | ... |
 
-As we can see, the "unary plus" has a priority of `16` which is higher than the `13` of "addition" (binary plus). That's why, in the expression `"+apples + +oranges"`, unary pluses work before the addition.
+Як ми бачемо, "унарний плюс" має пріоритет `16`, який вище за `13` — пріоритет "додавання" (бінарний плюс). Саме тому, у виразі `"+apples + +oranges"`, унарні плюси виконуються до додавання (бінарного плюса).
 
-## Assignment
+## Призначення
 
 Let's note that an assignment `=` is also an operator. It is listed in the precedence table with the very low priority of `3`.
 

From ff2e0cf86f5b745b9974e3c48a549792b67b05c7 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Thu, 23 May 2019 23:32:49 +0300
Subject: [PATCH 04/10] saving progress

---
 1-js/02-first-steps/07-operators/article.md | 26 ++++++++++-----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index e01fa6ab0..451c3f625 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -152,11 +152,11 @@ alert( +apples + +oranges ); // 5
 
 Як ми бачемо, "унарний плюс" має пріоритет `16`, який вище за `13` — пріоритет "додавання" (бінарний плюс). Саме тому, у виразі `"+apples + +oranges"`, унарні плюси виконуються до додавання (бінарного плюса).
 
-## Призначення
+## Присвоювання
 
-Let's note that an assignment `=` is also an operator. It is listed in the precedence table with the very low priority of `3`.
+Зазначемо, що присвоювання `=` також є оператором. Воно є в таблиці з пріоритетами і має дуже низький пріоритет `3`.
 
-That's why, when we assign a variable, like `x = 2 * 2 + 1`, the calculations are done first and then the `=` is evaluated, storing the result in `x`.
+Тому, коли ми присвоюємо значення змінній, наприклад, `x = 2 * 2 + 1`, спочатку виконуються обчислення, а потім виконується присвоювання `=`, зберігаючи результат у `x`.
 
 ```js
 let x = 2 * 2 + 1;
@@ -164,7 +164,7 @@ let x = 2 * 2 + 1;
 alert( x ); // 5
 ```
 
-It is possible to chain assignments:
+Можливе лангюгове присвоювання:
 
 ```js run
 let a, b, c;
@@ -178,14 +178,14 @@ alert( b ); // 4
 alert( c ); // 4
 ```
 
-Chained assignments evaluate from right to left. First, the rightmost expression `2 + 2` is evaluated and then assigned to the variables on the left: `c`, `b` and `a`. At the end, all the variables share a single value.
+Лангюгове присвоювання виконується справа наліво. Спочатку обчислюється самий правий вираз `2 + 2`, а потім присвоюється зінним ліворуч   : `c`, `b` and `a`. Наприкінці всі змінні мають спільне значення.
 
-````smart header="The assignment operator `\"=\"` returns a value"
-An operator always returns a value. That's obvious for most of them like addition `+` or multiplication `*`. But the assignment operator follows this rule too.
+````smart header="Оператор присвоювання `\"=\"` повертає значення"
+Оператор завжди повертає значення. Це очевидно для більшості з них, як додавання `+` або множення `*`. Але оператор присвоювання також додтримується цього правила.
 
-The call `x = value` writes the `value` into `x` *and then returns it*.
+Виклик `x = значення` записує `значення` у `x`, *а потім повертає його*.
 
-Here's a demo that uses an assignment as part of a more complex expression:
+Ось демонстрація, яка використовує присвоювання як частину більш складного виразу:
 
 ```js run
 let a = 1;
@@ -199,14 +199,14 @@ alert( a ); // 3
 alert( c ); // 0
 ```
 
-In the example above, the result of `(a = b + 1)` is the value which is assigned to `a` (that is `3`). It is then used to subtract from `3`.
+У наведенному вище прикладі результат `(a = b + 1)` є значенням, яке присвоюється змінній `a` (тобто `3`). Потім вона використовується для віднімання від `3`.
 
-Funny code, isn't it? We should understand how it works, because sometimes we see it in 3rd-party libraries, but shouldn't write anything like that ourselves. Such tricks definitely don't make code clearer or readable.
+Смішний код, чи не так? Ми повинні зрозуміти, як це працює, бо іноді ми бачимо подібне у бібліотеках третьої сторони, але самі не повинні писати нічого подібного. Такі трюки, безумовно, не роблять код більш ясним або читабельним.
 ````
 
-## Remainder %
+## Залишок %
 
-The remainder operator `%`, despite its appearance, is not related to percents.
+Оператор залишку `%`, despite its appearance, is not related to percents.
 
 The result of `a % b` is the remainder of the integer division of `a` by `b`.
 

From d5b90bb6480a26122d947aa26a796e919a729ad3 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Fri, 24 May 2019 23:18:13 +0300
Subject: [PATCH 05/10] finished translation

---
 .../1-increment-order/solution.md             |  10 +-
 .../07-operators/1-increment-order/task.md    |   4 +-
 .../2-assignment-result/solution.md           |   6 +-
 .../07-operators/2-assignment-result/task.md  |   4 +-
 1-js/02-first-steps/07-operators/article.md   | 148 +++++++++---------
 5 files changed, 86 insertions(+), 86 deletions(-)

diff --git a/1-js/02-first-steps/07-operators/1-increment-order/solution.md b/1-js/02-first-steps/07-operators/1-increment-order/solution.md
index 8a44d798e..eb170ba86 100644
--- a/1-js/02-first-steps/07-operators/1-increment-order/solution.md
+++ b/1-js/02-first-steps/07-operators/1-increment-order/solution.md
@@ -1,5 +1,5 @@
 
-The answer is:
+Відповідь:
 
 - `a = 2`
 - `b = 2`
@@ -9,10 +9,10 @@ The answer is:
 ```js run no-beautify
 let a = 1, b = 1;
 
-alert( ++a ); // 2, prefix form returns the new value
-alert( b++ ); // 1, postfix form returns the old value
+alert( ++a ); // 2, префиксна форма повертає нове значення
+alert( b++ ); // 1, постфіксна форма повертає старе значення
 
-alert( a ); // 2, incremented once
-alert( b ); // 2, incremented once
+alert( a ); // 2, збільшується один раз
+alert( b ); // 2, збільшується один раз
 ```
 
diff --git a/1-js/02-first-steps/07-operators/1-increment-order/task.md b/1-js/02-first-steps/07-operators/1-increment-order/task.md
index 7db092389..19baf11e6 100644
--- a/1-js/02-first-steps/07-operators/1-increment-order/task.md
+++ b/1-js/02-first-steps/07-operators/1-increment-order/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# The postfix and prefix forms
+# Постфіксна та префіксна форми
 
-What are the final values of all variables `a`, `b`, `c` and `d` after the code below?
+Які кінцеви значення всіх змінних `a`, `b`, `c` та `d` після виконання коду нижче?
 
 ```js
 let a = 1, b = 1;
diff --git a/1-js/02-first-steps/07-operators/2-assignment-result/solution.md b/1-js/02-first-steps/07-operators/2-assignment-result/solution.md
index e3113b4cd..39cffb56e 100644
--- a/1-js/02-first-steps/07-operators/2-assignment-result/solution.md
+++ b/1-js/02-first-steps/07-operators/2-assignment-result/solution.md
@@ -1,5 +1,5 @@
-The answer is:
+Відповідь:
 
-- `a = 4` (multiplied by 2)
-- `x = 5` (calculated as 1 + 4)
+- `a = 4` (помножиться на 2)
+- `x = 5` (обчислюється як 1 + 4)
 
diff --git a/1-js/02-first-steps/07-operators/2-assignment-result/task.md b/1-js/02-first-steps/07-operators/2-assignment-result/task.md
index 5345c9485..bcae7416d 100644
--- a/1-js/02-first-steps/07-operators/2-assignment-result/task.md
+++ b/1-js/02-first-steps/07-operators/2-assignment-result/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# Assignment result
+# Рузльтат присвоювання
 
-What are the values of `a` and `x` after the code below?
+Які значення мають `a` та `x` після виконання коду нижче?
 
 ```js
 let a = 2;
diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index 451c3f625..0aba32ecc 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -206,25 +206,25 @@ alert( c ); // 0
 
 ## Залишок %
 
-Оператор залишку `%`, despite its appearance, is not related to percents.
+Оператор залишку `%`, незважаючи на свій зовнішній вигляд, не пов'язаний з відсотками.
 
-The result of `a % b` is the remainder of the integer division of `a` by `b`.
+Результатом `a % b` є залишок цілочисельного ділення `a` на `b`.
 
-For instance:
+Наприклад:
 
 ```js run
-alert( 5 % 2 ); // 1 is a remainder of 5 divided by 2
-alert( 8 % 3 ); // 2 is a remainder of 8 divided by 3
-alert( 6 % 3 ); // 0 is a remainder of 6 divided by 3
+alert( 5 % 2 ); // 1 — залишок від 5 розділеного на 2
+alert( 8 % 3 ); // 2 — залишок від 8 розділеного на 3
+alert( 6 % 3 ); // 0 — залишок від 6 розділеного на 3
 ```
 
-## Exponentiation **
+## Піднесення до степеня **
 
-The exponentiation operator `**` is a recent addition to the language.
+Оператор піднесення до степеня `**` був доданий у мову нещодавно.
 
-For a natural number `b`, the result of `a ** b` is `a` multiplied by itself `b` times.
+Для натурального числа `b`, результатом `a ** b` є `a` помножене на себе `b` разів.
 
-For instance:
+Наприклад:
 
 ```js run
 alert( 2 ** 2 ); // 4  (2 * 2)
@@ -232,54 +232,54 @@ alert( 2 ** 3 ); // 8  (2 * 2 * 2)
 alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)
 ```
 
-The operator works for non-integer numbers as well.
+Оператор працює і для нецілих чисел.
 
-For instance:
+Наприклад:
 
 ```js run
-alert( 4 ** (1/2) ); // 2 (power of 1/2 is the same as a square root, that's maths)
-alert( 8 ** (1/3) ); // 2 (power of 1/3 is the same as a cubic root)
+alert( 4 ** (1/2) ); // 2 (степінь 1/2 — це теж саме, що і квадратний корінь, це математика)
+alert( 8 ** (1/3) ); // 2 (степінь 1/3 — це теж саме, що і кубічний корінь)
 ```
 
-## Increment/decrement
+## Інкремент/декремент
 
 <!-- Can't use -- in title, because built-in parse turns it into – -->
 
-Increasing or decreasing a number by one is among the most common numerical operations.
+Збільшення або зменшення числа на одиницю є однією з найпоширеніших операцій.
 
-So, there are special operators for it:
+Тому для цього існують спеціальні оператори:
 
-- **Increment** `++` increases a variable by 1:
+- **Інкремент** `++` збільшує змінну на 1:
 
     ```js run no-beautify
     let counter = 2;
-    counter++;      // works the same as counter = counter + 1, but is shorter
+    counter++;      // працює так само, як counter = counter + 1, але коротше
     alert( counter ); // 3
     ```
-- **Decrement** `--` decreases a variable by 1:
+- **Декремент** `--` зменьшує змінну на 1:
 
     ```js run no-beautify
     let counter = 2;
-    counter--;      // works the same as counter = counter - 1, but is shorter
+    counter--;      // працює так само, як counter = counter - 1, але коротше
     alert( counter ); // 1
     ```
 
 ```warn
-Increment/decrement can only be applied to variables. Trying to use it on a value like `5++` will give an error.
+Інкремент/декремент можуть застосовуватись лише до змінних. Спроба використовувати їх на значенні як `5++` дасть помилку.
 ```
 
-The operators `++` and `--` can be placed either before or after a variable.
+Оператори `++` та `--` можуть розташовуватись до або після змінної.
 
-- When the operator goes after the variable, it is in "postfix form": `counter++`.
-- The "prefix form" is when the operator goes before the variable: `++counter`.
+- Коли оператор йде за змінною, він знаходиться у "постфіксній формі": `counter++`.
+- "Префіксна форма" – це коли оператор йде попереду змінної: `++counter`.
 
-Both of these statements do the same thing: increase `counter` by `1`.
+Обидві конструкції роблять те ж саме: збільшують `counter` на `1`.
 
-Is there any difference? Yes, but we can only see it if we use the returned value of `++/--`.
+Чи є різниця? Так, але ми можемо побачити її якщо будемо використовувати повернене значення `++/--`.
 
-Let's clarify. As we know, all operators return a value. Increment/decrement is no exception. The prefix form returns the new value while the postfix form returns the old value (prior to increment/decrement).
+Давайте розберемось. Як відомо, усі оператори повертають значення. Інкремент/декремент не є винятком. Префіксна форма повертає нове значення, тоді як постфіксна форма повертає повертає старе значення (до збільшення/зменшення).
 
-To see the difference, here's an example:
+Щоб побачитит різницю, наведемо приклад:
 
 ```js run
 let counter = 1;
@@ -288,64 +288,64 @@ let a = ++counter; // (*)
 alert(a); // *!*2*/!*
 ```
 
-In the line `(*)`, the *prefix* form `++counter` increments `counter` and returns the new value, `2`. So, the `alert` shows `2`.
+У рядку `(*)`, *префіксна* форма `++counter` збільшує `counter` та повертає нове значення, `2`. Отже, `alert` показує `2`.
 
-Now, let's use the postfix form:
+Тепер скористаємося постфіксною формою:
 
 ```js run
 let counter = 1;
-let a = counter++; // (*) changed ++counter to counter++
+let a = counter++; // (*) змінили ++counter на counter++
 
 alert(a); // *!*1*/!*
 ```
 
-In the line `(*)`, the *postfix* form `counter++` also increments `counter` but returns the *old* value (prior to increment). So, the `alert` shows `1`.
+У рядку `(*)`, *постфіксна* форма `counter++` також збільшує `counter`, але повертає *старе* значення (до інкременту). Отже, `alert` показує `1`.
 
-To summarize:
+Підсумки:
 
-- If the result of increment/decrement is not used, there is no difference in which form to use:
+- Якщо результат збільшення/зменшення не використовується, немає ніякої різниці яку форму використовувати:
 
     ```js run
     let counter = 0;
     counter++;
     ++counter;
-    alert( counter ); // 2, the lines above did the same
+    alert( counter ); // 2, у рядках вище робиться одне і те ж саме
     ```
-- If we'd like to increase a value *and* immediately use the result of the operator, we need the prefix form:
+- Якщо ми хочемо збільшити значення *та* негайно використати результат оператора, нам потрібна префіксна форма:
 
     ```js run
     let counter = 0;
     alert( ++counter ); // 1
     ```
-- If we'd like to increment a value but use its previous value, we need the postfix form:
+- Якщо ми хочемо збільшити значення, але використати його попереднє значення, нам потрібна постфіксна форма:
 
     ```js run
     let counter = 0;
     alert( counter++ ); // 0
     ```
 
-````smart header="Increment/decrement among other operators"
-The operators `++/--` can be used inside expressions as well. Their precedence is higher than most other arithmetical operations.
+````smart header="Інкремент/декремент серед інших операторів"
+Оператори `++/--` також можуть використовуватись всередені виразів. Їх пріоритет віще за більшість інщих арифметичних операцій.
 
-For instance:
+Наприклад:
 
 ```js run
 let counter = 1;
 alert( 2 * ++counter ); // 4
 ```
 
-Compare with:
+Порівняйте із:
 
 ```js run
 let counter = 1;
-alert( 2 * counter++ ); // 2, because counter++ returns the "old" value
+alert( 2 * counter++ ); // 2, тому що counter++ повертається "старе" значення
 ```
 
-Though technically okay, such notation usually makes code less readable. One line does multiple things -- not good.
+Не дивлячісь на те, що з технічної точки зору це допустимо, таке використання робить код меньш читабельним. Один рядок робить кілька речей -- не є добре.
 
-While reading code, a fast "vertical" eye-scan can easily miss something like `counter++` and it won't be obvious that the variable increased.
+При читанні коду швидке "вертикальне" сканування оком може легко пропустити щось подібне до `counter++` і не буде очевидним, що змінна була збільшена.
 
-We advise a style of "one line -- one action":
+Ми рекомендуємо стиль "одна лінія -- одна дія":
 
 ```js run
 let counter = 1;
@@ -354,13 +354,13 @@ counter++;
 ```
 ````
 
-## Bitwise operators
+## Побітові оператори
 
-Bitwise operators treat arguments as 32-bit integer numbers and work on the level of their binary representation.
+Побітові оператори розглядають аргументи як 32-бітні цілі числа та працюють на рівні їх двійкового представлення.
 
-These operators are not JavaScript-specific. They are supported in most programming languages.
+Ці оператори не є специфічними для JavaScript. Вони підтримуються у більшості мов програмування.
 
-The list of operators:
+Список операторів:
 
 - AND ( `&` )
 - OR ( `|` )
@@ -370,13 +370,13 @@ The list of operators:
 - RIGHT SHIFT ( `>>` )
 - ZERO-FILL RIGHT SHIFT ( `>>>` )
 
-These operators are used very rarely. To understand them, we need to delve into low-level number representation and it would not be optimal to do that right now, especially since we won't need them any time soon. If you're curious, you can read the [Bitwise Operators](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators) article on MDN. It would be more practical to do that when a real need arises.
+Ці оператори використовуються дуже рідко. Цоб їх зрозуміти, нам потрібно заглибитись у представлення числа на низькому рівні і зараз не самий оптимальний час для цього, тим більше, що нам вони не будуть потрібні найближчим часом. Якщо вам цікаво, ви можете прочитати статтю [Bitwise Operators](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators) на MDN. Це було би більш практично зробити, коли виникне реальна потреба.
 
-## Modify-in-place
+## Змінити-на-місці
 
-We often need to apply an operator to a variable and store the new result in that same variable.
+Часто нам потрібно застосувати оператор до змінної та зберегти новий результат у ту ж саму змінну.
 
-For example:
+Наприклад:
 
 ```js
 let n = 2;
@@ -384,63 +384,63 @@ n = n + 5;
 n = n * 2;
 ```
 
-This notation can be shortened using the operators `+=` and `*=`:
+Це запис скоротити за допомогою операторів `+=` та `*=`:
 
 ```js run
 let n = 2;
-n += 5; // now n = 7 (same as n = n + 5)
-n *= 2; // now n = 14 (same as n = n * 2)
+n += 5; // тепер n = 7 (теж саме, що і n = n + 5)
+n *= 2; // now n = 14 (теж саме, що і n = n * 2)
 
 alert( n ); // 14
 ```
 
-Short "modify-and-assign" operators exist for all arithmetical and bitwise operators: `/=`, `-=`, etc.
+Короткий "модифікуй-та-присвоюй" оператор існує для всіх арифметичних та побітових операторів: `/=`, `-=`, тощо.
 
-Such operators have the same precedence as a normal assignment, so they run after most other calculations:
+Такі оператори мають такуж перевагу, як і звичайне присвоювання, тому вони виконуються після більшості інших обчисленнь:
 
 ```js run
 let n = 2;
 
 n *= 3 + 5;
 
-alert( n ); // 16  (right part evaluated first, same as n *= 8)
+alert( n ); // 16  (права частина обчислюється першою, так само, як і n *= 8)
 ```
 
-## Comma
+## Кома
 
-The comma operator `,` is one of the rarest and most unusual operators. Sometimes, it's used to write shorter code, so we need to know it in order to understand what's going on.
+Оператор кома `,` є одним за найрідкіших та незвичайних операторів. Іноді використовується для написання бальш короткого коду, тому нам потрібно знати його, щоб зрозуміти, що відбувається.
 
-The comma operator allows us to evaluate several expressions, dividing them with a comma `,`. Each of them is evaluated but only the result of the last one is returned.
+Оператор кома дозволяє обчислити кілька виразів, розділивши їх комою `,`. Кожен з них обчислюється, але повертається тільки результат останнього.
 
-For example:
+Наприклад:
 
 ```js run
 *!*
 let a = (1 + 2, 3 + 4);
 */!*
 
-alert( a ); // 7 (the result of 3 + 4)
+alert( a ); // 7 (результат обчислення 3 + 4)
 ```
 
-Here, the first expression `1 + 2` is evaluated and its result is thrown away. Then, `3 + 4` is evaluated and returned as the result.
+Тут обчислюється перший вираз `1 + 2` і його результат викидається. Потім обчислюється `3 + 4` і повертається як результат.
 
-```smart header="Comma has a very low precedence"
-Please note that the comma operator has very low precedence, lower than `=`, so parentheses are important in the example above.
+```smart header="Кома має дуже низький пріоритет"
+Зверніть увагу, що оператор кома має дуже низький пріоритет, нижчий за `=`, тому дужки є важливими в наведеному вище прикладі.
 
-Without them: `a = 1 + 2, 3 + 4` evaluates `+` first, summing the numbers into `a = 3, 7`, then the assignment operator `=` assigns    `a = 3`, and finally the number after the comma, `7`, is not processed so it's ignored.
+Без них: `a = 1 + 2, 3 + 4` обчислює спочатку `+`, підсумовуючи числа у `a = 3, 7`, потім оператор присвоювання `=` присвоює    `a = 3`, і нарешті число після коми, `7`, не обробляється, тому його ігнорують.
 ```
 
-Why do we need an operator that throws away everything except the last part?
+Чому нам потрібен оператор, що викидає все, окрім останньої частини?
 
-Sometimes, people use it in more complex constructs to put several actions in one line.
+Іноді люди використовують його в більш складних конструкціях, щоб помістити кілька дій в один рядок.
 
-For example:
+Наприклад:
 
 ```js
-// three operations in one line
+// три операціх в одному рядку
 for (*!*a = 1, b = 3, c = a * b*/!*; a < 10; a++) {
  ...
 }
 ```
 
-Such tricks are used in many JavaScript frameworks. That's why we're mentioning them. But, usually, they don't improve code readability so we should think well before using them.
+Такі трюки використовуються в багатьох фреймворках JavaScript. Саме тому ми їх згадуємо. Але, як правило, вони не покращують читабельність коду, тому ми повинні добре подумати перед їх використанням.

From d0e64c7fd3954c479c4db992d500e38bc41c389d Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Fri, 24 May 2019 23:39:07 +0300
Subject: [PATCH 06/10] corrections

---
 .../1-increment-order/solution.md             |  2 +-
 .../07-operators/1-increment-order/task.md    |  2 +-
 1-js/02-first-steps/07-operators/article.md   | 46 +++++++++----------
 3 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/1-js/02-first-steps/07-operators/1-increment-order/solution.md b/1-js/02-first-steps/07-operators/1-increment-order/solution.md
index eb170ba86..66034a7c6 100644
--- a/1-js/02-first-steps/07-operators/1-increment-order/solution.md
+++ b/1-js/02-first-steps/07-operators/1-increment-order/solution.md
@@ -9,7 +9,7 @@
 ```js run no-beautify
 let a = 1, b = 1;
 
-alert( ++a ); // 2, префиксна форма повертає нове значення
+alert( ++a ); // 2, префіксна форма повертає нове значення
 alert( b++ ); // 1, постфіксна форма повертає старе значення
 
 alert( a ); // 2, збільшується один раз
diff --git a/1-js/02-first-steps/07-operators/1-increment-order/task.md b/1-js/02-first-steps/07-operators/1-increment-order/task.md
index 19baf11e6..b710c8a14 100644
--- a/1-js/02-first-steps/07-operators/1-increment-order/task.md
+++ b/1-js/02-first-steps/07-operators/1-increment-order/task.md
@@ -4,7 +4,7 @@ importance: 5
 
 # Постфіксна та префіксна форми
 
-Які кінцеви значення всіх змінних `a`, `b`, `c` та `d` після виконання коду нижче?
+Які кінцеві значення всіх змінних `a`, `b`, `c` та `d` після виконання коду нижче?
 
 ```js
 let a = 1, b = 1;
diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index 0aba32ecc..2df30d12f 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -8,7 +8,7 @@
 
 Перш ніж ми почнемо, давайте розберемо певну загальну термінологію.
 
-- *Операнд* -- це те, до чого затосовуються оператори. Наприклад, у множенні `5 * 2` є два операнди: лівий операнд `5` і правий операнд `2`. Іноді, люди називають їх "аргументами", а не "операндами".
+- *Операнд* -- це те, до чого затосовуються оператори. Наприклад, у множенні `5 * 2` є два операнди: лівий операнд `5` і правий операнд `2`. Іноді люди називають їх "аргументами", а не "операндами".
 - Опреатор є *унарним*, якщо він має один операнд. Наприклад, унарне заперечення `-` змінює знак числа:
 
     ```js run
@@ -26,9 +26,9 @@
     alert( y - x ); // 2, бінарний мінус віднімає значення
     ```
 
-    Формально, ми говоримо про двох різних операторів: унарне заперечення (єдиний операнд: змінює знак) та бінарне віднімання (два опернди: віднімає).
+    Формально, ми говоримо про два різні оператори: унарне заперечення (єдиний операнд: змінює знак) та бінарне віднімання (два опернди: віднімає).
 
-## Об'єднаяння рядків, бінарний +
+## Об'єднання рядків, бінарний +
 
 Тепер розглянемо особливості JavaScript операторів, які виходять за межі шкільної арифметики.
 
@@ -50,7 +50,7 @@ alert( '1' + 2 ); // "12"
 alert( 2 + '1' ); // "21"
 ```
 
-Бачите, на має значення, чи перший операнд є рядком або другий. Правило просте: якщо будь-який операнд є радком, інший також перетворюється на рядок.
+Бачите, не має значення, чи перший операнд є рядком або другий. Правило просте: якщо будь-який операнд є радком, інший також перетворюється на рядок.
 
 Однак зверніть увагу, що операції виконуються зліва направо. Якщо є два числа, за якими йде рядок, числа будуть додані перед перетворенням на рядок:
 
@@ -59,7 +59,7 @@ alert( 2 + '1' ); // "21"
 alert(2 + 2 + '1' ); // "41" а не "221"
 ```
 
-Об'єднання рядків і перетворення є особливою ознакою бінарного плюса `+`. Інші арифметичні оператори працюють тільки з числами і завжди перетворюють свої операнди в числа.
+Об'єднання рядків і перетворення є особливою ознакою бінарного плюса `+`. Інші арифметичні оператори працюють тільки з числами і завжди перетворюють свої операнди на числа.
 
 Наприклад, віднімання і ділення:
 
@@ -72,7 +72,7 @@ alert( '6' / '2' ); // 3
 
 Плюс `+` існує у двох формах: бінарна форма, яку ми використовували вище та унарна форма.
 
-Унарний плюс або, іншими словами, оператор плюс `+`, застосований до єдиного операнда, нічого не зробить, якщо операнд є числом. Але якщо операнд не є числом, унарний плюс перетворить його в число.
+Унарний плюс або, іншими словами, оператор плюс `+`, застосований до єдиного операнда, нічого не зробить, якщо операнд є числом. Але якщо операнд не є числом, унарний плюс перетворить його на число.
 
 Наприклад:
 
@@ -123,17 +123,17 @@ alert( +apples + +oranges ); // 5
 
 З точки зору математика, надмір плюсів може здатися дивним. Але з точки зору програміста, немає нічого особливого: спочатку застосовується унарні плюси, вони перетворюють рядки на числа, а потім бінарний плюс підсумовує їх.
 
-Чому унарні плюси застосовуються до значень перед бінарними плюсами? Як ми побичмо далі, це пов'язано з їх *більш високим пріоритетом*.
+Чому унарні плюси застосовуються до значень перед бінарними плюсами? Як ми побачимо далі, це пов'язано з їх *більш високим пріоритетом*.
 
 ## Пріоритет оператора
 
 Ящо вираз має більше одного оператора, порядок виконання визначається їх *пріоритетом*, або, іншими словами, неявним порядком пріоритетів операторів.
 
-Зі школи ми всі знаємо, що множення у виразі `1 + 2 * 2` повинно бути вираховано перед додаванням. Саме це і є пріоритетом. Кажуть, що множення має *більш високий пріоритет*, ніж додавання.
+Зі школи ми всі знаємо, що множення у виразі `1 + 2 * 2` повинно бути обчислене перед додаванням. Саме це і є пріоритетом. Кажуть, що множення має *більш високий пріоритет*, ніж додавання.
 
 Дужки перевизначають будь-який пріоритет, тому, якщо ми не задоволенні неявним приорітетом, ми можемо використовувати дужки, щоб змінити його. Наприклад: `(1 + 2) * 2`.
 
-У JavaScript є багато операторів. Кожен оператор має відповідний номер пріоритету. Першим виконується той оператор, який має найбільший номер. Якщо пріоритет є одниковим, порядок виконання — зліва направо.
+У JavaScript є багато операторів. Кожен оператор має відповідний номер пріоритету. Першим виконується той оператор, який має найбільший номер. Якщо пріоритет є однаковим, порядок виконання — зліва направо.
 
 Ось витяг із [таблиці пріоритетів](https://developer.mozilla.org/en/JavaScript/Reference/operators/operator_precedence) (вам не потрібно запам'ятовувати це, але зверніть увагу, що унарні оператори вище за відповідні бінарні):
 
@@ -147,7 +147,7 @@ alert( +apples + +oranges ); // 5
 | 13 | додавання | `+` |
 | 13 | віднімання | `-` |
 | ... | ... | ... |
-| 3 | призначення | `=` |
+| 3 | присвоювання | `=` |
 | ... | ... | ... |
 
 Як ми бачемо, "унарний плюс" має пріоритет `16`, який вище за `13` — пріоритет "додавання" (бінарний плюс). Саме тому, у виразі `"+apples + +oranges"`, унарні плюси виконуються до додавання (бінарного плюса).
@@ -164,7 +164,7 @@ let x = 2 * 2 + 1;
 alert( x ); // 5
 ```
 
-Можливе лангюгове присвоювання:
+Можливе ланцюгове присвоювання:
 
 ```js run
 let a, b, c;
@@ -178,7 +178,7 @@ alert( b ); // 4
 alert( c ); // 4
 ```
 
-Лангюгове присвоювання виконується справа наліво. Спочатку обчислюється самий правий вираз `2 + 2`, а потім присвоюється зінним ліворуч   : `c`, `b` and `a`. Наприкінці всі змінні мають спільне значення.
+Ланцюгове присвоювання виконується справа наліво. Спочатку обчислюється самий правий вираз `2 + 2`, а потім присвоюється зінним ліворуч   : `c`, `b` and `a`. Наприкінці всі змінні мають спільне значення.
 
 ````smart header="Оператор присвоювання `\"=\"` повертає значення"
 Оператор завжди повертає значення. Це очевидно для більшості з них, як додавання `+` або множення `*`. Але оператор присвоювання також додтримується цього правила.
@@ -199,7 +199,7 @@ alert( a ); // 3
 alert( c ); // 0
 ```
 
-У наведенному вище прикладі результат `(a = b + 1)` є значенням, яке присвоюється змінній `a` (тобто `3`). Потім вона використовується для віднімання від `3`.
+У наведенному вище прикладі результат `(a = b + 1)` є значенням, яке присвоюється змінній `a` (тобто `3`). Потім воне використовується для віднімання від `3`.
 
 Смішний код, чи не так? Ми повинні зрозуміти, як це працює, бо іноді ми бачимо подібне у бібліотеках третьої сторони, але самі не повинні писати нічого подібного. Такі трюки, безумовно, не роблять код більш ясним або читабельним.
 ````
@@ -208,14 +208,14 @@ alert( c ); // 0
 
 Оператор залишку `%`, незважаючи на свій зовнішній вигляд, не пов'язаний з відсотками.
 
-Результатом `a % b` є залишок цілочисельного ділення `a` на `b`.
+Результатом `a % b` є залишком цілочисельного ділення `a` на `b`.
 
 Наприклад:
 
 ```js run
-alert( 5 % 2 ); // 1 — залишок від 5 розділеного на 2
-alert( 8 % 3 ); // 2 — залишок від 8 розділеного на 3
-alert( 6 % 3 ); // 0 — залишок від 6 розділеного на 3
+alert( 5 % 2 ); // 1 — залишок від 5 поділеного на 2
+alert( 8 % 3 ); // 2 — залишок від 8 поділеного на 3
+alert( 6 % 3 ); // 0 — залишок від 6 поділеного на 3
 ```
 
 ## Піднесення до степеня **
@@ -277,7 +277,7 @@ alert( 8 ** (1/3) ); // 2 (степінь 1/3 — це теж саме, що і
 
 Чи є різниця? Так, але ми можемо побачити її якщо будемо використовувати повернене значення `++/--`.
 
-Давайте розберемось. Як відомо, усі оператори повертають значення. Інкремент/декремент не є винятком. Префіксна форма повертає нове значення, тоді як постфіксна форма повертає повертає старе значення (до збільшення/зменшення).
+Давайте розберемось. Як відомо, усі оператори повертають значення. Інкремент/декремент не є винятком. Префіксна форма повертає нове значення, тоді як постфіксна форма повертає старе значення (до збільшення/зменшення).
 
 Щоб побачитит різницю, наведемо приклад:
 
@@ -325,7 +325,7 @@ alert(a); // *!*1*/!*
     ```
 
 ````smart header="Інкремент/декремент серед інших операторів"
-Оператори `++/--` також можуть використовуватись всередені виразів. Їх пріоритет віще за більшість інщих арифметичних операцій.
+Оператори `++/--` також можуть використовуватись всередені виразів. Їх пріоритет вище за більшість інщих арифметичних операцій.
 
 Наприклад:
 
@@ -384,7 +384,7 @@ n = n + 5;
 n = n * 2;
 ```
 
-Це запис скоротити за допомогою операторів `+=` та `*=`:
+Цей запис може бути скорочений за допомогою операторів `+=` та `*=`:
 
 ```js run
 let n = 2;
@@ -396,7 +396,7 @@ alert( n ); // 14
 
 Короткий "модифікуй-та-присвоюй" оператор існує для всіх арифметичних та побітових операторів: `/=`, `-=`, тощо.
 
-Такі оператори мають такуж перевагу, як і звичайне присвоювання, тому вони виконуються після більшості інших обчисленнь:
+Такі оператори мають таку ж перевагу, як і звичайне присвоювання, тому вони виконуються після більшості інших обчисленнь:
 
 ```js run
 let n = 2;
@@ -408,7 +408,7 @@ alert( n ); // 16  (права частина обчислюється перш
 
 ## Кома
 
-Оператор кома `,` є одним за найрідкіших та незвичайних операторів. Іноді використовується для написання бальш короткого коду, тому нам потрібно знати його, щоб зрозуміти, що відбувається.
+Оператор кома `,` є одним з найрідкіших та незвичайних операторів. Іноді використовується для написання більш короткого коду, тому нам потрібно знати його, щоб зрозуміти, що відбувається.
 
 Оператор кома дозволяє обчислити кілька виразів, розділивши їх комою `,`. Кожен з них обчислюється, але повертається тільки результат останнього.
 
@@ -437,7 +437,7 @@ alert( a ); // 7 (результат обчислення 3 + 4)
 Наприклад:
 
 ```js
-// три операціх в одному рядку
+// три операції в одному рядку
 for (*!*a = 1, b = 3, c = a * b*/!*; a < 10; a++) {
  ...
 }

From b8c37c3c3e7eb873db0c63951ef5972a687b30e2 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Sat, 25 May 2019 00:18:21 +0300
Subject: [PATCH 07/10] correction

---
 1-js/02-first-steps/07-operators/2-assignment-result/task.md | 2 +-
 1-js/02-first-steps/07-operators/article.md                  | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/1-js/02-first-steps/07-operators/2-assignment-result/task.md b/1-js/02-first-steps/07-operators/2-assignment-result/task.md
index bcae7416d..58b05e471 100644
--- a/1-js/02-first-steps/07-operators/2-assignment-result/task.md
+++ b/1-js/02-first-steps/07-operators/2-assignment-result/task.md
@@ -2,7 +2,7 @@ importance: 3
 
 ---
 
-# Рузльтат присвоювання
+# Результат присвоювання
 
 Які значення мають `a` та `x` після виконання коду нижче?
 
diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index 2df30d12f..9a395b608 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -4,12 +4,12 @@
 
 У цьому розділі ми зупинимося на аспектах операторів, які не охоплені шкільною арифметикою.
 
-## Тарміни: "унарний", "бінарний", "операнд"
+## Терміни: "унарний", "бінарний", "операнд"
 
 Перш ніж ми почнемо, давайте розберемо певну загальну термінологію.
 
 - *Операнд* -- це те, до чого затосовуються оператори. Наприклад, у множенні `5 * 2` є два операнди: лівий операнд `5` і правий операнд `2`. Іноді люди називають їх "аргументами", а не "операндами".
-- Опреатор є *унарним*, якщо він має один операнд. Наприклад, унарне заперечення `-` змінює знак числа:
+- Оператор є *унарним*, якщо він має один операнд. Наприклад, унарне заперечення `-` змінює знак числа:
 
     ```js run
     let x = 1;

From a5236a0e6120e80a0804f35c86b1308f03372e44 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Sat, 25 May 2019 00:25:57 +0300
Subject: [PATCH 08/10] correction

---
 1-js/02-first-steps/07-operators/article.md | 22 ++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index 9a395b608..061dec069 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -147,16 +147,16 @@ alert( +apples + +oranges ); // 5
 | 13 | додавання | `+` |
 | 13 | віднімання | `-` |
 | ... | ... | ... |
-| 3 | присвоювання | `=` |
+| 3 | присвоєння | `=` |
 | ... | ... | ... |
 
 Як ми бачемо, "унарний плюс" має пріоритет `16`, який вище за `13` — пріоритет "додавання" (бінарний плюс). Саме тому, у виразі `"+apples + +oranges"`, унарні плюси виконуються до додавання (бінарного плюса).
 
-## Присвоювання
+## Присвоєння
 
-Зазначемо, що присвоювання `=` також є оператором. Воно є в таблиці з пріоритетами і має дуже низький пріоритет `3`.
+Зазначемо, що присвоєння `=` також є оператором. Воно є в таблиці з пріоритетами і має дуже низький пріоритет `3`.
 
-Тому, коли ми присвоюємо значення змінній, наприклад, `x = 2 * 2 + 1`, спочатку виконуються обчислення, а потім виконується присвоювання `=`, зберігаючи результат у `x`.
+Тому, коли ми присвоюємо значення змінній, наприклад, `x = 2 * 2 + 1`, спочатку виконуються обчислення, а потім виконується присвоєння `=`, зберігаючи результат у `x`.
 
 ```js
 let x = 2 * 2 + 1;
@@ -164,7 +164,7 @@ let x = 2 * 2 + 1;
 alert( x ); // 5
 ```
 
-Можливе ланцюгове присвоювання:
+Можливе ланцюгове присвоєння:
 
 ```js run
 let a, b, c;
@@ -178,14 +178,14 @@ alert( b ); // 4
 alert( c ); // 4
 ```
 
-Ланцюгове присвоювання виконується справа наліво. Спочатку обчислюється самий правий вираз `2 + 2`, а потім присвоюється зінним ліворуч   : `c`, `b` and `a`. Наприкінці всі змінні мають спільне значення.
+Ланцюгове присвоєння виконується справа наліво. Спочатку обчислюється самий правий вираз `2 + 2`, а потім присвоюється зінним ліворуч   : `c`, `b` and `a`. Наприкінці всі змінні мають спільне значення.
 
-````smart header="Оператор присвоювання `\"=\"` повертає значення"
-Оператор завжди повертає значення. Це очевидно для більшості з них, як додавання `+` або множення `*`. Але оператор присвоювання також додтримується цього правила.
+````smart header="Оператор присвоєння `\"=\"` повертає значення"
+Оператор завжди повертає значення. Це очевидно для більшості з них, як додавання `+` або множення `*`. Але оператор присвоєння також додтримується цього правила.
 
 Виклик `x = значення` записує `значення` у `x`, *а потім повертає його*.
 
-Ось демонстрація, яка використовує присвоювання як частину більш складного виразу:
+Ось демонстрація, яка використовує присвоєння як частину більш складного виразу:
 
 ```js run
 let a = 1;
@@ -396,7 +396,7 @@ alert( n ); // 14
 
 Короткий "модифікуй-та-присвоюй" оператор існує для всіх арифметичних та побітових операторів: `/=`, `-=`, тощо.
 
-Такі оператори мають таку ж перевагу, як і звичайне присвоювання, тому вони виконуються після більшості інших обчисленнь:
+Такі оператори мають таку ж перевагу, як і звичайне присвоєння, тому вони виконуються після більшості інших обчисленнь:
 
 ```js run
 let n = 2;
@@ -427,7 +427,7 @@ alert( a ); // 7 (результат обчислення 3 + 4)
 ```smart header="Кома має дуже низький пріоритет"
 Зверніть увагу, що оператор кома має дуже низький пріоритет, нижчий за `=`, тому дужки є важливими в наведеному вище прикладі.
 
-Без них: `a = 1 + 2, 3 + 4` обчислює спочатку `+`, підсумовуючи числа у `a = 3, 7`, потім оператор присвоювання `=` присвоює    `a = 3`, і нарешті число після коми, `7`, не обробляється, тому його ігнорують.
+Без них: `a = 1 + 2, 3 + 4` обчислює спочатку `+`, підсумовуючи числа у `a = 3, 7`, потім оператор присвоєння `=` присвоює    `a = 3`, і нарешті число після коми, `7`, не обробляється, тому його ігнорують.
 ```
 
 Чому нам потрібен оператор, що викидає все, окрім останньої частини?

From 0c9ef76e8114034ab694a667535210364b451ab6 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Sat, 25 May 2019 00:27:07 +0300
Subject: [PATCH 09/10] correction

---
 1-js/02-first-steps/07-operators/2-assignment-result/task.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1-js/02-first-steps/07-operators/2-assignment-result/task.md b/1-js/02-first-steps/07-operators/2-assignment-result/task.md
index 58b05e471..f20afdd8a 100644
--- a/1-js/02-first-steps/07-operators/2-assignment-result/task.md
+++ b/1-js/02-first-steps/07-operators/2-assignment-result/task.md
@@ -2,7 +2,7 @@ importance: 3
 
 ---
 
-# Результат присвоювання
+# Результат присвоєння
 
 Які значення мають `a` та `x` після виконання коду нижче?
 

From c314d4346ef6921dc700a919b62fc3713951a9b0 Mon Sep 17 00:00:00 2001
From: Taras <oster.ok@gmail.com>
Date: Sat, 25 May 2019 15:30:32 +0300
Subject: [PATCH 10/10] small language corrections

---
 1-js/02-first-steps/07-operators/article.md | 52 ++++++++++-----------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md
index 061dec069..ffc45bf5a 100644
--- a/1-js/02-first-steps/07-operators/article.md
+++ b/1-js/02-first-steps/07-operators/article.md
@@ -1,6 +1,6 @@
 # Оператори
 
-Ми знаємо багато операторів зі школи. Це такі речі, як додавання `+`, множення `*`, віднімання `-`, тощо.
+Зі шкільної програми, ми знаємо багато арифметичний операцій, такі як додавання `+`, множення `*`, віднімання `-`, тощо.
 
 У цьому розділі ми зупинимося на аспектах операторів, які не охоплені шкільною арифметикою.
 
@@ -26,7 +26,7 @@
     alert( y - x ); // 2, бінарний мінус віднімає значення
     ```
 
-    Формально, ми говоримо про два різні оператори: унарне заперечення (єдиний операнд: змінює знак) та бінарне віднімання (два опернди: віднімає).
+    Формально, ми говоримо про два різні оператори: унарне заперечення (єдиний операнд: змінює знак) та бінарне віднімання (два операнди: віднімає).
 
 ## Об'єднання рядків, бінарний +
 
@@ -50,13 +50,13 @@ alert( '1' + 2 ); // "12"
 alert( 2 + '1' ); // "21"
 ```
 
-Бачите, не має значення, чи перший операнд є рядком або другий. Правило просте: якщо будь-який операнд є радком, інший також перетворюється на рядок.
+Бачите, не має значення, чи перший операнд є рядком чи другий. Правило просте: якщо будь-який операнд є рядком, інший також перетворюється на рядок.
 
 Однак зверніть увагу, що операції виконуються зліва направо. Якщо є два числа, за якими йде рядок, числа будуть додані перед перетворенням на рядок:
 
 
 ```js run
-alert(2 + 2 + '1' ); // "41" а не "221"
+alert(2 + 2 + '1' ); // "41", а не "221"
 ```
 
 Об'єднання рядків і перетворення є особливою ознакою бінарного плюса `+`. Інші арифметичні оператори працюють тільки з числами і завжди перетворюють свої операнди на числа.
@@ -121,23 +121,23 @@ alert( +apples + +oranges ); // 5
 // alert( Number(apples) + Number(oranges) ); // 5
 ```
 
-З точки зору математика, надмір плюсів може здатися дивним. Але з точки зору програміста, немає нічого особливого: спочатку застосовується унарні плюси, вони перетворюють рядки на числа, а потім бінарний плюс підсумовує їх.
+З точки зору математики, надмірні плюси можуть здатися дивними. Але з точки зору програміста, немає нічого особливого: спочатку застосовується унарні плюси, вони перетворюють рядки на числа, а потім бінарний плюс підсумовує їх.
 
 Чому унарні плюси застосовуються до значень перед бінарними плюсами? Як ми побачимо далі, це пов'язано з їх *більш високим пріоритетом*.
 
 ## Пріоритет оператора
 
-Ящо вираз має більше одного оператора, порядок виконання визначається їх *пріоритетом*, або, іншими словами, неявним порядком пріоритетів операторів.
+Якщо вираз має більше одного оператора, порядок виконання визначається їх *пріоритетом*, або, іншими словами, неявним порядком пріоритетів операторів.
 
-Зі школи ми всі знаємо, що множення у виразі `1 + 2 * 2` повинно бути обчислене перед додаванням. Саме це і є пріоритетом. Кажуть, що множення має *більш високий пріоритет*, ніж додавання.
+Зі школи ми всі знаємо, що множення у виразі `1 + 2 * 2` повинно бути обчислене перед додаванням. Саме це і є пріоритетом. Кажуть, що множення має *вищий пріоритет*, ніж додавання.
 
 Дужки перевизначають будь-який пріоритет, тому, якщо ми не задоволенні неявним приорітетом, ми можемо використовувати дужки, щоб змінити його. Наприклад: `(1 + 2) * 2`.
 
-У JavaScript є багато операторів. Кожен оператор має відповідний номер пріоритету. Першим виконується той оператор, який має найбільший номер. Якщо пріоритет є однаковим, порядок виконання — зліва направо.
+У JavaScript є багато операторів. Кожен оператор має відповідний номер пріоритету. Першим виконується той оператор, який має найбільший номер пріоритету. Якщо пріоритет є однаковим, порядок виконання — зліва направо.
 
-Ось витяг із [таблиці пріоритетів](https://developer.mozilla.org/en/JavaScript/Reference/operators/operator_precedence) (вам не потрібно запам'ятовувати це, але зверніть увагу, що унарні оператори вище за відповідні бінарні):
+Ось витяг із [таблиці пріоритетів](https://developer.mozilla.org/en/JavaScript/Reference/operators/operator_precedence) (вам не потрібно це запам'ятовувати, але зверніть увагу, що унарні оператори мають вищий пріоритет за відповідні бінарні):
 
-| Приорітет | Ім'я | Знак |
+| Пріоритет | Ім'я | Знак |
 |------------|------|------|
 | ... | ... | ... |
 | 16 | унарний плюс | `+` |
@@ -150,7 +150,7 @@ alert( +apples + +oranges ); // 5
 | 3 | присвоєння | `=` |
 | ... | ... | ... |
 
-Як ми бачемо, "унарний плюс" має пріоритет `16`, який вище за `13` — пріоритет "додавання" (бінарний плюс). Саме тому, у виразі `"+apples + +oranges"`, унарні плюси виконуються до додавання (бінарного плюса).
+Як ми бачемо, "унарний плюс" має пріоритет `16`, що вище за `13` — пріоритет "додавання" (бінарний плюс). Саме тому, у виразі `"+apples + +oranges"`, унарні плюси виконуються до додавання (бінарного плюса).
 
 ## Присвоєння
 
@@ -178,7 +178,7 @@ alert( b ); // 4
 alert( c ); // 4
 ```
 
-Ланцюгове присвоєння виконується справа наліво. Спочатку обчислюється самий правий вираз `2 + 2`, а потім присвоюється зінним ліворуч   : `c`, `b` and `a`. Наприкінці всі змінні мають спільне значення.
+Ланцюгове присвоєння виконується справа наліво. Спочатку обчислюється самий правий вираз `2 + 2`, а потім присвоюється змінним ліворуч: `c`, `b` та `a`. В результаті всі змінні мають спільне значення.
 
 ````smart header="Оператор присвоєння `\"=\"` повертає значення"
 Оператор завжди повертає значення. Це очевидно для більшості з них, як додавання `+` або множення `*`. Але оператор присвоєння також додтримується цього правила.
@@ -199,9 +199,9 @@ alert( a ); // 3
 alert( c ); // 0
 ```
 
-У наведенному вище прикладі результат `(a = b + 1)` є значенням, яке присвоюється змінній `a` (тобто `3`). Потім воне використовується для віднімання від `3`.
+У наведенному вище прикладі результат `(a = b + 1)` є значенням, яке присвоюється змінній `a` (тобто `3`). Потім воно використовується для віднімання від `3`.
 
-Смішний код, чи не так? Ми повинні зрозуміти, як це працює, бо іноді ми бачимо подібне у бібліотеках третьої сторони, але самі не повинні писати нічого подібного. Такі трюки, безумовно, не роблять код більш ясним або читабельним.
+Смішний код, чи не так? Ми повинні зрозуміти, як це працює, бо іноді ми бачимо подібне у сторонніх бібліотеках, але самі не повинні писати нічого подібного. Такі трюки, безумовно, не роблять код більш ясним або читабельним.
 ````
 
 ## Залишок %
@@ -256,7 +256,7 @@ alert( 8 ** (1/3) ); // 2 (степінь 1/3 — це теж саме, що і
     counter++;      // працює так само, як counter = counter + 1, але коротше
     alert( counter ); // 3
     ```
-- **Декремент** `--` зменьшує змінну на 1:
+- **Декремент** `--` зменшує змінну на 1:
 
     ```js run no-beautify
     let counter = 2;
@@ -265,7 +265,7 @@ alert( 8 ** (1/3) ); // 2 (степінь 1/3 — це теж саме, що і
     ```
 
 ```warn
-Інкремент/декремент можуть застосовуватись лише до змінних. Спроба використовувати їх на значенні як `5++` дасть помилку.
+Інкремент/декремент можуть застосовуватись лише до змінних. Спроба використати їх на значенні як `5++` дасть помилку.
 ```
 
 Оператори `++` та `--` можуть розташовуватись до або після змінної.
@@ -279,7 +279,7 @@ alert( 8 ** (1/3) ); // 2 (степінь 1/3 — це теж саме, що і
 
 Давайте розберемось. Як відомо, усі оператори повертають значення. Інкремент/декремент не є винятком. Префіксна форма повертає нове значення, тоді як постфіксна форма повертає старе значення (до збільшення/зменшення).
 
-Щоб побачитит різницю, наведемо приклад:
+Щоб побачити різницю, наведемо приклад:
 
 ```js run
 let counter = 1;
@@ -325,7 +325,7 @@ alert(a); // *!*1*/!*
     ```
 
 ````smart header="Інкремент/декремент серед інших операторів"
-Оператори `++/--` також можуть використовуватись всередені виразів. Їх пріоритет вище за більшість інщих арифметичних операцій.
+Оператори `++/--` також можуть використовуватись всередені виразів. Їх пріоритет вищий за більшість інщих арифметичних операцій.
 
 Наприклад:
 
@@ -338,10 +338,10 @@ alert( 2 * ++counter ); // 4
 
 ```js run
 let counter = 1;
-alert( 2 * counter++ ); // 2, тому що counter++ повертається "старе" значення
+alert( 2 * counter++ ); // 2, тому що counter++ повертає "старе" значення
 ```
 
-Не дивлячісь на те, що з технічної точки зору це допустимо, таке використання робить код меньш читабельним. Один рядок робить кілька речей -- не є добре.
+Не дивлячись на те, що з технічної точки зору це допустимо, таке використання робить код менш читабельним. Коли один рядок робить кілька речей -- це не добре.
 
 При читанні коду швидке "вертикальне" сканування оком може легко пропустити щось подібне до `counter++` і не буде очевидним, що змінна була збільшена.
 
@@ -370,11 +370,11 @@ counter++;
 - RIGHT SHIFT ( `>>` )
 - ZERO-FILL RIGHT SHIFT ( `>>>` )
 
-Ці оператори використовуються дуже рідко. Цоб їх зрозуміти, нам потрібно заглибитись у представлення числа на низькому рівні і зараз не самий оптимальний час для цього, тим більше, що нам вони не будуть потрібні найближчим часом. Якщо вам цікаво, ви можете прочитати статтю [Bitwise Operators](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators) на MDN. Це було би більш практично зробити, коли виникне реальна потреба.
+Ці оператори використовуються дуже рідко. Щоб їх зрозуміти, нам потрібно заглибитись у представлення числа на низькому рівні і зараз не самий оптимальний час для цього, тим більше, що нам вони не будуть потрібні найближчим часом. Якщо вам цікаво, ви можете прочитати статтю [Bitwise Operators](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators) на MDN. Це було би більш практично зробити, коли виникне реальна потреба.
 
-## Змінити-на-місці
+## Оператор "модифікувати та присвоїти"
 
-Часто нам потрібно застосувати оператор до змінної та зберегти новий результат у ту ж саму змінну.
+Часто нам потрібно застосувати оператор до змінної і зберегти новий результат у ту ж саму змінну.
 
 Наприклад:
 
@@ -389,12 +389,12 @@ n = n * 2;
 ```js run
 let n = 2;
 n += 5; // тепер n = 7 (теж саме, що і n = n + 5)
-n *= 2; // now n = 14 (теж саме, що і n = n * 2)
+n *= 2; // тепер n = 14 (теж саме, що і n = n * 2)
 
 alert( n ); // 14
 ```
 
-Короткий "модифікуй-та-присвоюй" оператор існує для всіх арифметичних та побітових операторів: `/=`, `-=`, тощо.
+Короткий оператор "модифікувати та присвоїти" існує для всіх арифметичних та побітових операторів: `/=`, `-=`, тощо.
 
 Такі оператори мають таку ж перевагу, як і звичайне присвоєння, тому вони виконуються після більшості інших обчисленнь:
 
@@ -427,7 +427,7 @@ alert( a ); // 7 (результат обчислення 3 + 4)
 ```smart header="Кома має дуже низький пріоритет"
 Зверніть увагу, що оператор кома має дуже низький пріоритет, нижчий за `=`, тому дужки є важливими в наведеному вище прикладі.
 
-Без них: `a = 1 + 2, 3 + 4` обчислює спочатку `+`, підсумовуючи числа у `a = 3, 7`, потім оператор присвоєння `=` присвоює    `a = 3`, і нарешті число після коми, `7`, не обробляється, тому його ігнорують.
+Без них: `a = 1 + 2, 3 + 4` обчислює спочатку `+`, підсумовуючи числа у `a = 3, 7`, потім оператор присвоєння `=` присвоює    `a = 3`, і нарешті число після коми, `7`, не обробляється та ігнорується.
 ```
 
 Чому нам потрібен оператор, що викидає все, окрім останньої частини?