final polish

Author: bogdanbacosca

Diff for: 1-js/04-object-basics/09-object-toprimitive/article.md

@@ -3,11 +3,11 @@
 
 Ce se întâmplă atunci când obiectele sunt adunate `obj1 + obj2`, scăzute `obj1 - obj2` sau tipărite folosind `alert(obj)`?
 
-JavaScript nu prea permite să personalizeze cum operatorii lucrează pe obiecte. Spre deosebire de alte limbaje de programare, cum ar fi Ruby sau C++, nu putem implementa o metodă specială de obiect pentru a gestiona o adunare (sau alți operatori).
+JavaScript nu vă permite să personalizați modul în care operatorii lucrează pe obiecte. Spre deosebire de alte limbaje de programare, cum ar fi Ruby sau C++, nu putem implementa o metodă specială de obiect pentru a gestiona o adunare (sau alți operatori).
 
 În cazul unor astfel de operații, obiectele sunt convertite automat în primitive, iar apoi operația este efectuată asupra acestor primitive și are ca rezultat o valoare primitivă.
 
-Aceasta este o limitare importantă, deoarece rezultatul a `obj1 + obj2` nu poate fi un alt obiect!
+Aceasta este o limitare importantă: rezultatul lui `obj1 + obj2` (sau altă operație matematică) nu poate fi un alt obiect!
 
 E.g. nu putem crea obiecte reprezentând vectori sau matrici (sau realizări sau orice altceva), să le adunăm și să ne așteptăm ca rezultat un obiect "însumat". Astfel de realizări arhitecturale sunt automat "în afara discuției".
 
@@ -17,7 +17,7 @@ Așadar, pentru că nu putem face mare lucru aici, nu există matematică cu obi
 
 Avem două scopuri:
 
-1. Ne va permite să înțelegem ce se întâmplă în cazul unor greșeli de codare, atunci cândaler o astfel de operațiune s-a întâmplat accidental.
+1. Ne va permite să înțelegem ce se întâmplă în cazul unor greșeli de codare, atunci când o astfel de operațiune s-a întâmplat accidental.
 2. Există excepții, unde astfel de operații sunt posibile și arată bine. E.g. scăderea sau compararea datelor (obiecte `Date`). Le vom întâlni mai târziu.
 
 ## Reguli de conversie
@@ -26,13 +26,17 @@ Avem două scopuri:
 
 1. Într-un context boolean toate obiectele sunt `true` (adevărate). Există doar conversii numerice și conversii de șiruri.
 2. Conversia numerică are loc atunci când scădem obiecte sau aplicăm funcții matematice. De exemplu, obiectele de tip `Date` (ce vor fi studiate în capitolul <info:date>) pot fi scăzute, iar rezultatul  `date1 - date2` este diferența de timp dintre cele două date.
-3. În ceea ce privește conversia șirului - se întâmplă de obicei atunci când afișăm un obiect precum `alert(obj)` și în contexte similare.
+3. În ceea ce privește conversia șirului -- se întâmplă de obicei atunci când afișăm un obiect precum `alert(obj)` și în contexte similare.
 
-Putem regla fin șirurile și conversia numerică, folosind metode speciale de obiecte. 
+Putem implementa singuri conversia șirurilor de caractere și a numerelor, folosind metode de obiect speciale.
 
-Există trei variante de conversie de tip, care se întâmplă în diferite situații. 
+Acum să intrăm în detalii tehnice, pentru că este singura modalitate de a acoperi subiectul în profunzime.
 
