diff --git a/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md b/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
index 51f1d4680..51ee75c8e 100644
--- a/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
+++ b/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
@@ -1,12 +1,12 @@
-**Yes, it will.**
+**Tak, pokaże się.**
 
-Any string except an empty one (and `"0"` is not empty) becomes `true` in the logical context.
+Każdy ciąg znaków z wyjątkiem pustego (a `"0"` nie jest puste) zostaje `true` w kontekście logicznym.
 
-We can run and check:
+Możemy uruchomić kod aby sprawdzić:
 
 ```js run
 if ("0") {
-  alert( 'Hello' );
+  alert( 'Witaj' );
 }
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md b/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
index 5f16cda85..328b02bc0 100644
--- a/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
+++ b/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# if (a string with zero)
+# if (ciąg znaków "0")
 
-Will `alert` be shown?
+czy pokaże się `alert`?
 
 ```js
 if ("0") {
-  alert( 'Hello' );
+  alert( 'Witaj' );
 }
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
index ea9966653..a56debfc1 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
@@ -5,12 +5,12 @@
   <script>
     'use strict';
 
-    let value = prompt('What is the "official" name of JavaScript?', '');
+    let value = prompt('Jaka jest "oficjalna" nazwa JavaScript?', '');
 
     if (value == 'ECMAScript') {
-      alert('Right!');
+      alert('Racja!');
     } else {
-      alert("You don't know? ECMAScript!");
+      alert("Nie wiedziałeś? ECMAScript!");
     }
   </script>
 
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
index a4d943245..1aba6477b 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
@@ -2,11 +2,12 @@ importance: 2
 
 ---
 
-# The name of JavaScript
+# Nazwa JavaScript
 
-Using the `if..else` construct, write the code which asks: 'What is the "official" name of JavaScript?'
+Używając instrukcji `if..else`, napisz kod który będzie pytał: 'Jaka jest "oficjalna" nazwa JavaScript?'
 
-If the visitor enters "ECMAScript", then output "Right!", otherwise -- output: "Didn't know? ECMAScript!"
+Jeżeli odwiedzający wpisze "ECMAScript", wtedy 
+If the visitor enters "ECMAScript", then zwróć wynik "Racja!", w przeciwnym wypadku -- zwróć wynik: "Nie wiedziałeś? ECMAScript!"
 
 ![](ifelse_task2.svg)
 
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html b/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
index f168360dd..0d2592a5e 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
+++ b/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
@@ -6,7 +6,7 @@
   <script>
     'use strict';
 
