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
A `switch`statement can replace multiple `if` checks.
3
+
O instrucțiune `switch`poate înlocui mai multe teste `if`.
4
4
5
-
It gives a more descriptive way to compare a value with multiple variants.
5
+
Reprezintă un mod mai descriptiv de a compara o valoare cu mai multe variante.
6
6
7
-
## The syntax
7
+
## Sintaxă
8
8
9
-
The`switch`has one or more `case`blocks and an optional default.
9
+
Instrucțiunea`switch`are unul sau mai multe blocuri `case`și un bloc opțional `default`.
10
10
11
-
It looks like this:
11
+
Ea arată în felul următor:
12
12
13
13
```js no-beautify
14
14
switch(x) {
@@ -26,71 +26,71 @@ switch(x) {
26
26
}
27
27
```
28
28
29
-
-The value of `x`is checked for a strict equality to the value from the first `case` (that is, `value1`) then to the second (`value2`) and so on.
30
-
-If the equality is found, `switch`starts to execute the code starting from the corresponding `case`, until the nearest `break` (or until the end of`switch`).
31
-
-If no case is matched then the `default`code is executed (if it exists).
29
+
-Valoarea variabilei `x`este comparată prin egalitate strictă cu valoarea din primul `case` (adică, `value1`), apoi cu a doua valoare (`value2`) și așa mai departe.
30
+
-Dacă găsește egalitate într-unul din cazuri, `switch`începe să execute codul începând cu `case` corespunzător, până la cel mai apropiat `break` (sau până la sfârșitul instrucțiunii`switch`).
31
+
-Dacă niciun caz nu satisface egalitatea, codul din blocul `default`este executat, dacă acest bloc există.
32
32
33
-
## An example
33
+
## Un exemplu
34
34
35
-
An example of`switch` (the executed code is highlighted):
35
+
Un exemplu de`switch` (codul executat este evidențiat):
36
36
37
37
```js run
38
38
let a =2+2;
39
39
40
40
switch (a) {
41
41
case3:
42
-
alert( 'Too small' );
42
+
alert( 'Prea mic' );
43
43
break;
44
44
*!*
45
45
case4:
46
-
alert( 'Exactly!' );
46
+
alert( 'Exact!' );
47
47
break;
48
48
*/!*
49
49
case5:
50
-
alert( 'Too large' );
50
+
alert( 'Prea mare' );
51
51
break;
52
52
default:
53
-
alert( "I don't know such values" );
53
+
alert( "Nu știu astfel de valori" );
54
54
}
55
55
```
56
56
57
-
Here the `switch`starts to compare `a`from the first `case` variant that is `3`. The match fails.
57
+
Aici, `switch`începe să compare `a`cu valoarea din primul `case`, adică `3`. Egalitatea nu este îndeplinită.
58
58
59
-
Then`4`. That's a match, so the execution starts from`case 4`until the nearest`break`.
59
+
Urmează`4`. Acesta se potrivește, deci execuția începe de la`case 4`până la cel mai apropiat`break`.
60
60
61
-
**If there is no `break`then the execution continues with the next `case`without any checks.**
61
+
**Dacă instrucțiunea `break`lipsește, execuția continuă cu următorul bloc `case`fără a mai face vreo verificare.**
62
62
63
-
An example without`break`:
63
+
Un exemplu fără`break`:
64
64
65
65
```js run
66
66
let a =2+2;
67
67
68
68
switch (a) {
69
69
case3:
70
-
alert( 'Too small' );
70
+
alert( 'Prea mic' );
71
71
*!*
72
72
case4:
73
-
alert( 'Exactly!' );
73
+
alert( 'Exact!' );
74
74
case5:
75
-
alert( 'Too big' );
75
+
alert( 'Prea mare' );
76
76
default:
77
-
alert( "I don't know such values" );
77
+
alert( "Nu știu astfel de valori" );
78
78
*/!*
79
79
}
80
80
```
81
81
82
-
In the example above we'll see sequential execution of three `alert`s:
82
+
În exemplul de mai sus vom vedea execuția în secvență a trei `alert`:
83
83
84
84
```js
85
-
alert( 'Exactly!' );
86
-
alert( 'Too big' );
87
-
alert( "I don't know such values" );
85
+
alert( 'Exact!' );
86
+
alert( 'Prea mare' );
87
+
alert( "Nu știu astfel de valori" );
88
88
```
89
89
90
-
````smart header="Any expression can be a `switch/case` argument"
91
-
Both`switch` and `case`allow arbitrary expressions.
90
+
````smart header="Orice expresie poate fi un argument pentru `switch/case`"
91
+
Atât`switch`, cât și `case`permit expresii arbitrare.
92
92
93
-
For example:
93
+
De exemplu:
94
94
95
95
```js run
96
96
let a ="1";
@@ -99,74 +99,74 @@ let b = 0;
99
99
switch (+a) {
100
100
*!*
101
101
case b +1:
102
-
alert("this runs, because +a is 1, exactly equals b+1");
102
+
alert("acesta merge, deoarece +a este 1, exact cât este și b+1");
103
103
break;
104
104
*/!*
105
105
106
106
default:
107
-
alert("this doesn't run");
107
+
alert("asta nu merge");
108
108
}
109
109
```
110
-
Here`+a`gives `1`, that's compared with `b + 1`in`case`, and the corresponding code is executed.
110
+
Aici,`+a`este evaluat la `1`, care este comparat cu `b + 1`în`case` și codul corespunzător este executat.
111
111
````
112
112
113
-
## Grouping of "case"
113
+
## Grupări de "case"
114
114
115
-
Several variants of `case` which share the same code can be grouped.
115
+
Mai multe instrucțiuni `case` care partajează același cod pot fi grupate.
116
116
117
-
For example, if we want the same code to run for `case 3` and `case 5`:
117
+
De exemplu, dacă vrem să executăm același cod pentru `case 3` și `case 5`:
118
118
119
119
```js run no-beautify
120
120
let a = 2 + 2;
121
121
122
122
switch (a) {
123
123
case 4:
124
-
alert('Right!');
124
+
alert('Corect!');
125
125
break;
126
126
127
127
*!*
128
-
case 3: // (*) grouped two cases
128
+
case 3: // (*) douș cazuri grupate
129
129
case 5:
130
-
alert('Wrong!');
131
-
alert("Why don't you take a math class?");
130
+
alert('Greșit!');
131
+
alert("De ce nu urmezi un curs de matematică?");
132
132
break;
133
133
*/!*
134
134
135
135
default:
136
-
alert('The result is strange. Really.');
136
+
alert('Acest rezultat e ciudat. Pe bune.');
137
137
}
138
138
```
139
139
140
-
Now both `3` and `5` show the same message.
140
+
Acum atât `3` cât și `5` arată același mesaj.
141
141
142
-
The ability to "group" cases is a side-effect of how `switch/case` works without `break`. Here the execution of `case 3` starts from the line `(*)` and goes through `case 5`, because there's no `break`.
142
+
Posibilitatea de a ȚgrupaȚ cazuri este un efect secundar al modului în care funcționează `switch/case` fără `break`. Execuția blocului `case 3` începe de la linia marcată `(*)` și continuă în `case 5`, pentru că nu există niciun `break`.
143
143
144
-
## Type matters
144
+
## Tipul contează
145
145
146
-
Let's emphasize that the equality check is always strict. The values must be of the same type to match.
146
+
Să accentuăm faptul că egalitatea este întotdeauna strictă. Valorile trebuie să fie de același tip pentru a avea o potrivire.
147
147
148
-
For example, let's consider the code:
148
+
De exemplu, să considerăm codul:
149
149
150
150
```js run
151
-
let arg = prompt("Enter a value?");
151
+
let arg = prompt("Introduceți o valoare?");
152
152
switch (arg) {
153
153
case '0':
154
154
case '1':
155
-
alert( 'One or zero' );
155
+
alert( 'Unu sau zero' );
156
156
break;
157
157
158
158
case '2':
159
-
alert( 'Two' );
159
+
alert( 'Doi' );
160
160
break;
161
161
162
162
case 3:
163
-
alert( 'Never executes!' );
163
+
alert( 'Nu se execută niciodată!' );
164
164
break;
165
165
default:
166
-
alert( 'An unknown value' );
166
+
alert( 'Valoare necunoscută' );
167
167
}
168
168
```
169
169
170
-
1. For `0`, `1`, the first `alert` runs.
171
-
2. For `2` the second `alert` runs.
172
-
3. But for `3`, the result of the `prompt` is a string `"3"`, which is not strictly equal `===` to the number `3`. So we've got a dead code in `case 3`! The `default` variant will execute.
170
+
1. Pentru `0`, `1`, primul `alert` este executat.
171
+
2. Pentru `2` se execută al doilea `alert`.
172
+
3. Dar pentru `3`, rezultatul instrucțiunii `prompt` este șirul `"3"`, care nu este strict egal `===` cu numărul `3`, deci am obținut cod mort pentru `case 3`! Blocul `default` va fi executat în acest caz.
0 commit comments