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/14-switch/2-rewrite-if-switch/solution.md
+3-3Lines changed: 3 additions & 3 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1,4 +1,4 @@
1
-
The first two checks turn into two`case`. The third check is split into two cases:
1
+
De første to tjek bliver til to`case`. Det tredje tjek er opdelt i to cases:
2
2
3
3
```js run
4
4
let a =+prompt('a?', '');
@@ -21,6 +21,6 @@ switch (a) {
21
21
}
22
22
```
23
23
24
-
Please note: the `break`at the bottom is not required. But we put it to make the code future-proof.
24
+
Bemærk: `break`nederst er ikke påkrævet. Men vi sætter det for at gøre koden fremtidssikret.
25
25
26
-
In the future, there is a chance that we'd want to add one more`case`, for example`case 4`. And if we forget to add a break before it, at the end of `case 3`, there will be an error. So that's a kind of self-insurance.
26
+
I fremtiden er der en chance for, at du vil tilføje en mere`case`, for eksempel`case 4`. Og hvis du glemmer at tilføje et break før det, i slutningen af `case 3`, vil der opstå en fejl. Så det er en form for sikkerhed mod fejl i fremtiden.
A`switch`statement can replace multiple`if` checks.
3
+
Et`switch`udtryk kan erstatte flere`if`-kontroller.
4
4
5
-
It gives a more descriptive way to compare a value with multiple variants.
5
+
Det giver en mere beskrivende måde at sammenligne en værdi med flere varianter på.
6
6
7
-
## The syntax
7
+
## Syntaksen
8
8
9
-
The `switch`has one or more`case`blocks and an optional default.
9
+
`switch`har en eller flere`case`blokke og en valgfri `default`.
10
10
11
-
It looks like this:
11
+
Det ser sådan ud:
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
+
-Værdien af `x`bliver tjekket for streng lighed med værdien fra den første `case` (det vil sige `value1`), derefter den anden (`value2`) og så videre.
30
+
-Hvis ligheden findes, starter `switch`med at udføre koden fra den tilsvarende `case`, indtil den nærmeste`break` (eller indtil slutningen af`switch`).
31
+
-Hvis ingen `case` matcher, bliver `default`koden udført (hvis den findes).
32
32
33
-
## An example
33
+
## Et eksempel
34
34
35
-
An example of`switch` (the executed code is highlighted):
35
+
Et eksempel på`switch` (den udførte kode er fremhævet):
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( 'For lille' );
43
43
break;
44
44
*!*
45
45
case4:
46
-
alert( 'Exactly!' );
46
+
alert( 'Præcis!' );
47
47
break;
48
48
*/!*
49
49
case5:
50
-
alert( 'Too big' );
50
+
alert( 'For stort' );
51
51
break;
52
52
default:
53
-
alert( "I don't know such values" );
53
+
alert( "Jeg kender ikke sådanne værdier" );
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
+
Her starter`switch`med at sammenligne`a`med den første`case` variant, som er`3`. Matchen fejler.
58
58
59
-
Then`4`. That's a match, so the execution starts from `case 4`until the nearest`break`.
59
+
Så`4`. Det er et match, så udførelsen starter fra `case 4`indtil den nærmeste`break`.
60
60
61
-
**If there is no `break` then the execution continues with the next `case`without any checks.**
61
+
**Hvis der ikke er nogen `break`, fortsætter udførelsen med den næste `case`uden nogen kontrol.**
62
62
63
-
An example without`break`:
63
+
Et eksempel uden`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( 'For lille' );
71
71
*!*
72
72
case4:
73
-
alert( 'Exactly!' );
73
+
alert( 'Præcis!' );
74
74
case5:
75
-
alert( 'Too big' );
75
+
alert( 'For stort' );
76
76
default:
77
-
alert( "I don't know such values" );
77
+
alert( "Jeg kender ikke sådanne værdier" );
78
78
*/!*
79
79
}
80
80
```
81
81
82
-
In the example above we'll see sequential execution of three`alert`s:
82
+
I eksemplet ovenfor vil vi se sekventiel udførelse af tre`alert`:
83
83
84
84
```js
85
-
alert( 'Exactly!' );
86
-
alert( 'Too big' );
87
-
alert( "I don't know such values" );
85
+
alert( 'Præcis!' );
86
+
alert( 'For stort' );
87
+
alert( "Jeg kender ikke sådanne værdier" );
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="Alle udtryk kan være et`switch/case` argument"
91
+
Både`switch`og`case`tillader vilkårlige udtryk.
92
92
93
-
For example:
93
+
For eksempel:
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("dette kører, fordi +a er 1, som præcis svarer til b+1");
103
103
break;
104
104
*/!*
105
105
106
106
default:
107
-
alert("this doesn't run");
107
+
alert("dette kører ikke");
108
108
}
109
109
```
110
-
Here `+a`gives`1`, that's compared with`b + 1`in`case`, and the corresponding code is executed.
110
+
`+a`giver`1`, som sammenlignes med`b + 1`i`case`, og den tilsvarende kode udføres.
111
111
````
112
112
113
-
## Grouping of "case"
113
+
## Gruppering af "case"
114
114
115
-
Several variants of `case` which share the same code can be grouped.
115
+
Flere varianter af `case`, som deler den samme kode, kan grupperes.
116
116
117
-
For example, if we want the same code to run for `case 3` and `case 5`:
117
+
For eksempel, hvis vi ønsker at den samme kode skal køre for `case 3` og `case 5`:
118
118
119
119
```js run no-beautify
120
120
let a = 3;
121
121
122
122
switch (a) {
123
123
case 4:
124
-
alert('Right!');
124
+
alert('Rigtigt!');
125
125
break;
126
126
127
127
*!*
128
128
case 3: // (*) grouped two cases
129
129
case 5:
130
-
alert('Wrong!');
131
-
alert("Why don't you take a math class?");
130
+
alert('Forkert!');
131
+
alert("Hvorfor tager du ikke et matematikhold?");
132
132
break;
133
133
*/!*
134
134
135
135
default:
136
-
alert('The result is strange. Really.');
136
+
alert('Resultatet er mærkeligt. Virkelig?!');
137
137
}
138
138
```
139
139
140
-
Now both `3` and `5` show the same message.
140
+
Nu vil både `3` og `5` vise den samme besked.
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
+
Muligheden for at "gruppere" cases er en bivirkning af, hvordan `switch/case` fungerer uden `break`. Her starter udførelsen af `case 3` fra linjen `(*)` og fortsætter gennem `case 5`, fordi der ikke er noget `break`.
143
143
144
-
## Type matters
144
+
## Datatype betyder noget
145
145
146
-
Let's emphasize that the equality check is always strict. The values must be of the same type to match.
146
+
Lad os understrege, at lighedstjekket altid er strengt. Værdierne skal være af samme type for at matche.
147
147
148
-
For example, let's consider the code:
148
+
For eksempel, lad os se på koden:
149
149
150
150
```js run
151
-
let arg = prompt("Enter a value?");
151
+
let arg = prompt("Indtast en værdi?");
152
152
switch (arg) {
153
153
case '0':
154
154
case '1':
155
-
alert( 'One or zero' );
155
+
alert( 'Et eller nul' );
156
156
break;
157
157
158
158
case '2':
159
-
alert( 'Two' );
159
+
alert( 'To' );
160
160
break;
161
161
162
162
case 3:
163
-
alert( 'Never executes!' );
163
+
alert( 'Kører aldrig!' );
164
164
break;
165
165
default:
166
-
alert( 'An unknown value' );
166
+
alert( 'En ukendt værdi' );
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. For `0`, `1`, kører den første `alert`.
171
+
2. For `2` kører den anden `alert`.
172
+
3. Men for `3` er resultatet af `prompt` en streng `"3"`, som ikke er strengt lig med `===` tallet `3`. Så vi har død kode i `case 3`! `default` varianten vil blive udført.
0 commit comments