Jun 3, 2025 · Jan 25, 2025
diff --git a/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/solution.md b/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/solution.md
 Let's store read messages in `WeakSet`:
 Uložme přečtené zprávy do `WeakSet`:

 ```js run
 letmessages = [
  {text: "Hello",from: "John"},
  {text: "How goes?",from: "John"},
  {text: "See you soon",from: "Alice"}
 letzprávy = [
  {text: "Ahoj",od: "Jan"},
  {text: "Jak se máš?",od: "Jan"},
  {text: "Brzy nashle",od: "Alice"}
 ];

 letreadMessages = new WeakSet();
 letpřečtenéZprávy = new WeakSet();

 //two messages have been read
 readMessages.add(messages[0]);
 readMessages.add(messages[1]);
 //readMessages has 2elements
 //dvě zprávy byly přečteny
 přečtenéZprávy.add(zprávy[0]);
 přečtenéZprávy.add(zprávy[1]);
 //přečtenéZprávy obsahuje 2prvky

 // ...let's read the first message again!
 readMessages.add(messages[0]);
 //readMessages still has 2unique elements
 // ...znovu přečteme první zprávu!
 přečtenéZprávy.add(zprávy[0]);
 //přečtenéZprávy stále obsahuje 2unikátní prvky

 //answer: was the message[0] read?
 alert("Read message 0: " +readMessages.has(messages[0])); // true
 //odpověď: byla zpráva s indexem 0 přečtena?
 alert("Zpráva 0 přečtena: " +přečtenéZprávy.has(zprávy[0])); // true

 messages.shift();
 //now readMessages has 1element (technically memory may be cleaned later)
 zprávy.shift();
 //nyní přečtenéZprávy obsahuje 1prvek (technicky může být paměť vyčištěna později)
 ```

 The`WeakSet`allows to store a set of messages and easily check for the existence of a message in it.
 `WeakSet`nám umožňuje uložit množinu zpráv a snadno ověřovat, zda v ní zpráva existuje.

 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.
 Automaticky se vyčistí. Nevýhodou je, že nad ní nemůžeme iterovat, nemůžeme získat „všechny přečtené zprávy“ přímo z ní. Můžeme to však udělat iterací nad všemi zprávami a filtrováním těch, které jsou v této množině.

 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.
 Jiným řešením by bylo přidání vlastnosti, např. `zpráva.jePřečtena=true`, do zprávy poté, co bude přečtena. Pokud objekty zpráv spravuje jiný kód, obecně se to nedoporučuje, ale můžeme se vyhnout konfliktům použitím symbolické vlastnosti.

 Like this:
 Třeba takto:
 ```js
 //the symbolic property is only known to our code
 letisRead = Symbol("isRead");
 messages[0][isRead] = true;
 //symbolickou vlastnost zná pouze náš kód
 letjePřečtena = Symbol("jePřečtena");
 zprávy[0][jePřečtena] = true;
 ```

 Now third-party code probably won't see our extra property.
 Nyní kód třetí strany naši přidanou vlastnost neuvidí.

 Although symbols allow to lower the probability of problems, using `WeakSet` is better from the architectural point of view.
 Přestože symboly mohou snížit pravděpodobnost problémů, z architektonického hlediska je lepší použít `WeakSet`.
