final polish

Translated smart headers and other minor improvements.

Author: bogdanbacosca

1-js/02-first-steps/04-variables/article.md

@@ -53,7 +53,7 @@ De asemenea putem declara multiple variabile într-o singură linie:
 let user = 'John', age = 25, message = 'Bună';
 ```
 
-Asta ar putea să pară mai scurt, dar nu recomandăm. De dragul unei lizibilități mai bune, te rugăm să folosești o singură linie per variabilă.
+Asta ar putea să pară mai scurt, dar nu o recomandăm. De dragul unei lizibilități mai bune, te rugăm să folosești o singură linie per variabilă.
 
 Varianta pe mai multe linii este puțin mai lungă, dar mai ușor de citit:
 
@@ -63,7 +63,7 @@ let age = 25;
 let message = 'Bună';
 ```
 
-Unele persoane definesc de asemenea multiple variabile în acest stil pe mai multe linii:
+Unele persoane definesc de asemenea multiple variabile în acest stil multiliniar:
 
 ```js no-beautify
 let user = 'John',
@@ -81,7 +81,7 @@ let user = 'John'
 
 Technic, toate aceste variante fac același lucru. Deci, este o problemă de preferință personală și de estetică..
 
-````smart header="`var` instead of `let`"
+````smart header="`var` în loc de `let`"
 În scripturi mai vechi, ai putea găsi de asemenea un alt cuvânt cheie: `var` în loc de `let`:
 
 ```js
@@ -132,14 +132,14 @@ message = hello;
 */!*
 
 // acum două variabile conțin aceleași date
-alert(hello); // Bună ziua lume!
-alert(message); // Bună ziua lume!
+alert(hello); // Bună lume!!
+alert(message); // Bună lume!
 ```
 
-````warn header="Declaring twice triggers an error"
+````warn header="Declararea de două ori declanșează o eroare"
 O variabilă ar trebui declarată o singură dată.
 
-O declarație repetată a aceleiași  variabile este o eroare:
+O declarație repetată a aceleiași variabile este o eroare:
 
 ```js run
 let message = "Acesta";
@@ -150,15 +150,15 @@ let message = "Acesta"; // SyntaxError: 'message' has already been declared
 Deci, ar trebui să declarăm o variabilă o dată și apoi să ne referim la aceasta fără `let`.
 ````
 
