From ddffb126767c198240e5014643e1ff60a08be846 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Mon, 1 Jul 2019 21:04:50 +0300
Subject: [PATCH 1/8] saving progress

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

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 0773a10cb..982f41a9e 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,20 +1,20 @@
-# Logical operators
+# Логічні оператори
 
-There are three logical operators in JavaScript: `||` (OR), `&&` (AND), `!` (NOT).
+У JavaScript існує три логічних опратори: `||` (OR), `&&` (AND), `!` (NOT).
 
-Although they are called "logical", they can be applied to values of any type, not only boolean. Their result can also be of any type.
+Хоча вони називаються "логічними", вони можуть бути застосовані до значень будь-якого типу, те тільки булевих. Їх результати також може бути будь-якого типу.
 
-Let's see the details.
+Подивимось більш детально.
 
 ## || (OR)
 
-The "OR" operator is represented with two vertical line symbols:
+Оператор "OR" представлений двома символами вертикальної лінії:
 
 ```js
 result = a || b;
 ```
 
-In classical programming, the logical OR is meant to manipulate boolean values only. If any of its arguments are `true`, it returns `true`, otherwise it returns `false`.
+У класичному програмуванні логічний OR призначений для маніпулювання лише булевими значеннями. Якщо будь-який з його аргументів `true`, він повертає `true`, інакше повертає `false`.
 
 In JavaScript, the operator is a little bit trickier and more powerful. But first, let's see what happens with boolean values.
 

From 81b1fd9d5de2d8ca6342d82f2b7515c2a9556ea0 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Wed, 3 Jul 2019 20:55:09 +0300
Subject: [PATCH 2/8] saveing progress

---
 .../11-logical-operators/article.md           | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 982f41a9e..8f168f2c0 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -16,9 +16,9 @@ result = a || b;
 
 У класичному програмуванні логічний OR призначений для маніпулювання лише булевими значеннями. Якщо будь-який з його аргументів `true`, він повертає `true`, інакше повертає `false`.
 
-In JavaScript, the operator is a little bit trickier and more powerful. But first, let's see what happens with boolean values.
+У JavaScript оператор більш складніший і потужніший. Але спочатку подивимося, що відбувається з булевими значеннями.
 
-There are four possible logical combinations:
+Є чотири можливі логічні комбінації:
 
 ```js run
 alert( true || true );   // true
@@ -27,21 +27,21 @@ alert( true || false );  // true
 alert( false || false ); // false
 ```
 
-As we can see, the result is always `true` except for the case when both operands are `false`.
+Як бачимо, результат завжди `true`, за винятком випадку, коли обидва операнда `false`.
 
-If an operand is not a boolean, it's converted to a boolean for the evaluation.
+Якщо операнд не є булевим, він перетворюється на логічний для обчислення.
 
-For instance, the number `1` is treated as `true`, the number `0` as `false`:
+Наприклад, число `1` розглядається як `true`, число `0` — як `false`:
 
 ```js run
-if (1 || 0) { // works just like if( true || false )
-  alert( 'truthy!' );
+if (1 || 0) { // працює так само, як ( true || false )
+  alert( 'правдиво!' );
 }
 ```
 
-Most of the time, OR `||` is used in an `if` statement to test if *any* of the given conditions is `true`.
+У бильшості випадків OR `||` використовується в операторі `if`, щоб перевірити, чи є *будь-яка* з заданих умов `true`.
 
-For example:
+Наприклад:
 
 ```js run
 let hour = 9;
@@ -49,18 +49,18 @@ let hour = 9;
 *!*
 if (hour < 10 || hour > 18) {
 */!*
-  alert( 'The office is closed.' );
+  alert( 'Офіс зачинений.' );
 }
 ```
 
-We can pass more conditions:
+Ми можемо передавати більше умов:
 
 ```js run
 let hour = 12;
 let isWeekend = true;
 
 if (hour < 10 || hour > 18 || isWeekend) {
-  alert( 'The office is closed.' ); // it is the weekend
+  alert( 'Офіс зачинений.' ); // цу вихідні
 }
 ```
 

From d3fa8135a1f87bd7b2aad9a9e90685c5120ff348 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Sun, 7 Jul 2019 22:25:34 +0300
Subject: [PATCH 3/8] saving progress

---
 .../11-logical-operators/article.md           | 38 +++++++++----------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 8f168f2c0..a93fc8250 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -60,46 +60,46 @@ let hour = 12;
 let isWeekend = true;
 
 if (hour < 10 || hour > 18 || isWeekend) {
-  alert( 'Офіс зачинений.' ); // цу вихідні
+  alert( 'Офіс зачинений.' ); // це вихідні
 }
 ```
 
-## OR finds the first truthy value
+## OR знаходить перше правдиве значенн
 
-The logic described above is somewhat classical. Now, let's bring in the "extra" features of JavaScript.
+Описана вище логіка дещо класична. Тепер давайте введемо "додаткові" особливості JavaScript.
 
-The extended algorithm works as follows.
+Розширений алгоритм працює наступним чином.
 
-Given multiple OR'ed values:
+Дано кілька значень, розділених опертором OR:
 
 ```js
 result = value1 || value2 || value3;
 ```
 
-The OR `||` operator does the following:
+Оператор OR `||` робить наступне:
 
-- Evaluates operands from left to right.
-- For each operand, converts it to boolean. If the result is `true`, stops and returns the original value of that operand.
-- If all operands have been evaluated (i.e. all were `false`), returns the last operand.
+- Обчислює операнди зліва направо.
+- Перетворює значення кожного операнда на булеве. Якщо результат `true`, зупиняється і повертає початкове значення цього операнда.
+- Якщо всі операнди були обчисленні (тобто усі були `false`), повертає останній операнд.
 
-A value is returned in its original form, without the conversion.
+Значення повертається у первісному вигляді без конвертації.
 
-In other words, a chain of OR `"||"` returns the first truthy value or the last one if no truthy value is found.
+Іншими словами, ланцюжок с OR `"||"` повертає перше правдиве значення або останнє, якщо не знайдено правдивого значення.
 
-For instance:
+Наприклад:
 
 ```js run
-alert( 1 || 0 ); // 1 (1 is truthy)
-alert( true || 'no matter what' ); // (true is truthy)
+alert( 1 || 0 ); // 1 (1 є правдивим)
+alert( true || 'no matter what' ); // (true є правдивим)
 
