Merge pull request #240 from ockley/master

WeakMap and WeakSet

Author: ockley

1-js/05-data-types/08-weakmap-weakset/01-recipients-read/solution.md

@@ -9,35 +9,35 @@ let messages = [
 
 let readMessages = new WeakSet();
 
-// two messages have been read
+// to beskeder er læst
 readMessages.add(messages[0]);
 readMessages.add(messages[1]);
-// readMessages has 2 elements
+// readMessages har 2 elementer
 
-// ...let's read the first message again!
+// ...lad os læse den første besked igen!
 readMessages.add(messages[0]);
-// readMessages still has 2 unique elements
+// readMessages stadig har 2 unikke elementer
 
-// answer: was the message[0] read?
-alert("Read message 0: " + readMessages.has(messages[0])); // true
+// svar: var message[0] læst?
+alert("Er besked 0 læst: " + readMessages.has(messages[0])); // true
 
 messages.shift();
-// now readMessages has 1 element (technically memory may be cleaned later)
+// nu har readMessages 1 element (teknisk set kan hukommelsen ryddes senere)
 ```
 
-The `WeakSet` allows to store a set of messages and easily check for the existence of a message in it.
+Et `WeakSet` tillader at gemme et sæt af beskeder og nemt kontrollere, om en besked findes i det.
 
-It cleans up itself automatically. The tradeoff is that we can't iterate over it,  can't get "all read messages" from it directly. But we can do it by iterating over all messages and filtering those that are in the set.
+Det rydder automatisk op i sig selv. Ulempen er, at vi ikke kan iterere over det, og vi kan ikke få "alle læste beskeder" direkte fra det. Men vi kan gøre det ved at iterere over alle beskeder og filtrere dem, der er i sættet.
 
-Another, different solution could be to add a property like `message.isRead=true` to a message after it's read. As messages objects are managed by another code, that's generally discouraged, but we can use a symbolic property to avoid conflicts.
+En anden, forskellig løsning kunne være at tilføje en egenskab som `message.isRead=true` til en besked, efter den er læst. Da beskedobjekter styres af en anden kode, er det generelt ikke anbefalet, men vi kan bruge en symbolsk egenskab for at undgå konflikter.
 
-Like this:
+Som dette:
 ```js
-// the symbolic property is only known to our code
+// den symbolske egenskab er kun kendt af vores kode
 let isRead = Symbol("isRead");
 messages[0][isRead] = true;
 ```
 
-Now third-party code probably won't see our extra property.
+Nu vil 3de-parts kode sandsynligvis ikke se vores ekstra egenskab.
 
-Although symbols allow to lower the probability of problems, using `WeakSet` is better from the architectural point of view.
+Selvom symboler reducerer sandsynligheden for problemer, er brugen af `WeakSet` bedre fra et arkitektonisk synspunkt.

1-js/05-data-types/08-weakmap-weakset/01-recipients-read/task.md

@@ -2,22 +2,22 @@ importance: 5
 
 ---
 
-# Store "unread" flags
+# Opbevar "ulæste" flag
 
-There's an array of messages:
+Her er et array af beskeder:
 
 ```js
 let messages = [
-  {text: "Hello", from: "John"},
-  {text: "How goes?", from: "John"},
-  {text: "See you soon", from: "Alice"}
+  {text: "Hej", from: "John"},
+  {text: "Hvordan går det?", from: "John"},
+  {text: "Vi ses snart", from: "Alice"}
 ];
 ```
 
-Your code can access it, but the messages are managed by someone else's code. New messages are added, old ones are removed regularly by that code, and you don't know the exact moments when it happens.
+Din kode kan tilgå det, men beskederne styres af en andens kode. Nye beskeder tilføjes, gamle fjernes regelmæssigt af den kode, og du kender ikke de præcise tidspunkter, hvor det sker.
 
-Now, which data structure could you use to store information about whether the message "has been read"? The structure must be well-suited to give the answer "was it read?" for the given message object.
+Hvilken datastruktur kunne du bruge til at gemme information om, hvorvidt beskeden "er blevet læst"? Strukturen skal være velegnet til at give svaret "blev den læst?" for det givne beskedobjekt.
 
-P.S. When a message is removed from `messages`, it should disappear from your structure as well.
+P.S. Når en besked fjernes fra `messages`, skal den også forsvinde fra din struktur.
 
-P.P.S. We shouldn't modify message objects, add our properties to them. As they are managed by someone else's code, that may lead to bad consequences.
+P.P.S. Vi bør ikke ændre beskedobjekterne ved at tilføje vores egne egenskaber til dem. Da de styres af en andens kode, kan det føre til uønskede konsekvenser.

1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/solution.md

@@ -1,15 +1,15 @@
 
-To store a date, we can use `WeakMap`:
+For at gemme en dato, kan vi bruge `WeakMap`:
 
 ```js
 let messages = [
-  {text: "Hello", from: "John"},
-  {text: "How goes?", from: "John"},
-  {text: "See you soon", from: "Alice"}
+  {text: "Hej", from: "John"},
+  {text: "Hvordan går det?", from: "John"},
+  {text: "Vi ses snart", from: "Alice"}
 ];
 
 let readMap = new WeakMap();
 
 readMap.set(messages[0], new Date(2017, 1, 1));
-// Date object we'll study later
+// Date objektet vil vi studere senere
 ```

1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/task.md

@@ -2,20 +2,20 @@ importance: 5
 
 ---
 
-# Store read dates
+# Gem datoer for læsning
 
-There's an array of messages as in the [previous task](info:task/recipients-read). The situation is similar.
+Der er et array af beskeder som i [forrige opgave](info:task/recipients-read). Situationen er lignende.
 
 ```js
 let messages = [
-  {text: "Hello", from: "John"},
-  {text: "How goes?", from: "John"},
-  {text: "See you soon", from: "Alice"}
+  {text: "Hej", from: "John"},
+  {text: "Hvordan går det?", from: "John"},
+  {text: "Vi ses snart", from: "Alice"}
 ];
 ```
 
-The question now is: which data structure you'd suggest to store the information: "when the message was read?".
+Spørgsmålet nu er: hvilken datastruktur vil du foreslå til at gemme informationen: "hvornår blev beskeden læst?".
 
-In the previous task we only needed to store the "yes/no" fact. Now we need to store the date, and it should only remain in memory until the message is garbage collected.
+I den forrige opgave skulle vi kun gemme "ja/nej"-faktumet. Nu skal vi gemme datoen, og den skal kun forblive i hukommelsen, indtil beskeden bliver garbage collected.
 
-P.S. Dates can be stored as objects of built-in `Date` class, that we'll cover later.
+P.S. Datoer kan gemmes som objekter af den indbyggede `Date`-klasse, som vi dækker senere.