Skip to content

Commit d0d2279

Browse files
armino-devarmino-dev
committed
Initial translation
1 parent d99e3b8 commit d0d2279

File tree

1 file changed

+79
-78
lines changed
  • 1-js/04-object-basics/05-object-toprimitive

1 file changed

+79
-78
lines changed

‎1-js/04-object-basics/05-object-toprimitive/article.md‎

Lines changed: 79 additions & 78 deletions
Original file line numberDiff line numberDiff line change
@@ -1,38 +1,38 @@
11

22
# Conversia obiectelor la primitive
33

4-
What happens when objects are added `obj1 + obj2`, subtracted `obj1 - obj2` or printed using `alert(obj)`?
4+
Ce se întâmplă atunci când obiectele sunt adunate `obj1 + obj2`, scăzute` obj1 - obj2` sau tipărite folosind `alert (obj)`?
55

6-
In that case, objects are auto-converted to primitives, and then the operation is carried out.
6+
În acest caz, obiectele sunt convertite automat în primitive, după care este efectuată operația.
77

8-
In the chapter <info:type-conversions> we've seen the rules for numeric, string and boolean conversions of primitives. But we left a gap for objects. Now, as we know about methods and symbols it becomes possible to fill it.
8+
În capitolul <info: tip-conversions> am văzut regulile pentru conversiile numerice, string și booleane ale primitivelor. Dar am lăsat un gol pentru obiecte. Acum, după cum știm despre metode și simboluri, devine posibil să o completăm.
99

10-
1. All objects are `true` in a boolean context. There are only numeric and string conversions.
11-
2. The numeric conversion happens when we subtract objects or apply mathematical functions. For instance, `Date` objects (to be covered in the chapter <info:date>) can be subtracted, and the result of `date1 - date2` is the time difference between two dates.
12-
3. As for the string conversion -- it usually happens when we output an object like `alert(obj)` and in similar contexts.
10+
1. Într-un context boolean toate obiectele sunt `true` (adevărate). Există doar conversii numerice și conversii de șiruri.
11+
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.
12+
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.
1313

1414
## ToPrimitive
1515

16-
We can fine-tune string and numeric conversion, using special object methods.
16+
Putem ajusta conversia la șir și conversia numerică folosind metode speciale de obiect.
1717

