You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: 1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md
+7-7
Original file line number
Diff line number
Diff line change
@@ -17,10 +17,10 @@ undefined + 1 = NaN // (6)
17
17
"\t\n"-2=-2// (7)
18
18
```
19
19
20
-
1.The addition with a string `"" + 1`converts`1`to a string: `"" + 1 = "1"`, and then we have`"1" + 0`, the same rule is applied.
21
-
2.The subtraction `-` (like most math operations) only works with numbers, it converts an empty string `""`to`0`.
22
-
3.The addition with a string appends the number `5`to the string.
23
-
4.The subtraction always converts to numbers, so it makes `" -9 "`a number`-9` (ignoring spaces around it).
24
-
5.`null`becomes`0`after the numeric conversion.
25
-
6.`undefined`becomes`NaN`after the numeric conversion.
26
-
7.Space characters, are trimmed off string start and end when a string is converted to a number. Here the whole string consists of space characters, such as `\t`, `\n`and a "regular" space between them. So, similarly to an empty string, it becomes`0`.
20
+
1.Sudėtis su eilute `"" + 1`paverčia`1`į eilutę: `"" + 1 = "1"`, o tada mes turime`"1" + 0`, taikoma ta pati taisyklė.
21
+
2.Atimtis `-` (kaip ir didžioji dalis matematinių operacijų) veikia tik su skaičiais, tad tuščią eilutę `""`paverčia į`0`.
22
+
3.Sudėtis su eilute prijungia skaičių `5`prie eilutės.
23
+
4.Atimtis visada paverčia į numerius, tad `" -9 "`tampa numeriu`-9` (ignoruoja tarpus aplink).
24
+
5.`null`tampa`0`po skaičių konversijos.
25
+
6.`undefined`tampa`NaN`po skaičių konversijos.
26
+
7.Tarpų ženklai yra nukerpami nuo eilutės pradžios ir pabaigos kai eilutė paverčiama į skaičių. Čia visa eilutė susideda iš tarpo ženklų kaip `\t`, `\n`ir "įprastinių" tarpų esančių tarp jų. Tad panašiai kaip ir tuščia eilutė, ji tampa`0`.
Most of the time, operators and functions automatically convert the values given to them to the right type.
3
+
Dažniausiai operatoriai ir funkcijos automatiškai pakeičia jiems duotas vertes į teisingą tipą.
4
4
5
-
For example, `alert`automatically converts any value to a string to show it. Mathematical operations convert values to numbers.
5
+
Pavyzdžiui `alert`automatiškai paverčia bet kokią jiems duotą vertę į eilutės tipą, kad galėtų jį parodytų. Matematinės operacijos pakeičia vertes į skaičius.
6
6
7
-
There are also cases when we need to explicitly convert a value to the expected type.
7
+
Yra tokių konkrečių atvejų kai mums reikia vertę pakeisti į atitinkamą tipą.
8
8
9
-
```smart header="Not talking about objects yet"
10
-
In this chapter, we won't cover objects. Instead, we'll study primitives first. Later, after we learn about objects, we'll see how object conversion works in the chapter <info:object-toprimitive>.
9
+
```smart header="Dar nekalbame apie objektus"
10
+
Šiame skyriuje kol kas dar nekalbėsime apie objektus. Vietoje to studijuosime primityvius tipus. Vėliau kai sužinosime daugiau apie objektus, pamatysime kaip objektų keitimai veikia skyriuje <info:object-toprimitive>.
11
11
```
12
12
13
-
## String Conversion
13
+
## Eilutės konversijos
14
14
15
-
String conversion happens when we need the string form of a value.
15
+
Eilutės keitimas įvyksta tada kai mums reikia eilutės formos vertės.
16
16
17
-
For example, `alert(value)`does it to show the value.
17
+
Pavyzdžiui, `alert(value)`tai padaro, kad parodytų vertę.
18
18
19
-
We can also call the`String(value)`function to convert a value to a string:
19
+
Mes taip pat galime iššaukti`String(value)`funkciją, kad konvertuotume vertę į eilutę:
20
20
21
21
```js run
22
22
let value =true;
23
-
alert(typeof value); // boolean
23
+
alert(typeof value); // boolean (loginis)
24
24
25
25
*!*
26
-
value =String(value); //now value is a string "true"
26
+
value =String(value); //dabar vertė yra eilutė "true"
27
27
alert(typeof value); // string
28
28
*/!*
29
29
```
30
30
31
-
String conversion is mostly obvious. A `false`becomes`"false"`, `null`becomes`"null"`, etc.
31
+
Eilutės konversijos dažniausiai yra labai akivaizdžios. `false`tampa`"false"`, `null`tampa`"null"` ir t.t.
32
32
33
-
## Numeric Conversion
33
+
## Skaičių konversijos
34
34
35
-
Numeric conversion happens in mathematical functions and expressions automatically.
35
+
Skaičių konversijos įvyksta automatiškai matematinėse funkcijose ir formulėse.
36
36
37
-
For example, when division`/`is applied to non-numbers:
37
+
Pavyzdžiui, kai dalyba`/`taikoma ne skaičiams:
38
38
39
39
```js run
40
-
alert( "6"/"2" ); // 3, strings are converted to numbers
We can use the `Number(value)`function to explicitly convert a`value`to a number:
43
+
Mes taip pat galime naudoti `Number(value)`funkciją konkrečiai tam, kad paverstume`value`į skaičių:
44
44
45
45
```js run
46
46
let str ="123";
47
47
alert(typeof str); // string
48
48
49
-
let num =Number(str); //becomes a number 123
49
+
let num =Number(str); //tampa numeriu 123
50
50
51
51
alert(typeof num); // number
52
52
```
53
53
54
-
Explicit conversion is usually required when we read a value from a string-based source like a text form but expect a number to be entered.
54
+
Akivaizdžios konversijos dažniausiai reikalingos kai gauname vertę eilutės tipo formatu iš tekstinių šaltinių, bet mums iš tikrųjų reikalingas skaičius.
55
55
56
-
If the string is not a valid number, the result of such a conversion is `NaN`. For instance:
56
+
Jeigu eilutė nėra tinkamas skaičius, tada tokios konversijos rezultatas bus is `NaN`. Pavyzdžiui:
57
57
58
58
```js run
59
-
let age =Number("an arbitrary string instead of a number");
59
+
let age =Number("arbitriška eilutė vietoje skaičiaus");
|`string`|Whitespaces from the start and end are removed. If the remaining string is empty, the result is `0`. Otherwise, the number is "read" from the string. An error gives`NaN`. |
70
+
|<code>true ir false</code> |`1`ir`0`|
71
+
|`string`|Tarpai pradžioje ir pabaigoje panaikinami. Jeigu likusi eilutė yra tuščia, rezultatas yra `0`. Kitu atveju, skaičius "perskaitomas" iš eilutės. Klaida grąžina`NaN`. |
72
72
73
-
Examples:
73
+
Pavyzdžiai:
74
74
75
75
```js run
76
76
alert( Number(" 123 ") ); // 123
77
-
alert( Number("123z") ); // NaN (error reading a number at "z")
77
+
alert( Number("123z") ); // NaN (klaida perskaitė skaičiuje "z")
78
78
alert( Number(true) ); // 1
79
79
alert( Number(false) ); // 0
80
80
```
81
81
82
-
Please note that`null`and`undefined`behave differently here: `null`becomes zero while`undefined`becomes`NaN`.
82
+
Atkreipkite dėmesį, kad`null`ir`undefined`elgiasi kitaip šiuo atveju: `null`tampa nuliu kai`undefined`tampa`NaN`.
Almost all mathematical operations convert values to numbers. A notable exception is addition `+`. If one of the added values is a string, the other one is also converted to a string.
84
+
````smart header="Sudėtis '+' sujungia eilutes"
85
+
Beveik visos matematinės operacijos paverčia vertes numeriais. Svarbi išimtis yra sudėtis `+`. Jeigu viena iš verčių yra eilutės, kita taip pat paverčiama eilute.
86
86
87
-
Then, it concatenates (joins) them:
87
+
Tada ji sujungia (ang. concatenates) vertes:
88
88
89
89
```js run
90
-
alert( 1 + '2' ); // '12' (string to the right)
91
-
alert( '1' + 2 ); // '12' (string to the left)
90
+
alert( 1 + '2' ); // '12' (eilutė iš dešinės)
91
+
alert( '1' + 2 ); // '12' (eilutė iš kairės)
92
92
```
93
93
94
-
This only happens when at least one of the arguments is a string. Otherwise, values are converted to numbers.
94
+
Taip įvyksta tik tokiu atveju kai vienas iš argumentų yra eilutė. Kitu atveju vertės konvertuojamos į skaičius.
95
95
````
96
96
97
-
## Boolean Conversion
97
+
## Loginės konversijos
98
98
99
-
Boolean conversion is the simplest one.
99
+
Loginės konversijos yra pačios paprasčiausios.
100
100
101
-
It happens in logical operations (later we'll meet condition tests and other similar things) but can also be performed explicitly with a call to `Boolean(value)`.
101
+
Jos nutinka loginėse operacijose (vėliau dar matysime padėties testus, ang. condition tests, ir panašius atvejus), bet taip pat gali būti atliekamos akivaizdžiam `Boolean(value)` iškvietimui.
102
102
103
-
The conversion rule:
103
+
Konversijos taisyklės:
104
104
105
-
-Values that are intuitively "empty", like`0`, an empty string, `null`, `undefined`, and`NaN`, become`false`.
106
-
-Other values become`true`.
105
+
-Vertės kurios intuityviai yra tuščios, kaip`0`, tuščia eilutė, `null`, `undefined` ir`NaN`, tampa`false`.
````warn header="Please note: the string with zero `\"0\"`is`true`"
119
-
Some languages (namely PHP) treat `"0"`as`false`. But in JavaScript, a non-empty string is always`true`.
118
+
````warn header="Atkreipkite dėmesė: eilutė su nuliu `\"0\"`yra`true`"
119
+
Kai kurios kalbos (pavyzdžiui PHP) `"0"`laiko`false`. Bet JavaScript netuščia eilutė visada bus`true`.
120
120
121
121
```js run
122
122
alert( Boolean("0") ); // true
123
-
alert( Boolean("") ); //spaces, also true (any non-empty string is true)
123
+
alert( Boolean("") ); //tarpai, taip pat tinka (bet kokia netuščia eilutė yra tinkama - true)
124
124
```
125
125
````
126
126
127
-
## Summary
127
+
## Santrauka
128
128
129
-
The three most widely used type conversions are to string, to number, and to boolean.
129
+
Trys labiausiai naudojamos tipų konversijos yra į eilutę, skaičių ir loginiai.
130
130
131
-
**`String Conversion`** -- Occurs when we output something. Can be performed with `String(value)`. The conversion to string is usually obvious for primitive values.
131
+
**`Eilutės Konversija`** -- Nutinka kai mes kažką gauname. Gali būti atliekama su `String(value)`. Konversija į eilutę su primityviais tipais dažniausiai yra akivaizdi.
132
132
133
-
**`Numeric Conversion`** -- Occurs in math operations. Can be performed with `Number(value)`.
133
+
**`Skaičių Konversija`** -- Nutinka matematinėse operacijos. Gali būti atliekama su `Number(value)`.
134
134
135
-
The conversion follows the rules:
135
+
Konversija laikosi taisyklių:
136
136
137
-
| Value | Becomes... |
137
+
| Vertė | Tampa... |
138
138
|-------|-------------|
139
139
|`undefined`|`NaN`|
140
140
|`null`|`0`|
141
141
|<code>true / false</code> | `1 / 0` |
142
-
| `string` | The string is read "as is", whitespaces from both sides are ignored. An empty string becomes `0`. An error gives `NaN`. |
142
+
| `string` | Eilutė skaitoma taip kaip yra, tarpai iš abiejų pusių ignoruojami. Tuščia eilutė tampa `0`. Klaida grąžina `NaN`. |
143
143
144
-
**`Boolean Conversion`** -- Occurs in logical operations. Can be performed with `Boolean(value)`.
144
+
**`Loginės Konversijos`** -- Nutinka loginėse operacijose. Gali būti atliekama su `Boolean(value)`.
145
145
146
-
Follows the rules:
146
+
Laikosi taisyklių:
147
147
148
-
| Value | Becomes... |
148
+
| Vertė | Tampa... |
149
149
|-------|-------------|
150
150
|`0`, `null`, `undefined`, `NaN`, `""` |`false`|
151
-
|any other value| `true` |
151
+
|bet kokia kita vertė| `true` |
152
152
153
153
154
-
Most of these rules are easy to understand and memorize. The notable exceptions where people usually make mistakes are:
154
+
Didžiąją dalį šių taisyklių lengva suprasti ir prisiminti. Svarbios išimtys kur žmonės daro klaidas yra:
155
155
156
-
- `undefined` is `NaN` as a number, not `0`.
157
-
- `"0"` and space-only strings like `" "` are true as a boolean.
156
+
- `undefined` kaip skaičius yra `NaN` kaip skaičius, ne `0`.
157
+
- `"0"` ir eilutė tik su tarpu kaip `" "` yra tiesa loginėse vertėse.
158
158
159
-
Objects aren't covered here. We'll return to them later in the chapter <info:object-toprimitive> that is devoted exclusively to objects after we learn more basic things about JavaScript.
159
+
Objektai čia neaptariami. Prie jų sugrįšime vėliau skyriuje <info:object-toprimitive>, kuris yra skirtas išskirtinai objektams kai tik sužinosime daugiau apie JavaScript.
0 commit comments