diff --git a/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/task.md b/1-js/05-data-types/08-weakmap-weakset/01-recipients-read/task.md

 ---

 #Store "unread" flags
 #Uložení označení „přečteno“

 There's an array of messages:
 Máme pole zpráv:

 ```js
 letmessages = [
  {text: "Hello",from: "John"},
  {text: "How goes?",from: "John"},
  {text: "See you soon",from: "Alice"}
 letzprávy = [
  {text: "Ahoj",od: "Jan"},
  {text: "Jak se máš?",od: "Jan"},
  {text: "Brzy nashle",od: "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.
 Váš kód k němu může přistupovat, ale zprávy spravuje kód někoho jiného. Tento kód pravidelně přidává nové zprávy a odebírá staré. Vy neznáte přesný okamžik, kdy se to stane.

 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.
 Kterou datovou strukturu nyní můžete použít k uložení informace, že zpráva „byla přečtena“? Struktura musí být vybavena tak, aby pro zadaný objekt zprávy vydala odpověď na otázku „byla zpráva přečtena?“.

 P.S.When a message is removed from `messages`,it should disappear from your structure as well.
 P.S.Když je zpráva odstraněna z pole `zprávy`,měla by zmizet i z vaší struktury.

 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 leadtobad consequences.
 P.P.S.Objekty zpráv bychom neměli modifikovat a přidávat do nich naše vlastnosti. Protože je spravuje kód někoho jiného, mohlo bytovést k nežádoucím důsledkům.
diff --git a/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/solution.md b/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/solution.md

 To store a date, we can use `WeakMap`:
 K uložení data můžeme použít `WeakMap`:

 ```js
 letmessages = [
  {text: "Hello",from: "John"},
  {text: "How goes?",from: "John"},
  {text: "See you soon",from: "Alice"}
 letzprávy = [
  {text: "Ahoj",od: "Jan"},
  {text: "Jak se máš?",od: "Jan"},
  {text: "Brzy se uvidíme",od: "Alice"}
 ];

 letreadMap = new WeakMap();
 letmapaPřečtení = new WeakMap();

 readMap.set(messages[0], new Date(2017, 1, 1));
 // Dateobject we'll study later
 mapaPřečtení.set(zprávy[0], new Date(2017, 1, 1));
 //objektyDateprostudujeme později
 ```
diff --git a/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/task.md b/1-js/05-data-types/08-weakmap-weakset/02-recipients-when-read/task.md

 ---

 #Store read dates
 #Uložení data přečtení

 There's an array of messages as in the [previous task](info:task/recipients-read).The situation is similar.
 Máme stejné pole zpráv, jako [v předchozí úloze](info:task/recipients-read).Situace je obdobná.

 ```js
 letmessages = [
  {text: "Hello",from: "John"},
  {text: "How goes?",from: "John"},
  {text: "See you soon",from: "Alice"}
 letzprávy = [
  {text: "Ahoj",od: "Jan"},
  {text: "Jak se máš?",od: "Jan"},
  {text: "Brzy se uvidíme",od: "Alice"}
 ];
 ```

 The question now is: which data structure you'd suggest to store the information: "when the message was read?".
 Otázka teď zní: kterou datovou strukturu byste doporučili k uložení informace „kdy byla zpráva přečtena“?

 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.
 V předchozí úloze jsme potřebovali ukládat jen skutečnost „ano/ne“. Nyní musíme ukládat datum, které by mělo zůstat v paměti jen do doby, než bude zpráva odklizena sběračem odpadků.

 P.S.Dates can be stored as objects of built-in`Date` class, that we'll cover later.
 P.S.Data lze ukládat jako objekty vestavěné třídy`Date`, kterou probereme později.
Original file line number	Diff line number	Diff line change
		@@ -1,43 +1,43 @@
		Let's store read messages in `WeakSet`:
		Uložme přečtené zprávy do `WeakSet`:

		```js run
		letmessages = [
		{text: "Hello",from: "John"},
		{text: "How goes?",from: "John"},
		{text: "See you soon",from: "Alice"}
		letzprávy = [
		{text: "Ahoj",od: "Jan"},
		{text: "Jak se máš?",od: "Jan"},
		{text: "Brzy nashle",od: "Alice"}
		];

		letreadMessages = new WeakSet();
		letpřečtenéZprávy = new WeakSet();

		//two messages have been read
		readMessages.add(messages[0]);
		readMessages.add(messages[1]);
		//readMessages has 2elements
		//dvě zprávy byly přečteny
		přečtenéZprávy.add(zprávy[0]);
		přečtenéZprávy.add(zprávy[1]);
		//přečtenéZprávy obsahuje 2prvky

		// ...let's read the first message again!
		readMessages.add(messages[0]);
		//readMessages still has 2unique elements
		// ...znovu přečteme první zprávu!
		přečtenéZprávy.add(zprávy[0]);
		//přečtenéZprávy stále obsahuje 2unikátní prvky

		//answer: was the message[0] read?
		alert("Read message 0: " +readMessages.has(messages[0])); // true
		//odpověď: byla zpráva s indexem 0 přečtena?
		alert("Zpráva 0 přečtena: " +přečtenéZprávy.has(zprávy[0])); // true

		messages.shift();
		//now readMessages has 1element (technically memory may be cleaned later)
		zprávy.shift();
		//nyní přečtenéZprávy obsahuje 1prvek (technicky může být paměť vyčištěna později)
		```

		The`WeakSet`allows to store a set of messages and easily check for the existence of a message in it.
		`WeakSet`nám umožňuje uložit množinu zpráv a snadno ověřovat, zda v ní zpráva existuje.

		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.
		Automaticky se vyčistí. Nevýhodou je, že nad ní nemůžeme iterovat, nemůžeme získat „všechny přečtené zprávy“ přímo z ní. Můžeme to však udělat iterací nad všemi zprávami a filtrováním těch, které jsou v této množině.

		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.
		Jiným řešením by bylo přidání vlastnosti, např. `zpráva.jePřečtena=true`, do zprávy poté, co bude přečtena. Pokud objekty zpráv spravuje jiný kód, obecně se to nedoporučuje, ale můžeme se vyhnout konfliktům použitím symbolické vlastnosti.

		Like this:
		Třeba takto:
		```js
		//the symbolic property is only known to our code
		letisRead = Symbol("isRead");
		messages[0][isRead] = true;
		//symbolickou vlastnost zná pouze náš kód
		letjePřečtena = Symbol("jePřečtena");
		zprávy[0][jePřečtena] = true;
		```

		Now third-party code probably won't see our extra property.
		Nyní kód třetí strany naši přidanou vlastnost neuvidí.

		Although symbols allow to lower the probability of problems, using `WeakSet` is better from the architectural point of view.
		Přestože symboly mohou snížit pravděpodobnost problémů, z architektonického hlediska je lepší použít `WeakSet`.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,22 +2,22 @@ importance: 5

		---

		#Store "unread" flags
		#Uložení označení „přečteno“

		There's an array of messages:
		Máme pole zpráv:

		```js
		letmessages = [
		{text: "Hello",from: "John"},
		{text: "How goes?",from: "John"},
		{text: "See you soon",from: "Alice"}
		letzprávy = [
		{text: "Ahoj",od: "Jan"},
		{text: "Jak se máš?",od: "Jan"},
		{text: "Brzy nashle",od: "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.
		Váš kód k němu může přistupovat, ale zprávy spravuje kód někoho jiného. Tento kód pravidelně přidává nové zprávy a odebírá staré. Vy neznáte přesný okamžik, kdy se to stane.

		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.
		Kterou datovou strukturu nyní můžete použít k uložení informace, že zpráva „byla přečtena“? Struktura musí být vybavena tak, aby pro zadaný objekt zprávy vydala odpověď na otázku „byla zpráva přečtena?“.

		P.S.When a message is removed from `messages`,it should disappear from your structure as well.
		P.S.Když je zpráva odstraněna z pole `zprávy`,měla by zmizet i z vaší struktury.

		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 leadtobad consequences.
		P.P.S.Objekty zpráv bychom neměli modifikovat a přidávat do nich naše vlastnosti. Protože je spravuje kód někoho jiného, mohlo bytovést k nežádoucím důsledkům.
Original file line number	Diff line number	Diff line change
		@@ -1,15 +1,15 @@

		To store a date, we can use `WeakMap`:
		K uložení data můžeme použít `WeakMap`:

		```js
		letmessages = [
		{text: "Hello",from: "John"},
		{text: "How goes?",from: "John"},
		{text: "See you soon",from: "Alice"}
		letzprávy = [
		{text: "Ahoj",od: "Jan"},
		{text: "Jak se máš?",od: "Jan"},
		{text: "Brzy se uvidíme",od: "Alice"}
		];

		letreadMap = new WeakMap();
		letmapaPřečtení = new WeakMap();

		readMap.set(messages[0], new Date(2017, 1, 1));
		// Dateobject we'll study later
		mapaPřečtení.set(zprávy[0], new Date(2017, 1, 1));
		//objektyDateprostudujeme později
		```
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,20 +2,20 @@ importance: 5

		---

		#Store read dates
		#Uložení data přečtení

		There's an array of messages as in the [previous task](info:task/recipients-read).The situation is similar.
		Máme stejné pole zpráv, jako [v předchozí úloze](info:task/recipients-read).Situace je obdobná.

		```js
		letmessages = [
		{text: "Hello",from: "John"},
		{text: "How goes?",from: "John"},
		{text: "See you soon",from: "Alice"}
		letzprávy = [
		{text: "Ahoj",od: "Jan"},
		{text: "Jak se máš?",od: "Jan"},
		{text: "Brzy se uvidíme",od: "Alice"}
		];
		```

		The question now is: which data structure you'd suggest to store the information: "when the message was read?".
		Otázka teď zní: kterou datovou strukturu byste doporučili k uložení informace „kdy byla zpráva přečtena“?

		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.
		V předchozí úloze jsme potřebovali ukládat jen skutečnost „ano/ne“. Nyní musíme ukládat datum, které by mělo zůstat v paměti jen do doby, než bude zpráva odklizena sběračem odpadků.

		P.S.Dates can be stored as objects of built-in`Date` class, that we'll cover later.
		P.S.Data lze ukládat jako objekty vestavěné třídy`Date`, kterou probereme později.