-    let value = prompt('Type a number', 0);
+    let value = prompt('Wpisz liczbę', 0);
 
     if (value > 0) {
       alert(1);
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/solution.md b/1-js/02-first-steps/10-ifelse/3-sign/solution.md
index 262a605c2..3cf8b2455 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/solution.md
+++ b/1-js/02-first-steps/10-ifelse/3-sign/solution.md
@@ -1,7 +1,7 @@
 
 
 ```js run
-let value = prompt('Type a number', 0);
+let value = prompt('Wpisz liczbę', 0);
 
 if (value > 0) {
   alert( 1 );
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/task.md b/1-js/02-first-steps/10-ifelse/3-sign/task.md
index 0c5d0e008..931931897 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/task.md
+++ b/1-js/02-first-steps/10-ifelse/3-sign/task.md
@@ -2,14 +2,14 @@ importance: 2
 
 ---
 
-# Show the sign
+# Pokaż znak
 
-Using `if..else`, write the code which gets a number via `prompt` and then shows in `alert`:
+Używając instrukcji `if..else`, napisz kod który pobiera licznę za pomocą metody `prompt` i pokazuje w `alert`:
 
-- `1`, if the value is greater than zero,
-- `-1`, if less than zero,
-- `0`, if equals zero.
+- `1`, Jeżeli wartość jest większa od zera,
+- `-1`, jeżeli jest mniejsza od zera,
+- `0`, jeżeli jest równa zeru.
 
-In this task we assume that the input is always a number.
+W tym zadaniu przyjmujemy że wpisana wartość zawsze jest liczbą.
 
 [demo src="if_sign"]
diff --git a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
index ff32354fa..09cb10b09 100644
--- a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
+++ b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
@@ -1,6 +1,6 @@
 
 
 ```js
-let result = (a + b < 4) ? 'Below' : 'Over';
+let result = (a + b < 4) ? 'Poniżej' : 'Ponad';
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
index 6bdf8453e..b298ed512 100644
--- a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
+++ b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
@@ -2,16 +2,16 @@ importance: 5
 
 ---
 
-# Rewrite 'if' into '?'
+# Przepisz instrukcję `if` na operator warunkowy '?'
 
-Rewrite this `if` using the conditional operator `'?'`:
+Przepisz tę instrukcję `if` na operator warunkowy '?'
 
 ```js
 let result;
 
 if (a + b < 4) {
-  result = 'Below';
+  result = 'Poniżej';
 } else {
-  result = 'Over';
+  result = 'Ponad';
 }
 ```
diff --git a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
index 6d68e29d7..a6664c042 100644
--- a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
+++ b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
@@ -1,9 +1,9 @@
 
 
 ```js
-let message = (login == 'Employee') ? 'Hello' :
-  (login == 'Director') ? 'Greetings' :
-  (login == '') ? 'No login' :
+let message = (login == 'Pracownik') ? 'Witaj' :
+  (login == 'Dyrektor') ? 'Pozdrowienia' :
+  (login == '') ? 'Brak loginu' :
   '';
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
index 4f7d994a2..0d75a7f91 100644
--- a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
+++ b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
@@ -2,21 +2,21 @@ importance: 5
 
 ---
 
-# Rewrite 'if..else' into '?'
+#  Przepisz instrukcję `if` na operator warunkowy '?
 
-Rewrite `if..else` using multiple ternary operators `'?'`.
+ Przepisz instrukcję `if` na używając wielokrotnego operatora warunkowego '?`.
 
-For readability, it's recommended to split the code into multiple lines.
+Dla czytelności zalecamy podzielić kod na wiele linii.
 
 ```js
 let message;
 
-if (login == 'Employee') {
-  message = 'Hello';
-} else if (login == 'Director') {
-  message = 'Greetings';
+if (login == 'Pracownik') {
+  message = 'Witaj';
+} else if (login == 'Dyrektor') {
+  message = 'Pozdrowienia';
 } else if (login == '') {
-  message = 'No login';
+  message = 'Brak loginu';
 } else {
   message = '';
 }
diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
index 30287ccba..f7c525b81 100644
--- a/1-js/02-first-steps/10-ifelse/article.md
+++ b/1-js/02-first-steps/10-ifelse/article.md
@@ -1,117 +1,117 @@
-# Conditional operators: if, '?'
+# Operatory warunkowe: if, '?'
 
-Sometimes, we need to perform different actions based on different conditions.
+Czasami potrzebujemy wykonać różne akcje w zależności od warunków.
 
-To do that, we can use the `if` statement and the conditional operator `?`, that's also called a "question mark" operator.
+Aby to zrobić możemy użyć polecenia `if` albo operatora warunkowego `?` (ang. *conditional (ternary) operator* / *question mark operator*).
 
-## The "if" statement
+## Polecenie "if"
 
-The `if(...)` statement evaluates a condition in parentheses and, if the result is `true`, executes a block of code.
+Polecenie `if(...)` sprawdza warunek w nawiasach, a następnie jeżeli warunek jest prawdziwy wykonuje instrukcje zawarte w bloku kodu.
 
-For example:
+Na przykład:
 
 ```js run
-let year = prompt('In which year was ECMAScript-2015 specification published?', '');
+let year = prompt('W którym roku specyfikacja ECMAScript-2015 została opublikowana?', '');
 
 *!*
-if (year == 2015) alert( 'You are right!' );
+if (year == 2015) alert( 'Masz rację!' );
 */!*
 ```
 
-In the example above, the condition is a simple equality check (`year == 2015`), but it can be much more complex.
+W powyższym przykładzie warunkiem jest proste sprawdzenie (`year == 2015`), ale warunki mogą być dużo bardziej skomplikowane.
 
-If we want to execute more than one statement, we have to wrap our code block inside curly braces:
+Jeżeli chcemy wykonać więcej niż jedno polecenie, musimy umieścić masz blok kodu w nawiasach klamrowych:
 
 ```js
 if (year == 2015) {
-  alert( "That's correct!" );
-  alert( "You're so smart!" );
+  alert( "Poprawnie!" );
+  alert( "Jesteś taki mądry!" );
 }
 ```
 
-We recommend wrapping your code block with curly braces `{}` every time you use an `if` statement, even if there is only one statement to execute. Doing so improves readability.
+Zalecamy umieszczenie bloku kodu w nawiasach klamrowych `{}` za każdym razem gdy używasz polecenia `if`, nawet gdy do wykonania masz tylko jedno polecenie ponieważ znacznie poprawi to czytelność twojego kodu. 
 
-## Boolean conversion
+## Konwersja logiczna
 
-The `if (…)` statement evaluates the expression in its parentheses and converts the result to a boolean.
+Polecenie `if(...)` sprawdza wyrażenie w nawiasach, a następnie konwertuje wynik na typ logiczny
 
-Let's recall the conversion rules from the chapter <info:type-conversions>:
+Przypomnijmy sobie zasady konwersji z rozdziału <info:type-conversions>:
 
-- A number `0`, an empty string `""`, `null`, `undefined`, and `NaN` all become `false`. Because of that they are called "falsy" values.
-- Other values become `true`, so they are called "truthy".
+- Liczba `0`, pusty ciąg znaków `""`, `null`, `undefined`, oraz `Nan` są konwertowane na `false`. Dlatego właśnie nazywane są wartościami "falsy".
+- Inne wartości są konwertowane na `true` i nazywane są "truthy".
 
-So, the code under this condition would never execute:
+Tak więc kod poniżej tego warunku nigdy się nie wykona:
 
 ```js
-if (0) { // 0 is falsy
+if (0) { // 0 jest falsy
   ...
 }
 ```
 
-...and inside this condition -- it always will:
+...i wewnątrz tego warunku - zawsze sie wykona:
 
 ```js
-if (1) { // 1 is truthy
+if (1) { // 1 jest truthy
   ...
 }
 ```
 
-We can also pass a pre-evaluated boolean value to `if`, like this:
+możemy także przekazać wcześniej sprawdzoną wartość logiczną w taki sposób:
 
 ```js
-let cond = (year == 2015); // equality evaluates to true or false
+let cond = (year == 2015); // równanie przekształca się w prawdę lub fałsz
 
 if (cond) {
   ...
 }
 ```
 
-## The "else" clause
+## Klauzula "else"
 
-The `if` statement may contain an optional "else" block. It executes when the condition is false.
+Wyrażenie `if` może opcjonalnie zawierać blok "else", który wykona się w przypadku gdy sprawdzany warunek jest fałszywy  (ang. *falsy*).
 
-For example:
+Na przykład:
 ```js run
-let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
+let year = prompt('W którym roku została opublikowana specyfikacja ECMAScript-2015?', '');
 
 if (year == 2015) {
-  alert( 'You guessed it right!' );
+  alert( 'Poprawnie zgadłeś!' );
 } else {
-  alert( 'How can you be so wrong?' ); // any value except 2015
+  alert( 'Jak mogłeś się tak pomylić?' ); // każda wartość oprócz 2015
 }
 ```
 
-## Several conditions: "else if"
+## Kilka warunków: "else if"
 
-Sometimes, we'd like to test several variants of a condition. The `else if` clause lets us do that.
+Czasami chcielibyśmy sprawdzić kilka wariantów warunku. Pozwala nam na to klauzula `else if`.
 
-For example:
+Na przykład:
 
 ```js run
-let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
+let year = prompt('W którym roku została opublikowana specyfikacja ECMAScript-2015?', '');
 
 if (year < 2015) {
-  alert( 'Too early...' );
+  alert( 'Za wcześnie...' );
 } else if (year > 2015) {
-  alert( 'Too late' );
+  alert( 'Za późno' );
 } else {
-  alert( 'Exactly!' );
+  alert( 'Dokładnie!' );
 }
 ```
 
-In the code above, JavaScript first checks `year < 2015`. If that is falsy, it goes to the next condition `year > 2015`. If that is also falsy, it shows the last `alert`.
+W kodzie powyżej JavaScript najpierw sprawdza czy `year < 2015`. Jeśli wartość tego wyrażenia jest fałszywa, sprawdzany jest kolejny warunek `year > 2015`. Jeżeli to wyrażenie również jest fałszywe  (ang. *truthy*), pokazuje się ostatni `alert`.
 
-There can be more `else if` blocks. The final `else` is optional.
+Może być więcej bloków `else if`. Ostateczny blok `else` jest opcjonalny.
 
-## Conditional operator '?'
+## Operator warunkowy '?'
 
-Sometimes, we need to assign a variable depending on a condition.
+Czasami potrzebujemy przypisać zmienną w zależności od warunku.
 
-For instance:
+Na przykład:
 
 ```js run no-beautify
 let accessAllowed;
-let age = prompt('How old are you?', '');
+let age = prompt('Ile masz lat?', '');
 
 *!*
 if (age > 18) {
@@ -124,116 +124,111 @@ if (age > 18) {
 alert(accessAllowed);
 ```
 
-The so-called "conditional" or "question mark" operator lets us do that in a shorter and simpler way.
+Za pomocą operatora warunkowego '?' możemy to zrobić w o wiele prostszy i szybszy sposób.
 
-The operator is represented by a question mark `?`. Sometimes it's called "ternary", because the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
+Operator jest reprezentowany za pomocą znaku zapytania `?`. Czasami nazywany jest "potrójnym", ponieważ operator ma trzy operandy. W zasadzie to jedyny operator w języku JavaScript który posiada ich aż tyle.
 
-The syntax is:
+Oto jego składnia:
 ```js
 let result = condition ? value1 : value2;
 ```
+`condition` jest sprawdzany: jeżeli jest prawdziwy (ang. *truthy*) wtedy zwrócona zostaje wartość `value1`, w przeciwnym wypadku -- `value2`.
 
-The `condition` is evaluated: if it's truthy then `value1` is returned, otherwise -- `value2`.
-
-For example:
+Na przykład:
 
 ```js
 let accessAllowed = (age > 18) ? true : false;
 ```
+Technicznie rzecz biorąc omijamy nawiasy dookoła `age > 18`. Operator warunkowy '?' ma niskie pierwszeństwo, więc wykonuje się dopiero po porównaniu `>`.
 
-Technically, we can omit the parentheses around `age > 18`. The question mark operator has a low precedence, so it executes after the comparison `>`.
-
-This example will do the same thing as the previous one:
+Ten przykład robi dokładnie to samo co poprzedni:
 
 ```js
-// the comparison operator "age > 18" executes first anyway
-// (no need to wrap it into parentheses)
+// porównanie operatora age > 18 tak czy inaczej wykonywane jest jako pierwsze
+// (nie musimy opakowywać je w nawiasy)
 let accessAllowed = age > 18 ? true : false;
 ```
-
-But parentheses make the code more readable, so we recommend using them.
+Ale dzięki nawiasom nim kod staje się czytelniejszy, dlatego polecamy ich używać.
 
 ````smart
+W powyższym przykładzie powinieneś unikać używania operatora logicznego '?', ponieważ porównanie damo zwraca `true/false`:
 In the example above, you can avoid using the question mark operator because the comparison itself returns `true/false`:
 
 ```js
-// the same
+// to samo
 let accessAllowed = age > 18;
 ```
 ````
 
-## Multiple '?'
+## Wielokrotne wykorzystanie operatora '?'
 
-A sequence of question mark operators `?` can return a value that depends on more than one condition.
+Sekwencja operatorów logicznych '?' może zwracać wartość która zależy od więcej niż jednego warunku.
 
-For instance:
+Na przykład:
 ```js run
-let age = prompt('age?', 18);
+let age = prompt('wiek?', 18);
 
-let message = (age < 3) ? 'Hi, baby!' :
-  (age < 18) ? 'Hello!' :
-  (age < 100) ? 'Greetings!' :
-  'What an unusual age!';
+let message = (age < 3) ? 'Witaj, dziecko!' :
+  (age < 18) ? 'Witaj!' :
+  (age < 100) ? 'Pozdrowienia!' :
+  'Cóż za niespotykany wiek!';
 
 alert( message );
 ```
+Za pierwszym razem może być ciężko zrozumieć co właściwie się dzieje, ale gdy bliżej się przyjrzymy można łatwo zauważyć że tak na prawdę jest to zwyczajna sekwencja sprawdzeń:
 
-It may be difficult at first to grasp what's going on. But after a closer look, we can see that it's just an ordinary sequence of tests:
+1. Pierwszy operator warunkowy '?' sprawdza czy `age <3 `.
+2. Jeśli tak -- zwraca `'Witaj, dziecko!'`. W przeciwnym wypadku kontynuuje wyrażenie za dwukropkiem '":"' i sprawdza czy `age < 18`.
+3. Jeśli tak -- zwraca `'Witaj!'`. W przeciwnym wypadku kontynuuje wyrażenie za dwukropkiem '":"' i sprawdza czy `age < 100`.
+4. Jeśli tak -- zwraca `'Pozdrowienia!'`.  W przeciwnym wypadku kontynuuje wyrażenie za ostatnim dwukropkiem '":"' i zwraca  `'Cóż za niespotykany wiek!'`.
 
-1. The first question mark checks whether `age < 3`.
-2. If true -- it returns `'Hi, baby!'`. Otherwise, it continues to the expression after the colon '":"', checking `age < 18`.
-3. If that's true -- it returns `'Hello!'`. Otherwise, it continues to the expression after the next colon '":"', checking `age < 100`.
-4. If that's true -- it returns `'Greetings!'`. Otherwise, it continues to the expression after the last colon '":"', returning `'What an unusual age!'`.
-
-Here's how this looks using `if..else`:
+Oto jak powyższy kod wyglądał by używając `if..else`
 
 ```js
 if (age < 3) {
-  message = 'Hi, baby!';
+  message = 'Witaj, dziecko!';
 } else if (age < 18) {
-  message = 'Hello!';
+  message = 'Witaj!';
 } else if (age < 100) {
-  message = 'Greetings!';
+  message = 'Pozdrowienia!';
 } else {
-  message = 'What an unusual age!';
+  message = 'Cóż za niespotykany wiek!';
 }
 ```
 
-## Non-traditional use of '?'
+## Nietradycjonalne użycie '?'
 
-Sometimes the question mark `?` is used as a replacement for `if`:
+Czasami operator logiczny '?' jest używany jako zastępstwo dla polecenia `if`:
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('Jaka firma stworzyła JavaScript?', '');
 
 *!*
 (company == 'Netscape') ?
-   alert('Right!') : alert('Wrong.');
+   alert('Prawda!') : alert('Źle.');
 */!*
 ```
 
-Depending on the condition `company == 'Netscape'`, either the first or the second expression after the `?` gets executed and shows an alert.
+W zależności od warunku `company == 'Netscape' zostanie wykonane pierwsze lub drugie wyrażenie po znaku `?` i zostanie pokazane przez alert. 
 
-We don't assign a result to a variable here. Instead, we execute different code depending on the condition.
+Nie przypisujemy tutaj żadnej wartości do zmiennej. Zamiast tego wykonujemy różny kod w zależności od warunku.
 
-**It's not recommended to use the question mark operator in this way.**
+**Nie zalecamy używania operatora warunkowego '?' w ten sposób.**
 
-The notation is shorter than the equivalent `if` statement, which appeals to some programmers. But it is less readable.
+Notacja jest krótsza niż równoważna instrukcja `if`, która przemawia do niektórych programistów. Ale kod jest o wiele mniej czytelny.
 
-Here is the same code using `if` for comparison:
+Dla porównania oto kod który używa instrukcji `if`:
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('Jaka firma stworzyła JavaScript?', '');
 
 *!*
 if (company == 'Netscape') {
-  alert('Right!');
+  alert('Prawda!');
 } else {
-  alert('Wrong.');
+  alert('Źle.');
 }
 */!*
 ```
-
-Our eyes scan the code vertically. Code blocks which span several lines are easier to understand than a long, horizontal instruction set.
-
-The purpose of the question mark operator `?` is to return one value or another depending on its condition. Please use it for exactly that. Use `if` when you need to execute different branches of code.
+Nasze oczy skanują kod pionowo. Bloki kodu, które obejmują kilka linii, są łatwiejsze do zrozumienia niż długi, poziomy zestaw instrukcji. 
+Celem operatora warunkowego `?` Jest zwrócenie jednej lub drugiej wartości w zależności od warunku. Użyj go dokładnie do tego. Jeżeli chcesz wykonać różne kawałki kodu użyj instrukcji `if`.
\ No newline at end of file
diff --git a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
new file mode 100644
index 000000000..55e0c2067
--- /dev/null
+++ b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
@@ -0,0 +1,166 @@
+# Nullish coalescing operator '??'
+
+[recent browser="new"]
+
+Here, in this article, we'll say that an expression is "defined" when it's neither `null` nor `undefined`.
+
+The nullish coalescing operator is written as two question marks `??`.
+
+The result of `a ?? b` is:
+- if `a` is defined, then `a`,
+- if `a` isn't defined, then `b`.
+
+
+In other words, `??` returns the first argument if it's not `null/undefined`. Otherwise, the second one.
+
+The nullish coalescing operator isn't anything completely new. It's just a nice syntax to get the first "defined" value of the two.
+
+We can rewrite `result = a ?? b` using the operators that we already know, like this:
+
+```js
+result = (a !== null && a !== undefined) ? a : b;
+```
+
+The common use case for `??` is to provide a default value for a potentially undefined variable.
+
+For example, here we show `Anonymous` if `user` isn't defined:
+
+```js run
+let user;
+
+alert(user ?? "Anonymous"); // Anonymous
+```
+
+Of course, if `user` had any value except `null/undefined`, then we would see it instead:
+
+```js run
+let user = "John";
+
+alert(user ?? "Anonymous"); // John
+```
+
+We can also use a sequence of `??` to select the first value from a list that isn't `null/undefined`.
+
+Let's say we have a user's data in variables `firstName`, `lastName` or `nickName`. All of them may be undefined, if the user decided not to enter a value.
+
+We'd like to display the user name using one of these variables, or show "Anonymous" if all of them are undefined.
+
+Let's use the `??` operator for that:
+
+```js run
+let firstName = null;
+let lastName = null;
+let nickName = "Supercoder";
+
+// shows the first defined value:
+*!*
+alert(firstName ?? lastName ?? nickName ?? "Anonymous"); // Supercoder
+*/!*
+```
+
+## Comparison with ||
+
+The OR `||` operator can be used in the same way as `??`, as it was described in the [previous chapter](info:logical-operators#or-finds-the-first-truthy-value).
+
+For example, in the code above we could replace `??` with `||` and still get the same result:
+
+```js run
+let firstName = null;
+let lastName = null;
+let nickName = "Supercoder";
+
+// shows the first truthy value:
+*!*
+alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
+*/!*
+```
+
+The OR `||` operator exists since the beginning of JavaScript, so developers were using it for such purposes for a long time.
+
+On the other hand, the nullish coalescing operator `??` was added to JavaScript only recently, and the reason for that was that people weren't quite happy with `||`.
+
+The important difference between them is that:
+- `||` returns the first *truthy* value.
+- `??` returns the first *defined* value.
+
+In other words, `||` doesn't distinguish between `false`, `0`, an empty string `""` and `null/undefined`. They are all the same -- falsy values. If any of these is the first argument of `||`, then we'll get the second argument as the result.
+
+In practice though, we may want to use default value only when the variable is `null/undefined`. That is, when the value is really unknown/not set.
+
+For example, consider this:
+
+```js run
+let height = 0;
+
+alert(height || 100); // 100
+alert(height ?? 100); // 0
+```
+
+- The `height || 100` checks `height` for being a falsy value, and it really is.
+    - so the result is the second argument, `100`.
+- The `height ?? 100` checks `height` for being `null/undefined`, and it's not,
+    - so the result is `height` "as is", that is `0`.
+
+If the zero height is a valid value, that shouldn't be replaced with the default, then `??` does just the right thing.
+
+## Precedence
+
+The precedence of the `??` operator is rather low: `5` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table). So `??` is evaluated before `=` and `?`, but after most other operations, such as `+`, `*`.
+
+So if we'd like to choose a value with `??` in an expression with other operators, consider adding parentheses:
+
+```js run
+let height = null;
+let width = null;
+
+// important: use parentheses
+let area = (height ?? 100) * (width ?? 50);
+
+alert(area); // 5000
+```
+
+Otherwise, if we omit parentheses, then as `*` has the higher precedence than `??`, it would execute first, leading to incorrect results.
+
+```js
+// without parentheses
+let area = height ?? 100 * width ?? 50;
+
+// ...works the same as this (probably not what we want):
+let area = height ?? (100 * width) ?? 50;
+```
+
+### Using ?? with && or ||
+
+Due to safety reasons, JavaScript forbids using `??` together with `&&` and `||` operators, unless the precedence is explicitly specified with parentheses.
+
+The code below triggers a syntax error:
+
+```js run
+let x = 1 && 2 ?? 3; // Syntax error
+```
+
+The limitation is surely debatable, but it was added to the language specification with the purpose to avoid programming mistakes, when people start to switch to `??` from `||`.
+
+Use explicit parentheses to work around it:
+
+```js run
+*!*
+let x = (1 && 2) ?? 3; // Works
+*/!*
+
+alert(x); // 2
+```
+
+## Summary
+
+- The nullish coalescing operator `??` provides a short way to choose the first "defined" value from a list.
+
+    It's used to assign default values to variables:
+
+    ```js
+    // set height=100, if height is null or undefined
+    height = height ?? 100;
+    ```
+
+- The operator `??` has a very low precedence, only a bit higher than `?` and `=`, so consider adding parentheses when using it in an expression.
+- It's forbidden to use it with `||` or `&&` without explicit parentheses.
diff --git a/1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md b/1-js/02-first-steps/18-while-for/1-loop-last-value/solution.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/1-loop-last-value/solution.md
rename to 1-js/02-first-steps/18-while-for/1-loop-last-value/solution.md
diff --git a/1-js/02-first-steps/12-while-for/1-loop-last-value/task.md b/1-js/02-first-steps/18-while-for/1-loop-last-value/task.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/1-loop-last-value/task.md
rename to 1-js/02-first-steps/18-while-for/1-loop-last-value/task.md
diff --git a/1-js/02-first-steps/12-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/18-while-for/2-which-value-while/solution.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/2-which-value-while/solution.md
rename to 1-js/02-first-steps/18-while-for/2-which-value-while/solution.md
diff --git a/1-js/02-first-steps/12-while-for/2-which-value-while/task.md b/1-js/02-first-steps/18-while-for/2-which-value-while/task.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/2-which-value-while/task.md
rename to 1-js/02-first-steps/18-while-for/2-which-value-while/task.md
diff --git a/1-js/02-first-steps/12-while-for/3-which-value-for/solution.md b/1-js/02-first-steps/18-while-for/3-which-value-for/solution.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/3-which-value-for/solution.md
rename to 1-js/02-first-steps/18-while-for/3-which-value-for/solution.md
diff --git a/1-js/02-first-steps/12-while-for/3-which-value-for/task.md b/1-js/02-first-steps/18-while-for/3-which-value-for/task.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/3-which-value-for/task.md
rename to 1-js/02-first-steps/18-while-for/3-which-value-for/task.md
diff --git a/1-js/02-first-steps/12-while-for/4-for-even/solution.md b/1-js/02-first-steps/18-while-for/4-for-even/solution.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/4-for-even/solution.md
rename to 1-js/02-first-steps/18-while-for/4-for-even/solution.md
diff --git a/1-js/02-first-steps/12-while-for/4-for-even/task.md b/1-js/02-first-steps/18-while-for/4-for-even/task.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/4-for-even/task.md
rename to 1-js/02-first-steps/18-while-for/4-for-even/task.md
diff --git a/1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md b/1-js/02-first-steps/18-while-for/5-replace-for-while/solution.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/5-replace-for-while/solution.md
rename to 1-js/02-first-steps/18-while-for/5-replace-for-while/solution.md
diff --git a/1-js/02-first-steps/12-while-for/5-replace-for-while/task.md b/1-js/02-first-steps/18-while-for/5-replace-for-while/task.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/5-replace-for-while/task.md
rename to 1-js/02-first-steps/18-while-for/5-replace-for-while/task.md
diff --git a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md b/1-js/02-first-steps/18-while-for/6-repeat-until-correct/solution.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/6-repeat-until-correct/solution.md
rename to 1-js/02-first-steps/18-while-for/6-repeat-until-correct/solution.md
diff --git a/1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md b/1-js/02-first-steps/18-while-for/6-repeat-until-correct/task.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/6-repeat-until-correct/task.md
rename to 1-js/02-first-steps/18-while-for/6-repeat-until-correct/task.md
diff --git a/1-js/02-first-steps/12-while-for/7-list-primes/solution.md b/1-js/02-first-steps/18-while-for/7-list-primes/solution.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/7-list-primes/solution.md
rename to 1-js/02-first-steps/18-while-for/7-list-primes/solution.md
diff --git a/1-js/02-first-steps/12-while-for/7-list-primes/task.md b/1-js/02-first-steps/18-while-for/7-list-primes/task.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/7-list-primes/task.md
rename to 1-js/02-first-steps/18-while-for/7-list-primes/task.md
diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/18-while-for/article.md
similarity index 100%
rename from 1-js/02-first-steps/12-while-for/article.md
rename to 1-js/02-first-steps/18-while-for/article.md