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
By specification, only two primitive types may serve as object property keys:
4
+
Ifølge specifikationen kan kun to primitive typer bruges som objekt-egenskabsnøgler:
5
5
6
-
- string type, or
7
-
-symbol type.
6
+
-Typen string (tekststreng), eller
7
+
-Typen symbol.
8
8
9
-
Otherwise, if one uses another type, such as number, it's autoconverted to string. So that `obj[1]`is the same as`obj["1"]`, and`obj[true]`is the same as`obj["true"]`.
9
+
Hvis andre typer bruges, såsom tal, konverteres de automatisk til en tekststreng. Så `obj[1]`er det samme som`obj["1"]`, og`obj[true]`er det samme som`obj["true"]`.
10
10
11
-
Until now we've been using only strings.
11
+
Indtil nu har vi kun brugt tekststregne.
12
12
13
-
Now let's explore symbols, see what they can do for us.
13
+
Nu skal vi udforske symboler og se, hvad de kan gøre for os.
14
14
15
-
## Symbols
15
+
## Symboler
16
16
17
-
A "symbol" represents a unique identifier.
17
+
Et "symbol" repræsenterer en unik identifikator.
18
18
19
-
A value of this type can be created using`Symbol()`:
19
+
En værdi af denne type kan oprettes ved hjælp af`Symbol()`:
20
20
21
21
```js
22
22
let id =Symbol();
23
23
```
24
24
25
-
Upon creation, we can give symbols a description (also called a symbol name), mostly useful for debugging purposes:
25
+
Når det oprettes, kan vi give symboler en beskrivelse (også kaldet et symbolnavn), som mest bruges til debugging-formål:
26
26
27
27
```js
28
-
// id is a symbol with the description "id"
28
+
// id er et symbol med beskrivelsen "id"
29
29
let id =Symbol("id");
30
30
```
31
31
32
-
Symbols are guaranteed to be unique. Even if we create many symbols with exactly the same description, they are different values. The description is just a label that doesn't affect anything.
32
+
Symboler er garanteret unikke. Selv hvis vi opretter mange symboler med præcis samme beskrivelse, er de forskellige værdier. Beskrivelsen er bare en etiket, der ikke påvirker noget.
33
33
34
-
For instance, here are two symbols with the same description -- they are not equal:
34
+
For eksempel ser vi her to symboler med samme beskrivelse -- de er ikke ens:
35
35
36
36
```js run
37
37
let id1 =Symbol("id");
@@ -42,14 +42,14 @@ alert(id1 == id2); // false
42
42
*/!*
43
43
```
44
44
45
-
If you are familiar with Ruby or another language that also has some sort of "symbols" -- please don't be misguided. JavaScript symbols are different.
45
+
Hvis du er bekendt med Ruby eller et andet sprog, der også har en form for "symboler" -- lad dig ikke forvirre. JavaScript-symboler er forskellige.
46
46
47
-
So, to summarize, a symbol is a "primitive unique value" with an optional description. Let's see where we can use them.
47
+
Kort sagt, et symbol er en "primitiv unik værdi" med en valgfri beskrivelse. Lad os se, hvor vi kan bruge dem.
48
48
49
-
````warn header="Symbols don't auto-convert to a string"
50
-
Most values in JavaScript support implicit conversion to a string. For instance, we can `alert` almost any value, and it will work. Symbols are special. They don't auto-convert.
49
+
````warn header="Symboler konverteres ikke automatisk til en streng"
50
+
De fleste værdier i JavaScript understøtter implicit konvertering til en streng. For eksempel kan vi `alert` næsten enhver værdi, og det vil fungere. Symboler er specielle. De konverteres ikke automatisk.
51
51
52
-
For instance, this `alert` will show an error:
52
+
For eksempel vil denne `alert` vise en fejl:
53
53
54
54
```js run
55
55
let id = Symbol("id");
@@ -58,18 +58,18 @@ alert(id); // TypeError: Cannot convert a Symbol value to a string
58
58
*/!*
59
59
```
60
60
61
-
That's a "language guard" against messing up, because strings and symbols are fundamentally different and should not accidentally convert one into another.
61
+
Dette er en "sproglig beskyttelse" mod fejl, fordi strenge og symboler er fundamentalt forskellige og ikke utilsigtet bør konverteres til hinanden.
62
62
63
-
If we really want to show a symbol, we need to explicitly call `.toString()` on it, like here:
63
+
Hvis vi virkelig vil vise et symbol, skal vi eksplicit kalde `.toString()` på det, som her:
64
64
65
65
```js run
66
66
let id = Symbol("id");
67
67
*!*
68
-
alert(id.toString()); // Symbol(id), now it works
68
+
alert(id.toString()); // Symbol(id), nu virker det
69
69
*/!*
70
70
```
71
71
72
-
Or get `symbol.description` property to show the description only:
72
+
Eller få `symbol.description`-egenskaben for kun at vise beskrivelsen:
73
73
74
74
```js run
75
75
let id = Symbol("id");
@@ -80,81 +80,81 @@ alert(id.description); // id
80
80
81
81
````
82
82
83
-
## "Hidden" properties
83
+
## "Skjulte" egenskaber
84
84
85
85
86
-
Symbols allow us to create "hidden" properties of an object, that no other part of code can accidentally access or overwrite.
86
+
Symboler tillader os at skabe "skjulte" egenskaber på et objekt, som ingen anden del af koden kan tilgå eller overskrive ved et uheld.
87
87
88
-
For instance, if we're working with`user`objects, that belong to a third-party code. We'd like to add identifiers to them.
88
+
For eksempel, hvis vi arbejder med`user`objekter, der tilhører en tredjepartskode. Vi vil gerne tilføje identifikatorer til dem.
89
89
90
-
Let's use a symbol key for it:
90
+
Lad os bruge en symbolnøgle til det:
91
91
92
92
```js run
93
-
let user = { //belongs to another code
93
+
let user = { //tilhører en anden kode
94
94
name:"John"
95
95
};
96
96
97
97
let id =Symbol("id");
98
98
99
99
user[id] =1;
100
100
101
-
alert( user[id] ); //we can access the data using the symbol as the key
101
+
alert( user[id] ); //vi kan tilgå dataene ved hjælp af symbolet som nøgle
102
102
```
103
103
104
-
What's the benefit of using `Symbol("id")`over a string`"id"`?
104
+
Hvad er fordelen ved at bruge `Symbol("id")`frem for en streng`"id"`?
105
105
106
-
As`user`objects belong to another codebase, it's unsafe to add fields to them, since we might affect pre-defined behavior in that other codebase. However, symbols cannot be accessed accidentally. The third-party code won't be aware of newly defined symbols, so it's safe to add symbols to the`user`objects.
106
+
Da`user`objekter tilhører en anden kodebase, er det usikkert at tilføje felter til dem, da vi måske påvirker foruddefineret adfærd i den anden kodebase. Symboler kan dog ikke tilgås ved et uheld. Tredjepartskoden vil ikke være opmærksom på nyligt definerede symboler, så det er sikkert at tilføje symboler til`user`objekterne.
107
107
108
-
Also, imagine that another script wants to have its own identifier inside `user`, for its own purposes.
108
+
Forestil dig også, at et andet script ønsker at have sin egen identifikator inde i `user`, til sine egne formål.
109
109
110
-
Then that script can create its own `Symbol("id")`, like this:
110
+
Så kan det script oprette sit eget `Symbol("id")`, sådan her:
111
111
112
112
```js
113
113
// ...
114
114
let id =Symbol("id");
115
115
116
-
user[id] ="Their id value";
116
+
user[id] ="Deres id værdi";
117
117
```
118
118
119
-
There will be no conflict between our and their identifiers, because symbols are always different, even if they have the same name.
119
+
Der vil ikke være nogen konflikt mellem vores og deres identifikatorer, fordi symboler altid er forskellige, selvom de har samme navn.
120
120
121
-
...But if we used a string`"id"`instead of a symbol for the same purpose, then there *would* be a conflict:
121
+
...Men hvis vi brugte en streng`"id"`i stedet for et symbol til det samme formål, så *ville* der være en konflikt:
122
122
123
123
```js
124
124
let user = { name:"John" };
125
125
126
-
//Our script uses "id" property
127
-
user.id="Our id value";
126
+
//Vores script bruger "id" egenskaben
127
+
user.id="Vores id værdi";
128
128
129
-
// ...Another script also wants "id" for its purposes...
129
+
// ...Et andet script ønsker også "id" til sine formål...
130
130
131
-
user.id="Their id value"
131
+
user.id="Deres id værdi"
132
132
// Boom! overwritten by another script!
133
133
```
134
134
135
-
### Symbols in an object literal
135
+
### Symboler i et objekt-literal
136
136
137
-
If we want to use a symbol in an object literal `{...}`, we need square brackets around it.
137
+
Hvis vi vil bruge et symbol i et objekt-literal `{...}`, skal vi have firkantede parenteser omkring det.
138
138
139
-
Like this:
139
+
Som dette:
140
140
141
141
```js
142
142
let id =Symbol("id");
143
143
144
144
let user = {
145
145
name:"John",
146
146
*!*
147
-
[id]:123//not "id": 123
147
+
[id]:123//ikke "id": 123
148
148
*/!*
149
149
};
150
150
```
151
-
That's because we need the value from the variable `id`as the key, not the string "id".
151
+
Dette er fordi vi har brug for værdien fra variablen `id`som nøgle, ikke strengen "id".
152
152
153
-
### Symbols are skipped by for..in
153
+
### Symboler springes over af for..in
154
154
155
-
Symbolic properties do not participate in `for..in` loop.
155
+
Symboliske egenskaber deltager ikke i `for..in`-løkker.
156
156
157
-
For instance:
157
+
For eksempel:
158
158
159
159
```js run
160
160
let id =Symbol("id");
@@ -165,16 +165,16 @@ let user = {
165
165
};
166
166
167
167
*!*
168
-
for (let key in user) alert(key); // name, age (no symbols)
168
+
for (let key in user) alert(key); // name, age (ingen symboler)
169
169
*/!*
170
170
171
-
//the direct access by the symbol works
172
-
alert( "Direct: "+ user[id] ); //Direct: 123
171
+
//direkte adgang via symbolet virker
172
+
alert( "Direkte: "+ user[id] ); //Direkte: 123
173
173
```
174
174
175
-
[Object.keys(user)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)also ignores them. That's a part of the general "hiding symbolic properties" principle. If another script or a library loops over our object, it won't unexpectedly access a symbolic property.
175
+
[Object.keys(user)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)ignorerer dem også. Det er en del af det generelle princip om "at skjule symbolske egenskaber". Hvis et andet script eller et bibliotek løber over vores objekt, vil det ikke utilsigtet få adgang til en egenskaber der er symboler.
176
176
177
-
In contrast, [Object.assign](mdn:js/Object/assign)copies both string and symbol properties:
177
+
Modsat så kopierer [Object.assign](mdn:js/Object/assign)både streng- og symbol-egenskaber. Det er ikke en fejl, det er designet sådan. Ideen er, at når vi kloner et objekt eller merger objekter, vil vi normalt have *alle* egenskaber kopieret (inklusive symboler som `id`).:
178
178
179
179
```js run
180
180
let id =Symbol("id");
@@ -187,103 +187,103 @@ let clone = Object.assign({}, user);
187
187
alert( clone[id] ); // 123
188
188
```
189
189
190
-
There's no paradox here. That's by design. The idea is that when we clone an object or merge objects, we usually want *all* properties to be copied (including symbols like`id`).
190
+
Der er ikke noget paradoks her. Det er designet sådan. Ideen er, at når vi kloner et objekt eller merger objekter, vil vi normalt have *alle* egenskaber kopieret (inklusive symboler som`id`).
191
191
192
-
## Global symbols
192
+
## Globale symboler
193
193
194
-
As we've seen, usually all symbols are different, even if they have the same name. But sometimes we want same-named symbols to be same entities. For instance, different parts of our application want to access symbol `"id"` meaning exactly the same property.
194
+
Som vi har set, er alle symboler normalt forskellige, selvom de har samme navn. Men nogle gange ønsker vi, at symboler med samme navn skal være de samme entiteter. For eksempel ønsker forskellige dele af vores applikation at få adgang til symbolet `"id"`, som betyder præcis den samme egenskab.
195
195
196
-
To achieve that, there exists a *global symbol registry*. We can create symbols in it and access them later, and it guarantees that repeated accesses by the same name return exactly the same symbol.
196
+
For at opnå dette findes der et *globalt symbolregister*. Vi kan oprette symboler i det og få adgang til dem senere, og det garanterer, at gentagne adgangsforsøg med samme navn returnerer præcis det samme symbol.
197
197
198
-
In order to read (create if absent) a symbol from the registry, use`Symbol.for(key)`.
198
+
For at læse (eller oprette, hvis det ikke findes) et symbol fra registret, brug`Symbol.for(key)`.
199
199
200
-
That call checks the global registry, and if there's a symbol described as`key`, then returns it, otherwise creates a new symbol `Symbol(key)`and stores it in the registry by the given`key`.
200
+
Dette kald tjekker det globale register, og hvis der findes et symbol beskrevet som`key`, returnerer det det, ellers opretter det et nyt symbol `Symbol(key)`og gemmer det i registret under den givne`key`.
201
201
202
-
For instance:
202
+
For eksempel:
203
203
204
204
```js run
205
-
//read from the global registry
206
-
let id =Symbol.for("id"); //if the symbol did not exist, it is created
205
+
//læs fra det globale register
206
+
let id =Symbol.for("id"); //hvis symbolet ikke fandtes, oprettes det
207
207
208
-
//read it again (maybe from another part of the code)
208
+
//læs det igen (måske fra en anden del af koden)
209
209
let idAgain =Symbol.for("id");
210
210
211
-
//the same symbol
211
+
//det samme symbol
212
212
alert( id === idAgain ); // true
213
213
```
214
214
215
-
Symbols inside the registry are called *global symbols*. If we want an application-wide symbol, accessible everywhere in the code -- that's what they are for.
215
+
Symboler i registret kaldes *globale symboler*. Hvis vi ønsker et symbol, der er tilgængeligt på tværs af hele applikationen, er det dem, vi skal bruge.
216
216
217
-
```smart header="That sounds like Ruby"
218
-
In some programming languages, like Ruby, there's a single symbol per name.
217
+
```smart header="Det lyder som Ruby"
218
+
I nogle programmeringssprog, som Ruby, er der kun ét symbol pr. navn.
219
219
220
-
In JavaScript, as we can see, that's true for global symbols.
220
+
I JavaScript, som vi kan se, gælder det for globale symboler.
221
221
```
222
222
223
223
### Symbol.keyFor
224
224
225
-
We have seen that for global symbols, `Symbol.for(key)`returns a symbol by name. To do the opposite -- return a name by global symbol -- we can use: `Symbol.keyFor(sym)`:
225
+
Vi har set, at for globale symboler returnerer `Symbol.for(key)`et symbol efter navn. For at gøre det modsatte -- returnere et navn efter globalt symbol -- kan vi bruge: `Symbol.keyFor(sym)`:
226
226
227
-
For instance:
227
+
For eksempel:
228
228
229
229
```js run
230
-
//get symbol by name
230
+
//få symbol efter navn
231
231
let sym =Symbol.for("name");
232
232
let sym2 =Symbol.for("id");
233
233
234
-
//get name by symbol
234
+
//få navn efter symbol
235
235
alert( Symbol.keyFor(sym) ); // name
236
236
alert( Symbol.keyFor(sym2) ); // id
237
237
```
238
238
239
-
The `Symbol.keyFor`internally uses the global symbol registry to look up the key for the symbol. So it doesn't work for non-global symbols. If the symbol is not global, it won't be able to find it and returns`undefined`.
239
+
`Symbol.keyFor`bruger internt det globale symbolregister til at slå nøglen op for symbolet. Så det virker ikke for ikke-globale symboler. Hvis symbolet ikke er globalt, vil det ikke kunne finde det og returnerer`undefined`.
240
240
241
-
That said, all symbols have the `description` property.
241
+
Med det sagt har alle symboler egenskaben `description`.
242
242
243
-
For instance:
243
+
For eksempel:
244
244
245
245
```js run
246
246
let globalSymbol =Symbol.for("name");
247
247
let localSymbol =Symbol("name");
248
248
249
-
alert( Symbol.keyFor(globalSymbol) ); // name, global symbol
250
-
alert( Symbol.keyFor(localSymbol) ); // undefined, not global
249
+
alert( Symbol.keyFor(globalSymbol) ); // name, globalt symbol
250
+
alert( Symbol.keyFor(localSymbol) ); // undefined, ikke globalt
251
251
252
252
alert( localSymbol.description ); // name
253
253
```
254
254
255
-
## System symbols
255
+
## System symboler
256
256
257
-
There exist many "system" symbols that JavaScript uses internally, and we can use them to fine-tune various aspects of our objects.
257
+
Der findes mange "system" symboler, som JavaScript bruger internt, og vi kan bruge dem til at finjustere forskellige aspekter af vores objekter.
258
258
259
-
They are listed in the specification in the [Well-known symbols](https://tc39.github.io/ecma262/#sec-well-known-symbols) table:
259
+
De er listet i specifikationen i tabellen [Well-known symbols](https://tc39.github.io/ecma262/#sec-well-known-symbols):
260
260
261
261
-`Symbol.hasInstance`
262
262
-`Symbol.isConcatSpreadable`
263
263
-`Symbol.iterator`
264
264
-`Symbol.toPrimitive`
265
-
- ...and so on.
265
+
- ...og så videre.
266
266
267
-
For instance, `Symbol.toPrimitive`allows us to describe object to primitive conversion. We'll see its use very soon.
267
+
For eksempel, `Symbol.toPrimitive`tillader os at beskrive objekt-til-primitive konvertering. Vi vil se dets brug meget snart.
268
268
269
-
Other symbols will also become familiar when we study the corresponding language features.
269
+
Andre symboler vil også blive kendt, når vi studerer de tilsvarende sprogfunktioner.
270
270
271
-
## Summary
271
+
## Opsummering
272
272
273
-
`Symbol`is a primitive type for unique identifiers.
273
+
`Symbol`er en primitiv type til unikke identifikatorer.
274
274
275
-
Symbols are created with`Symbol()`call with an optional description (name).
275
+
Symboler oprettes med kaldet`Symbol()`med en valgfri beskrivelse (navn).
276
276
277
-
Symbols are always different values, even if they have the same name. If we want same-named symbols to be equal, then we should use the global registry: `Symbol.for(key)`returns (creates if needed) a global symbol with`key`as the name. Multiple calls of`Symbol.for`with the same `key`return exactly the same symbol.
277
+
Symboler er altid forskellige værdier, selvom de har samme navn. Hvis vi ønsker, at symboler med samme navn skal være ens, skal vi bruge det globale register: `Symbol.for(key)`returnerer (opretter om nødvendigt) et globalt symbol med`key`som navn. Flere kald af`Symbol.for`med samme `key`returnerer præcis det samme symbol.
278
278
279
-
Symbols have two main use cases:
279
+
Symboler har to hovedanvendelser:
280
280
281
-
1. "Hidden" object properties.
281
+
1. "Skjulte" objekt-egenskaber.
282
282
283
-
If we want to add a property into an object that "belongs" to another script or a library, we can create a symbol and use it as a property key. A symbolic property does not appear in `for..in`, so it won't be accidentally processed together with other properties. Also it won't be accessed directly, because another script does not have our symbol. So the property will be protected from accidental use or overwrite.
283
+
Hvis vi ønsker at tilføje en egenskab til et objekt, der "tilhører" et andet script eller et bibliotek, kan vi oprette et symbol og bruge det som en egenskabsnøgle. En symbolsk egenskab vises ikke i `for..in`, så den vil ikke blive behandlet ved et uheld sammen med andre egenskaber. Den vil heller ikke blive tilgået direkte, fordi et andet script ikke har vores symbol. Så egenskaben vil være beskyttet mod utilsigtet brug eller overskrivning.
284
284
285
-
So we can "covertly" hide something into objects that we need, but others should not see, using symbolic properties.
285
+
Dermed kan vi "skjult" gemme noget i objekter, som vi har brug for, men som andre ikke bør se, ved hjælp af egenskaber oprettet som symboler.
286
286
287
-
2.There are many system symbols used by JavaScript which are accessible as `Symbol.*`. We can use them to alter some built-in behaviors. For instance, later in the tutorial we'll use`Symbol.iterator`for[iterables](info:iterable), `Symbol.toPrimitive`to setup [object-to-primitive conversion](info:object-toprimitive)and so on.
287
+
2.Der findes mange systemsymboler, som JavaScript bruger internt, og som er tilgængelige som `Symbol.*`. Vi kan bruge dem til at ændre nogle indbyggede adfærd. For eksempel vil vi senere i vejledningen bruge`Symbol.iterator`til[iterables](info:iterable), `Symbol.toPrimitive`til at opsætte [objekt-til-primitive konvertering](info:object-toprimitive)og så videre.
288
288
289
-
Technically, symbols are not 100% hidden. There is a built-in method[Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols) that allows us to get all symbols. Also there is a method named[Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) that returns *all* keys of an object including symbolic ones. But most libraries, built-in functions and syntax constructs don't use these methods.
289
+
Teknisk set er symboler ikke 100% skjulte. Der findes en indbygget metode[Object.getOwnPropertySymbols(obj)](mdn:js/Object/getOwnPropertySymbols), der tillader os at få alle symboler. Der findes også en metode kaldet[Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys), som returnerer *alle* nøgler i et objekt, inklusive symbolske. Men de fleste biblioteker, indbyggede funktioner og syntaks-konstruktioner bruger ikke disse metoder. Så i praksis er symboler skjulte for de fleste operationer, og det er usandsynligt, at de vil blive tilgået ved et uheld.
0 commit comments