-```smart header="Functional languages"
-Este interesant de notat dacă acolo există așa-numitele [funcțional pure](https://en.wikipedia.org/wiki/Purely_functional_programming) limbaje de programare, cum ar fi [Haskell](https://en.wikipedia.org/wiki/Haskell), care interzic schimbarea valorii variabilelor.
+```smart header="Limbaje funcționale"
+Este interesant de notat că există așa-numitele limbaje de programare [pur funcționale](https://en.wikipedia.org/wiki/Purely_functional_programming), cum ar fi [Haskell](https://en.wikipedia.org/wiki/Haskell), care interzic schimbarea valorii variabilelor.
 
 În limbaje ca acestea, odată ce valoarea este stocată "în cutie", există acolo pentru totdeauna. Dacă avem nevoie să stocăm altceva, limbajul ne forțează să creăm o nouă cutie (declarăm o nouă variabilă). Nu o putem refolosi pe cea veche.
 
 Deși pare un pic ciudat la prima vedere, aceste limbaje sunt destul de capabile de dezvoltare serioasă. Mai mult decât atât, sunt zone ca de exemplu calcule paralele unde această limitare conferă beneficii sigure.
 ```
 
-## Denumirea variabilelor  [#variable-naming]
+## Denumirea variabilelor [#variable-naming]
 
 Există două limitări în denumirea variabilelor în JavaScript:
 
@@ -172,7 +172,7 @@ let userName;
 let test123;
 ```
 
-Când numele conține cuvinte multiple, [camelCase](https://en.wikipedia.org/wiki/CamelCase) este folosit adesea. Acesta este: cuvintele vin unul după celălalt, fiecare cuvânt exceptând primul care începe cu majusculă: `numeleMeuFoarteLung`.
+Când numele conține cuvinte multiple, [camelCase](https://en.wikipedia.org/wiki/CamelCase) este adesea folosit. Adică: cuvintele vin unul după celălalt, fiecare cuvânt cu excepția celui dintâi începe cu majusculă: `numeleMeuFoarteLung`.
 
 Ceea ce este interesant -- semnul de dolar `'$'` și bara jos `'_'` pot fi de asemenea folosite în nume. Acestea sunt simboluri obișnuite, la fel ca și literele, fără însemnătate specială.
 
@@ -185,20 +185,20 @@ let _ = 2; // și acum o variabilă cu numele "_"
 alert($ + _); // 3
 ```
 
-Example de nume de variabile greșite:
+Example de nume de variabile incorecte:
 
 ```js no-beautify
 let 1a; // nu poate începe cu o cifră
 
 let my-name; // liniuțele '-' nu sunt permise în nume
 ```
 
-```smart header="Case matters"
+```smart header="Uscula contează"
 Variabilele numite `apple` și `APPLE` sunt două variabile diferite.
 ```
 
-````smart header="Non-Latin letters are allowed, but not recommended"
-Este posibil să folosim orice limbă, inclusiv litere chirilice, caractere chinezești și altele, precum acestea:
+````smart header="Literele non-latine sunt permise, dar nu sunt recomandate"
+Este posibil să folosim orice limbă, inclusiv litere chirilice, caractere chinezești și așa mai departe, precum acestea:
 
 ```js
 let имя = '...';
@@ -208,10 +208,10 @@ let 我 = '...';
 Technic, aici nu este nicio eroare. Astfel de nume sunt permise, dar există o convenție internațională de a folosi limba engleză în denumirile variabilelor. Chiar dacă scriem un script mic, poate avea viață lungă. Oamenii din alte țări ar putea avea nevoie să le citescă uneori.
 ````
 
-````warn header="Reserved names"
+````warn header="Nume rezervate"
 Există o [listă de cuvinte rezervate](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), care nu poate fi folostă ca nume de variabile pentru că sunt folosite de către limbajul însuși.
 
-De exemplu:  `let`, `class`, `return`, and `function` sunt rezervate..
+De exemplu: `let`, `class`, `return`, și `function` sunt rezervate..
 
 Codul următor dă eroare de sintaxă:
 
@@ -221,12 +221,12 @@ let return = 5; // de asemenea nu o putem numi "return", eroare!
 ```
 ````
 
-````warn header="An assignment without `use strict`"
+````warn header="O atribuire fără `use strict`"
 
 În mod normal, avem nevoie să definim o variabilă înainte să o folosim. Dar în timpurile vechi, era technic posibil să creezi o variabilă prin simpla alocare a unei valori fără a folosi `let`. Acesta încă funcționează acum dacă nu punem `use strict` în scriptul nostru pentru a menține compatibilitatea cu scripturile vechi.
 
 ```js run no-strict
-// notă: nu există "use strict" în acest exemplu
+// notă: fără "use strict" în acest exemplu
 
 num = 5; // variabila "num" este creată chiar dacă nu există
 
@@ -283,18 +283,18 @@ alert(color); // #FF7F00
 
 Beneficii:
 
-- `COLOR_ORANGE` este mai ușor de reținut decât  `"#FF7F00"`.
-- Este mai ușor de scris greșit  `"#FF7F00"` decât `COLOR_ORANGE`.
+- `COLOR_ORANGE` este mai ușor de reținut decât `"#FF7F00"`.
+- Este mult mai ușor de scris greșit `"#FF7F00"` decât `COLOR_ORANGE`.
 - Când citim codul, `COLOR_ORANGE` are o însemnătate mai mare decât `#FF7F00`.
 
-Când ar trebui să folosim majuscule pentru o constantă și când ar trebui să o denumim în mod obișnuit? Haideți să clarificăm acest lucru.
+Când ar trebui să folosim majuscule pentru o constantă și când ar trebui să o denumim în mod obișnuit? Haideți să clarificăm asta.
 
 A fi o "constantă" înseamnă doar a fi o valoare a unei variabile care nu se schimbă. Dar există și constante care sunt cunoscute înainte de execuție (ca de exemplu valoarea hexadecimală pentru roșu) și există constante care sunt *calculate* în timpul execuției, dar nu se schimbă după ce sunt alocate inițial.
 
 De exemplu:
 
 ```js
-const pageLoadTime = /* durata timpului de încărcare a unei pagini web  */;
+const pageLoadTime = /* durata timpului de încărcare a unei pagini web */;
 ```
 
 Valoarea lui `pageLoadTime` nu este cunoscută înainte ca pagina să se încarce, astfel că este denumită obișnuit. Dar este totuși o constantă pentru că nu se schimbă după ce este alocată.
@@ -322,7 +322,7 @@ Câteva reguli bune de urmat sunt:
 
 Sună simplu? Chiar este, dar crearea de variabile descriptive și concise în practică nu este. Încearcă.
 
-```smart header="Reuse or create?"
+```smart header="Reutilizare sau creare?"
 Și ultima notă. Există programatori leneși care, în loc să declare variabile noi, tind să le reutilizeze pe cele deja existente.
 
 Drept rezultat, variabilele lor sunt ca niște cutii în care oamenii aruncă diferite lucruri fără să schimbe etichetele. Ce este înăuntrul cutiei acum? Cine știe? Trebuie să ne apropiem și să verificăm.
@@ -339,7 +339,7 @@ Minificatoarele și browserele moderne de JavaScript optimizează codul suficien
 Putem declara variabile pentru a stoca date folosind `var`, `let`, sau cuvântul cheie `const`.
 
 - `let` -- este o declarație modernă de variabilă.
-- `var` -- este o declarație de variabilă de "școală-veche". În mod normal nu o mai folosim deloc, dar o să acoperim diferențele subtile față de `let` în capitolul <info:var>, în cazul în care ai nevoie de ele.
+- `var` -- este o declarație de variabilă de "școală-veche". În mod normal nu o mai folosim deloc, dar o să acoperim diferențele subtile față de `let` în capitolul <info:var>, doar în cazul în care ai nevoie de ele.
 - `const` -- este la fel ca `let`, doar că valoarea variabilei nu se poate schimba.
 
 Variabilele ar trebui să fie denumite într-un mod care să ne permită să înțelegem cu ușurință ce se află în ele.