From aaf2254ba146189eb0a8a3830b3c8ba258f9f22c Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Sat, 25 Mar 2023 08:31:07 +0200
Subject: [PATCH 01/29] article translation

---
 1-js/02-first-steps/11-logical-operators/article.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 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 78c4fd2f1..c1b6bcfdb 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,8 +1,9 @@
-# Logical operators
+# Operatori logici
 
-There are four logical operators in JavaScript: `||` (OR), `&&` (AND), `!` (NOT), `??` (Nullish Coalescing). Here we cover the first three, the `??` operator is in the next article.
+În JavaScript există patru operatori logici: `||` (ORI), `&&` (ȘI), `!` (NU), `??` (Fuzionare nulă). În acest articol vorbim doar despre primi trei, operatorul `??` va fi acoperit în următorul articol.
 
-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.
+Chiar dacă aceștia sunt denumiți operatori „logici”
+<!-- 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.
 

From 111c08ef115900497393dd28e7f963d30d8214a8 Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 20 Apr 2023 12:35:52 +0300
Subject: [PATCH 02/29] translating to line 38. articel.md: logival-operators

---
 .../11-logical-operators/article.md           | 34 +++++++++----------
 1 file changed, 16 insertions(+), 18 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 c1b6bcfdb..576946974 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -2,41 +2,39 @@
 
 În JavaScript există patru operatori logici: `||` (ORI), `&&` (ȘI), `!` (NU), `??` (Fuzionare nulă). În acest articol vorbim doar despre primi trei, operatorul `??` va fi acoperit în următorul articol.
 
-Chiar dacă aceștia sunt denumiți operatori „logici”
-<!-- 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. -->
+Chiar dacă sunt denumiți operatori „logici”, aceștia pot fi folosiți pentru valori de orice tip, nu doar pentru cele de tip boolean. Rezultatul acetora putând fi de orice tip. 
 
-Let's see the details.
+Haideți să aflăm mai multe detalii.
 
-## || (OR)
+## || (ORI)
 
-The "OR" operator is represented with two vertical line symbols:
+Simbolul pentru operatorul „ORI” este reprezentat prin două linii verticale.
 
 ```js
 result = a || b;
 ```
+În programarea clasică, operatorul logic „ORI” este folosit pentru a manipula doar valori de tip boolean. Dacă valoarea unuia dintre argumente acesuita este „adevărat”, rezultatul acelei operații va fi „adevărat”, dacă nu rezultatul va fi „fals”.
 
-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`.
+În JavaScript, acest operator este puțin mai complicat, dar mult mai eficient. Pentru început, haideți să vedem ce se întâmplă cu aceste valori de tip boolean. 
 
-In JavaScript, the operator is a little bit trickier and more powerful. But first, let's see what happens with boolean values.
-
-There are four possible logical combinations:
+Pot fi posibile doar patru combinații logice.
 
 ```js run
-alert( true || true );   // true
-alert( false || true );  // true
-alert( true || false );  // true
-alert( false || false ); // false
+alert( true || true );   // adevărat
+alert( false || true );  // adevărat
+alert( true || false );  // adevărat
+alert( false || false ); // fals
 ```
 
-As we can see, the result is always `true` except for the case when both operands are `false`.
+După cum putem vedea, rezultat este mereu „adevărat” cu excepția cazului în care ambii operanți au valoarea de „fals”.
 
-If an operand is not a boolean, it's converted to a boolean for the evaluation.
+Dacă un operant nu este de tip boolean, acesta este convertit automat într-unul pentru evaluare.
 
-For instance, the number `1` is treated as `true`, the number `0` as `false`:
+De exemplu, numărul „1” este tratat ca fiind „adevărat”, iar numărul „0” este „fals”:
 
 ```js run