-alert( null || 1 ); // 1 (1 is the first truthy value)
-alert( null || 0 || 1 ); // 1 (the first truthy value)
-alert( undefined || null || 0 ); // 0 (all falsy, returns the last value)
+alert( null || 1 ); // 1 (1 є першим правдивим значенням)
+alert( null || 0 || 1 ); // 1 (перше правдиве значення)
+alert( undefined || null || 0 ); // 0 (усі не правдиві, повертає останнє значення)
 ```
 
-This leads to some interesting usage compared to a "pure, classical, boolean-only OR".
+Це призводить до цікавого використання у порівнянни з "чистим, класичним, виключно-булевим OR".
 
-1. **Getting the first truthy value from a list of variables or expressions.**
+1. **Отримання першого правдивого значення зі списку змінних або виразів.**
 
     Imagine we have a list of variables which can either contain data or be `null/undefined`. How can we find the first one with data?
 

From bbfdd3d0e6a62b61908273efc29e3d30fd841c98 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Sat, 13 Jul 2019 22:48:37 +0300
Subject: [PATCH 4/8] saving progress

---
 .../11-logical-operators/article.md           | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index a93fc8250..9e463e5af 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -101,39 +101,39 @@ alert( undefined || null || 0 ); // 0 (усі не правдиві, повер
 
 1. **Отримання першого правдивого значення зі списку змінних або виразів.**
 
-    Imagine we have a list of variables which can either contain data or be `null/undefined`. How can we find the first one with data?
+    Уявіть, що у нас є список змінних, які можуть містити дані убо бути `null/undefined`. Як знайти першу змінну за даними?
 
-    We can use OR `||`:
+    Ми можемо використати OR `||`:
 
     ```js run
     let currentUser = null;
-    let defaultUser = "John";
+    let defaultUser = "Іван";
 
     *!*
     let name = currentUser || defaultUser || "unnamed";
     */!*
 
-    alert( name ); // selects "John" – the first truthy value
+    alert( name ); // обере "Іван" – перше правдиве значення
     ```
 
-    If both `currentUser` and `defaultUser` were falsy, `"unnamed"` would be the result.
-2. **Short-circuit evaluation.**
+    Якщо і `currentUser`, і `defaultUser` були б не правдивими, `"unnamed"` було б результатом.
+2. **Обчислення короткого змичання.**
 
-    Operands can be not only values, but arbitrary expressions. OR evaluates and tests them from left to right. The evaluation stops when a truthy value is reached, and the value is returned. This process is called "a short-circuit evaluation" because it goes as short as possible from left to right.
+    Операндами можуть бути не тільки значення, але й довільні вирази. OR обчислює Цей процес називається "обчисленням короткого замикання", оскільки він іде якомога коротше зліва направо.
 
-    This is clearly seen when the expression given as the second argument has a side effect like a variable assignment.
+    Це чітко видно, коли вираз, заданий як другий аргумент, має побічний ефект, як присвоєння змінної.
 
-    In the example below, `x` does not get assigned:
+    У наведеному нижче прикладі `x` не присвоюється значення:
 
     ```js run no-beautify
     let x;
 
     *!*true*/!* || (x = 1);
 
-    alert(x); // undefined, because (x = 1) not evaluated
+    alert(x); // undefined, оскільки (x = 1) не був обчислений
     ```
 
-    If, instead, the first argument is `false`, `||` evaluates the second one, thus running the assignment:
+    Якщо замість цього перший аргумент є `false`, `||` обчислює другий, таким чином виконуючи присвоєння:
 
     ```js run no-beautify
     let x;
@@ -143,7 +143,7 @@ alert( undefined || null || 0 ); // 0 (усі не правдиві, повер
     alert(x); // 1
     ```
 
-    An assignment is a simple case. There may be side effects, that won't show up if the evaluation doesn't reach them.
+    Присвоєння — це простий випадок. Можливі побічні ефекти, які не з'являтимуться, якщо обчислення не досяген їх.
 
     As we can see, such a use case is a "shorter way of doing `if`". The first operand is converted to boolean. If it's false, the second one is evaluated.
 

From 483de94aa032826b3d641c42a581d2cbbc069af5 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Sun, 14 Jul 2019 23:04:05 +0300
Subject: [PATCH 5/8] saving progress

---
 .../11-logical-operators/article.md           | 98 +++++++++----------
 1 file changed, 49 insertions(+), 49 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 9e463e5af..5651c86b1 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -145,19 +145,19 @@ alert( undefined || null || 0 ); // 0 (усі не правдиві, повер
 
     Присвоєння — це простий випадок. Можливі побічні ефекти, які не з'являтимуться, якщо обчислення не досяген їх.
 
-    As we can see, such a use case is a "shorter way of doing `if`". The first operand is converted to boolean. If it's false, the second one is evaluated.
+    Як ми бачимо, таке використання є "більш коротким способом виконання `if`". Перший операнд перетворюється на булевий. Якщо він false, то обчислюється другий.
 
-    Most of time, it's better to use a "regular" `if` to keep the code easy to understand, but sometimes this can be handy.
+    У більшості випадків краще використовувати "звичайний" `if`, щоб код буле легше зрозуміти, але іноді це може бути зручно.
 
 ## && (AND)
 
-The AND operator is represented with two ampersands `&&`:
+Оператор AND представлений двома амперсандами `&&`:
 
 ```js
 result = a && b;
 ```
 
-In classical programming, AND returns `true` if both operands are truthy and `false` otherwise:
+У класичному програмуванні AND повертає `true`, якщо обидва оператора є правдивими і `false` у іншому випадку:
 
 ```js run
 alert( true && true );   // true
@@ -166,138 +166,138 @@ alert( true && false );  // false
 alert( false && false ); // false
 ```
 
-An example with `if`:
+Приклад з `if`:
 
 ```js run
 let hour = 12;
 let minute = 30;
 
 if (hour == 12 && minute == 30) {
-  alert( 'The time is 12:30' );
+  alert( 'Час: 12:30' );
 }
 ```
 
-Just as with OR, any value is allowed as an operand of AND:
+Так само, як з OR, будь-яке значення дозволено як операнд AND:
 
 ```js run
