From 01abb36bf9a48c8c27ab7011dd5da3e846f37f26 Mon Sep 17 00:00:00 2001 From: vplentinax Date: Sun, 10 May 2020 02:02:37 -0400 Subject: [PATCH 01/12] WeakMap and WeakSet --- .../01-recipients-read/solution.md | 43 +++ .../01-recipients-read/task.md | 23 ++ .../02-recipients-when-read/solution.md | 15 + .../02-recipients-when-read/task.md | 21 ++ 1-js/05-data-types/weakmap-weakset/article.md | 288 ++++++++++++++++++ 5 files changed, 390 insertions(+) create mode 100644 1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md create mode 100644 1-js/05-data-types/weakmap-weakset/01-recipients-read/task.md create mode 100644 1-js/05-data-types/weakmap-weakset/02-recipients-when-read/solution.md create mode 100644 1-js/05-data-types/weakmap-weakset/02-recipients-when-read/task.md create mode 100644 1-js/05-data-types/weakmap-weakset/article.md diff --git a/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md b/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md new file mode 100644 index 000000000..1ebbb6a88 --- /dev/null +++ b/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md @@ -0,0 +1,43 @@ +Guardemos los mensajes leídos en `WeakSet`: + +```js run +let messages = [ + {text: "Hello", from: "John"}, + {text: "How goes?", from: "John"}, + {text: "See you soon", from: "Alice"} +]; + +let readMessages = new WeakSet(); + +// se han leído dos mensajes +readMessages.add(messages[0]); +readMessages.add(messages[1]); +// readMessages tiene 2 elementos + +// ...¡leamos nuevamente el primer mensaje! +readMessages.add(messages[0]); +// readMessages todavía tiene dos únicos elementos + +// respuesta: ¿se leyó el mensaje [0]? +alert("Read message 0: " + readMessages.has(messages[0])); // true + +messages.shift(); +// ahora readMessages tiene 1 elemento (técnicamente la memoria puede limpiarse más tarde) +``` + +El `WeakEst` permite almacenar un conjunto de mensajes y verificar fácilmente la existencia de un mensaje en él. + +Se limpia automáticamente. La compensación es que no podemos iterar sobre él, no podemos obtener "todos los mensajes leídos" directamente. Pero podemos hacerlo iterando sobre todos los mensajes y filtrando los que están en el conjunto. + +Otra solución diferente podría ser agregar una propiedad como `message.isRead = true` a un mensaje después de leerlo. Como los objetos de mensajes son administrados por otro código, generalmente se desaconseja, pero podemos usar una propiedad simbólica para evitar conflictos. + +Like this: +```js +// la propiedad simbólica solo es conocida por nuestro código +let isRead = Symbol("isRead"); +messages[0][isRead] = true; +``` + +Ahora el código de terceros probablemente no verá nuestra propiedad adicional. + +Aunque los símbolos permiten reducir la probabilidad de problemas, usar `WeakSet` es mejor desde el punto de vista arquitectónico. diff --git a/1-js/05-data-types/weakmap-weakset/01-recipients-read/task.md b/1-js/05-data-types/weakmap-weakset/01-recipients-read/task.md new file mode 100644 index 000000000..69a0d2246 --- /dev/null +++ b/1-js/05-data-types/weakmap-weakset/01-recipients-read/task.md @@ -0,0 +1,23 @@ +importance: 5 + +--- + +# Almacenar banderas "no leídas" + +Hay un array de mensajes: + +```js +let messages = [ + {text: "Hello", from: "John"}, + {text: "How goes?", from: "John"}, + {text: "See you soon", from: "Alice"} +]; +``` + +Su código puede acceder a él, pero los mensajes son administrados por el código de otra persona. Se agregan mensajes nuevos, los códigos viejos se eliminan regularmente con ese código, y usted no sabe los momentos exactos en que sucede. + +Ahora, ¿qué estructura de datos podría usar para almacenar información sobre si el mensaje "ha sido leído"? La estructura debe ser adecuada para dar la respuesta "¿se leyó?" para el objeto del mensaje dado. + +P.D Cuando un mensaje se elimina de `messages`, también debería desaparecer de su estructura. + +P.P.D. No debemos modificar los objetos del mensaje, o agregarles nuestras propiedades. Como son administrados por el código de otra persona, eso puede generarnos resultados no deseados. diff --git a/1-js/05-data-types/weakmap-weakset/02-recipients-when-read/solution.md b/1-js/05-data-types/weakmap-weakset/02-recipients-when-read/solution.md new file mode 100644 index 000000000..a3ad7f659 --- /dev/null +++ b/1-js/05-data-types/weakmap-weakset/02-recipients-when-read/solution.md @@ -0,0 +1,15 @@ + +Para almacenar una fecha, podemos usar `WeakMap`: + +```js +let messages = [ + {text: "Hello", from: "John"}, + {text: "How goes?", from: "John"}, + {text: "See you soon", from: "Alice"} +]; + +let readMap = new WeakMap(); + +readMap.set(messages[0], new Date(2017, 1, 1)); +// // Obeto Date que estudiaremos más tarde +``` diff --git a/1-js/05-data-types/weakmap-weakset/02-recipients-when-read/task.md b/1-js/05-data-types/weakmap-weakset/02-recipients-when-read/task.md new file mode 100644 index 000000000..62a4a2670 --- /dev/null +++ b/1-js/05-data-types/weakmap-weakset/02-recipients-when-read/task.md @@ -0,0 +1,21 @@ +importance: 5 + +--- + +# Almacenar fechas de lectura + +Hay un array semejante al de la actividad anterior [previous task](info:task/recipients-read). La sitación es similar: + +```js +let messages = [ + {text: "Hello", from: "John"}, + {text: "How goes?", from: "John"}, + {text: "See you soon", from: "Alice"} +]; +``` + +La pregunta ahora es: ¿qué estructura de datos es la adecuada para almacenar la información: "cuando se leyó el mensaje?". + +En la tarea anterior solo necesitábamos almacenar el hecho de "sí / no". Ahora necesitamos almacenar la fecha, y solo debe permanecer en la memoria hasta que el mensaje sea recolectado como basura. + +P.D Las fechas se pueden almacenar como objetos de la clase incorporada `Fecha`, que cubriremos más adelante. diff --git a/1-js/05-data-types/weakmap-weakset/article.md b/1-js/05-data-types/weakmap-weakset/article.md new file mode 100644 index 000000000..a09765883 --- /dev/null +++ b/1-js/05-data-types/weakmap-weakset/article.md @@ -0,0 +1,288 @@ +# WeakMap y WeakSet + +Como sabemos por el capítulo , el motor de JavaScript almacena un valor en la memoria mientras es accesible(y puede ser potencialmente usado). + +Por ejemplo: +```js +let john = { name: "John" }; + +// se puede acceder al objeto, john es su referencia + +// sobrescribe la referencia +john = null; + +*!* +// el objeto será eliminado de la memoria +*/!* +``` + +Por lo general, las propiedades de un objeto o elementos de un array u otra estructura de datos se consideran accesibles y se mantienen en la memoria mientras esa estructura de datos permanezca en la memoria. + +Por ejemplo, si colocamos un objeto en un array, mientras el array esté vivo, el objeto también estará vivo, incluso si no hay otras referencias a él. + +Like this: + +```js +let john = { name: "John" }; + +let array = [ john ]; + +john = null; // sobrescribe la referencia + +*!* +// John se almacena dentro del array, por lo que no será recolectado por el recolector de basura +// Lo podemos obtener como array[0] +*/!* +``` + +Similar a eso, si usamos un objeto como la propiedad en un `Map` regular, entonces mientras exista el` Map`, ese objeto también existe. Éste objeto cupa memoria y no puede ser recolectado por el recolector de basura. + +Por ejemplo + +```js +let john = { name: "John" }; + +let map = new Map(); +map.set(john, "..."); + +john = null; // sobreescribe la referencia + +*!* +// john se almacena dentro de map, +// podemos obtenerlo usando map.keys () +*/!* +``` + +`WeakMap` es fundamentalmente diferente en este aspecto. No impide la recolección de basura de propiedades de objetos. + +Veamos qué significa esto en los ejemplos. + +## WeakMap + +La primera diferencia con `Map` es que las propiedades `WeakMap` deben ser objetos, no valores primitivos: + +```js run +let weakMap = new WeakMap(); + +let obj = {}; + +weakMap.set(obj, "ok"); // funciona bien(propiedad de objeto) + +*!* +// no puede usar un string como propiedad +weakMap.set("test", "Whoops"); // Error, porque "test" no es un objeto +*/!* +``` + +Ahora, si usamos un objeto como propiedad y no hay otras referencias a ese objeto, se eliminará de la memoria (y del map) automáticamente. + +```js +let john = { name: "John" }; + +let weakMap = new WeakMap(); +weakMap.set(john, "..."); + +john = null; // sobreescribe la referencia + +// John se eliminó de la memoria! +``` + +Compárelo con el ejemplo del `Map` regular anterior. Ahora, si `john` solo existe como la propiedad de` WeakMap`, se eliminará automáticamente del map (y de la memoria). + +`WeakMap` no admite iteración y métodos `keys()`, `values()`, `entries()`, así que no hay forma de obtener todas las propiedades o valores de él. + +`WeakMap` tiene solo los siguientes métodos: + +- `weakMap.get(propiedad)` +- `weakMap.set(propiedad, valor)` +- `weakMap.delete(propiedad)` +- `weakMap.has(propiedad)` + +¿Por qué tanta limitación? Eso es por razones técnicas. Si un objeto ha perdido todas las demás referencias (como `john` en el código anterior), entonces se debe recolectar basura automáticamente. Pero técnicamente no se especifica exactamente *cuando se realiza la limpieza*. + +El motor de JavaScript decide eso. Puede optar por realizar la limpieza de la memoria inmediatamente o esperar y realizar la limpieza más tarde cuando ocurran más eliminaciones. Por lo tanto, técnicamente no se conoce el recuento actual de elementos de un `WeakMap`. El motor puede haberlo limpiado o no, o lo hizo parcialmente. Por esa razón, los métodos que acceden a todas las propiedades / valores no son compatibles. + +Ahora, ¿dónde necesitamos esta estructura de datos? + +## Caso de uso: datos adicionales + +El área principal de aplicación de `WeakMap` es en un *almacenamiento de datos adicional*. + +Si estamos trabajando con un objeto que "pertenece" a otro código, tal vez incluso una biblioteca de terceros, y quisiera almacenar algunos datos asociados con él, eso solo debería existir mientras el objeto esté vivo, entonces `WeakMap` es exactamente lo que se necesita. + +Ponemos los datos en un `WeakMap`, utilizando el objeto como propiedad, y cuando el objeto sea recolectado por el recolector de basura, esos datos también desaparecerán automáticamente. + +```js +weakMap.set(john, "secret documents"); +// si John muere, secret documents será destruido automáticamente +``` + +Veamos un ejemplo. + +Por ejemplo, tenemos un código que mantiene un recuento de visitas para los usuarios. La información se almacena en un mapa: un objeto de usuario es la propiedad y el recuento de visitas es el valor. Cuando un usuario se va (su objeto será recolectado por el recolector de basura), ya no queremos almacenar su recuento de visitas. + +Aquí hay un ejemplo de una función de conteo con `Map`: + +```js +// 📁 visitsCount.js +let visitsCountMap = new Map(); // map: user => visits count + +// incrementar el recuento de visitas +function countUser(user) { + let count = visitsCountMap.get(user) || 0; + visitsCountMap.set(user, count + 1); +} +``` + +Y aquí hay otra parte del código, tal vez otro archivo usándolo: + +```js +// 📁 main.js +let john = { name: "John" }; + +countUser(john); // cuenta sus visitas + +// luego John nos deja +john = null; +``` + +Ahora el objeto `john` debería ser recolectado como basura, pero permanece en la memoria, ya que es una propiedad en` visitCountMap`. + +Necesitamos limpiar `visitCountMap` cuando eliminamos usuarios, de lo contrario, crecerá en la memoria indefinidamente. Tal limpieza puede convertirse en una tarea tediosa en arquitecturas complejas. + +Lo podemos evitar cambiando a `WeakMap` en su lugar: + +```js +// 📁 visitsCount.js +let visitsCountMap = new WeakMap(); // weakmap: user => visits count + +// incrementar el recuento de visitas +function countUser(user) { + let count = visitsCountMap.get(user) || 0; + visitsCountMap.set(user, count + 1); +} +``` + +Ahora no tenemos que limpiar `visitasCountMap`. Después de que el objeto `john` se vuelve inalcanzable por todos los medios, excepto como una propiedad de` WeakMap`, se elimina de la memoria, junto con la información de esa propiedad de `WeakMap`. + +## Caso de uso: almacenamiento en caché + +Otro ejemplo común es el almacenamiento en caché: cuando se debe recordar el resultado de una función ("en caché"), para que las llamadas futuras en el mismo objeto lo reutilicen. + +Podemos usar `Map` para almacenar resultados, así: + +```js run +// 📁 cache.js +let cache = new Map(); + +// calcular y recordar el resultado +function process(obj) { + if (!cache.has(obj)) { + let result = /* calculations of the result for */ obj; + + cache.set(obj, result); + } + + return cache.get(obj); +} + +*!* +// Ahora nosotros usamos process() en otro archivo: +*/!* + +// 📁 main.js +let obj = {/* let's say we have an object */}; + +let result1 = process(obj); // calculated + +// ...después, en otro lugar del código... +let result2 = process(obj); // resultado recordado tomado de la memoria caché + +// ...después, cuando el objeto no se necesitará nada más: +obj = null; + +alert(cache.size); // 1 (Ouch! ¡El objeto todavía está en caché, tomando memoria!) +``` + +Para múltiples llamadas de `proceso (obj)` con el mismo objeto, solo calcula el resultado la primera vez, y luego lo toma de `caché`. La desventaja es que necesitamos limpiar el 'caché' cuando el objeto ya no es necesario. + +Si reemplazamos `Map` por `WeakMap`, este problema desaparece: el resultado en caché se eliminará de la memoria automáticamente después de que el objeto se recolecte. + +```js run +// 📁 cache.js +*!* +let cache = new WeakMap(); +*/!* + +// calcular y recordad el resultado +function process(obj) { + if (!cache.has(obj)) { + let result = /* calcular el resultado para */ obj; + + cache.set(obj, result); + } + + return cache.get(obj); +} + +// 📁 main.js +let obj = {/* some object */}; + +let result1 = process(obj); +let result2 = process(obj); + +// ...después, cuando el objeto no se necesitarám más: +obj = null; + +// No se puede obtener cache.size, ya que es un WeakMap, +// pero es 0 o pronto será 0 +// Cuando obj obtiene basura recolectada, los datos en caché también se eliminarán +``` + +## WeakSet + +`WeakSet` se comporta de manera similar: + +- Es análogo a `Set`, pero solo podemos agregar objetos a `WeakSet` (no primitivos). +- Existe un objeto en el conjunto mientras es accesible desde otro lugar. +- Al igual que `Set`, admite` add`, `has` y` delete`, pero no `size`,` keys()` ni iteraciones. + +Al ser "débil", también sirve como almacenamiento adicional. Pero no para datos arbitrarios, sino para hechos "sí / no". Una membresía en `WeakSet` puede significar algo sobre el objeto. + +Por ejemplo, podemos agregar usuarios a `WeakSet` para realizar un seguimiento de los que visitaron nuestro sitio: + +```js run +let visitedSet = new WeakSet(); + +let john = { name: "John" }; +let pete = { name: "Pete" }; +let mary = { name: "Mary" }; + +visitedSet.add(john); // John nos visita +visitedSet.add(pete); // luego Pete +visitedSet.add(john); // John otra vez + +// visitedSet tiene 2 usuarios ahora + +// comprobar si John nos visitó? +alert(visitedSet.has(john)); // true + +// comprobar si Mary nos visitó? +alert(visitedSet.has(mary)); // false + +john = null; + +// visitedSet se limpiará automáticamente +``` + + La limitación más notable de `WeakMap` y` WeakSet` es la ausencia de iteraciones y la imposibilidad de obtener todo el contenido actual. Esto puede parecer inconveniente, pero no impide que `WeakMap / WeakSet` haga su trabajo principal: ser un almacenamiento "adicional" de datos para objetos que se almacenan / administran en otro lugar. + +## Resumen + +`WeakMap` es una colección similar a `Map` que permite solo objetos como propiedades y los elimina junto con el valor asociado una vez que se vuelven inaccesibles por otros medios. + +`WeakSet` es una colección tipo `Set` que almacena solo objetos y los elimina una vez que se vuelven inaccesibles por otros medios. + +Ambos no admiten métodos y propiedades que se refieren a todas las propiedades o su recuento. Solo se permiten operaciones individuales. + +`WeakMap` y` WeakSet` se utilizan como estructuras de dato "secundarias" además del almacenamiento de objetos "principal". Una vez que el objeto se elimina del almacenamiento principal, si solo se encuentra como la propiedad de `WeakMap` o en un` WeakSet`, se limpiará automáticamente. From 46913d1239781d25a95285bfab0f22740b96a31d Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 19:28:27 -0400 Subject: [PATCH 02/12] Update 1-js/05-data-types/weakmap-weakset/article.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com> --- 1-js/05-data-types/weakmap-weakset/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/article.md b/1-js/05-data-types/weakmap-weakset/article.md index a09765883..a42f2bb37 100644 --- a/1-js/05-data-types/weakmap-weakset/article.md +++ b/1-js/05-data-types/weakmap-weakset/article.md @@ -66,7 +66,7 @@ let weakMap = new WeakMap(); let obj = {}; -weakMap.set(obj, "ok"); // funciona bien(propiedad de objeto) +weakMap.set(obj, "ok"); // funciona bien (propiedad de objeto) *!* // no puede usar un string como propiedad From 50372baceaa72d8022685979471d4d16b298274e Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 19:28:36 -0400 Subject: [PATCH 03/12] Update 1-js/05-data-types/weakmap-weakset/article.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com> --- 1-js/05-data-types/weakmap-weakset/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/article.md b/1-js/05-data-types/weakmap-weakset/article.md index a42f2bb37..774a7483b 100644 --- a/1-js/05-data-types/weakmap-weakset/article.md +++ b/1-js/05-data-types/weakmap-weakset/article.md @@ -20,7 +20,7 @@ Por lo general, las propiedades de un objeto o elementos de un array u otra estr Por ejemplo, si colocamos un objeto en un array, mientras el array esté vivo, el objeto también estará vivo, incluso si no hay otras referencias a él. -Like this: +Como esto: ```js let john = { name: "John" }; From 114d8168aa7527f97392b401e4f2726507d34fd5 Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 19:28:47 -0400 Subject: [PATCH 04/12] Update 1-js/05-data-types/weakmap-weakset/02-recipients-when-read/task.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com> --- .../weakmap-weakset/02-recipients-when-read/task.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/02-recipients-when-read/task.md b/1-js/05-data-types/weakmap-weakset/02-recipients-when-read/task.md index 62a4a2670..85dd42dd2 100644 --- a/1-js/05-data-types/weakmap-weakset/02-recipients-when-read/task.md +++ b/1-js/05-data-types/weakmap-weakset/02-recipients-when-read/task.md @@ -18,4 +18,4 @@ La pregunta ahora es: ¿qué estructura de datos es la adecuada para almacenar l En la tarea anterior solo necesitábamos almacenar el hecho de "sí / no". Ahora necesitamos almacenar la fecha, y solo debe permanecer en la memoria hasta que el mensaje sea recolectado como basura. -P.D Las fechas se pueden almacenar como objetos de la clase incorporada `Fecha`, que cubriremos más adelante. +P.D Las fechas se pueden almacenar como objetos de la clase incorporada `Date`, que cubriremos más adelante. From 1c9082b28cf4a68e72b0540bda00466a522b7c3f Mon Sep 17 00:00:00 2001 From: Valentina VP <34555644+vplentinax@users.noreply.github.com> Date: Wed, 10 Jun 2020 19:28:55 -0400 Subject: [PATCH 05/12] Update 1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Carlos Ortiz Gutiérrez <56600925+cortizg@users.noreply.github.com> --- .../weakmap-weakset/01-recipients-read/solution.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md b/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md index 1ebbb6a88..512c02ac4 100644 --- a/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md +++ b/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md @@ -31,7 +31,7 @@ Se limpia automáticamente. La compensación es que no podemos iterar sobre él, Otra solución diferente podría ser agregar una propiedad como `message.isRead = true` a un mensaje después de leerlo. Como los objetos de mensajes son administrados por otro código, generalmente se desaconseja, pero podemos usar una propiedad simbólica para evitar conflictos. -Like this: +Como esto: ```js // la propiedad simbólica solo es conocida por nuestro código let isRead = Symbol("isRead"); From 7ec5e4bdb4b7d41266b8d046a2404120e2a0f08a Mon Sep 17 00:00:00 2001 From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com> Date: Mon, 15 Jun 2020 18:24:07 -0300 Subject: [PATCH 06/12] Update 1-js/05-data-types/weakmap-weakset/article.md Co-authored-by: joaquinelio --- 1-js/05-data-types/weakmap-weakset/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/article.md b/1-js/05-data-types/weakmap-weakset/article.md index 774a7483b..9ce73a1eb 100644 --- a/1-js/05-data-types/weakmap-weakset/article.md +++ b/1-js/05-data-types/weakmap-weakset/article.md @@ -231,7 +231,7 @@ let obj = {/* some object */}; let result1 = process(obj); let result2 = process(obj); -// ...después, cuando el objeto no se necesitarám más: +// ...después, cuando el objeto no se necesitará más: obj = null; // No se puede obtener cache.size, ya que es un WeakMap, From e8a6054bbe1164471003d0f5169a3f6dde0bfb8c Mon Sep 17 00:00:00 2001 From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com> Date: Mon, 15 Jun 2020 18:24:17 -0300 Subject: [PATCH 07/12] Update 1-js/05-data-types/weakmap-weakset/article.md Co-authored-by: joaquinelio --- 1-js/05-data-types/weakmap-weakset/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/article.md b/1-js/05-data-types/weakmap-weakset/article.md index 9ce73a1eb..a5c6c654b 100644 --- a/1-js/05-data-types/weakmap-weakset/article.md +++ b/1-js/05-data-types/weakmap-weakset/article.md @@ -163,7 +163,7 @@ function countUser(user) { } ``` -Ahora no tenemos que limpiar `visitasCountMap`. Después de que el objeto `john` se vuelve inalcanzable por todos los medios, excepto como una propiedad de` WeakMap`, se elimina de la memoria, junto con la información de esa propiedad de `WeakMap`. +Ahora no tenemos que limpiar `visitasCountMap`. Después de que el objeto `john` se vuelve inalcanzable por todos los medios excepto como una propiedad de` WeakMap`, se elimina de la memoria, junto con la información de esa propiedad de `WeakMap`. ## Caso de uso: almacenamiento en caché From 1fa8c93c5237a1646280dc2053184755c5b705a6 Mon Sep 17 00:00:00 2001 From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com> Date: Mon, 15 Jun 2020 18:24:34 -0300 Subject: [PATCH 08/12] Update 1-js/05-data-types/weakmap-weakset/article.md Co-authored-by: joaquinelio --- 1-js/05-data-types/weakmap-weakset/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/article.md b/1-js/05-data-types/weakmap-weakset/article.md index a5c6c654b..bd6c1ab03 100644 --- a/1-js/05-data-types/weakmap-weakset/article.md +++ b/1-js/05-data-types/weakmap-weakset/article.md @@ -98,7 +98,7 @@ Compárelo con el ejemplo del `Map` regular anterior. Ahora, si `john` solo exis - `weakMap.delete(propiedad)` - `weakMap.has(propiedad)` -¿Por qué tanta limitación? Eso es por razones técnicas. Si un objeto ha perdido todas las demás referencias (como `john` en el código anterior), entonces se debe recolectar basura automáticamente. Pero técnicamente no se especifica exactamente *cuando se realiza la limpieza*. +¿Por qué tanta limitación? Eso es por razones técnicas. Si un objeto ha perdido todas las demás referencias (como `john` en el código anterior), entonces se debe recolectar automáticamente como basura. Pero técnicamente no se especifica exactamente *cuándo se realiza la limpieza*. El motor de JavaScript decide eso. Puede optar por realizar la limpieza de la memoria inmediatamente o esperar y realizar la limpieza más tarde cuando ocurran más eliminaciones. Por lo tanto, técnicamente no se conoce el recuento actual de elementos de un `WeakMap`. El motor puede haberlo limpiado o no, o lo hizo parcialmente. Por esa razón, los métodos que acceden a todas las propiedades / valores no son compatibles. From af3268f08903a9142af2907f93497afcf5b8b30b Mon Sep 17 00:00:00 2001 From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com> Date: Mon, 15 Jun 2020 18:25:04 -0300 Subject: [PATCH 09/12] Update 1-js/05-data-types/weakmap-weakset/article.md Co-authored-by: joaquinelio --- 1-js/05-data-types/weakmap-weakset/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/article.md b/1-js/05-data-types/weakmap-weakset/article.md index bd6c1ab03..ff32141ad 100644 --- a/1-js/05-data-types/weakmap-weakset/article.md +++ b/1-js/05-data-types/weakmap-weakset/article.md @@ -89,7 +89,7 @@ john = null; // sobreescribe la referencia Compárelo con el ejemplo del `Map` regular anterior. Ahora, si `john` solo existe como la propiedad de` WeakMap`, se eliminará automáticamente del map (y de la memoria). -`WeakMap` no admite iteración y métodos `keys()`, `values()`, `entries()`, así que no hay forma de obtener todas las propiedades o valores de él. +`WeakMap` no admite la iteración ni los métodos `keys()`, `values()`, `entries()`, así que no hay forma de obtener todas las propiedades o valores de él. `WeakMap` tiene solo los siguientes métodos: From 826a7efb67d74b79b5fefe8c5165717795494050 Mon Sep 17 00:00:00 2001 From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com> Date: Mon, 15 Jun 2020 18:25:16 -0300 Subject: [PATCH 10/12] Update 1-js/05-data-types/weakmap-weakset/article.md Co-authored-by: joaquinelio --- 1-js/05-data-types/weakmap-weakset/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/article.md b/1-js/05-data-types/weakmap-weakset/article.md index ff32141ad..291e2faa5 100644 --- a/1-js/05-data-types/weakmap-weakset/article.md +++ b/1-js/05-data-types/weakmap-weakset/article.md @@ -84,7 +84,7 @@ weakMap.set(john, "..."); john = null; // sobreescribe la referencia -// John se eliminó de la memoria! +// ¡John se eliminó de la memoria! ``` Compárelo con el ejemplo del `Map` regular anterior. Ahora, si `john` solo existe como la propiedad de` WeakMap`, se eliminará automáticamente del map (y de la memoria). From c66d582e0841e9b32ceda0490646ab588a74d891 Mon Sep 17 00:00:00 2001 From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com> Date: Mon, 15 Jun 2020 18:25:28 -0300 Subject: [PATCH 11/12] Update 1-js/05-data-types/weakmap-weakset/article.md Co-authored-by: joaquinelio --- 1-js/05-data-types/weakmap-weakset/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/article.md b/1-js/05-data-types/weakmap-weakset/article.md index 291e2faa5..96a42d1e1 100644 --- a/1-js/05-data-types/weakmap-weakset/article.md +++ b/1-js/05-data-types/weakmap-weakset/article.md @@ -35,7 +35,7 @@ john = null; // sobrescribe la referencia */!* ``` -Similar a eso, si usamos un objeto como la propiedad en un `Map` regular, entonces mientras exista el` Map`, ese objeto también existe. Éste objeto cupa memoria y no puede ser recolectado por el recolector de basura. +Similar a eso, si usamos un objeto como la propiedad en un `Map` regular, entonces mientras exista el` Map`, ese objeto también existe. Este objeto ocupa memoria y no puede ser reclamado por el recolector de basura. Por ejemplo From 6c6d71a14b96cc13158f1ef4d4148ce132dfed08 Mon Sep 17 00:00:00 2001 From: Ezequiel Castellanos <51804994+ezzep66@users.noreply.github.com> Date: Mon, 15 Jun 2020 18:25:38 -0300 Subject: [PATCH 12/12] Update 1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md Co-authored-by: joaquinelio --- .../weakmap-weakset/01-recipients-read/solution.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md b/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md index 512c02ac4..8994f5962 100644 --- a/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md +++ b/1-js/05-data-types/weakmap-weakset/01-recipients-read/solution.md @@ -27,7 +27,7 @@ messages.shift(); El `WeakEst` permite almacenar un conjunto de mensajes y verificar fácilmente la existencia de un mensaje en él. -Se limpia automáticamente. La compensación es que no podemos iterar sobre él, no podemos obtener "todos los mensajes leídos" directamente. Pero podemos hacerlo iterando sobre todos los mensajes y filtrando los que están en el conjunto. +Se limpia automáticamente. La desventaja es que no podemos iterar sobre él, no podemos obtener "todos los mensajes leídos" directamente. Pero podemos hacerlo iterando sobre todos los mensajes y filtrando los que están en el conjunto. Otra solución diferente podría ser agregar una propiedad como `message.isRead = true` a un mensaje después de leerlo. Como los objetos de mensajes son administrados por otro código, generalmente se desaconseja, pero podemos usar una propiedad simbólica para evitar conflictos.