-if (1 || 0) { // works just like if( true || false )
-  alert( 'truthy!' );
+if (1 || 0) { // funcționează asemenea lui if( adevărat || false )
+  alert( 'efectiv adevărat!' );
 }
 ```
 

From 3c92cb30c4b0f3d6c08f79e741b65c5715aefbaf Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Sat, 29 Apr 2023 11:50:38 +0300
Subject: [PATCH 03/29] translation to line 126

---
 .../11-logical-operators/article.md           | 63 ++++++++++---------
 1 file changed, 33 insertions(+), 30 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 576946974..9b488680d 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -33,14 +33,14 @@ Dacă un operant nu este de tip boolean, acesta este convertit automat într-unu
 De exemplu, numărul „1” este tratat ca fiind „adevărat”, iar numărul „0” este „fals”:
 
 ```js run
-if (1 || 0) { // funcționează asemenea lui if( adevărat || false )
+if (1 || 0) { // funcționează asemenea lui if( adevărat || fals )
   alert( 'efectiv adevărat!' );
 }
 ```
 
-Most of the time, OR `||` is used in an `if` statement to test if *any* of the given conditions is `true`.
+De cele mai multe ori, semnul ORI `||` este folositi într-un if statement pentru a testa dacă vreauna dintre condiții este adevărată.
 
-For example:
+Spre exemplu:
 
 ```js run
 let hour = 9;
@@ -48,61 +48,61 @@ let hour = 9;
 *!*
 if (hour < 10 || hour > 18) {
 */!*
-  alert( 'The office is closed.' );
+  alert( 'Biroul este închis.' );
 }
 ```
 
-We can pass more conditions:
+Putem adăuga mai multe condiții:
 
 ```js run
 let hour = 12;
 let isWeekend = true;
 
 if (hour < 10 || hour > 18 || isWeekend) {
-  alert( 'The office is closed.' ); // it is the weekend
+  alert( 'Biroul este închis.' ); // este weekend.
 }
 ```
 
-## OR "||" finds the first truthy value [#or-finds-the-first-truthy-value]
+## ORI "||" identifică prima valoare efectiv adevărată [#or-finds-the-first-truthy-value]
 
-The logic described above is somewhat classical. Now, let's bring in the "extra" features of JavaScript.
+Logica descrisă mai sus este oarecum clasică. Haideți să discutăm despre calitățile „extra” din JavaScript.  
 
-The extended algorithm works as follows.
+Algoritmul extinds funcționează după cum urmează.
 
-Given multiple OR'ed values:
+Sunt date mai multe valori ale lui ORI.
 
 ```js
 result = value1 || value2 || value3;
 ```
 
-The OR `||` operator does the following:
+Operatorul ORI `||` face următoarele lucruri:
 
-- 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.
+- Evaluzează operanții de la stânga spre dreapta.
+- Fiecare operant este convertit într-o valoare de tip boolean. Dacă rezultatul este „adevărat”, execuția se oprește și valoarea originală a acelui operant este returnată.
+- Dacă toți operanții au fost evaluați (iar toți erau falși), ultimul operant este returnat.
 
-A value is returned in its original form, without the conversion.
+O valoare este returnată în forma ei originală, fără conversiune.
 
-In other words, a chain of OR `||` returns the first truthy value or the last one if no truthy value is found.
+Cu alte cuvinte, într-un lanț de ORI `||` este returnată prima valoare efectiv adevărată sau ultima dacă nicio valoare efectiv adevărată nu este găsită.
 
-For instance:
+Spre exemplu:
 
 ```js run
-alert( 1 || 0 ); // 1 (1 is truthy)
+alert( 1 || 0 ); // 1 (1 este efectiv adevărat)
 
-alert( null || 1 ); // 1 (1 is the first truthy value)
-alert( null || 0 || 1 ); // 1 (the first truthy value)
+alert( null || 1 ); // 1 (1 este prima valoare efectiv adevărată)
+alert( null || 0 || 1 ); // 1 (prima valoare efectiv adevărată)
 
-alert( undefined || null || 0 ); // 0 (all falsy, returns the last value)
+alert( undefined || null || 0 ); // 0 (toate valorile sunt efectiv false, este returnată ultima valoare)
 ```
 
-This leads to some interesting usage compared to a "pure, classical, boolean-only OR".
+Asta conduce la o utilizate mai interesantă spre deosebire de un boolean clasic de tip ORI.
 
-1. **Getting the first truthy value from a list of variables or expressions.**
+1. **Poate fi obținută prima valoare efectiv adevărată dintr-o listă de variabile sau expresii.**
 
-    For instance, we have `firstName`, `lastName` and `nickName` variables, all optional (i.e. can be undefined or have falsy values).
+    Spre exemplu, avem variabilele `firstName`, `lastName` si `nickName`, toate opționale (adică pot fi undefined sau pot avea valori efectiv false)
 
-    Let's use OR `||` to choose the one that has the data and show it (or `"Anonymous"` if nothing set):
+    Hai să folosim operatorul ORI `||` pentru a selecta variabila care conține date și să le facem să apară (sau `"Anonim"` dacă niciuna nu are nicio valoare):
 
     ```js run
     let firstName = "";
@@ -110,17 +110,20 @@ This leads to some interesting usage compared to a "pure, classical, boolean-onl
     let nickName = "SuperCoder";
 
     *!*
-    alert( firstName || lastName || nickName || "Anonymous"); // SuperCoder
+    alert( firstName || lastName || nickName || "Anonim"); // SuperCoder
     */!*
     ```
 
-    If all variables were falsy, `"Anonymous"` would show up.
+    <!-- If all variables were falsy, `"Anonymous"` would show up. -->
+    Dacă toate variabilele ar fi efectiv false, ar apărea textul `"Anonim"`.
 
-2. **Short-circuit evaluation.**
+2. **Evaulare de tip scurt circuit**
 
-    Another feature of OR `||` operator is the so-called "short-circuit" evaluation.
+    O altă caracteristică a operatorului ORI `||` este așa numita evaluare de tip scurt circuit.
 
-    It means that `||` processes its arguments until the first truthy value is reached, and then the value is returned immediately, without even touching the other argument.
+    <!-- It means that `||` processes its arguments until the first truthy value is reached, and then the value is returned immediately, without even touching the other argument. -->
+    Aceasta înseamnă că `||` își procesează argumentele până când prima valoare efectiv adevărată este întâlnită, iar apoi acea valoare este returnată imediat, fără ca restul argumentelor să mai fie luate în considerate.
+    <!-- Mai îmbunătățește traducere de mai sus! -->
 
     The importance of this feature becomes obvious if an operand isn't just a value, but an expression with a side effect, such as a variable assignment or a function call.
 

From ae846192bb050f3c95bd52417a54597c8a818293 Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Sun, 30 Apr 2023 11:49:06 +0300
Subject: [PATCH 04/29] translation to the line 141

---
 .../11-logical-operators/article.md           | 22 +++++++++----------
 1 file changed, 10 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 9b488680d..3193030c0 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -121,26 +121,24 @@ Asta conduce la o utilizate mai interesantă spre deosebire de un boolean clasic
 
     O altă caracteristică a operatorului ORI `||` este așa numita evaluare de tip scurt circuit.
 
-    <!-- It means that `||` processes its arguments until the first truthy value is reached, and then the value is returned immediately, without even touching the other argument. -->
-    Aceasta înseamnă că `||` își procesează argumentele până când prima valoare efectiv adevărată este întâlnită, iar apoi acea valoare este returnată imediat, fără ca restul argumentelor să mai fie luate în considerate.
-    <!-- Mai îmbunătățește traducere de mai sus! -->
+    Aceasta înseamnă că `||` își procesează argumentele până când prima valoare efectiv adevărată este întâlnită, iar apoi acea valoare este returnată imediat, fără ca celălalt argument să mai fie luat în considera.
 
-    The importance of this feature becomes obvious if an operand isn't just a value, but an expression with a side effect, such as a variable assignment or a function call.
+    Importanța acestei caracteristici începe să devina evidentă în momentul în care unul dintre operanți nu reprezintă doar o valoare, ci o expresie care aduce cu sine și un efect advers, cum ar fi atribuirea valorii unei variabile sau apelarea unei funcții. 
 
-    In the example below, only the second message is printed:
+    Pentru exemplul de mai jos, doar al doilea mesaj este printat:
 
     ```js run no-beautify
-    *!*true*/!* || alert("not printed");
-    *!*false*/!* || alert("printed");
+    *!*true*/!* || alert("Acest mesaj nu este printat!");
+    *!*false*/!* || alert("Acest mesaj este printat!");
     ```
 
-    In the first line, the OR `||` operator stops the evaluation immediately upon seeing `true`, so the `alert` isn't run.
+    În prima linie, operatorul OR `||` imediat ce întâlnește valoarea true oprește evaluarea, astfel încât methoda alert nu este rulată. 
 
-    Sometimes, people use this feature to execute commands only if the condition on the left part is falsy.
+    Uneori, oeamni folosesc această funcție pentru a executa comenzi doar dacă condiția din partea stângă este efectiv falsă.
+## && (ȘI)
 
-## && (AND)
-
-The AND operator is represented with two ampersands `&&`:
+Operatorul ȘI este representat de două semne de tip ampersand `&&`:
+<!-- Aici am rămas -->
 
 ```js
 result = a && b;

From f543570f35ce54fb4c11e6489e679ad3b8f33c98 Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 4 May 2023 15:51:50 +0300
Subject: [PATCH 05/29] translated: logical-operators> articel.md to line 191

---
 .../11-logical-operators/article.md           | 34 ++++++++++---------
 1 file changed, 18 insertions(+), 16 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 3193030c0..ea5065a53 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -137,14 +137,15 @@ Asta conduce la o utilizate mai interesantă spre deosebire de un boolean clasic
     Uneori, oeamni folosesc această funcție pentru a executa comenzi doar dacă condiția din partea stângă este efectiv falsă.
 ## && (ȘI)
 
-Operatorul ȘI este representat de două semne de tip ampersand `&&`:
-<!-- Aici am rămas -->
+Operatorul ȘI este reprezentat de două semne de tip ampersand `&&`:
 
 ```js
 result = a && b;
 ```
 
-In classical programming, AND returns `true` if both operands are truthy and `false` otherwise:
+<!-- Până aici trebuie înlocuit true, truthy, false, falsey. -->
+
+În programarea clasică, operatorul ȘI are ca rezultat `true` dacă ambii operanți sunt truthy și `false` în caz contrar:
 
 ```js run
 alert( true && true );   // true
@@ -153,41 +154,42 @@ alert( true && false );  // false
 alert( false && false ); // false
 ```
 
-An example with `if`:
+Un exemplu cu `if`:
 
 ```js run
 let hour = 12;
 let minute = 30;
-
+                 
 if (hour == 12 && minute == 30) {
   alert( 'The time is 12:30' );
 }
 ```
 
-Just as with OR, any value is allowed as an operand of AND:
+La fel cum se întâmplă cu operatorul ORI, orice valoare poate fi acceptată ca fiind operantul lui ȘI:
 
 ```js run
-if (1 && 0) { // evaluated as true && false
-  alert( "won't work, because the result is falsy" );
+if (1 && 0) { // evaluat ca true && false
+  alert( "nu va funcționa, din cauză că rezultatul este falsy" );
 }
 ```
 
+## ȘI "&&" identifică prima valoare falsy
 
-## AND "&&" finds the first falsy value
-
-Given multiple AND'ed values:
+Sunt date mai multe valori conectate prin operatorul logic ȘI:
 
 ```js
 result = value1 && value2 && value3;
 ```
 
-The AND `&&` operator does the following:
+Operatorul ȘI `&&` face următoarele lucruri:
 
-- 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.
+- Evaluează operanții de la stânga la dreapta.
+- Convertește fiecare operant într-un boolean. Dacă rezultatul este `false`, procesul este oprit, iar valoarea originală a operantului este returnată.
+- Dacă toți operanții au fost evaluați (și toți sunt truthy), ultimul operant este returnat.
 
-In other words, AND returns the first falsy value or the last value if none were found.
+<!-- In other words, AND returns the first falsy value or the last value if none were found. -->
+Cu alte cuvinte, operatorul ȘI are ca rezultat prima valoare falsy sau ultima valoare dacă nicuna nu este găsită.
+<!-- Mai verifică încă odată propoziția de mai sus. Aici am rămas -->
 
 The rules above are similar to OR. The difference is that AND returns the first *falsy* value while OR returns the first *truthy* one.
 

From aa4592976751880e67ed4151a060b4fbc3465a8a Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 4 May 2023 21:18:15 +0300
Subject: [PATCH 06/29] translated: logical-operators> articel.md to line 206

---
 .../11-logical-operators/article.md           | 93 +++++++++----------
 1 file changed, 45 insertions(+), 48 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 ea5065a53..8fe3fdfe8 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,8 +1,8 @@
 # Operatori logici
 
-În JavaScript există patru operatori logici: `||` (ORI), `&&` (ȘI), `!` (NU), `??` (Fuzionare nulă). În acest articol vorbim doar despre primi trei, operatorul `??` va fi acoperit în următorul articol.
+În JavaScript există patru operatori logici: `||` (ORI), `&&` (ȘI), `!` (NU), `??` (Nullish Coalescing). În acest articol vorbim doar despre primi trei, operatorul `??` va fi acoperit în următorul articol.
 
-Chiar dacă sunt denumiți operatori „logici”, aceștia pot fi folosiți pentru valori de orice tip, nu doar pentru cele de tip boolean. Rezultatul acetora putând fi de orice tip. 
+Chiar dacă sunt denumiți operatori „logici”, aceștia pot fi folosiți pentru valori de orice tip, nu doar pentru cele de tip boolean. Rezultatul acestora putând fi de orice tip. 
 
 Haideți să aflăm mai multe detalii.
 
@@ -13,32 +13,32 @@ Simbolul pentru operatorul „ORI” este reprezentat prin două linii verticale
 ```js
 result = a || b;
 ```
-În programarea clasică, operatorul logic „ORI” este folosit pentru a manipula doar valori de tip boolean. Dacă valoarea unuia dintre argumente acesuita este „adevărat”, rezultatul acelei operații va fi „adevărat”, dacă nu rezultatul va fi „fals”.
+În programarea clasică, operatorul logic „ORI” este folosit pentru a manipula doar valori de tip boolean. Dacă valoarea unuia dintre argumente este `true`, rezultatul operației va fi `true`, în caz contrar rezultatul va fi `false`.
 
-În JavaScript, acest operator este puțin mai complicat, dar mult mai eficient. Pentru început, haideți să vedem ce se întâmplă cu aceste valori de tip boolean. 
+În JavaScript, acest operator este puțin mai complex, dar mult mai eficient. Pentru început, haideți să vedem ce se întâmplă cu aceste valori de tip boolean. 
 
 Pot fi posibile doar patru combinații logice.
 
 ```js run
-alert( true || true );   // adevărat
-alert( false || true );  // adevărat
-alert( true || false );  // adevărat
-alert( false || false ); // fals
+alert( true || true );   // true
+alert( false || true );  // true
+alert( true || false );  // true
+alert( false || false ); // false
 ```
 
-După cum putem vedea, rezultat este mereu „adevărat” cu excepția cazului în care ambii operanți au valoarea de „fals”.
+După cum putem vedea, rezultat este mereu `true` cu excepția cazului în care ambii operanți au valoarea `false`.
 
-Dacă un operant nu este de tip boolean, acesta este convertit automat într-unul pentru evaluare.
+Dacă un operant nu este de tip boolean, acesta este convertit automat pentru evaluare.
 
-De exemplu, numărul „1” este tratat ca fiind „adevărat”, iar numărul „0” este „fals”:
+De exemplu, numărul `1` este tratat ca fiind `true`, iar numărul `0` este `false`:
 
 ```js run
-if (1 || 0) { // funcționează asemenea lui if( adevărat || fals )
-  alert( 'efectiv adevărat!' );
+if (1 || 0) { // funcționează asemenea if( true || false )
+  alert( 'truthy' );
 }
 ```
 
-De cele mai multe ori, semnul ORI `||` este folositi într-un if statement pentru a testa dacă vreauna dintre condiții este adevărată.
+De cele mai multe ori, semnul ORI `||` este folosit într-un if statement pentru a testa dacă vreauna dintre condiții este `true`.
 
 Spre exemplu:
 
@@ -63,9 +63,9 @@ if (hour < 10 || hour > 18 || isWeekend) {
 }
 ```
 
-## ORI "||" identifică prima valoare efectiv adevărată [#or-finds-the-first-truthy-value]
+## ORI "||" identifică prima valoare truthy [#or-finds-the-first-truthy-value]
 
-Logica descrisă mai sus este oarecum clasică. Haideți să discutăm despre calitățile „extra” din JavaScript.  
+Logica descrisă mai sus este oarecum cea basic. Haideți să discutăm despre calitățile „extra” din JavaScript.  
 
 Algoritmul extinds funcționează după cum urmează.
 
@@ -78,31 +78,31 @@ result = value1 || value2 || value3;
 Operatorul ORI `||` face următoarele lucruri:
 
 - Evaluzează operanții de la stânga spre dreapta.
-- Fiecare operant este convertit într-o valoare de tip boolean. Dacă rezultatul este „adevărat”, execuția se oprește și valoarea originală a acelui operant este returnată.
+- Fiecare operant este convertit într-o valoare boolean. Dacă rezultatul este `true`, execuția este oprită și valoarea originală a acelui operant este returnată.
 - Dacă toți operanții au fost evaluați (iar toți erau falși), ultimul operant este returnat.
 
 O valoare este returnată în forma ei originală, fără conversiune.
 
-Cu alte cuvinte, într-un lanț de ORI `||` este returnată prima valoare efectiv adevărată sau ultima dacă nicio valoare efectiv adevărată nu este găsită.
+Cu alte cuvinte, într-un lanț de operatori logici ORI `||` este returnată prima valoare truthy sau ultima dacă nicio valoare truthy nu este identificată.
 
 Spre exemplu:
 
 ```js run
-alert( 1 || 0 ); // 1 (1 este efectiv adevărat)
+alert( 1 || 0 ); // 1 (1 este truthy)
 
-alert( null || 1 ); // 1 (1 este prima valoare efectiv adevărată)
-alert( null || 0 || 1 ); // 1 (prima valoare efectiv adevărată)
+alert( null || 1 ); // 1 (1 este prima valoare truthy)
+alert( null || 0 || 1 ); // 1 (prima valoare truthy)
 
-alert( undefined || null || 0 ); // 0 (toate valorile sunt efectiv false, este returnată ultima valoare)
+alert( undefined || null || 0 ); // 0 (toate valorile sunt falsy, ultima valoare este returnată)
 ```
 
-Asta conduce la o utilizate mai interesantă spre deosebire de un boolean clasic de tip ORI.
+Asta conduce la utilizări mai interesante față de cele calsice în care operatorul ORI compară doar valori pur booleene.
 
-1. **Poate fi obținută prima valoare efectiv adevărată dintr-o listă de variabile sau expresii.**
+1. **Obținerea primei valori truthy dintr-o listă de variabile sau expresii.**
 
-    Spre exemplu, avem variabilele `firstName`, `lastName` si `nickName`, toate opționale (adică pot fi undefined sau pot avea valori efectiv false)
+    Spre exemplu, avem variabilele `firstName`, `lastName` si `nickName`, toate opționale (adică valoarea lor poate fi undefined sau falsy)
 
-    Hai să folosim operatorul ORI `||` pentru a selecta variabila care conține date și să le facem să apară (sau `"Anonim"` dacă niciuna nu are nicio valoare):
+    Haideți să folosim operatorul ORI `||` pentru a identifica variabila truthy și să folosim conținutul acesteia (sau `"Anonim"` în caz contrar):
 
     ```js run
     let firstName = "";
@@ -114,16 +114,15 @@ Asta conduce la o utilizate mai interesantă spre deosebire de un boolean clasic
     */!*
     ```
 
-    <!-- If all variables were falsy, `"Anonymous"` would show up. -->
-    Dacă toate variabilele ar fi efectiv false, ar apărea textul `"Anonim"`.
+    Dacă toate variabilele ar fi fost falsy, ar fi fost folosit `"Anonim"`.
 
-2. **Evaulare de tip scurt circuit**
+2. **Evaluarea de tip scurt circuit.**
 
     O altă caracteristică a operatorului ORI `||` este așa numita evaluare de tip scurt circuit.
 
-    Aceasta înseamnă că `||` își procesează argumentele până când prima valoare efectiv adevărată este întâlnită, iar apoi acea valoare este returnată imediat, fără ca celălalt argument să mai fie luat în considera.
+    Aceasta înseamnă că `||` își procesează argumentele până când prima valoare truthy este întâlnită, iar apoi acea valoare este returnată imediat, fără ca celălalt argument să mai fie luat în considerare.
 
-    Importanța acestei caracteristici începe să devina evidentă în momentul în care unul dintre operanți nu reprezintă doar o valoare, ci o expresie care aduce cu sine și un efect advers, cum ar fi atribuirea valorii unei variabile sau apelarea unei funcții. 
+    Importanța acestei caracteristici începe să devină evidentă în momentul în care unul dintre operanți nu conține doar o valoare, ci o expresie care aduce cu sine și un efect advers, cum ar fi atribuirea valorii unei variabile sau invocarea unei funcții. 
 
     Pentru exemplul de mai jos, doar al doilea mesaj este printat:
 
@@ -132,19 +131,17 @@ Asta conduce la o utilizate mai interesantă spre deosebire de un boolean clasic
     *!*false*/!* || alert("Acest mesaj este printat!");
     ```
 
-    În prima linie, operatorul OR `||` imediat ce întâlnește valoarea true oprește evaluarea, astfel încât methoda alert nu este rulată. 
+    În prima linie, operatorul ORI `||` imediat ce întâlnește valoarea `true` oprește evaluarea, astfel încât metoda `alert` nu este executată. 
 
-    Uneori, oeamni folosesc această funcție pentru a executa comenzi doar dacă condiția din partea stângă este efectiv falsă.
+    Uneori, oamenii folosesc această funcție pentru a executa comenzi doar dacă condiția din partea stângă este falsy.
 ## && (ȘI)
 
-Operatorul ȘI este reprezentat de două semne de tip ampersand `&&`:
+Operatorul ȘI este reprezentat de două semne ampersand `&&`:
 
 ```js
 result = a && b;
 ```
 
-<!-- Până aici trebuie înlocuit true, truthy, false, falsey. -->
-
 În programarea clasică, operatorul ȘI are ca rezultat `true` dacă ambii operanți sunt truthy și `false` în caz contrar:
 
 ```js run
@@ -165,7 +162,7 @@ if (hour == 12 && minute == 30) {
 }
 ```
 
-La fel cum se întâmplă cu operatorul ORI, orice valoare poate fi acceptată ca fiind operantul lui ȘI:
+La fel cum se întâmplă cu operatorul ORI, ȘI poate accepta ca operant orice valoare:
 
 ```js run
 if (1 && 0) { // evaluat ca true && false
@@ -187,27 +184,27 @@ Operatorul ȘI `&&` face următoarele lucruri:
 - Convertește fiecare operant într-un boolean. Dacă rezultatul este `false`, procesul este oprit, iar valoarea originală a operantului este returnată.
 - Dacă toți operanții au fost evaluați (și toți sunt truthy), ultimul operant este returnat.
 
-<!-- In other words, AND returns the first falsy value or the last value if none were found. -->
-Cu alte cuvinte, operatorul ȘI are ca rezultat prima valoare falsy sau ultima valoare dacă nicuna nu este găsită.
-<!-- Mai verifică încă odată propoziția de mai sus. Aici am rămas -->
+Cu alte cuvinte, operatorul ȘI are ca rezultat prima valoare falsy sau ultima valoare dacă niciuna nu este falsy.
 
-The rules above are similar to OR. The difference is that AND returns the first *falsy* value while OR returns the first *truthy* one.
+Regulile de mai sus sunt similare și pentru ORI. Diferența constă în faputl că ȘI are ca rezultat prima valoare *falsy* în timp ce ORI are ca rezultat prima valoare *truthy*.
 
-Examples:
+Exemple:
 
 ```js run
-// if the first operand is truthy,
-// AND returns the second operand:
+// dacă primul operant este truthy,
+// ȘI are ca rezultat cel de al doilea operant:
 alert( 1 && 0 ); // 0
 alert( 1 && 5 ); // 5
 
-// if the first operand is falsy,
-// AND returns it. The second operand is ignored
+// dacă primul operant este falsy,
+// acesta este rezultatul lui ȘI, iar cel de al doilea este ignorat
 alert( null && 5 ); // null
-alert( 0 && "no matter what" ); // 0
+alert( 0 && "orice s-ar întâmpla" ); // 0
 ```
 
-We can also pass several values in a row. See how the first falsy one is returned:
+<!-- We can also pass several values in a row. See how the first falsy one is returned: -->
+De asemenea, putem oferi mai multe valori în același timp. Observați cum prima valoare falsy este returnată:
+<!-- Mai verifică puțin traducerea de mai sus -->
 
 ```js run
 alert( 1 && 2 && null && 3 ); // null

From 43565c17a5111aadfd778da253327d67857cd53f Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 11 May 2023 15:57:22 +0300
Subject: [PATCH 07/29] 11-logical-operators finish translation for article.md

---
 .../11-logical-operators/article.md           | 50 +++++++++----------
 1 file changed, 24 insertions(+), 26 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 8fe3fdfe8..6e3e0fde3 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -202,87 +202,85 @@ alert( null && 5 ); // null
 alert( 0 && "orice s-ar întâmpla" ); // 0
 ```
 
-<!-- We can also pass several values in a row. See how the first falsy one is returned: -->
-De asemenea, putem oferi mai multe valori în același timp. Observați cum prima valoare falsy este returnată:
-<!-- Mai verifică puțin traducerea de mai sus -->
+De asemenea, pot fi folosite mai multe valori simultan. Observați cum prima valoare falsy este returnată:
 
 ```js run
 alert( 1 && 2 && null && 3 ); // null
 ```
 
-When all values are truthy, the last value is returned:
+Dacă toate valorile sunt truthy, ultima dintre ele este returnată:
 
 ```js run
-alert( 1 && 2 && 3 ); // 3, the last one
+alert( 1 && 2 && 3 ); // 3, ultima
 ```
 
-````smart header="Precedence of AND `&&` is higher than OR `||`"
-The precedence of AND `&&` operator is higher than OR `||`.
+````smart header="Prioritatea lui ȘI `&&` este mai mare decât cea a lui ORI `||`"
+Prioritatea operatorului ȘI `&&` este mai mare față de ce a lui ORI `||`.
 
-So the code `a && b || c && d` is essentially the same as if the `&&` expressions were in parentheses: `(a && b) || (c && d)`.
+Astfel, codul `a && b || c && d` este în esență exact la fel cu folosirea operatorului `&&` între paranteze: `(a && b) || (c && d)`.
 ````
 
-````warn header="Don't replace `if` with `||` or `&&`"
-Sometimes, people use the AND `&&` operator as a "shorter way to write `if`".
+````warn header="Nu înlocuiți `if` cu `||` sau `&&`"
+Uneori, oamenii folosesc operatorul ȘI `&&` pentru a scrie o formă mai scurtă de `if` statement.
 
-For instance:
+De exemplu:
 
 ```js run
 let x = 1;
 
-(x > 0) && alert( 'Greater than zero!' );
+(x > 0) && alert( 'Mai mare decât zero!' );
 ```
 
-The action in the right part of `&&` would execute only if the evaluation reaches it. That is, only if `(x > 0)` is true.
+Alerta din partea dreaptă a lui `&&` ajugne să fie executată doar dacă evaluarea ajunge până la ea. Adică, doar dacă if `(x > 0)` este true.
 
-So we basically have an analogue for:
+Astfel echivalentul este:
 
 ```js run
 let x = 1;
 
-if (x > 0) alert( 'Greater than zero!' );
+if (x > 0) alert( 'Mai mare decât zero!' );
 ```
 
-Although, the variant with `&&` appears shorter, `if` is more obvious and tends to be a little bit more readable. So we recommend using every construct for its purpose: use `if` if we want `if` and use `&&` if we want AND.
+Deși, varianta cu `&&` pare a fi mai scurtă, varianta cu `if` statement este mai evidentă și mai ușor de citit. Așa că, recomandarea noastră este ca fiecare construcție să fie folosită pentru propriul scop: folosim `if` dacă vreum un `if` statement și folosit `&&` dacă avem nevoie de operatorul ȘI.
 ````
 
 
 ## ! (NOT)
 
-The boolean NOT operator is represented with an exclamation sign `!`.
+Operatorul boolean NU este reprezentat printrun semn de exclamare.
 
-The syntax is pretty simple:
+Sintaxa este destul de simplă:
 
 ```js
 result = !value;
 ```
 
-The operator accepts a single argument and does the following:
+Operatorul acceptă un singur argument și face umrătoarele lucruri:
 
-1. Converts the operand to boolean type: `true/false`.
-2. Returns the inverse value.
+1. Convertește operantul într-un boolean de tipul: `true/false`.
+2. Returnează valoarea opusă.
 
-For instance:
+Spre exemplu:
 
 ```js run
 alert( !true ); // false
 alert( !0 ); // true
 ```
 
-A double NOT `!!` is sometimes used for converting a value to boolean type:
+Dublu NU `!!` poate fi folosit uneori pentru a converti o valoare într-un boolean.
 
 ```js run
 alert( !!"non-empty string" ); // 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.
+Adică, primul NU convertește valoare într-un boolean și returnează valoarea opusă, iar cel de al doilea NU inversează valoarea din nou. În final, obținem o conversie de la o valoare la un boolean.
 
-There's a little more verbose way to do the same thing -- a built-in `Boolean` function:
+Există o metodă special concepută pentru acest lucru -- o funcție `Boolean` concepută expres pentru acesastă necesitate.
 
 ```js run
 alert( Boolean("non-empty string") ); // true
 alert( Boolean(null) ); // false
 ```
 
-The precedence of NOT `!` is the highest of all logical operators, so it always executes first, before `&&` or `||`.
+Prioritatea lui NU `!` este cea mai mare dintre toți operatorii logici, fiind executat mereu primul, înaintea lui `&&` sau `||`.
\ No newline at end of file

From 5531ae1c878840abf6be6c5e8714dd4c7d935745 Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 11 May 2023 15:59:23 +0300
Subject: [PATCH 08/29] small change

---
 1-js/02-first-steps/11-logical-operators/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 6e3e0fde3..cfd265386 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -245,7 +245,7 @@ Deși, varianta cu `&&` pare a fi mai scurtă, varianta cu `if` statement este m
 ````
 
 
-## ! (NOT)
+## ! (NU)
 
 Operatorul boolean NU este reprezentat printrun semn de exclamare.
 

From a0d0439be9e9580e837234d272c70fc6f146bd3a Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 11 May 2023 16:04:08 +0300
Subject: [PATCH 09/29] 1-alert-null-2-undefined finish translation

---
 .../11-logical-operators/1-alert-null-2-undefined/solution.md | 2 +-
 .../11-logical-operators/1-alert-null-2-undefined/task.md     | 4 ++--
 2 files changed, 3 insertions(+), 3 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..b23c7dc31 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.
+Răpunsul este `2`, aceasta este prima valoare truthy.
 
 ```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..1ed991a42 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?
+# Care este rezultatul lui ORI?
 
-What is the code below going to output?
+Care va fi output-ul codului de mai jos?
 
 ```js
 alert( null || 2 || undefined );

From ad93b73ac1de4e8bd1fb1f1f0fa2696722315eb5 Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 11 May 2023 16:16:36 +0300
Subject: [PATCH 10/29] 2-alert-or finish translation

---
 .../11-logical-operators/2-alert-or/solution.md      | 12 ++++++------
 .../11-logical-operators/2-alert-or/task.md          |  4 ++--
 2 files changed, 8 insertions(+), 8 deletions(-)

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 f85b56366..ecf563a17 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`.
+Răspunsul este: prima dată `1`, apoi `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`.
+Metoda `alert` nu întoarce o valoare. Prin alte cuvinte, întoarce `undefined`.
 
-1. The first OR `||` evaluates its 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. Primul ORI `||` evaluează operantul din stânga sa `alert(1)`. Acesta afișează primul mesaj cu `1`.
+2. `alert` întoarce `undefined`, prin urmare, ORI merge la cel de al doilea operant, deaorece caută o valoare truthy. 
+3. Cel de al doilea operant `2` este truthy, așa că execuția este oprită, `2` este returnat fiind afișat de către `alert`-ul  exterior.
 
-There will be no `3`, because the evaluation does not reach `alert(3)`.
+`3` nu va fi afișat, deoarece evaluarea nu ajunge la `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..d5a9b5c36 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?
+# Care este rezultatul alertelor combinate prin ORI?
 
-What will the code below output?
+Care va vi output-ul codului de mai jos?
 
 ```js
 alert( alert(1) || 2 || alert(3) );

From 47660e708bd463107556fe9dd5282ef07d413fc5 Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 11 May 2023 16:22:21 +0300
Subject: [PATCH 11/29] 3-alert-1-null-2 finish translation

---
 .../11-logical-operators/3-alert-1-null-2/solution.md         | 2 +-
 .../11-logical-operators/3-alert-1-null-2/task.md             | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

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..28e6bf205 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.
+Răspunsul: `null`, deoarece este prin valoare falsy din șir.
 
 ```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..757e3b98a 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?
+# Care este rezultatul lui ȘI?
 
-What is this code going to show?
+Ce va afișa codul de mai jos?
 
 ```js
 alert( 1 && null && 2 );

From 1e59490ec1d841347ac70801913cadf40bd73dcc Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 11 May 2023 16:29:22 +0300
Subject: [PATCH 12/29] 4-alert-and finish translation

---
 .../11-logical-operators/4-alert-and/solution.md           | 7 +++----
 .../11-logical-operators/4-alert-and/task.md               | 4 ++--
 2 files changed, 5 insertions(+), 6 deletions(-)

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..cc893ffe2 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,9 @@
-The answer: `1`, and then `undefined`.
+Răspunsul: `1`, iar apoi `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).
-
-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.
+Metoda `alert` întoarce `undefined` (afișează doar un mesaj, deci nu întoarce nimic semnificativ).
 
+Din cauza aceasta, `&&` evaluează operantul din stânga (output-ul `1`), și oprește imediat evaluarea, deoarece `undefined` este o valoare falsy. `&&` caută o valoare falsy și o întoarce, așadar procesul este finalizat.
\ No newline at end of file
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..c04d37215 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?
+# Care este rezultatul alertelor combinate cu ȘI?
 
-What will this code show?
+Ce va afișa codul de mai jos?
 
 ```js
 alert( alert(1) && alert(2) );

From 086f19298b0096641d19e7cdcc03149400f1616b Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 11 May 2023 16:35:20 +0300
Subject: [PATCH 13/29] 5-alert-and-or finish translation

---
 .../11-logical-operators/5-alert-and-or/solution.md    | 10 +++++-----
 .../11-logical-operators/5-alert-and-or/task.md        |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

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..a9de7a24d 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`.
+Răspunsul este: `3`
 
 ```js run
 alert( null || 2 && 3 || 4 );
 ```
 
-The precedence of AND `&&` is higher than `||`, so it executes first.
+<!-- The precedence of AND `&&` is higher than `||`, so it executes first. -->
+Prioritatea lui ȘI `&&` este mai mare decât cea a lui ORI `||`, așa că `&&` executat primul.
 
-The result of `2 && 3 = 3`, so the expression becomes:
+Rezultatul lui `2 && 3 = 3`, așa că expresia devine:
 
 ```
 null || 3 || 4
 ```
 
-Now the result is the first truthy value: `3`.
-
+În acest caz, rezultatul este prima valoare truthy: `3`.
\ No newline at end of file
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..5b202ba73 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
+# Rezultatul lui ORI ȘI ORI
 
-What will the result be?
+Care va fi rezultatul?
 
 ```js
 alert( null || 2 && 3 || 4 );

From ecc18751fd6bd6302ab35f9979d22a73823915ac Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 11 May 2023 16:42:01 +0300
Subject: [PATCH 14/29] 6-check-if-in-range finish translation

---
 .../11-logical-operators/6-check-if-in-range/task.md        | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

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 fc9e336c1..2f4aef21a 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
+# Verificați interval dintre
 
-Write an `if` condition to check that `age` is between `14` and `90` inclusively.
+Scrie of condiție `if` care verifică dacă `age` se încadrează între valorile `14` și `90`, inclusiv. 
 
-"Inclusively" means that `age` can reach the edges `14` or `90`.
+”Inclusiv” înseamnă că `age` poate fi de asemenea și `14` sau `90`.

From 41589526f498e0eafcd695e7869ffdb292ce7c6b Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 11 May 2023 16:59:35 +0300
Subject: [PATCH 15/29] 7-check-if-out-range

---
 .../11-logical-operators/7-check-if-out-range/solution.md   | 4 ++--
 .../11-logical-operators/7-check-if-out-range/task.md       | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

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..192f50fa1 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:
+Prima variantă:
 
 ```js
 if (!(age >= 14 && age <= 90))
 ```
 
-The second variant:
+A doua 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 9b947d00f..f958b387e 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
+# Verifică intervalul din afara.
 
-Write an `if` condition to check that `age` is NOT between `14` and `90` inclusively.
+Scrie o condiție `if` care verifică dacă `age` nu este cuprins înte `14` și `90`, inclusiv. 
 
-Create two variants: the first one using NOT `!`, the second one -- without it.
+Creează două variante: în prima să folosești NU `!`, iar ceea de-a doua nu.
\ No newline at end of file

From 35dda727a0aa592391c140680fdf2d94b07abd17 Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Thu, 11 May 2023 17:00:28 +0300
Subject: [PATCH 16/29] small corection

---
 .../11-logical-operators/7-check-if-out-range/task.md           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 f958b387e..e361c3fae 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
 
 Scrie o condiție `if` care verifică dacă `age` nu este cuprins înte `14` și `90`, inclusiv. 
 
-Creează două variante: în prima să folosești NU `!`, iar ceea de-a doua nu.
\ No newline at end of file
+Creează două variante: în prima să folosești NU `!`, iar în ceea de-a doua nu.
\ No newline at end of file

From 9cd16a48e1f491dbc41df23314551f3a541380a2 Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Fri, 12 May 2023 15:16:44 +0300
Subject: [PATCH 17/29] 8-if-question finish translation

---
 .../8-if-question/solution.md                 | 22 +++++++++----------
 .../8-if-question/task.md                     | 12 +++++-----
 2 files changed, 17 insertions(+), 17 deletions(-)

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..8a9a29b57 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.
+Răspuns: primul și al treilea vor fi afișate.
 
-Details:
+Detalii:
 
 ```js run
-// Runs.
-// The result of -1 || 0 = -1, truthy
-if (-1 || 0) alert( 'first' );
+// Este executat.
+// Rezultatul dintre -1 || 0 = -1, truthy
+if (-1 || 0) alert( 'primul' );
 
-// Doesn't run
+// Nu este executat
 // -1 && 0 = 0, falsy
-if (-1 && 0) alert( 'second' );
+if (-1 && 0) alert( 'al doilea' );
 
-// Executes
-// Operator && has a higher precedence than ||
-// so -1 && 1 executes first, giving us the chain:
+// Este executat
+// Oparatorul && are o primoritate mai mare decât ||
+// așadar -1 && 1 este exuctat mai întâi, dând lanțul următor:
 // null || -1 && 1  ->  null || 1  ->  1
-if (null || -1 && 1) alert( 'third' );
+if (null || -1 && 1) alert( 'al treilea' );
 ```
 
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..9d883cd63 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"
+# O întrebare despre "if"
 
-Which of these `alert`s are going to execute?
+Care dintre următoarele `alert`-uri va fi executată.
 
-What will the results of the expressions be inside `if(...)`?
+Care va fi rezultatul expresiei din interiorul lui `if(...)`?
 
 ```js
-if (-1 || 0) alert( 'first' );
-if (-1 && 0) alert( 'second' );
-if (null || -1 && 1) alert( 'third' );
+if (-1 || 0) alert( 'primul' );
+if (-1 && 0) alert( 'al doilea' );
+if (null || -1 && 1) alert( 'al treilea' );
 ```
 

From 24572f092e395574911f0e2659fc5f3b0ce04bcb Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Fri, 12 May 2023 15:55:51 +0300
Subject: [PATCH 18/29] 9-check-login finish translation

---
 .../9-check-login/solution.md                 |  2 +-
 .../9-check-login/task.md                     | 20 +++++++++----------
 2 files changed, 11 insertions(+), 11 deletions(-)

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 604606259..1a70edf92 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
@@ -22,4 +22,4 @@ if (userName === 'Admin') {
 }
 ```
 
-Note the vertical indents inside the `if` blocks. They are technically not required, but make the code more readable.
+Observați indentările din interiorul blocului `if`. Acesta nu sunt neapărat necesare, dar fac codul mult mai lizibil.x 
\ No newline at end of file
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 290a52642..2c072fb07 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
+# Verificați login-ul
 
-Write the code which asks for a login with `prompt`.
+Scrieți codul care necesită logare cu `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".
+Dacă vizitatorul introduce `"Admin"`, atunci `prompt` pentru o parolă, dacă inputul este gol sau `key:Esc` -- afișați "Anulat", dacă este un alt string -- afișați "Nu te cunosc".
 
-The password is checked as follows:
+Parola este verificată după cum umrmează:
 
-- If it equals "TheMaster", then show "Welcome!",
-- Another string -- show "Wrong password",
-- For an empty string or cancelled input, show "Canceled"
+- Dacă inputul este egal cu "TheMaster", atunci afișează "Welcome!",
+- Dacă este un alt string -- afișează "Wrong password"
+- Dacă este un string gol sau inputul este anulat, afișează "Canceled"
 
-The schema:
+Schema:
 
 ![](ifelse_task.svg)
 
-Please use nested `if` blocks. Mind the overall readability of the code.
+Vă rugăm folosiți blocuri `if` încorporate. Aveți în vedere lizibilitatea generală a codului.
 
-Hint:  passing an empty input to a prompt returns an empty string `''`. Pressing `key:ESC` during a prompt returns `null`.
+Sugestie: transmiterea unui input gol în timpul unui promt returnează un string gol `''`. Apăsarea tastei `key:ESC` în timpul unui promt returnează `null`.
 
 [demo]

From 3af9522b302b766fae805d0b1749b936c3f4aa59 Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Sat, 13 May 2023 15:28:37 +0300
Subject: [PATCH 19/29] 11-logical-operator article.md checking mistakes

---
 .../11-logical-operators/article.md           | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 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 cfd265386..60c5421e3 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -13,11 +13,11 @@ Simbolul pentru operatorul „ORI” este reprezentat prin două linii verticale
 ```js
 result = a || b;
 ```
-În programarea clasică, operatorul logic „ORI” este folosit pentru a manipula doar valori de tip boolean. Dacă valoarea unuia dintre argumente este `true`, rezultatul operației va fi `true`, în caz contrar rezultatul va fi `false`.
+În programarea clasică, operatorul logic „ORI” este folosit pentru a manipula doar valori de tip boolean. Dacă valoarea unuia dintre argumentele acestuia este `true`, rezultatul operației va fi `true`, în caz contrar rezultatul va fi `false`.
 
-În JavaScript, acest operator este puțin mai complex, dar mult mai eficient. Pentru început, haideți să vedem ce se întâmplă cu aceste valori de tip boolean. 
+În JavaScript, acest operator este puțin mai complex, dar și mult mai eficient. Pentru început, haideți să vedem ce se întâmplă cu aceste valori de tip boolean. 
 
-Pot fi posibile doar patru combinații logice.
+Pot fi posibile doar patru combinații.
 
 ```js run
 alert( true || true );   // true
@@ -28,9 +28,9 @@ alert( false || false ); // false
 
 După cum putem vedea, rezultat este mereu `true` cu excepția cazului în care ambii operanți au valoarea `false`.
 
-Dacă un operant nu este de tip boolean, acesta este convertit automat pentru evaluare.
+Dacă un operant nu este de tip boolean, acesta este convertit automat pentru a putea fi evaluat.
 
-De exemplu, numărul `1` este tratat ca fiind `true`, iar numărul `0` este `false`:
+De exemplu, numărul `1` este `true`, iar numărul `0` este `false`:
 
 ```js run
 if (1 || 0) { // funcționează asemenea if( true || false )
@@ -38,7 +38,7 @@ if (1 || 0) { // funcționează asemenea if( true || false )
 }
 ```
 
-De cele mai multe ori, semnul ORI `||` este folosit într-un if statement pentru a testa dacă vreauna dintre condiții este `true`.
+De cele mai multe ori, semnul ORI `||` este folosit într-un `if` statement pentru a testa dacă vreauna dintre condiții este `true`.
 
 Spre exemplu:
 
@@ -65,9 +65,9 @@ if (hour < 10 || hour > 18 || isWeekend) {
 
 ## ORI "||" identifică prima valoare truthy [#or-finds-the-first-truthy-value]
 
-Logica descrisă mai sus este oarecum cea basic. Haideți să discutăm despre calitățile „extra” din JavaScript.  
+Logica descrisă mai sus este oarecum una de bază. Haideți să discutăm despre calitățile „extra” din JavaScript.  
 
-Algoritmul extinds funcționează după cum urmează.
+Algoritmul extins funcționează după cum urmează.
 
 Sunt date mai multe valori ale lui ORI.
 
@@ -79,7 +79,7 @@ Operatorul ORI `||` face următoarele lucruri:
 
 - Evaluzează operanții de la stânga spre dreapta.
 - Fiecare operant este convertit într-o valoare boolean. Dacă rezultatul este `true`, execuția este oprită și valoarea originală a acelui operant este returnată.
-- Dacă toți operanții au fost evaluați (iar toți erau falși), ultimul operant este returnat.
+- Dacă toți operanții au fost evaluați (iar toți erau `false`), ultimul operant este returnat.
 
 O valoare este returnată în forma ei originală, fără conversiune.
 
@@ -96,11 +96,11 @@ alert( null || 0 || 1 ); // 1 (prima valoare truthy)
 alert( undefined || null || 0 ); // 0 (toate valorile sunt falsy, ultima valoare este returnată)
 ```
 
-Asta conduce la utilizări mai interesante față de cele calsice în care operatorul ORI compară doar valori pur booleene.
+Asta conduce la utilizări mai interesante față de cele clasice în care operatorul ORI compară doar valori boolean.
 
 1. **Obținerea primei valori truthy dintr-o listă de variabile sau expresii.**
 
-    Spre exemplu, avem variabilele `firstName`, `lastName` si `nickName`, toate opționale (adică valoarea lor poate fi undefined sau falsy)
+    Spre exemplu, avem variabilele `firstName`, `lastName` și `nickName`, toate opționale (adică valoarea lor poate fi undefined sau falsy)
 
     Haideți să folosim operatorul ORI `||` pentru a identifica variabila truthy și să folosim conținutul acesteia (sau `"Anonim"` în caz contrar):
 
@@ -124,7 +124,7 @@ Asta conduce la utilizări mai interesante față de cele calsice în care opera
 
     Importanța acestei caracteristici începe să devină evidentă în momentul în care unul dintre operanți nu conține doar o valoare, ci o expresie care aduce cu sine și un efect advers, cum ar fi atribuirea valorii unei variabile sau invocarea unei funcții. 
 
-    Pentru exemplul de mai jos, doar al doilea mesaj este printat:
+    Pentru exemplul de mai jos, doar al doilea mesaj este afișat:
 
     ```js run no-beautify
     *!*true*/!* || alert("Acest mesaj nu este printat!");
@@ -158,7 +158,7 @@ let hour = 12;
 let minute = 30;
                  
 if (hour == 12 && minute == 30) {
-  alert( 'The time is 12:30' );
+  alert( 'Este ora 12:30' );
 }
 ```
 
@@ -186,7 +186,7 @@ Operatorul ȘI `&&` face următoarele lucruri:
 
 Cu alte cuvinte, operatorul ȘI are ca rezultat prima valoare falsy sau ultima valoare dacă niciuna nu este falsy.
 
-Regulile de mai sus sunt similare și pentru ORI. Diferența constă în faputl că ȘI are ca rezultat prima valoare *falsy* în timp ce ORI are ca rezultat prima valoare *truthy*.
+Regulile de mai sus sunt similare și pentru ORI. Diferența constă în faptul că ȘI are ca rezultat prima valoare *falsy* în timp ce ORI are ca rezultat prima valoare *truthy*.
 
 Exemple:
 
@@ -231,7 +231,7 @@ let x = 1;
 (x > 0) && alert( 'Mai mare decât zero!' );
 ```
 
-Alerta din partea dreaptă a lui `&&` ajugne să fie executată doar dacă evaluarea ajunge până la ea. Adică, doar dacă if `(x > 0)` este true.
+Metoda alert din partea dreaptă a lui `&&` ajugne să fie executată doar dacă evaluarea ajunge până la ea. Adică, doar dacă if `(x > 0)` este true.
 
 Astfel echivalentul este:
 

From d35c1d2dd6831f400baab76ecc687f3b003fef58 Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Sat, 13 May 2023 15:41:09 +0300
Subject: [PATCH 20/29] 11-logical-operators checking mistakes in tasks folders

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

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 ecf563a17..65649a456 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,10 +1,10 @@
-Răspunsul este: prima dată `1`, apoi `2`.
+Răspunsul este: prima dată `1`, iar apoi `2`.
 
 ```js run
 alert( alert(1) || 2 || alert(3) );
 ```
 
-Metoda `alert` nu întoarce o valoare. Prin alte cuvinte, întoarce `undefined`.
+Metoda `alert` nu returnează o valoare. Prin alte cuvinte, returnează `undefined`.
 
 1. Primul ORI `||` evaluează operantul din stânga sa `alert(1)`. Acesta afișează primul mesaj cu `1`.
 2. `alert` întoarce `undefined`, prin urmare, ORI merge la cel de al doilea operant, deaorece caută o valoare truthy. 
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 d5a9b5c36..f30bc24b8 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
 
 ---
 
-# Care este rezultatul alertelor combinate prin ORI?
+# Care este rezultatul metodelor de tip alert combinate prin ORI?
 
 Care va vi output-ul codului de mai jos?
 
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 c04d37215..81fca80da 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,7 +2,7 @@ importance: 3
 
 ---
 
-# Care este rezultatul alertelor combinate cu ȘI?
+# Care este rezultatul metodelor de tip aler combinate cu ȘI?
 
 Ce va afișa codul de mai jos?
 
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 a9de7a24d..1dc27eb29 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,6 @@ Răspunsul este: `3`
 alert( null || 2 && 3 || 4 );
 ```
 
-<!-- The precedence of AND `&&` is higher than `||`, so it executes first. -->
 Prioritatea lui ȘI `&&` este mai mare decât cea a lui ORI `||`, așa că `&&` executat primul.
 
 Rezultatul lui `2 && 3 = 3`, așa că expresia devine:
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 5b202ba73..c1fbe2f4d 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
 
 ---
 
-# Rezultatul lui ORI ȘI ORI
+# Rezultatul dintre ORI ȘI ORI
 
 Care va fi rezultatul?
 
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 2f4aef21a..356789c2b 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,7 +2,7 @@ importance: 3
 
 ---
 
-# Verificați interval dintre
+# Verificați intervalul dintre
 
 Scrie of condiție `if` care verifică dacă `age` se încadrează între valorile `14` și `90`, inclusiv. 
 
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 e361c3fae..e7a73341a 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
 
 Scrie o condiție `if` care verifică dacă `age` nu este cuprins înte `14` și `90`, inclusiv. 
 
-Creează două variante: în prima să folosești NU `!`, iar în ceea de-a doua nu.
\ No newline at end of file
+Creează două variante: în prima să folosești NU `!`, iar în ceea de-a doua să nu.
\ No newline at end of file
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 8a9a29b57..15334b45f 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
@@ -12,7 +12,7 @@ if (-1 || 0) alert( 'primul' );
 if (-1 && 0) alert( 'al doilea' );
 
 // Este executat
-// Oparatorul && are o primoritate mai mare decât ||
+// Oparatorul && are o prioritate mai mare decât ||
 // așadar -1 && 1 este exuctat mai întâi, dând lanțul următor:
 // null || -1 && 1  ->  null || 1  ->  1
 if (null || -1 && 1) alert( 'al treilea' );
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 9d883cd63..53dfdb7e1 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
@@ -4,7 +4,7 @@ importance: 5
 
 # O întrebare despre "if"
 
-Care dintre următoarele `alert`-uri va fi executată.
+Care dintre următoarele metode `alert` va fi executată.
 
 Care va fi rezultatul expresiei din interiorul lui `if(...)`?
 
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 1a70edf92..c740650e1 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
@@ -22,4 +22,4 @@ if (userName === 'Admin') {
 }
 ```
 
-Observați indentările din interiorul blocului `if`. Acesta nu sunt neapărat necesare, dar fac codul mult mai lizibil.x 
\ No newline at end of file
+Observați indentările din interiorul blocului `if`. Acesta nu sunt neapărat necesare, dar fac codul mult mai lizibil.
\ No newline at end of file
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 2c072fb07..4bdf1feb6 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
@@ -4,9 +4,9 @@ importance: 3
 
 # Verificați login-ul
 
-Scrieți codul care necesită logare cu `prompt`.
+Scrieți un bloc de cod care necesită logare prin `prompt`.
 
-Dacă vizitatorul introduce `"Admin"`, atunci `prompt` pentru o parolă, dacă inputul este gol sau `key:Esc` -- afișați "Anulat", dacă este un alt string -- afișați "Nu te cunosc".
+Dacă vizitatorul introduce `"Admin"`, atunci `prompt` pentru o parolă, dacă inputul este gol sau `key:Esc` -- afișați "Anulat", dacă este un alt string -- afișați "I don't know you".
 
 Parola este verificată după cum umrmează:
 
@@ -14,12 +14,12 @@ Parola este verificată după cum umrmează:
 - Dacă este un alt string -- afișează "Wrong password"
 - Dacă este un string gol sau inputul este anulat, afișează "Canceled"
 
-Schema:
+Schemă:
 
 ![](ifelse_task.svg)
 
-Vă rugăm folosiți blocuri `if` încorporate. Aveți în vedere lizibilitatea generală a codului.
+Vă rugăm folosiți blocuri `if` indentate. Aveți în vedere lizibilitatea generală a codului.
 
-Sugestie: transmiterea unui input gol în timpul unui promt returnează un string gol `''`. Apăsarea tastei `key:ESC` în timpul unui promt returnează `null`.
+Sugestie: transmiterea unui input către un `prompt` returnează un string gol `''`. Apăsarea tastei `key:ESC` returnează `null`.
 
 [demo]

From 4cb2e1ae7ddda7e590c58a05d7276ba8f6a4f38d Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Sat, 8 Jul 2023 09:21:36 +0300
Subject: [PATCH 21/29] implementing the changes requested

---
 .../1-alert-null-2-undefined/task.md                   |  2 +-
 .../11-logical-operators/2-alert-or/solution.md        | 10 +++++-----
 .../11-logical-operators/2-alert-or/task.md            |  2 +-
 .../11-logical-operators/3-alert-1-null-2/solution.md  |  2 +-
 .../11-logical-operators/3-alert-1-null-2/task.md      |  2 +-
 .../11-logical-operators/4-alert-and/task.md           |  4 ++--
 .../11-logical-operators/5-alert-and-or/solution.md    |  6 +++---
 .../11-logical-operators/5-alert-and-or/task.md        |  2 +-
 .../11-logical-operators/6-check-if-in-range/task.md   |  4 ++--
 .../11-logical-operators/7-check-if-out-range/task.md  |  6 +++---
 .../11-logical-operators/8-if-question/solution.md     |  2 +-
 .../11-logical-operators/9-check-login/task.md         | 10 +++++-----
 12 files changed, 26 insertions(+), 26 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 1ed991a42..ae44926de 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
 
 ---
 
-# Care este rezultatul lui ORI?
+# Care este rezultatul lui OR?
 
 Care va fi output-ul codului de mai jos?
 
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 65649a456..01592c472 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 @@
-Răspunsul este: prima dată `1`, iar apoi `2`.
+Răspunsul: prima dată `1`, iar apoi `2`.
 
 ```js run
 alert( alert(1) || 2 || alert(3) );
 ```
 
-Metoda `alert` nu returnează o valoare. Prin alte cuvinte, returnează `undefined`.
+Apelul către `alert` nu returnează o valoare. Sau, prin alte cuvinte, returnează `undefined`.
 
-1. Primul ORI `||` evaluează operantul din stânga sa `alert(1)`. Acesta afișează primul mesaj cu `1`.
-2. `alert` întoarce `undefined`, prin urmare, ORI merge la cel de al doilea operant, deaorece caută o valoare truthy. 
-3. Cel de al doilea operant `2` este truthy, așa că execuția este oprită, `2` este returnat fiind afișat de către `alert`-ul  exterior.
+1. Primul OR `||` evaluează operantul din stânga sa `alert(1)`. Aceasta afișează primul mesaj cu `1`. 
+2. `alert` întoarce `undefined`, așa că OR merge la al doilea operand căutând o valoare truthy.
+3. Cel de al doilea operand `2` este truthy, așa că execuția este oprită, `2` este returnat fiind afișat de către `alert`-ul  exterior.
 
 `3` nu va fi afișat, deoarece evaluarea nu ajunge la `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 f30bc24b8..fa03295ba 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
 
 ---
 
-# Care este rezultatul metodelor de tip alert combinate prin ORI?
+# Care este rezultatul alertelor combinate prin OR?
 
 Care va vi output-ul codului de mai jos?
 
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 28e6bf205..d8e19deee 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 @@
-Răspunsul: `null`, deoarece este prin valoare falsy din șir.
+Răspunsul: `null`, deoarece este prima valoare falsy din listă.
 
 ```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 757e3b98a..311598b22 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
 
 ---
 
-# Care este rezultatul lui ȘI?
+# Care este rezultatul lui AND?
 
 Ce va afișa codul de mai jos?
 
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 81fca80da..b58746694 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
 
 ---
 
-# Care este rezultatul metodelor de tip aler combinate cu ȘI?
+# Care este rezultatul alertelor combinate cu AND?
 
-Ce va afișa codul de mai jos?
+Ce va afișa acest cod?
 
 ```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 1dc27eb29..dec57c243 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,10 +1,10 @@
-Răspunsul este: `3`
+Răspunsul: `3`.
 
 ```js run
 alert( null || 2 && 3 || 4 );
 ```
 
-Prioritatea lui ȘI `&&` este mai mare decât cea a lui ORI `||`, așa că `&&` executat primul.
+Prioritatea lui AND `&&` este mai mare decât cea a lui OR `||`, așa că se execută primul.
 
 Rezultatul lui `2 && 3 = 3`, așa că expresia devine:
 
@@ -12,4 +12,4 @@ Rezultatul lui `2 && 3 = 3`, așa că expresia devine:
 null || 3 || 4
 ```
 
-În acest caz, rezultatul este prima valoare truthy: `3`.
\ No newline at end of file
+Acum rezultatul este prima valoare truthy: `3`.
\ No newline at end of file
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 c1fbe2f4d..3efe5f5c1 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
 
 ---
 
-# Rezultatul dintre ORI ȘI ORI
+# Rezultatul lui OR AND OR
 
 Care va fi rezultatul?
 
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 356789c2b..c10e5cb30 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
 
 # Verificați intervalul dintre
 
-Scrie of condiție `if` care verifică dacă `age` se încadrează între valorile `14` și `90`, inclusiv. 
+Scrie o condiție `if` care verifică dacă `age` se încadrează între valorile `14` și `90` inclusiv.
 
-”Inclusiv” înseamnă că `age` poate fi de asemenea și `14` sau `90`.
+"Inclusiv" înseamnă că `age` poate fi de asemenea `14` sau `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 e7a73341a..969676f4e 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
 
 ---
 
-# Verifică intervalul din afara.
+# Verifică intervalul din afară
 
-Scrie o condiție `if` care verifică dacă `age` nu este cuprins înte `14` și `90`, inclusiv. 
+Scrie o condiție `if` care verifică dacă `age` NU este cuprins înte `14` și `90` inclusiv.  
 
-Creează două variante: în prima să folosești NU `!`, iar în ceea de-a doua să nu.
\ No newline at end of file
+Creează două variante: în prima să folosești NOT `!`, iar în ceea de-a doua -- să nu.
\ No newline at end of file
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 15334b45f..77cde5d2c 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,4 +1,4 @@
-Răspuns: primul și al treilea vor fi afișate.
+Răspuns: primul și al treilea se vor executa.
 
 Detalii:
 
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 4bdf1feb6..51b7cc280 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,19 +6,19 @@ importance: 3
 
 Scrieți un bloc de cod care necesită logare prin `prompt`.
 
-Dacă vizitatorul introduce `"Admin"`, atunci `prompt` pentru o parolă, dacă inputul este gol sau `key:Esc` -- afișați "Anulat", dacă este un alt string -- afișați "I don't know you".
+Dacă vizitatorul introduce `"Admin"`, atunci `prompt` pentru o parolă, dacă inputul este gol sau `key:Esc` -- afișați "Anulat", dacă este un alt string -- afișați "Nu te cunosc".
 
 Parola este verificată după cum umrmează:
 
-- Dacă inputul este egal cu "TheMaster", atunci afișează "Welcome!",
-- Dacă este un alt string -- afișează "Wrong password"
-- Dacă este un string gol sau inputul este anulat, afișează "Canceled"
+- Dacă este egal cu "TheMaster", atunci afișează "Welcome!",
+- Dacă este un alt string -- afișează "Parolă greșită",
+- Dacă este un string gol sau inputul este anulat, afișează "Anulat",
 
 Schemă:
 
 ![](ifelse_task.svg)
 
-Vă rugăm folosiți blocuri `if` indentate. Aveți în vedere lizibilitatea generală a codului.
+Vă rugăm folosiți blocuri `if` nested. Aveți în vedere lizibilitatea generală a codului.
 
 Sugestie: transmiterea unui input către un `prompt` returnează un string gol `''`. Apăsarea tastei `key:ESC` returnează `null`.
 

From 042888196b41b3a870c960623dc1bb03c252efaf Mon Sep 17 00:00:00 2001
From: Cr3yZe <addy_czr@yahoo.com>
Date: Fri, 14 Jul 2023 17:42:05 +0300
Subject: [PATCH 22/29] reviewing article and tasks

---
 .../11-logical-operators/article.md           | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 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 60c5421e3..8bad3ae17 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,19 +1,19 @@
 # Operatori logici
 
-În JavaScript există patru operatori logici: `||` (ORI), `&&` (ȘI), `!` (NU), `??` (Nullish Coalescing). În acest articol vorbim doar despre primi trei, operatorul `??` va fi acoperit în următorul articol.
+În JavaScript există patru operatori logici: `||` (OR), `&&` (ȘI), `!` (NU), `??` (Nullish Coalescing). În acest articol vorbim doar despre primi trei, operatorul `??` va fi acoperit în următorul articol.
 
 Chiar dacă sunt denumiți operatori „logici”, aceștia pot fi folosiți pentru valori de orice tip, nu doar pentru cele de tip boolean. Rezultatul acestora putând fi de orice tip. 
 
 Haideți să aflăm mai multe detalii.
 
-## || (ORI)
+## || (OR)
 
-Simbolul pentru operatorul „ORI” este reprezentat prin două linii verticale.
+Simbolul pentru operatorul „OR” este reprezentat prin două linii verticale.
 
 ```js
 result = a || b;
 ```
-În programarea clasică, operatorul logic „ORI” este folosit pentru a manipula doar valori de tip boolean. Dacă valoarea unuia dintre argumentele acestuia este `true`, rezultatul operației va fi `true`, în caz contrar rezultatul va fi `false`.
+În programarea clasică, operatorul logic „OR” este folosit pentru a manipula doar valori de tip boolean. Dacă valoarea unuia dintre argumentele acestuia este `true`, rezultatul operației va fi `true`, în caz contrar rezultatul va fi `false`.
 
 În JavaScript, acest operator este puțin mai complex, dar și mult mai eficient. Pentru început, haideți să vedem ce se întâmplă cu aceste valori de tip boolean. 
 
@@ -38,7 +38,7 @@ if (1 || 0) { // funcționează asemenea if( true || false )
 }
 ```
 
-De cele mai multe ori, semnul ORI `||` este folosit într-un `if` statement pentru a testa dacă vreauna dintre condiții este `true`.
+De cele mai multe ori, semnul OR `||` este folosit într-un `if` statement pentru a testa dacă vreauna dintre condiții este `true`.
 
 Spre exemplu:
 
@@ -63,19 +63,19 @@ if (hour < 10 || hour > 18 || isWeekend) {
 }
 ```
 
-## ORI "||" identifică prima valoare truthy [#or-finds-the-first-truthy-value]
+## OR "||" identifică prima valoare truthy [#or-finds-the-first-truthy-value]
 
 Logica descrisă mai sus este oarecum una de bază. Haideți să discutăm despre calitățile „extra” din JavaScript.  
 
 Algoritmul extins funcționează după cum urmează.
 
-Sunt date mai multe valori ale lui ORI.
+Sunt date mai multe valori ale lui OR.
 
 ```js
 result = value1 || value2 || value3;
 ```
 
-Operatorul ORI `||` face următoarele lucruri:
+Operatorul OR `||` face următoarele lucruri:
 
 - Evaluzează operanții de la stânga spre dreapta.
 - Fiecare operant este convertit într-o valoare boolean. Dacă rezultatul este `true`, execuția este oprită și valoarea originală a acelui operant este returnată.
@@ -83,7 +83,7 @@ Operatorul ORI `||` face următoarele lucruri:
 
 O valoare este returnată în forma ei originală, fără conversiune.
 
-Cu alte cuvinte, într-un lanț de operatori logici ORI `||` este returnată prima valoare truthy sau ultima dacă nicio valoare truthy nu este identificată.
+Cu alte cuvinte, într-un lanț de operatori logici OR `||` este returnată prima valoare truthy sau ultima dacă nicio valoare truthy nu este identificată.
 
 Spre exemplu:
 
@@ -96,13 +96,13 @@ alert( null || 0 || 1 ); // 1 (prima valoare truthy)
 alert( undefined || null || 0 ); // 0 (toate valorile sunt falsy, ultima valoare este returnată)
 ```
 
-Asta conduce la utilizări mai interesante față de cele clasice în care operatorul ORI compară doar valori boolean.
+Asta conduce la utilizări mai interesante față de cele clasice în care operatorul OR compară doar valori boolean.
 
 1. **Obținerea primei valori truthy dintr-o listă de variabile sau expresii.**
 
     Spre exemplu, avem variabilele `firstName`, `lastName` și `nickName`, toate opționale (adică valoarea lor poate fi undefined sau falsy)
 
-    Haideți să folosim operatorul ORI `||` pentru a identifica variabila truthy și să folosim conținutul acesteia (sau `"Anonim"` în caz contrar):
+    Haideți să folosim operatorul OR `||` pentru a identifica variabila truthy și să folosim conținutul acesteia (sau `"Anonim"` în caz contrar):
 
     ```js run
     let firstName = "";
@@ -118,7 +118,7 @@ Asta conduce la utilizări mai interesante față de cele clasice în care opera
 
 2. **Evaluarea de tip scurt circuit.**
 
-    O altă caracteristică a operatorului ORI `||` este așa numita evaluare de tip scurt circuit.
+    O altă caracteristică a operatorului OR `||` este așa numita evaluare de tip scurt circuit.
 
     Aceasta înseamnă că `||` își procesează argumentele până când prima valoare truthy este întâlnită, iar apoi acea valoare este returnată imediat, fără ca celălalt argument să mai fie luat în considerare.
 
@@ -131,7 +131,7 @@ Asta conduce la utilizări mai interesante față de cele clasice în care opera
     *!*false*/!* || alert("Acest mesaj este printat!");
     ```
 
-    În prima linie, operatorul ORI `||` imediat ce întâlnește valoarea `true` oprește evaluarea, astfel încât metoda `alert` nu este executată. 
+    În prima linie, operatorul OR `||` imediat ce întâlnește valoarea `true` oprește evaluarea, astfel încât metoda `alert` nu este executată. 
 
     Uneori, oamenii folosesc această funcție pentru a executa comenzi doar dacă condiția din partea stângă este falsy.
 ## && (ȘI)

From 6be161abbf4ed9e91eb55997cf2372a42253f5c2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bogdan=20Baco=C8=99c=C4=83?= <bogdanbacosca@protonmail.com>
Date: Wed, 6 Sep 2023 08:50:32 +0300
Subject: [PATCH 23/29] task 4 solution minor fix

---
 .../11-logical-operators/4-alert-and/solution.md              | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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 cc893ffe2..650d319bc 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
@@ -4,6 +4,6 @@ Răspunsul: `1`, iar apoi `undefined`.
 alert( alert(1) && alert(2) );
 ```
 
-Metoda `alert` întoarce `undefined` (afișează doar un mesaj, deci nu întoarce nimic semnificativ).
+Apelul către `alert` întoarce `undefined` (afișează doar un mesaj, deci nu întoarce nimic semnificativ).
 
-Din cauza aceasta, `&&` evaluează operantul din stânga (output-ul `1`), și oprește imediat evaluarea, deoarece `undefined` este o valoare falsy. `&&` caută o valoare falsy și o întoarce, așadar procesul este finalizat.
\ No newline at end of file
+Din cauza aceasta, `&&` evaluează operantul din stânga (output-ul `1`), și se oprește imediat, deoarece `undefined` este o valoare falsy. Iar `&&` caută o valoare falsy și o întoarce, deci a terminat.
\ No newline at end of file

From 1ff779d9ca2f13a7d4a271fc346efa6367c926d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bogdan=20Baco=C8=99c=C4=83?= <bogdanbacosca@protonmail.com>
Date: Wed, 6 Sep 2023 08:55:54 +0300
Subject: [PATCH 24/29] task 6 minor fix

---
 .../11-logical-operators/6-check-if-in-range/task.md            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 c10e5cb30..ac6b172a1 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
 
 # Verificați intervalul dintre
 
-Scrie o condiție `if` care verifică dacă `age` se încadrează între valorile `14` și `90` inclusiv.
+Scrie o condiție `if` care verifică dacă `age` se încadrează între `14` și `90` inclusiv.
 
 "Inclusiv" înseamnă că `age` poate fi de asemenea `14` sau `90`.

From a7b86ac19710fcb888d6a7f3fa47b8928307ec4b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bogdan=20Baco=C8=99c=C4=83?= <bogdanbacosca@protonmail.com>
Date: Wed, 6 Sep 2023 09:04:20 +0300
Subject: [PATCH 25/29] task 8 minor fix

---
 .../02-first-steps/11-logical-operators/8-if-question/task.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

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 53dfdb7e1..5a68aa1ca 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
@@ -4,9 +4,9 @@ importance: 5
 
 # O întrebare despre "if"
 
-Care dintre următoarele metode `alert` va fi executată.
+Care dintre următoarele `alert`e se vor executa?
 
-Care va fi rezultatul expresiei din interiorul lui `if(...)`?
+Care va fi rezultatul expresiilor din interiorul lui `if(...)`?
 
 ```js
 if (-1 || 0) alert( 'primul' );

From 1475c221eb1d65a350a428744099b9f40052a807 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bogdan=20Baco=C8=99c=C4=83?= <bogdanbacosca@protonmail.com>
Date: Wed, 6 Sep 2023 09:12:39 +0300
Subject: [PATCH 26/29] task 9 minor fixes

---
 .../11-logical-operators/9-check-login/solution.md     |  2 +-
 .../11-logical-operators/9-check-login/task.md         | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

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 c740650e1..d43bd9d31 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
@@ -22,4 +22,4 @@ if (userName === 'Admin') {
 }
 ```
 
-Observați indentările din interiorul blocului `if`. Acesta nu sunt neapărat necesare, dar fac codul mult mai lizibil.
\ No newline at end of file
+Observați indentările verticale din interiorul blocului `if`. Acesta nu sunt neapărat necesare, dar fac codul mult mai lizibil.
\ No newline at end of file
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 51b7cc280..0059dbfd4 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,20 +6,20 @@ importance: 3
 
 Scrieți un bloc de cod care necesită logare prin `prompt`.
 
-Dacă vizitatorul introduce `"Admin"`, atunci `prompt` pentru o parolă, dacă inputul este gol sau `key:Esc` -- afișați "Anulat", dacă este un alt string -- afișați "Nu te cunosc".
+Dacă vizitatorul introduce `"Admin"`, atunci `prompt` pentru o parolă, dacă input-ul este gol sau `key:Esc` -- afișați "Anulat", dacă este un alt string -- atunci afișați "Nu te cunosc".
 
 Parola este verificată după cum umrmează:
 
 - Dacă este egal cu "TheMaster", atunci afișează "Welcome!",
-- Dacă este un alt string -- afișează "Parolă greșită",
-- Dacă este un string gol sau inputul este anulat, afișează "Anulat",
+- Un alt string -- afișează "Parolă greșită",
+- Pentru un string gol sau input-ul este anulat, afișează "Anulat",
 
-Schemă:
+Schema:
 
 ![](ifelse_task.svg)
 
 Vă rugăm folosiți blocuri `if` nested. Aveți în vedere lizibilitatea generală a codului.
 
-Sugestie: transmiterea unui input către un `prompt` returnează un string gol `''`. Apăsarea tastei `key:ESC` returnează `null`.
+Sugestie: transmiterea unui input gol către un `prompt` returnează un string gol `''`. Apăsând `key:ESC` în timpul unui prompt returnează `null`.
 
 [demo]

From f94decaba9dbf1338a8708cc5e532e7e980040bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bogdan=20Baco=C8=99c=C4=83?= <bogdanbacosca@protonmail.com>
Date: Wed, 6 Sep 2023 09:16:43 +0300
Subject: [PATCH 27/29] minor fixes

---
 1-js/02-first-steps/11-logical-operators/article.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 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 8bad3ae17..7281d8148 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,19 +1,19 @@
 # Operatori logici
 
-În JavaScript există patru operatori logici: `||` (OR), `&&` (ȘI), `!` (NU), `??` (Nullish Coalescing). În acest articol vorbim doar despre primi trei, operatorul `??` va fi acoperit în următorul articol.
+În JavaScript există patru operatori logici: `||` (OR), `&&` (AND), `!` (NOT), `??` (Nullish Coalescing). Aici vorbim doar despre primii trei, operatorul `??` va fi acoperit în următorul articol.
 
-Chiar dacă sunt denumiți operatori „logici”, aceștia pot fi folosiți pentru valori de orice tip, nu doar pentru cele de tip boolean. Rezultatul acestora putând fi de orice tip. 
+Chiar dacă sunt denumiți "logici", aceștia pot fi folosiți pentru valori de orice tip, nu doar pentru cele de tip boolean. Rezultatul acestora putând fi de orice tip. 
 
 Haideți să aflăm mai multe detalii.
 
 ## || (OR)
 
-Simbolul pentru operatorul „OR” este reprezentat prin două linii verticale.
+Simbolul pentru operatorul "OR" este reprezentat prin două linii verticale.
 
 ```js
 result = a || b;
 ```
-În programarea clasică, operatorul logic „OR” este folosit pentru a manipula doar valori de tip boolean. Dacă valoarea unuia dintre argumentele acestuia este `true`, rezultatul operației va fi `true`, în caz contrar rezultatul va fi `false`.
+În programarea clasică, operatorul logic "OR" este folosit pentru a manipula doar valori de tip boolean. Dacă valoarea unuia dintre argumentele acestuia este `true`, rezultatul operației va fi `true`, în caz contrar rezultatul va fi `false`.
 
 În JavaScript, acest operator este puțin mai complex, dar și mult mai eficient. Pentru început, haideți să vedem ce se întâmplă cu aceste valori de tip boolean. 
 
@@ -65,7 +65,7 @@ if (hour < 10 || hour > 18 || isWeekend) {
 
 ## OR "||" identifică prima valoare truthy [#or-finds-the-first-truthy-value]
 
-Logica descrisă mai sus este oarecum una de bază. Haideți să discutăm despre calitățile „extra” din JavaScript.  
+Logica descrisă mai sus este oarecum una de bază. Haideți să discutăm despre calitățile "extra" din JavaScript.  
 
 Algoritmul extins funcționează după cum urmează.
 

From 13c6cb87663c7100146c8f59f2d78c8908a1f1c6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bogdan=20Baco=C8=99c=C4=83?= <bogdanbacosca@protonmail.com>
Date: Wed, 6 Sep 2023 09:37:27 +0300
Subject: [PATCH 28/29] other fixes

---
 .../11-logical-operators/article.md           | 23 ++++++++++---------
 1 file changed, 12 insertions(+), 11 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 7281d8148..2100d7b1e 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -13,6 +13,7 @@ Simbolul pentru operatorul "OR" este reprezentat prin două linii verticale.
 ```js
 result = a || b;
 ```
+
 În programarea clasică, operatorul logic "OR" este folosit pentru a manipula doar valori de tip boolean. Dacă valoarea unuia dintre argumentele acestuia este `true`, rezultatul operației va fi `true`, în caz contrar rezultatul va fi `false`.
 
 În JavaScript, acest operator este puțin mai complex, dar și mult mai eficient. Pentru început, haideți să vedem ce se întâmplă cu aceste valori de tip boolean. 
@@ -30,15 +31,15 @@ După cum putem vedea, rezultat este mereu `true` cu excepția cazului în care
 
 Dacă un operant nu este de tip boolean, acesta este convertit automat pentru a putea fi evaluat.
 
-De exemplu, numărul `1` este `true`, iar numărul `0` este `false`:
+De exemplu, numărul `1` este tratat ca `true`, iar numărul `0` ca `false`:
 
 ```js run
-if (1 || 0) { // funcționează asemenea if( true || false )
-  alert( 'truthy' );
+if (1 || 0) { // funcționează exact ca if( true || false )
+  alert( 'truthy!' );
 }
 ```
 
-De cele mai multe ori, semnul OR `||` este folosit într-un `if` statement pentru a testa dacă vreauna dintre condiții este `true`.
+De cele mai multe ori, OR `||` este folosit într-un `if` statement pentru a testa dacă *vreuna* dintre condițiile date este `true`.
 
 Spre exemplu:
 
@@ -59,13 +60,13 @@ let hour = 12;
 let isWeekend = true;
 
 if (hour < 10 || hour > 18 || isWeekend) {
-  alert( 'Biroul este închis.' ); // este weekend.
+  alert( 'Biroul este închis.' ); // este weekend
 }
 ```
 
 ## OR "||" identifică prima valoare truthy [#or-finds-the-first-truthy-value]
 
-Logica descrisă mai sus este oarecum una de bază. Haideți să discutăm despre calitățile "extra" din JavaScript.  
+Logica descrisă mai sus este oarecum clasică. Haideți să discutăm despre caracteristicile "extra" din JavaScript.
 
 Algoritmul extins funcționează după cum urmează.
 
@@ -75,11 +76,11 @@ Sunt date mai multe valori ale lui OR.
 result = value1 || value2 || value3;
 ```
 
-Operatorul OR `||` face următoarele lucruri:
+Operatorul OR `||` face următoarele:
 
-- Evaluzează operanții de la stânga spre dreapta.
-- Fiecare operant este convertit într-o valoare boolean. Dacă rezultatul este `true`, execuția este oprită și valoarea originală a acelui operant este returnată.
-- Dacă toți operanții au fost evaluați (iar toți erau `false`), ultimul operant este returnat.
+- Evaluzează operanzii de la stânga spre dreapta.
+- Fiecare operand este convertit într-o valoare boolean. Dacă rezultatul este `true`, execuția este oprită și valoarea originală a acelui operand este returnată.
+- Dacă toți operanzii au fost evaluați (iar toți erau `false`), ultimul operant este returnat.
 
 O valoare este returnată în forma ei originală, fără conversiune.
 
@@ -96,7 +97,7 @@ alert( null || 0 || 1 ); // 1 (prima valoare truthy)
 alert( undefined || null || 0 ); // 0 (toate valorile sunt falsy, ultima valoare este returnată)
 ```
 
-Asta conduce la utilizări mai interesante față de cele clasice în care operatorul OR compară doar valori boolean.
+Asta conduce la utilizări mai interesante față de cele pur clasice în care operatorul OR compară doar valori boolean.
 
 1. **Obținerea primei valori truthy dintr-o listă de variabile sau expresii.**
 

From eb6f7e425b718c68e96299a841984bef28399054 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bogdan=20Baco=C8=99c=C4=83?= <bogdanbacosca@protonmail.com>
Date: Wed, 6 Sep 2023 09:49:00 +0300
Subject: [PATCH 29/29] minor fixes

added spacing as in the original article
---
 .../11-logical-operators/article.md           | 24 ++++++++++---------
 1 file changed, 13 insertions(+), 11 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 2100d7b1e..ff21900a5 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -135,7 +135,8 @@ Asta conduce la utilizări mai interesante față de cele pur clasice în care o
     În prima linie, operatorul OR `||` imediat ce întâlnește valoarea `true` oprește evaluarea, astfel încât metoda `alert` nu este executată. 
 
     Uneori, oamenii folosesc această funcție pentru a executa comenzi doar dacă condiția din partea stângă este falsy.
-## && (ȘI)
+
+## && (AND)
 
 Operatorul ȘI este reprezentat de două semne ampersand `&&`:
 
@@ -171,7 +172,8 @@ if (1 && 0) { // evaluat ca true && false
 }
 ```
 
-## ȘI "&&" identifică prima valoare falsy
+
+## AND "&&" identifică prima valoare falsy
 
 Sunt date mai multe valori conectate prin operatorul logic ȘI:
 
@@ -179,7 +181,7 @@ Sunt date mai multe valori conectate prin operatorul logic ȘI:
 result = value1 && value2 && value3;
 ```
 
-Operatorul ȘI `&&` face următoarele lucruri:
+Operatorul AND `&&` face următoarele lucruri:
 
 - Evaluează operanții de la stânga la dreapta.
 - Convertește fiecare operant într-un boolean. Dacă rezultatul este `false`, procesul este oprit, iar valoarea originală a operantului este returnată.
@@ -215,14 +217,14 @@ Dacă toate valorile sunt truthy, ultima dintre ele este returnată:
 alert( 1 && 2 && 3 ); // 3, ultima
 ```
 
-````smart header="Prioritatea lui ȘI `&&` este mai mare decât cea a lui ORI `||`"
-Prioritatea operatorului ȘI `&&` este mai mare față de ce a lui ORI `||`.
+````smart header="Prioritatea lui AND `&&` este mai mare decât cea a lui ORI `||`"
+Prioritatea operatorului AND `&&` este mai mare față de ce a lui ORI `||`.
 
 Astfel, codul `a && b || c && d` este în esență exact la fel cu folosirea operatorului `&&` între paranteze: `(a && b) || (c && d)`.
 ````
 
 ````warn header="Nu înlocuiți `if` cu `||` sau `&&`"
-Uneori, oamenii folosesc operatorul ȘI `&&` pentru a scrie o formă mai scurtă de `if` statement.
+Uneori, oamenii folosesc operatorul AND `&&` pentru a scrie o formă mai scurtă de `if` statement.
 
 De exemplu:
 
@@ -232,7 +234,7 @@ let x = 1;
 (x > 0) && alert( 'Mai mare decât zero!' );
 ```
 
-Metoda alert din partea dreaptă a lui `&&` ajugne să fie executată doar dacă evaluarea ajunge până la ea. Adică, doar dacă if `(x > 0)` este true.
+Acțiunea din partea dreaptă a lui `&&` ajunge să fie executată doar dacă evaluarea ajunge până la ea. Adică, doar dacă if `(x > 0)` este true.
 
 Astfel echivalentul este:
 
@@ -246,9 +248,9 @@ Deși, varianta cu `&&` pare a fi mai scurtă, varianta cu `if` statement este m
 ````
 
 
-## ! (NU)
+## ! (NOT)
 
-Operatorul boolean NU este reprezentat printrun semn de exclamare.
+Operatorul boolean NOT este reprezentat printrun semn de exclamare.
 
 Sintaxa este destul de simplă:
 
@@ -268,7 +270,7 @@ alert( !true ); // false
 alert( !0 ); // true
 ```
 
-Dublu NU `!!` poate fi folosit uneori pentru a converti o valoare într-un boolean.
+Dublu NOT `!!` poate fi folosit uneori pentru a converti o valoare într-un boolean.
 
 ```js run
 alert( !!"non-empty string" ); // true
@@ -284,4 +286,4 @@ alert( Boolean("non-empty string") ); // true
 alert( Boolean(null) ); // false
 ```
 
-Prioritatea lui NU `!` este cea mai mare dintre toți operatorii logici, fiind executat mereu primul, înaintea lui `&&` sau `||`.
\ No newline at end of file
+Prioritatea lui NOT `!` este cea mai mare dintre toți operatorii logici, fiind executat mereu primul, înaintea lui `&&` sau `||`.
\ No newline at end of file