-if (1 && 0) { // evaluated as true && false
-  alert( "won't work, because the result is falsy" );
+if (1 && 0) { // оцінюється як true && false
+  alert( "не буде працювати, тому що результат не правдивий" );
 }
 ```
 
 
-## AND finds the first falsy value
+## AND шукає перше не правдиве значення
 
-Given multiple AND'ed values:
+Дано декілька значень, об'єднаних AND:
 
 ```js
 result = value1 && value2 && value3;
 ```
 
-The AND `&&` operator does the following:
+Оператор AND `&&` робить наступне:
 
-- Evaluates operands from left to right.
-- For each operand, converts it to a boolean. If the result is `false`, stops and returns the original value of that operand.
-- If all operands have been evaluated (i.e. all were truthy), returns the last operand.
+- Обчислює операнди зліва направо.
+- Перетворює кожен операнд на булевий. Якщо результат `false`, зупиняється і повертає оригінальне значення того операнда.
+- Якщо всі операнди були обчисленні (тобто усі були правдиві), повертає останній операнд.
 
-In other words, AND returns the first falsy value or the last value if none were found.
+Іншими словами, AND повертає перше не правдиве значення, або останнє значення, якщо жодного не правдивого не було знайдено.
 
-The rules above are similar to OR. The difference is that AND returns the first *falsy* value while OR returns the first *truthy* one.
+Правила, наведені вище, подібні до OR. Різниця полягає в тому, що AND повертає перше *не правдиве* значення, тоді як OR повертає перше *правдиве*.
 
-Examples:
+Приклади:
 
 ```js run
-// if the first operand is truthy,
-// AND returns the second operand:
+// якщо перший операнд правдивий,
+// AND повертає другий операнд:
 alert( 1 && 0 ); // 0
 alert( 1 && 5 ); // 5
 
-// if the first operand is falsy,
-// AND returns it. The second operand is ignored
+// якщо перший операнд не правдивий,
+// AND повертає саме його. Другий операнд ігнорується
 alert( null && 5 ); // null
-alert( 0 && "no matter what" ); // 0
+alert( 0 && "не важливо" ); // 0
 ```
 
-We can also pass several values in a row. See how the first falsy one is returned:
+Ми також можемо передавати декілька значень поспіль. Подивіться, як повертається перший не правдивий:
 
 ```js run
 alert( 1 && 2 && null && 3 ); // null
 ```
 
-When all values are truthy, the last value is returned:
+Коли всі значення є правдивими, повертається останнє значення:
 
 ```js run
-alert( 1 && 2 && 3 ); // 3, the last one
+alert( 1 && 2 && 3 ); // 3, останнє
 ```
 
-````smart header="Precedence of AND `&&` is higher than OR `||`"
-The precedence of AND `&&` operator is higher than OR `||`.
+````smart header="Приорітет AND `&&` є більш високим за OR `||`"
+Приорітет оператора AND `&&` є більш високим за OR `||`.
 
-So the code `a && b || c && d` is essentially the same as if the `&&` expressions were in parentheses: `(a && b) || (c && d)`.
+Отже, код `a && b || c && d` по суті є таким самим, як би вираз `&&` був у дужках: `(a && b) || (c && d)`.
 ````
 
-Just like OR, the AND `&&` operator can sometimes replace `if`.
+Так само, як OR, оператор AND `&&` може іноді заміняти `if`.
 
-For instance:
+Наприклад:
 
 ```js run
 let x = 1;
 
-(x > 0) && alert( 'Greater than zero!' );
+(x > 0) && alert( 'Більше за нуль!' );
 ```
 
-The action in the right part of `&&` would execute only if the evaluation reaches it. That is, only if `(x > 0)` is true.
+Дія у правій частині `&&` буде виконуватися, тільки якщо обчислення дійде до неї. Тобто, тільки якщо `(x > 0)` є ічтинним.
 
-So we basically have an analogue for:
+Тому, власне, ми маємо аналог для:
 
 ```js run
 let x = 1;
 
 if (x > 0) {
-  alert( 'Greater than zero!' );
+  alert( 'Більше за нуль!' );
 }
 ```
 
-The variant with `&&` appears shorter. But `if` is more obvious and tends to be a little bit more readable.
+Варіант з `&&` є коротшим. Але `if` є більш очевидним і зазвичай є більш чтабельним.
 
-So we recommend using every construct for its purpose: use `if` if we want if and use `&&` if we want AND.
+Тому ми рекомендуємо використовувати кожну конструкцію за своїм призначенням: використовуємо `if` нам потрібен if і використовуємо `&&`, якщо нам потрібен AND.
 
 ## ! (NOT)
 
-The boolean NOT operator is represented with an exclamation sign `!`.
+Булевий оператор NOT представлений знаком оклику `!`.
 
-The syntax is pretty simple:
+Синтаксис дуже простий:
 
 ```js
 result = !value;
 ```
 
-The operator accepts a single argument and does the following:
+Оператор приймає один аргумент і виконує наступне:
 
-1. Converts the operand to boolean type: `true/false`.
-2. Returns the inverse value.
+1. Перетворює операнд на булевий тип: `true/false`.
+2. Повертає зворотне значення.
 
-For instance:
+Наприклад:
 
 ```js run
 alert( !true ); // false
 alert( !0 ); // true
 ```
 
-A double NOT `!!` is sometimes used for converting a value to boolean type:
+Подвійний NOT `!!` іноді використовується для перетворення значення у булевий тип:
 
 ```js run
-alert( !!"non-empty string" ); // true
+alert( !!"не пустий рядок" ); // true
 alert( !!null ); // false
 ```
 
-That is, the first NOT converts the value to boolean and returns the inverse, and the second NOT inverses it again. In the end, we have a plain value-to-boolean conversion.
+Тобто, перший NOT перетворює значення на булево і повертає зворотне, а другий NOT інвертує його знову. Зрештою, ми маємо просте перетворення значення на булевий тип.
 
-There's a little more verbose way to do the same thing -- a built-in `Boolean` function:
+Є трохи більш детальний спосіб зробити те ж саме -- вбудована функція `Boolean`:
 
 ```js run
-alert( Boolean("non-empty string") ); // true
+alert( Boolean("не пустий рядок") ); // true
 alert( Boolean(null) ); // false
 ```
 
-The precedence of NOT `!` is the highest of all logical operators, so it always executes first, before `&&` or `||`.
+Пріоритет NOT `!` є навищим з усіх логічних операторів, тому він завжди виконується першим, перед `&&` або `||`.

From 40f8158f919294293394ea70dd9cebb04381e71c Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Tue, 16 Jul 2019 10:14:18 +0300
Subject: [PATCH 6/8] finished translation

---
 .../1-alert-null-2-undefined/solution.md      |  2 +-
 .../1-alert-null-2-undefined/task.md          |  4 ++--
 .../2-alert-or/solution.md                    | 12 +++++-----
 .../11-logical-operators/2-alert-or/task.md   |  4 ++--
 .../3-alert-1-null-2/solution.md              |  2 +-
 .../3-alert-1-null-2/task.md                  |  4 ++--
 .../4-alert-and/solution.md                   |  6 ++---
 .../5-alert-and-or/solution.md                |  8 +++----
 .../5-alert-and-or/task.md                    |  4 ++--
 .../6-check-if-in-range/task.md               |  6 ++---
 .../7-check-if-out-range/solution.md          |  4 ++--
 .../7-check-if-out-range/task.md              |  6 ++---
 .../8-if-question/solution.md                 | 24 +++++++++----------
 .../8-if-question/task.md                     | 12 +++++-----
 .../9-check-login/solution.md                 | 16 ++++++-------
 .../9-check-login/task.md                     | 20 ++++++++--------
 16 files changed, 67 insertions(+), 67 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
index 8869d32e6..b4fb86f05 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
@@ -1,4 +1,4 @@
-The answer is `2`, that's the first truthy value.
+Відповідь `2`, це перше правдиве значення.
 
 ```js run
 alert( null || 2 || undefined );
diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
index a7c9addfc..adcb298af 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# What's the result of OR?
+# Який результат OR?
 
-What is the code below going to output?
+Що виведе код нижче?
 
 ```js
 alert( null || 2 || undefined );
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
index 8f4d664e8..b1b6d1e65 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
@@ -1,13 +1,13 @@
-The answer: first `1`, then `2`.
+Відповідь: спочатку `1`, потім `2`.
 
 ```js run
 alert( alert(1) || 2 || alert(3) );
 ```
 
-The call to `alert` does not return a value. Or, in other words, it returns `undefined`.
+Виклик `alert` не повертає значення. Або, іншими словами, повертає `undefined`.
 
-1. The first OR `||` evaluates it's left operand `alert(1)`. That shows the first message with `1`.
-2. The `alert` returns `undefined`, so OR goes on to the second operand searching for a truthy value.
-3. The second operand `2` is truthy, so the execution is halted, `2` is returned and then shown by the outer alert.
+1. Перший OR `||` обчислює його лівий операнд `alert(1)`. Це показує перше повідомлення з `1`.
+2. `alert` повертає `undefined`, тому OR переходить до другого операнда, шукаючи правдиве значення.
+3. Другий операнд `2` є правдивим, тому виконання зупинено, повернуто `2` і потім показано зовнішнім alert.
 
-There will be no `3`, because the evaluation does not reach `alert(3)`.
+Не буде `3`, тому що обчислення на досягає `alert(3)`.
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
index 3908fa2ec..df09e84ae 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# What's the result of OR'ed alerts?
+# Який результат alerts, об'еднаних OR?
 
-What will the code below output?
+Що виведе код нижче?
 
 ```js
 alert( alert(1) || 2 || alert(3) );
diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
index 5c2455ef4..5585844ae 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
@@ -1,4 +1,4 @@
-The answer: `null`, because it's the first falsy value from the list.
+Відповідь: `null`, тому що це перше не правдиве значення зі списку.
 
 ```js run
 alert( 1 && null && 2 );
diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
index 043d431e4..30dd81fc7 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# What is the result of AND?
+# Який результат AND?
 
-What is this code going to show?
+Що виведе код нижче?
 
 ```js
 alert( 1 && null && 2 );
diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
index b6fb10d72..4e42b67c2 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
@@ -1,10 +1,10 @@
-The answer: `1`, and then `undefined`.
+Відповідь: `1`, а потім `undefined`.
 
 ```js run
 alert( alert(1) && alert(2) );
 ```
 
-The call to `alert` returns `undefined` (it just shows a message, so there's no meaningful return).
+Виклик `alert` повертає `undefined` (він просто показує повідомлення, тому не повертається значення, яке б мало сенс).
 
-Because of that, `&&` evaluates the left operand (outputs `1`), and immediately stops, because `undefined` is a falsy value. And `&&` looks for a falsy value and returns it, so it's done.
+Через це `&&` обчислює лівий операнд (виводить `1`) і негайно зупиняється, оскільки `undefined` є не правдивим значенням. І `&&` шукає не правдиве значення і повертає його, як це і зроблено.
 
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
index 25e3568f8..490ad3cba 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
@@ -1,16 +1,16 @@
-The answer: `3`.
+Відповідь: `3`.
 
 ```js run
 alert( null || 2 && 3 || 4 );
 ```
 
-The precedence of AND `&&` is higher than `||`, so it executes first.
+Пріоритет AND `&&` вище за `||`, тому він виконується першим.
 
-The result of `2 && 3 = 3`, so the expression becomes:
+Результат `2 && 3 = 3`, тому вираз стає:
 
 ```
 null || 3 || 4
 ```
 
-Now the result is the first truthy value: `3`.
+Тепер результат — перше правдиве значення: `3`.
 
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
index b18bb9c51..ed002970b 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# The result of OR AND OR
+# Результат OR AND OR
 
-What will the result be?
+Який буде результат?
 
 ```js
 alert( null || 2 && 3 || 4 );
diff --git a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
index cc00ca9fc..fdc27bfc7 100644
--- a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
@@ -2,8 +2,8 @@ importance: 3
 
 ---
 
-# Check the range between
+# Перевірте діапазон
 
-Write an "if" condition to check that `age` is between `14` and `90` inclusively.
+Напишіть умову "if", щоб перевірити, що `age` iзнаходить між `14` та `90` включно.
 
-"Inclusively" means that `age` can reach the edges `14` or `90`.
+"Включно" означає, що `age` може досягати країв `14` або `90`.
diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
index d1946a967..25798e3ad 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
@@ -1,10 +1,10 @@
-The first variant:
+Перший варіант:
 
 ```js
 if (!(age >= 14 && age <= 90))
 ```
 
-The second variant:
+Другий варіант:
 
 ```js
 if (age < 14 || age > 90)
diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
index 7c22d6ad1..450d131bd 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
@@ -2,8 +2,8 @@ importance: 3
 
 ---
 
-# Check the range outside
+# Перевірте зовнішній діапазон
 
-Write an `if` condition to check that `age` is NOT between 14 and 90 inclusively.
+Напишіть умову `if`: щоб перевірити, що вік `age` НЕ знаходиться між 14 та 90 включно.
 
-Create two variants: the first one using NOT `!`, the second one -- without it.
+Створіть два варіанти: перший використовує NOT `!`, другий -- без нього.
diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
index 210509758..9fdfa7fe5 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
@@ -1,20 +1,20 @@
-The answer: the first and the third will execute.
+Відповідь: перший і третій виконаються.
 
-Details:
+Деталі:
 
 ```js run
-// Runs.
-// The result of -1 || 0 = -1, truthy
-if (-1 || 0) alert( 'first' );
+// Виконається.
+// Результат -1 || 0 = -1, правдивий
+if (-1 || 0) alert( 'перший' );
 
-// Doesn't run
-// -1 && 0 = 0, falsy
-if (-1 && 0) alert( 'second' );
+// Не виконається
+// -1 && 0 = 0, не правдивий
+if (-1 && 0) alert( 'другий' );
 
-// Executes
-// Operator && has a higher precedence than ||
-// so -1 && 1 executes first, giving us the chain:
+// Виконається
+// Оператор && має більший приорітет, ніж ||
+// тому -1 && 1 виконається першим, даючи нам послідовність:
 // null || -1 && 1  ->  null || 1  ->  1
-if (null || -1 && 1) alert( 'third' );
+if (null || -1 && 1) alert( 'третій' );
 ```
 
diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
index 55987121b..12a14e6ea 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
@@ -2,15 +2,15 @@ importance: 5
 
 ---
 
-# A question about "if"
+# Питання про "if"
 
-Which of these `alert`s are going to execute?
+Який з цих `alert` буде виконано?
 
-What will the results of the expressions be inside `if(...)`?
+Які рузельтати виразів будуть у `if(...)`?
 
 ```js
-if (-1 || 0) alert( 'first' );
-if (-1 && 0) alert( 'second' );
-if (null || -1 && 1) alert( 'third' );
+if (-1 || 0) alert( 'перший' );
+if (-1 && 0) alert( 'другий' );
+if (null || -1 && 1) alert( 'третій' );
 ```
 
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
index b535650ec..9111a01fc 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
@@ -1,25 +1,25 @@
 
 
 ```js run demo
-let userName = prompt("Who's there?", '');
+let userName = prompt("Хто там?", '');
 
 if (userName == 'Admin') {
 
-  let pass = prompt('Password?', '');
+  let pass = prompt('Пароль?', '');
 
   if (pass == 'TheMaster') {
-    alert( 'Welcome!' );
+    alert( 'Ласкаво просимо!' );
   } else if (pass == '' || pass == null) {
-    alert( 'Canceled.' );
+    alert( 'Скасовано.' );
   } else {
-    alert( 'Wrong password' );
+    alert( 'Неправильний пароль' );
   }
 
 } else if (userName == '' || userName == null) {
-  alert( 'Canceled' );
+  alert( 'Скасовано' );
 } else {
-  alert( "I don't know you" );
+  alert( "Я вас не знаю" );
 }
 ```
 
-Note the vertical indents inside the `if` blocks. They are technically not required, but make the code more readable.
+Зверніть увагу на вертикальні відступи у блоках `if`. Вони технічно не потрібні, але роблять код читабельним.
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
index 780e674a9..e63b2c3b4 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
@@ -2,24 +2,24 @@ importance: 3
 
 ---
 
-# Check the login
+# Перевірте логін
 
-Write the code which asks for a login with `prompt`.
+Напишіть код, який запитує логін за допомогою `prompt`.
 
-If the visitor enters `"Admin"`, then `prompt` for a password, if the input is an empty line or `key:Esc` -- show "Canceled.", if it's another string -- then show "I don't know you".
+Якщо відвідувач вводить `"Admin"`, тоді запропонуйте за допомогою `prompt` ввести пароль, iякщо вхідні данні є порожнім рядком або `key:Esc` -- показати "Скасовано.", якщо це інакший рядок -- тоді покажіть "Я вас не знаю".
 
-The password is checked as follows:
+Пароль перевіряється останнім чином:
 
-- If it equals "TheMaster", then show "Welcome!",
-- Another string -- show "Wrong password",
-- For an empty string or cancelled input, show "Canceled."
+- Якщо він дорівнює "TheMaster", тоді покажіть "Ласкаво просимо!",
+- Інший рядок -- покажіть "Неправильний пароль",
+- Для порожнього рядка або введення було скасовано, покажіть "Скасовано."
 
-The schema:
+Схема:
 
 ![](ifelse_task.png)
 
-Please use nested `if` blocks. Mind the overall readability of the code.
+Будь ласка, використовуйте вкладені `if` блоки. Майте на увазі загальну читабельність коду.
 
-Hint:  passing an empty input to a prompt returns an empty string `''`. Pressing `key:ESC` during a prompt returns `null`.
+Підказка:  передача порожнього вводу до запиту повертає порожній рядок `''`. Натискання `key:ESC` протягом запиту повертає `null`.
 
 [demo]

From 903f3efb6a5faa8db147e414f55b2de40defddc1 Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Tue, 16 Jul 2019 18:57:47 +0300
Subject: [PATCH 7/8] crrections

---
 .../11-logical-operators/article.md           | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 5651c86b1..43b115bc7 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -2,7 +2,7 @@
 
 У JavaScript існує три логічних опратори: `||` (OR), `&&` (AND), `!` (NOT).
 
-Хоча вони називаються "логічними", вони можуть бути застосовані до значень будь-якого типу, те тільки булевих. Їх результати також може бути будь-якого типу.
+Хоча вони називаються "логічними", вони можуть бути застосовані до значень будь-якого типу, не тільки булевих. Їх результати також можуть бути будь-якого типу.
 
 Подивимось більш детально.
 
@@ -29,7 +29,7 @@ alert( false || false ); // false
 
 Як бачимо, результат завжди `true`, за винятком випадку, коли обидва операнда `false`.
 
-Якщо операнд не є булевим, він перетворюється на логічний для обчислення.
+Якщо операнд не є булевим, він перетворюється на булевий для обчислення.
 
 Наприклад, число `1` розглядається як `true`, число `0` — як `false`:
 
@@ -64,7 +64,7 @@ if (hour < 10 || hour > 18 || isWeekend) {
 }
 ```
 
-## OR знаходить перше правдиве значенн
+## OR знаходить перше правдиве значення
 
 Описана вище логіка дещо класична. Тепер давайте введемо "додаткові" особливості JavaScript.
 
@@ -101,7 +101,7 @@ alert( undefined || null || 0 ); // 0 (усі не правдиві, повер
 
 1. **Отримання першого правдивого значення зі списку змінних або виразів.**
 
-    Уявіть, що у нас є список змінних, які можуть містити дані убо бути `null/undefined`. Як знайти першу змінну за даними?
+    Уявіть, що у нас є список змінних, які можуть містити дані або бути `null/undefined`. Як ми можемо знайти першу змінну, яка містить дані?
 
     Ми можемо використати OR `||`:
 
@@ -117,9 +117,9 @@ alert( undefined || null || 0 ); // 0 (усі не правдиві, повер
     ```
 
     Якщо і `currentUser`, і `defaultUser` були б не правдивими, `"unnamed"` було б результатом.
-2. **Обчислення короткого змичання.**
+2. **Обчислення короткого замикання.**
 
-    Операндами можуть бути не тільки значення, але й довільні вирази. OR обчислює Цей процес називається "обчисленням короткого замикання", оскільки він іде якомога коротше зліва направо.
+    Операндами можуть бути не тільки значення, але й довільні вирази. OR обчислює та перевіряє їх зліва направо. Обчислення припиняється, коли досягається правдиве значення, і значення повертається. Цей процес називається "обчисленням короткого замикання", оскільки він іде якомога коротше зліва направо.
 
     Це чітко видно, коли вираз, заданий як другий аргумент, має побічний ефект, як присвоєння змінної.
 
@@ -230,8 +230,8 @@ alert( 1 && 2 && null && 3 ); // null
 alert( 1 && 2 && 3 ); // 3, останнє
 ```
 
-````smart header="Приорітет AND `&&` є більш високим за OR `||`"
-Приорітет оператора AND `&&` є більш високим за OR `||`.
+````smart header="Пріоритет AND `&&` є більш високим за OR `||`"
+Пріоритет оператора AND `&&` є більш високим за OR `||`.
 
 Отже, код `a && b || c && d` по суті є таким самим, як би вираз `&&` був у дужках: `(a && b) || (c && d)`.
 ````
@@ -260,7 +260,7 @@ if (x > 0) {
 
 Варіант з `&&` є коротшим. Але `if` є більш очевидним і зазвичай є більш чтабельним.
 
-Тому ми рекомендуємо використовувати кожну конструкцію за своїм призначенням: використовуємо `if` нам потрібен if і використовуємо `&&`, якщо нам потрібен AND.
+Тому ми рекомендуємо використовувати кожну конструкцію за своїм призначенням: використовуємо `if`, якщо нам потрібен if і використовуємо `&&`, якщо нам потрібен AND.
 
 ## ! (NOT)
 
@@ -284,7 +284,7 @@ alert( !true ); // false
 alert( !0 ); // true
 ```
 
-Подвійний NOT `!!` іноді використовується для перетворення значення у булевий тип:
+Подвійний NOT `!!` іноді використовується для перетворення значення на булевий тип:
 
 ```js run
 alert( !!"не пустий рядок" ); // true

From f126cbaadfbda7a816e7b34fcc3e84a03d2151fd Mon Sep 17 00:00:00 2001
From: Yuriy Ostapyuk <zimne@ukr.net>
Date: Tue, 16 Jul 2019 20:15:45 +0300
Subject: [PATCH 8/8] after review corrections

---
 .../1-alert-null-2-undefined/task.md          |  2 +-
 .../2-alert-or/solution.md                    |  4 +-
 .../11-logical-operators/2-alert-or/task.md   |  2 +-
 .../3-alert-1-null-2/task.md                  |  2 +-
 .../11-logical-operators/4-alert-and/task.md  |  4 +-
 .../5-alert-and-or/solution.md                |  2 +-
 .../5-alert-and-or/task.md                    |  2 +-
 .../6-check-if-in-range/task.md               |  2 +-
 .../7-check-if-out-range/task.md              |  2 +-
 .../9-check-login/task.md                     |  4 +-
 .../11-logical-operators/article.md           | 64 +++++++++----------
 11 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
index adcb298af..23b58823e 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# Який результат OR?
+# Який результат АБО?
 
 Що виведе код нижче?
 
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
index b1b6d1e65..b498fd001 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
@@ -6,8 +6,8 @@ alert( alert(1) || 2 || alert(3) );
 
 Виклик `alert` не повертає значення. Або, іншими словами, повертає `undefined`.
 
-1. Перший OR `||` обчислює його лівий операнд `alert(1)`. Це показує перше повідомлення з `1`.
-2. `alert` повертає `undefined`, тому OR переходить до другого операнда, шукаючи правдиве значення.
+1. Перший АБО `||` обчислює його лівий операнд `alert(1)`. Це показує перше повідомлення з `1`.
+2. `alert` повертає `undefined`, тому АБО переходить до другого операнда, шукаючи правдиве значення.
 3. Другий операнд `2` є правдивим, тому виконання зупинено, повернуто `2` і потім показано зовнішнім alert.
 
 Не буде `3`, тому що обчислення на досягає `alert(3)`.
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
index df09e84ae..dc88592cc 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
@@ -2,7 +2,7 @@ importance: 3
 
 ---
 
-# Який результат alerts, об'еднаних OR?
+# Який результат alerts, об'єднаних АБО?
 
 Що виведе код нижче?
 
diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
index 30dd81fc7..46e68caa7 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# Який результат AND?
+# Який результат І?
 
 Що виведе код нижче?
 
diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
index 69f877b95..7fdfa2c5a 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# What is the result of AND'ed alerts?
+# Який результат alerts, об'єднаних І?
 
-What will this code show?
+Що виведе код нижче?
 
 ```js
 alert( alert(1) && alert(2) );
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
index 490ad3cba..6b3fd1f83 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
@@ -4,7 +4,7 @@
 alert( null || 2 && 3 || 4 );
 ```
 
-Пріоритет AND `&&` вище за `||`, тому він виконується першим.
+Пріоритет І `&&` вище за `||`, тому він виконується першим.
 
 Результат `2 && 3 = 3`, тому вираз стає:
 
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
index ed002970b..0327a666b 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
@@ -2,7 +2,7 @@ importance: 5
 
 ---
 
-# Результат OR AND OR
+# Результат АБО І АБО
 
 Який буде результат?
 
diff --git a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
index fdc27bfc7..c1784ae9f 100644
--- a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
@@ -4,6 +4,6 @@ importance: 3
 
 # Перевірте діапазон
 
-Напишіть умову "if", щоб перевірити, що `age` iзнаходить між `14` та `90` включно.
+Напишіть умову "if", щоб перевірити, що `age` знаходиться між `14` та `90` включно.
 
 "Включно" означає, що `age` може досягати країв `14` або `90`.
diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
index 450d131bd..1084a0151 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
@@ -6,4 +6,4 @@ importance: 3
 
 Напишіть умову `if`: щоб перевірити, що вік `age` НЕ знаходиться між 14 та 90 включно.
 
-Створіть два варіанти: перший використовує NOT `!`, другий -- без нього.
+Створіть два варіанти: перший використовує НЕ `!`, другий -- без нього.
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
index e63b2c3b4..54c2f1080 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
@@ -6,9 +6,9 @@ importance: 3
 
 Напишіть код, який запитує логін за допомогою `prompt`.
 
-Якщо відвідувач вводить `"Admin"`, тоді запропонуйте за допомогою `prompt` ввести пароль, iякщо вхідні данні є порожнім рядком або `key:Esc` -- показати "Скасовано.", якщо це інакший рядок -- тоді покажіть "Я вас не знаю".
+Якщо відвідувач вводить `"Admin"`, тоді запропонуйте за допомогою `prompt` ввести пароль, i якщо вхідні данні є порожнім рядком або `key:Esc` -- показати "Скасовано.", якщо це інакший рядок -- тоді покажіть "Я вас не знаю".
 
-Пароль перевіряється останнім чином:
+Пароль перевіряється наступним чином:
 
 - Якщо він дорівнює "TheMaster", тоді покажіть "Ласкаво просимо!",
 - Інший рядок -- покажіть "Неправильний пароль",
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 43b115bc7..33144dbb6 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,20 +1,20 @@
 # Логічні оператори
 
-У JavaScript існує три логічних опратори: `||` (OR), `&&` (AND), `!` (NOT).
+У JavaScript існує три логічні оператори: `||` (АБО), `&&` (І), `!` (НЕ).
 
 Хоча вони називаються "логічними", вони можуть бути застосовані до значень будь-якого типу, не тільки булевих. Їх результати також можуть бути будь-якого типу.
 
 Подивимось більш детально.
 
-## || (OR)
+## || (АБО)
 
-Оператор "OR" представлений двома символами вертикальної лінії:
+Оператор "АБО" представлений двома символами вертикальної лінії:
 
 ```js
 result = a || b;
 ```
 
-У класичному програмуванні логічний OR призначений для маніпулювання лише булевими значеннями. Якщо будь-який з його аргументів `true`, він повертає `true`, інакше повертає `false`.
+У класичному програмуванні логічний АБО призначений для маніпулювання лише булевими значеннями. Якщо будь-який з його аргументів `true`, він повертає `true`, інакше повертає `false`.
 
 У JavaScript оператор більш складніший і потужніший. Але спочатку подивимося, що відбувається з булевими значеннями.
 
@@ -39,7 +39,7 @@ if (1 || 0) { // працює так само, як ( true || false )
 }
 ```
 
-У бильшості випадків OR `||` використовується в операторі `if`, щоб перевірити, чи є *будь-яка* з заданих умов `true`.
+У бильшості випадків АБО `||` використовується в операторі `if`, щоб перевірити, чи є *будь-яка* з заданих умов `true`.
 
 Наприклад:
 
@@ -64,19 +64,19 @@ if (hour < 10 || hour > 18 || isWeekend) {
 }
 ```
 
-## OR знаходить перше правдиве значення
+## АБО знаходить перше правдиве значення
 
 Описана вище логіка дещо класична. Тепер давайте введемо "додаткові" особливості JavaScript.
 
 Розширений алгоритм працює наступним чином.
 
-Дано кілька значень, розділених опертором OR:
+Дано кілька значень, розділених опертором АБО:
 
 ```js
 result = value1 || value2 || value3;
 ```
 
-Оператор OR `||` робить наступне:
+Оператор АБО `||` робить наступне:
 
 - Обчислює операнди зліва направо.
 - Перетворює значення кожного операнда на булеве. Якщо результат `true`, зупиняється і повертає початкове значення цього операнда.
@@ -84,7 +84,7 @@ result = value1 || value2 || value3;
 
 Значення повертається у первісному вигляді без конвертації.
 
-Іншими словами, ланцюжок с OR `"||"` повертає перше правдиве значення або останнє, якщо не знайдено правдивого значення.
+Іншими словами, ланцюжок з АБО `"||"` повертає перше правдиве значення або останнє, якщо не знайдено правдивого значення.
 
 Наприклад:
 
@@ -97,13 +97,13 @@ alert( null || 0 || 1 ); // 1 (перше правдиве значення)
 alert( undefined || null || 0 ); // 0 (усі не правдиві, повертає останнє значення)
 ```
 
-Це призводить до цікавого використання у порівнянни з "чистим, класичним, виключно-булевим OR".
+Це призводить до цікавого використання у порівнянни з "чистим, класичним, виключно-булевим АБО".
 
 1. **Отримання першого правдивого значення зі списку змінних або виразів.**
 
     Уявіть, що у нас є список змінних, які можуть містити дані або бути `null/undefined`. Як ми можемо знайти першу змінну, яка містить дані?
 
-    Ми можемо використати OR `||`:
+    Ми можемо використати АБО `||`:
 
     ```js run
     let currentUser = null;
@@ -119,7 +119,7 @@ alert( undefined || null || 0 ); // 0 (усі не правдиві, повер
     Якщо і `currentUser`, і `defaultUser` були б не правдивими, `"unnamed"` було б результатом.
 2. **Обчислення короткого замикання.**
 
-    Операндами можуть бути не тільки значення, але й довільні вирази. OR обчислює та перевіряє їх зліва направо. Обчислення припиняється, коли досягається правдиве значення, і значення повертається. Цей процес називається "обчисленням короткого замикання", оскільки він іде якомога коротше зліва направо.
+    Операндами можуть бути не тільки значення, але й довільні вирази. АБО обчислює та перевіряє їх зліва направо. Обчислення припиняється, коли досягається правдиве значення, і значення повертається. Цей процес називається "обчисленням короткого замикання", оскільки він іде якомога коротше зліва направо.
 
     Це чітко видно, коли вираз, заданий як другий аргумент, має побічний ефект, як присвоєння змінної.
 
@@ -149,15 +149,15 @@ alert( undefined || null || 0 ); // 0 (усі не правдиві, повер
 
     У більшості випадків краще використовувати "звичайний" `if`, щоб код буле легше зрозуміти, але іноді це може бути зручно.
 
-## && (AND)
+## && (І)
 
-Оператор AND представлений двома амперсандами `&&`:
+Оператор І представлений двома амперсандами `&&`:
 
 ```js
 result = a && b;
 ```
 
-У класичному програмуванні AND повертає `true`, якщо обидва оператора є правдивими і `false` у іншому випадку:
+У класичному програмуванні І повертає `true`, якщо обидва оператора є правдивими і `false` у іншому випадку:
 
 ```js run
 alert( true && true );   // true
@@ -177,7 +177,7 @@ if (hour == 12 && minute == 30) {
 }
 ```
 
-Так само, як з OR, будь-яке значення дозволено як операнд AND:
+Так само, як з АБО, будь-яке значення дозволено як операнд І:
 
 ```js run
 if (1 && 0) { // оцінюється як true && false
@@ -186,34 +186,34 @@ if (1 && 0) { // оцінюється як true && false
 ```
 
 
-## AND шукає перше не правдиве значення
+## І шукає перше не правдиве значення
 
-Дано декілька значень, об'єднаних AND:
+Дано декілька значень, об'єднаних І:
 
 ```js
 result = value1 && value2 && value3;
 ```
 
-Оператор AND `&&` робить наступне:
+Оператор І `&&` робить наступне:
 
 - Обчислює операнди зліва направо.
 - Перетворює кожен операнд на булевий. Якщо результат `false`, зупиняється і повертає оригінальне значення того операнда.
 - Якщо всі операнди були обчисленні (тобто усі були правдиві), повертає останній операнд.
 
-Іншими словами, AND повертає перше не правдиве значення, або останнє значення, якщо жодного не правдивого не було знайдено.
+Іншими словами, І повертає перше не правдиве значення, або останнє значення, якщо жодного не правдивого не було знайдено.
 
-Правила, наведені вище, подібні до OR. Різниця полягає в тому, що AND повертає перше *не правдиве* значення, тоді як OR повертає перше *правдиве*.
+Правила, наведені вище, подібні до АБО. Різниця полягає в тому, що І повертає перше *не правдиве* значення, тоді як АБО повертає перше *правдиве*.
 
 Приклади:
 
 ```js run
 // якщо перший операнд правдивий,
-// AND повертає другий операнд:
+// І повертає другий операнд:
 alert( 1 && 0 ); // 0
 alert( 1 && 5 ); // 5
 
 // якщо перший операнд не правдивий,
-// AND повертає саме його. Другий операнд ігнорується
+// І повертає саме його. Другий операнд ігнорується
 alert( null && 5 ); // null
 alert( 0 && "не важливо" ); // 0
 ```
@@ -230,13 +230,13 @@ alert( 1 && 2 && null && 3 ); // null
 alert( 1 && 2 && 3 ); // 3, останнє
 ```
 
-````smart header="Пріоритет AND `&&` є більш високим за OR `||`"
-Пріоритет оператора AND `&&` є більш високим за OR `||`.
+````smart header="Пріоритет І `&&` є більш високим за АБО `||`"
+Пріоритет оператора І `&&` є більш високим за АБО `||`.
 
 Отже, код `a && b || c && d` по суті є таким самим, як би вираз `&&` був у дужках: `(a && b) || (c && d)`.
 ````
 
-Так само, як OR, оператор AND `&&` може іноді заміняти `if`.
+Так само, як АБО, оператор І `&&` може іноді заміняти `if`.
 
 Наприклад:
 
@@ -260,11 +260,11 @@ if (x > 0) {
 
 Варіант з `&&` є коротшим. Але `if` є більш очевидним і зазвичай є більш чтабельним.
 
-Тому ми рекомендуємо використовувати кожну конструкцію за своїм призначенням: використовуємо `if`, якщо нам потрібен if і використовуємо `&&`, якщо нам потрібен AND.
+Тому ми рекомендуємо використовувати кожну конструкцію за своїм призначенням: використовуємо `if`, якщо нам потрібен if і використовуємо `&&`, якщо нам потрібен І.
 
-## ! (NOT)
+## ! (НЕ)
 
-Булевий оператор NOT представлений знаком оклику `!`.
+Булевий оператор НЕ представлений знаком оклику `!`.
 
 Синтаксис дуже простий:
 
@@ -284,14 +284,14 @@ alert( !true ); // false
 alert( !0 ); // true
 ```
 
-Подвійний NOT `!!` іноді використовується для перетворення значення на булевий тип:
+Подвійний НЕ `!!` іноді використовується для перетворення значення на булевий тип:
 
 ```js run
 alert( !!"не пустий рядок" ); // true
 alert( !!null ); // false
 ```
 
-Тобто, перший NOT перетворює значення на булево і повертає зворотне, а другий NOT інвертує його знову. Зрештою, ми маємо просте перетворення значення на булевий тип.
+Тобто, перший НЕ перетворює значення на булево і повертає зворотне, а другий НЕ інвертує його знову. Зрештою, ми маємо просте перетворення значення на булевий тип.
 
 Є трохи більш детальний спосіб зробити те ж саме -- вбудована функція `Boolean`:
 
@@ -300,4 +300,4 @@ alert( Boolean("не пустий рядок") ); // true
 alert( Boolean(null) ); // false
 ```
 
-Пріоритет NOT `!` є навищим з усіх логічних операторів, тому він завжди виконується першим, перед `&&` або `||`.
+Пріоритет НЕ `!` є навищим з усіх логічних операторів, тому він завжди виконується першим, перед `&&` або `||`.