-Se numesc "indicii", așa cum sunt descrise în [specificația](https://tc39.github.io/ecma262/#sec-toprimitive):
+## Hints
+
+Cum decide JavaScript ce conversie să aplice?
+
+Există trei variante de conversie de tip, care se întâmplă în diverse situații. Acestea se numesc "indicii", așa cum sunt descrise în [specificație](https://tc39.github.io/ecma262/#sec-toprimitive):
 
 `"string"`
 : Pentru o conversie obiect-la-șir, atunci când efectuăm o operație asupra unui obiect care se așteaptă la un șir, cum ar fi `alert`:
@@ -60,52 +64,52 @@ Se numesc "indicii", așa cum sunt descrise în [specificația](https://tc39.git
     let greater = user1 > user2;
     ```
 
+    Majoritatea funcțiilor matematice încorporate includ, de asemenea, o astfel de conversie.
+
 `"default"`
 : Se întâmplă în cazuri rare când operatorul nu este „sigur” la ce tip să se aștepte.
 
     De exemplu, operatorul binar plus `+` poate funcționa atât cu șiruri (le concatenează) cât și cu numere (le adună), deci atât șirurile cât și numerele se acceptă. Așadar dacă un plus binar obține un obiect ca argument, acesta folosește indiciul `"default"` pentru a-l converti.
 
-    De asemenea dacă un obiect este comparat folosind `==` cu un șir, un număr sau un simbol, nu este clar ce conversie ar trebui efectuată, deci se utilizează indiciul `"default"`.
+    De asemenea, dacă un obiect este comparat folosind `==` cu un șir, un număr sau un simbol, nu este clar ce conversie ar trebui efectuată, deci se utilizează indiciul `"default"`.
 
     ```js
-    // binary plus uses the "default" hint
+    // binary plus utilizează indiciul "default".
     let total = obj1 + obj2;
 
-    // obj == number uses the "default" hint
+    // obj == number utilizează indiciul "default"
     if (user == 1) { ... };
     ```
 
     Operatorii de comparație mai mare și mai mic, cum ar fi `<` `>`, pot funcționa atât cu șiruri cât și cu numere. Totuși, ei folosesc indiciul `"number"`, nu `"default"`. Asta din motive istorice.
 
-    În practică însă, nu trebuie să ne amintim aceste detalii particulare, deoarece toate obiectele built-in cu excepția unui singur caz (obiectul `Date`, îl vom învăța mai târziu) implementează conversia `"default"` în același mod ca și `"number"`. Și noi putem face la fel.
+În practică însă, lucrurile sunt puțin mai simple.
 
-```smart header="No `\"boolean\"` hint"
-Please note -- there are only three hints. It's that simple.
+Toate obiectele încorporate cu excepția unui singur caz (obiectul `Date`, îl vom învăța mai târziu), implementează conversia `"default"` în același mod ca și `"number"`. Și probabil că ar trebui să facem la fel.
 
-There is no "boolean" hint (all objects are `true` in boolean context) or anything else. And if we treat `"default"` and `"number"` the same, like most built-ins do, then there are only two conversions.
-```
+Totuși, este important să cunoaștem toate cele 3 indicații, în curând vom vedea de ce.
 
 **Pentru a face conversia, JavaScript încearcă să găsească și să apeleze trei metode obiect:**
 
 1. Apelează `obj[Symbol.toPrimitive](indiciu)` - metoda cu cheia simbolică `Symbol.toPrimitive` (simbol de sistem), dacă o astfel de metodă există,
 2. În caz contrar, dacă indiciul este `"string"`
-    - încearcă `obj.toString()` și `obj.valueOf()`, oricare dintre ele există.
-3. Altfel, dacă indiciul este `"number"` sau `"default"`
-    - încearcă `obj.valueOf()` și `obj.toString()`, oricare dintre ele există.
+    - încearcă să apeleze `obj.toString()` sau `obj.valueOf()`, oricare dintre ele există.
+3. Altfel dacă indiciul este `"number"` sau `"default"`
+    - încearcă să apeleze `obj.valueOf()` sau `obj.toString()`, oricare dintre ele există.
 
 ## Symbol.toPrimitive
 
-Să începem de la prima metodă. Există un simbol încorporat numit `Symbol.toPrimitive`  care ar trebui utilizat pentru a denumi metoda de conversie, astfel:
+Să începem de la prima metodă. Există un simbol încorporat numit `Symbol.toPrimitive` care ar trebui utilizat pentru a denumi metoda de conversie, astfel:
 
 ```js
 obj[Symbol.toPrimitive] = function(hint) {
   // iată codul pentru a converti acest obiect într-o primitivă
   // trebuie să returneze o valoare primitivă
-  // hint = unul dintre "string", "number", "default"
+  // indiciu = unul dintre "string", "number", "default"
 };
 ```
 
-Dacă există metoda `Symbol.toPrimitive`, aceasta este utilizată pentru toate indiciile și nu mai sunt necesare alte metode.
+Dacă există metoda `Symbol.toPrimitive`, aceasta este utilizată pentru toate indiciile, și nu mai sunt necesare alte metode.
 
 De exemplu, aici obiectul `user` o implementează:
 
@@ -114,35 +118,34 @@ let user = {
   name: "John",
   money: 1000,
 
-  [Symbol.toPrimitive](indiciu) {
-    alert(`indiciu: ${indiciu}`);
-    return indiciu == "string" ? `{name: "${this.name}"}` : this.money;
+  [Symbol.toPrimitive](hint) {
+    alert(`indiciu: ${hint}`);
+    return hint == "string" ? `{name: "${this.name}"}` : this.money;
   }
 };
 
-// conversie demo:
+// conversii demo:
 alert(user); // indiciu: string -> {name: "John"}
 alert(+user); // indiciu: number -> 1000
 alert(user + 500); // indiciu: default -> 1500
 ```
 
 După cum putem vedea din cod, obiectul `user` devine un șir autodescriptiv sau o sumă de bani în funcție de conversie. Metoda unică `user[Symbol.toPrimitive]` gestionează toate cazurile de conversie.
 
-
 ## toString/valueOf
 
 Dacă nu există `Symbol.toPrimitive`, atunci JavaScript încearcă să găsească metodele `toString` și `valueOf`:
 
-- Pentru indiciul "string": `toString`, iar dacă nu există, atunci `valueOf` (deci `toString` are prioritate pentru conversiile de stringuri).
-- Pentru alte indicii: `valueOf`, iar dacă nu există, atunci `toString` (astfel încât `valueOf` are prioritate pentru conversii matematice).
+- Pentru indiciul "string": apelează metoda `toString`, și dacă nu există sau dacă returnează un obiect în loc de o valoare primitivă, atunci apelează `valueOf` (deci `toString` are prioritate pentru conversiile de șiruri).
+- Pentru alte indicii: apelează `valueOf`, iar dacă acesta nu există sau dacă returnează un obiect în loc de o valoare primitivă, atunci apelează `toString` (deci `valueOf` are prioritate pentru matematică).
 
-Metodele `toString` și `valueOf` provin din timpuri străvechi. Ele nu sunt simboluri (simbolurile nu existau cu mult timp în urmă), ci mai degrabă metode "obișnuite" cu nume de șir de caractere. Ele oferă o modalitate alternativă "în stil vechi" de a implementa conversia.
+Metodele `toString` și `valueOf` provin din timpuri străvechi. Ele nu sunt simboluri (simbolurile nu existau cu mult timp în urmă), ci mai degrabă metode "obișnuite" cu nume de șiruri. Ele oferă o modalitate alternativă "în stil vechi" de a implementa conversia.
 
 Aceste metode trebuie să returneze o valoare primitivă. Dacă `toString` sau `valueOf` returnează un obiect, atunci este ignorată (la fel ca în cazul în care nu ar exista nicio metodă).
 
 În mod implicit, un obiect simplu are următoarele metode `toString` și `valueOf`:
 
-- Metoda `toString` returnează un șir de caractere `"[object Object Object]"`.
+- Metoda `toString` returnează un șir `"[object Object]"`.
 - Metoda `valueOf` returnează obiectul în sine.
 
 Iată demonstrația:
@@ -154,7 +157,7 @@ alert(user); // [object Object]
 alert(user.valueOf() === user); // true
 ```
 
-Așadar, dacă încercăm să folosim un obiect ca șir de caractere, cum ar fi într-un `alert` sau așa ceva, atunci, în mod implicit, vom vedea `[object Object]`.
+Așadar, dacă încercăm să folosim un obiect ca șir de caractere, cum ar fi într-un `alert` sau așa ceva, atunci vom vedea în mod implicit `[object Object]`.
 
 Valoarea implicită `valueOf` este menționată aici doar de dragul completării, pentru a evita orice confuzie. După cum puteți vedea, acesta returnează obiectul în sine, deci este ignorat. Nu mă întrebați de ce, aceea este din motive istorice. Deci putem presupune că nu există.
 
@@ -203,7 +206,7 @@ alert(user + 500); // toString -> John500
 
 În absența metodelor `Symbol.toPrimitive` și `valueOf`, `toString` va gestiona toate conversiile primitive.
 
-### A conversion can return any primitive type
+### O conversie poate returna orice tip primitiv
 
 Lucrul important de știut despre toate metodele de conversie primitivă este că nu returnează neapărat primitiva "indicată".
 
@@ -212,7 +215,7 @@ Nu se poate controla dacă `toString` returnează exact un șir, sau dacă metod
 Singurul lucru obligatoriu: aceste metode trebuie să returneze o primitivă, nu un obiect.
 
 ```smart header="Note istorice"
-Din motive istorice, dacă `toString` sau `valueOf` returnează un obiect, nu este o eroare, dar o astfel de valoare este ignorată (ca și cum metoda nu ar exista). Asta deoarece mai demult, în JavaScript nu exista un concept de "eroare" sănătos.
+Din motive istorice, dacă `toString` sau `valueOf` returnează un obiect, nu este o eroare, dar o astfel de valoare este ignorată (ca și cum metoda nu ar exista). Asta deoarece în vremuri străvechi nu exista un concept de "eroare" bun în JavaScript.
 
 În contrast, `Symbol.toPrimitive` *trebuie* să returneze o primitivă, altfel va exista o eroare.
 ```
@@ -221,15 +224,15 @@ Din motive istorice, dacă `toString` sau `valueOf` returnează un obiect, nu es
 
 După cum știm deja, mulți operatori și funcții efectuează conversii de tip, e.g. înmulțirea `*` convertește operanzii în numere.
 
-Dacă trecem un obiect ca argument, atunci există două etape:
+Dacă transmitem un obiect ca argument, atunci există două etape de calcul:
 1. Obiectul este convertit într-o primitivă (folosind regulile descrise mai sus).
-2. Dacă primitiva rezultată nu este de tipul corect, aceasta este convertită.
+2. Dacă este necesar pentru calcule ulterioare, primitivul rezultat este de asemenea convertit.
 
 De exemplu:
 
 ```js run
 let obj = {
-  // toString se ocupă de toate conversiile în absența altor metode
+  // toString gestionează toate conversiile în absența altor metode
   toString() {
     return "2";
   }
@@ -253,25 +256,25 @@ let obj = {
 alert(obj + 2); // 22 ("2" + 2), conversia în primitivă a returnat un șir => concatenare
 ```
 
-## Rezumat
+## Sumar
 
 Conversia obiect-la-primitivă este apelată automat de multe funcții și operatori încorporați care așteaptă ca valoare o primitivă.
 
 Există trei tipuri (indicii) ale acesteia:
-- `"string (șir)"` (pentru `alert` sau altă instrucțiune care are nevoie de un șir)
-- `"number (număr)"` (pentru matematică)
-- `"default (implicit)"` (câțiva operatori)
+- `"string"` (pentru `alert` sau altă instrucțiune care are nevoie de un șir)
+- `"number"` (pentru matematică)
+- `"default"` (câțiva operatori, de obicei obiectele îl implementează în același mod ca și `"number"`.)
 
-Specificația descrie explicit ce operator folosește ce indiciu. Există foarte puțini operatori care "nu știu la ce să se aștepte" și folosesc indiciuul `"default"`. De obicei, pentru obiectele încorporate, indiciuul `"default"` în același mod ca `"number"`, astfel încât, în practică, ultimele două sunt adesea îmbinate între ele.
+Specificația descrie explicit ce operator folosește ce indiciu.
 
 Algoritmul de conversie este:
 
-1. Apelează `obj[Symbol.toPrimitive](hint)` dacă metoda există,
+1. Apelează `obj[Symbol.toPrimitive](indiciu)` dacă metoda există,
 2. În caz contrar, dacă indiciul este `"string"`
-    - încearcă `obj.toString()` și `obj.valueOf()`, oricare dintre ele există.
-3. Altfel, dacă indiciul este `"number"` sau `"default"`
-    - încearcă `obj.valueOf()` și `obj.toString()`, oricare dintre ele există.
+    - încearcă să apeleze `obj.toString()` sau `obj.valueOf()`, oricare dintre ele există.
+3. Altfel dacă indiciul este `"number"` sau `"default"`
+    - încearcă să apeleze `obj.valueOf()` sau `obj.toString()`, oricare dintre ele există.
 
-În practică, este adesea suficient să implementăm doar `obj.toString()` ca metodă "catch-all" pentru conversiile de șiruri care ar trebui să returneze o reprezentare "lizibilă pentru oameni" a unui obiect, în scopuri de logare sau de depanare. 
+Toate aceste metode trebuie să returneze o primitivă pentru a funcționa (dacă sunt definite).
 
-În ceea ce privește operațiile matematice, JavaScript nu oferă o modalitate de a le "suprascrie" cu ajutorul metodelor, deci proiectele din viața reală le folosesc rareori pe obiecte.
+În practică, este adesea suficient să implementăm doar `obj.toString()` ca metodă "catch-all" pentru conversiile de șiruri care ar trebui să returneze o reprezentare "lizibilă pentru oameni" a unui obiect, în scopuri de logare sau de depanare.