18-
There are three variants of type conversion, so-called "hints", described in the [specification](https://tc39.github.io/ecma262/#sec-toprimitive):
18+
Există trei variante de conversie a tipului, așa-numitele "indicii", descrise în [specificație](https://tc39.github.io/ecma262/#sec-toprimitive):
1919

20-
`"string"`
21-
: For an object-to-string conversion, when we're doing an operation on an object that expects a string, like `alert`:
20+
`"string (șir)"`
21+
: 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`:
2222

2323
```js
24-
// output
24+
// afișare
2525
alert(obj);
2626

27-
// using object as a property key
27+
// folosind obiectul ca și cheie de proprietate
2828
anotherObj[obj] = 123;
2929
```
3030

31-
`"number"`
32-
: For an object-to-number conversion, like when we're doing maths:
31+
`"number (număr)"`
32+
: Pentru o conversie obiect-la-număr, ca atunci când facem matematică:
3333

3434
```js
35-
// explicit conversion
35+
// conversie explicită
3636
let num = Number(obj);
3737

3838
// maths (except binary plus)
@@ -43,88 +43,88 @@ There are three variants of type conversion, so-called "hints", described in the
4343
let greater = user1 > user2;
4444
```
4545

46-
`"default"`
47-
: Occurs in rare cases when the operator is "not sure" what type to expect.
46+
`"default (implicit)"`
47+
: Se întâmplă în cazuri rare când operatorul nu este „sigur” la ce tip să se aștepte.
4848

49-
For instance, binary plus `+` can work both with strings (concatenates them) and numbers (adds them), so both strings and numbers would do. Or when an object is compared using `==` with a string, number or a symbol, it's also unclear which conversion should be done.
49+
De exemplu, operatorul binar plus `+` poate funcționa atât cu șiruri (le concatenează) cât și cu numere (le adună), astfel încât atât șirurile cât și numerele se acceptă. Sau când un obiect este comparat cu un șir, număr sau simbol folosind operatorul `==`, este de asemenea neclar ce conversie ar trebui făcută.
5050

5151
```js
52-
// binary plus
52+
// operatorul plus
5353
let total = car1 + car2;
5454

5555
// obj == string/number/symbol
5656
if (user == 1) { ... };
5757
```
5858

59-
The greater/less operator `<>` can work with both strings and numbers too. Still, it uses "number" hint, not "default". That's for historical reasons.
59+
Operatorul Mai mare / Mai mic `<>` poate funcționa și cu șiruri și cu numere. Totuși, folosește indiciul "number (număr)", nu "default (implicit)". Asta din motive istorice.
6060

61-
In practice, all built-in objects except for one case (`Date` object, we'll learn it later) implement `"default"` conversion the same way as `"number"`. And probably we should do the same.
61+
În practică, toate obiectele încorporate, cu excepția unui caz (obiectul `Date`, îl vom invăța mai târziu) implementează conversia `"default"` în același mod ca `"number"`. Și probabil că ar trebui să facem la fel.
6262

63-
Please note -- there are only three hints. It's that simple. 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.
63+
Vă rugăm să rețineți - există doar trei indicii. Este atat de simplu. Nu există niciun indiciu "boolean" (toate obiectele sunt `true` în context boolean) sau orice altceva. Iar dacă tratăm conversia `"default"` și `"number"` la fel, așa cum fac majoritatea obiectelor încorporate, atunci există doar două conversii.
6464

65-
**To do the conversion, JavaScript tries to find and call three object methods:**
65+
**Pentru a face conversia, JavaScript încearcă să găsească și să apeleze trei metode obiect:**
6666

67-
1. Call `obj[Symbol.toPrimitive](hint)` - the method with the symbolic key `Symbol.toPrimitive` (system symbol), if such method exists,
68-
2. Otherwise if hint is `"string"`
69-
- try `obj.toString()` and `obj.valueOf()`, whatever exists.
70-
3. Otherwise if hint is `"number"` or `"default"`
71-
- try `obj.valueOf()` and `obj.toString()`, whatever exists.
67+
1. Apelează `obj[Symbol.toPrimitive](indiciu)` - metoda cu cheia simbolică `Symbol.toPrimitive` (simbol de sistem), dacă o astfel de metodă există,
68+
2. În caz contrar, dacă indiciul este `"string"`
69+
- încearcă `obj.toString()` și `obj.valueOf()`, oricare dintre ele există.
70+
3. Altfel, dacă indiciul este `"number"` sau `"default"`
71+
- încearcă `obj.valueOf()` și `obj.toString()`, oricare dintre ele există.
7272

7373
## Symbol.toPrimitive
7474

75-
Let's start from the first method. There's a built-in symbol named `Symbol.toPrimitive` that should be used to name the conversion method, like this:
75+
Să începem de la prima metodă. Există un simbol încorporat numit `Symbol.toPrimitive` care ar trebui utilizat pentru a denumi metoda de conversie, astfel:
7676

7777
```js
7878
obj[Symbol.toPrimitive] = function(hint) {
79-
// must return a primitive value
80-
// hint = one of "string", "number", "default"
79+
// trebuie să returneze o valoare primitivă
80+
// hint = oricare dintre "string", "number", "default"
8181
};
8282
```
8383

84-
For instance, here `user` object implements it:
84+
De exemplu, aici obiectul `user` îl implementează:
8585

8686
```js run
8787
let user = {
8888
name: "John",
8989
money: 1000,
9090

91-
[Symbol.toPrimitive](hint) {
92-
alert(`hint: ${hint}`);
93-
return hint == "string" ? `{name: "${this.name}"}` : this.money;
91+
[Symbol.toPrimitive](indiciu) {
92+
alert(`indiciu: ${indiciu}`);
93+
return indiciu == "string" ? `{name: "${this.name}"}` : this.money;
9494
}
9595
};
9696

97-
// conversions demo:
98-
alert(user); // hint: string -> {name: "John"}
99-
alert(+user); // hint: number -> 1000
100-
alert(user + 500); // hint: default -> 1500
97+
// demo conversie:
98+
alert(user); // indiciu: string -> {name: "John"}
99+
alert(+user); // indiciu: number -> 1000
100+
alert(user + 500); // indiciu: default -> 1500
101101
```
102102

103-
As we can see from the code, `user` becomes a self-descriptive string or a money amount depending on the conversion. The single method `user[Symbol.toPrimitive]` handles all conversion cases.
103+
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.
104104

105105

106106
## toString/valueOf
107107

108-
Methods `toString` and `valueOf` come from ancient times. They are not symbols (symbols did not exist that long ago), but rather "regular" string-named methods. They provide an alternative "old-style" way to implement the conversion.
108+
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" denumite prin șiruri. Acestea oferă o modalitate alternativă de "stil-vechi" pentru a implementa conversia.
109109

110-
If there's no `Symbol.toPrimitive` then JavaScript tries to find them and try in the order:
110+
Dacă nu există `Symbol.toPrimitive` atunci JavaScript încearcă să le găsească și le încearcă în ordinea:
111111

112-
- `toString -> valueOf` for "string" hint.
113-
- `valueOf -> toString` otherwise.
112+
- `toString -> valueOf` pentru indiciul "string".
113+
- `valueOf -> toString` în caz contrar.
114114

115-
For instance, here `user` does the same as above using a combination of `toString` and `valueOf`:
115+
De exemplu, aici `user` face același lucru ca mai sus folosind o combinație de `toString` și `valueOf`:
116116

117117
```js run
118118
let user = {
119119
name: "John",
120120
money: 1000,
121121

122-
// for hint="string"
122+
// pentru indiciu="string"
123123
toString() {
124124
return `{name: "${this.name}"}`;
125125
},
126126

127-
// for hint="number" or "default"
127+
// pentru indiciu="number" sau "default"
128128
valueOf() {
129129
return this.money;
130130
}
@@ -136,9 +136,9 @@ alert(+user); // valueOf -> 1000
136136
alert(user + 500); // valueOf -> 1500
137137
```
138138

139-
As we can see, the behavior is the same as the previous example with `Symbol.toPrimitive`.
139+
După cum putem vedea, comportamentul este același cu cel din exemplul precedent cu `Symbol.toPrimitive`.
140140

141-
Often we want a single "catch-all" place to handle all primitive conversions. In this case, we can implement `toString` only, like this:
141+
Deseori ne dorim un singur loc "catch-all" care să se ocupe de toate conversiile primitive. În acest caz, putem implementa doar `toString`, astfel:
142142

143143
```js run
144144
let user = {
@@ -153,69 +153,70 @@ alert(user); // toString -> John
153153
alert(user + 500); // toString -> John500
154154
```
155155

156-
In the absence of `Symbol.toPrimitive` and `valueOf`, `toString` will handle all primitive conversions.
156+
În absența metodelor `Symbol.toPrimitive` și `valueOf`, `toString` va gestiona toate conversiile primitive.
157157

158158
## Return types
159159

160-
The important thing to know about all primitive-conversion methods is that they do not necessarily return the "hinted" primitive.
160+
Lucrul important de știut despre toate metodele de conversie primitivă este că nu returnează neapărat primitiva "indicată".
161161

162-
There is no control whether `toString()` returns exactly a string, or whether `Symbol.toPrimitive` method returns a number for a hint "number".
162+
Nu există niciun control că `toString()` returnează exact un șir, sau că metoda `Symbol.toPrimitive` returnează un număr pentru un indiciu "number".
163163

164-
The only mandatory thing: these methods must return a primitive, not an object.
164+
Singurul lucru obligatoriu: aceste metode trebuie să returneze o primitivă, nu un obiect.
165165

166-
```smart header="Historical notes"
167-
For historical reasons, if `toString` or `valueOf` returns an object, there's no error, but such value is ignored (like if the method didn't exist). That's because in ancient times there was no good "error" concept in JavaScript.
166+
```smart header="Note istorice"
167+
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.
168168
169-
In contrast, `Symbol.toPrimitive` *must* return a primitive, otherwise there will be an error.
169+
În contrast, `Symbol.toPrimitive` *trebuie* să returneze o primitivă, altfel va exista o eroare.
170170
```
171171

172-
## Further operations
172+
## Operații suplimentare
173173

174-
An operation that initiated the conversion gets the primitive, and then continues to work with it, applying further conversions if necessary.
174+
O instrucțiune care a inițiat conversia preia primitiva și apoi continuă să lucreze cu ea, aplicând conversii suplimentare dacă este necesar.
175175

176-
For instance:
176+
De exemplu:
177177

178-
- Mathematical operations, except binary plus, convert the primitive to a number:
178+
- Operațiile matematice, cu excepția plusului binar, convertesc primitiva într-un număr:
179179

180180
```js run
181181
let obj = {
182-
// toString handles all conversions in the absence of other methods
182+
// toString gestionează toate conversiile în absența altor metode
183183
toString() {
184184
return "2";
185185
}
186186
};
187187

188-
alert(obj * 2); // 4, object converted to primitive "2", then multiplication made it a number
188+
alert(obj * 2); // 4, obiectul convertit în primitiva "2", apoi înmulțirea a făcut din aceasta un număr
189189
```
190190

191-
- Binary plus will concatenate strings in the same situation:
191+
- În aceeași situație plusul binar va concatena șirurile:
192+
192193
```js run
193194
let obj = {
194195
toString() {
195196
return "2";
196197
}
197198
};
198199
199-
alert(obj + 2); // 22 (ToPrimitive returned string => concatenation)
200+
alert(obj + 2); // 22 (ToPrimitive a returnat string => concatenare)
200201
```
201202

202-
## Summary
203+
## Rezumat
203204

204-
The object-to-primitive conversion is called automatically by many built-in functions and operators that expect a primitive as a value.
205+
Conversia obiect-la-primitivă este apelată automat de multe funcții și operatori încorporați care așteaptă ca valoare o primitivă.
205206

206-
There are 3 types (hints) of it:
207-
- `"string"` (for `alert` and other operations that need a string)
208-
- `"number"` (for maths)
209-
- `"default"` (few operators)
207+
Există trei tipuri (indicii) ale acesteia:
208+
- `"string (șir)"` (pentru `alert` sau altă instrucțiune care are nevoie de un șir)
209+
- `"number (număr)"` (pentru matematică)
210+
- `"default (implicit)"` (câțiva operatori)
210211

211-
The specification describes explicitly which operator uses which hint. There are very few operators that "don't know what to expect" and use the `"default"` hint. Usually for built-in objects `"default"` hint is handled the same way as `"number"`, so in practice the last two are often merged together.
212+
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.
212213

213-
The conversion algorithm is:
214+
Algoritmul de conversie este:
214215

215-
1. Call `obj[Symbol.toPrimitive](hint)` if the method exists,
216-
2. Otherwise if hint is `"string"`
217-
- try `obj.toString()` and `obj.valueOf()`, whatever exists.
218-
3. Otherwise if hint is `"number"` or `"default"`
219-
- try `obj.valueOf()` and `obj.toString()`, whatever exists.
216+
1. Apelează `obj[Symbol.toPrimitive](hint)` dacă metoda există,
217+
2. În caz contrar, dacă indiciul este `"string"`
218+
- încearcă `obj.toString()` și `obj.valueOf()`, oricare dintre ele există.
219+
3. Altfel, dacă indiciul este `"number"` sau `"default"`
220+
- încearcă `obj.valueOf()` și `obj.toString()`, oricare dintre ele există.
220221

221-
In practice, it's often enough to implement only `obj.toString()` as a "catch-all" method for all conversions that return a "human-readable" representation of an object, for logging or debugging purposes.
222+
În practică, este suficient să implementăm doar `obj.toString()` ca metodă "catch-all" pentru toate conversiile care returnează o reprezentare "lizibilă pentru om" a unui obiect, în scopuri de depanare sau logare.

0 commit comments

Comments
 (0)