diff options
| -rw-r--r-- | files/es/web/javascript/reference/global_objects/weakmap/index.html | 279 | ||||
| -rw-r--r-- | files/es/web/javascript/reference/global_objects/weakmap/index.md | 147 |
2 files changed, 147 insertions, 279 deletions
diff --git a/files/es/web/javascript/reference/global_objects/weakmap/index.html b/files/es/web/javascript/reference/global_objects/weakmap/index.html deleted file mode 100644 index 7d85820c1d..0000000000 --- a/files/es/web/javascript/reference/global_objects/weakmap/index.html +++ /dev/null @@ -1,279 +0,0 @@ ---- -title: WeakMap -slug: Web/JavaScript/Reference/Global_Objects/WeakMap -tags: - - ECMAScript 2015 - - JavaScript - - WeakMap -translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap -original_slug: Web/JavaScript/Referencia/Objetos_globales/WeakMap ---- -<div>{{JSRef}}</div> - -<p>El objeto <strong><code>WeakMap</code></strong> es una colección de pares clave/valor en la que las claves son objetos y los valores son valores arbitrarios.</p> - -<h2 id="Sintaxis">Sintaxis</h2> - -<pre class="syntaxbox notranslate"><code>new WeakMap([iterable]) -</code></pre> - -<h3 id="Parámetros">Parámetros</h3> - -<dl> - <dt><code>iterable</code></dt> - <dd>Iterable es un Array u otro objeto iterable cuyos elementos son pares clave-valor (Arrays de dos elementos). Cada par clave-valor será añadido al nuevo WeakMap. null es tratado como undefined.</dd> -</dl> - -<h2 id="Descripción">Descripción</h2> - -<p>Las claves de los WeakMaps solamente pueden ser del tipo<code> Object</code>. Los {{Glossary("Primitive", "Primitive data types")}} como claves no están permitidos (ej. un {{jsxref("Symbol")}} no pueden ser una clave de <code>WeakMap</code>).</p> - -<h3 id="¿Por_qué_WeakMap">¿Por qué <em>Weak</em>Map?</h3> - -<p>El programador de JavaScript experimentado se habrá dado cuenta que esta API podría ser implementada en JavaScript con dos arrays (uno para las claves, otro para los valores) compartidos por los cuatro métodos de la API. Dicha implementación habría tenido dos inconvenientes principales: El primero es una búsqueda O(n) (siendo n el número de claves en el mapa). El segundo es un problema de pérdida de memoria. Con mapas escritos manualmente, el array de las claves mantendría referencias a la objetos clave, impidiéndoles ser recolectados. En los WeakMap nativos, las referencias a los objetos clave son mantenidas "débilmente", lo que quiere decir que no impiden la recolección de basura en caso de que no haya otras referencias al objeto.</p> - -<p>Dado que las referencias son débiles, <code>las claves de WeakMap</code> no son enumerables (ej: no existe un método que te devuelva la lista de las claves). Si existiera, la lista dependería de la recolección de basura, introduciendo indeterminismo. Si quieres una lista de las claves, se debe usar un {{jsxref("Map")}} o mantenerla tu mismo.</p> - -<h2 id="Propiedades">Propiedades</h2> - -<dl> - <dt><code>WeakMap.length</code></dt> - <dd>El valor de la propiedad <code>length</code> es 0.</dd> - <dt>{{jsxref("WeakMap.prototype")}}</dt> - <dd>Representa el prototipo para el nuevo constructor<code> WeakMap</code>. Permite añadir propiedades a todos los objetos <code>WeakMap</code>.</dd> -</dl> - -<h2 id="Instancias_de_WeakMap"><code>Instancias de WeakMap</code></h2> - -<p>Todas las instancias de <code>WeakMap</code> heredan de {{jsxref("WeakMap.prototype")}}.</p> - -<h3 id="Propiedades_2">Propiedades</h3> - -<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/WeakMap/prototype','Properties')}}</p> - -<h3 id="Métodos">Métodos</h3> - -<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/WeakMap/prototype','Methods')}}</p> - -<h2 id="Ejemplos">Ejemplos</h2> - -<h3 id="Usando_WeakMap">Usando <code>WeakMap</code></h3> - -<pre class="brush: js notranslate">var wm1 = new WeakMap(), - wm2 = new WeakMap(), - wm3 = new WeakMap(); -var o1 = {}, - o2 = function(){}, - o3 = window; - -wm1.set(o1, 37); -wm1.set(o2, "azerty"); -wm2.set(o1, o2); // un valor puede ser cualquier cosa, incluidos objetos o funciones -wm2.set(o3, undefined); -wm2.set(wm1, wm2); // claves y valores pueden ser objetos cualesquiera. !Incluso WeakMaps! - -wm1.get(o2); // "azerty" -wm2.get(o2); // undefined, porque no hay valor para o2 en wm2 -wm2.get(o3); // undefined, porque es es el valor del conjunto -wm1.has(o2); // true -wm2.has(o2); // false -wm2.has(o3); // true (incluso si el valor es 'undefined') - -wm3.set(o1, 37); -wm3.get(o1); // 37 - -wm1.has(o1); // true -wm1.delete(o1); -wm1.has(o1); // false - -</pre> - -<h3 id="Implementando_una_clase_tipo-WeakMap_con_un_método_.clear">Implementando una clase tipo-<code>WeakMap</code> con un método .clear()</h3> - -<p>Con propósito expositivo, el siguiente ejemplo usa el nuevo costruct class de ECMAScript 2015, que actualmente no ha sido implementado de forma amplia.</p> - -<pre class="brush: js notranslate">class ClearableWeakMap { - constructor(init) { - this._wm = new WeakMap(init) - } - clear() { - this._wm = new WeakMap() - } - delete(k) { - return this._wm.delete(k) - } - get(k) { - return this._wm.get(k) - } - has(k) { - return this._wm.has(k) - } - set(k, v) { - this._wm.set(k, v) - return this - } -} -</pre> - -<h2 id="Especificaciones">Especificaciones</h2> - -<table class="standard-table"> - <thead> - <tr> - <th scope="col">Especificación</th> - <th scope="col">Estado</th> - <th scope="col">Comentario</th> - </tr> - </thead> - <tbody> - <tr> - <td>{{SpecName('ES2015', '#sec-weakmap-objects', 'WeakMap')}}</td> - <td>{{Spec2('ES2015')}}</td> - <td>Definición inicial.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilidad_de_navegadores">Compatibilidad de navegadores</h2> - -<p>{{CompatibilityTable}}</p> - -<div id="compat-desktop"> -<table class="compat-table"> - <tbody> - <tr> - <th>Característica</th> - <th>Chrome</th> - <th>Firefox (SpiderMonkey)</th> - <th>Internet Explorer</th> - <th>Opera</th> - <th>Safari</th> - </tr> - <tr> - <td>Soporte básico</td> - <td>36</td> - <td>{{CompatGeckoDesktop("6.0")}}</td> - <td>11</td> - <td>{{ CompatOpera(23) }}</td> - <td>7.1</td> - </tr> - <tr> - <td><code>new WeakMap(iterable)</code></td> - <td>38</td> - <td>{{CompatGeckoDesktop("36")}}</td> - <td>{{CompatNo}}</td> - <td>{{ CompatOpera(25) }}</td> - <td>{{CompatNo}}</td> - </tr> - <tr> - <td><code>clear()</code></td> - <td>36</td> - <td>{{CompatGeckoDesktop("20.0")}}</td> - <td>11</td> - <td>{{ CompatOpera(23) }}</td> - <td>7.1</td> - </tr> - <tr> - <td>Constructor argument: <code>new WeakMap(null)</code></td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatGeckoDesktop("37")}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - </tr> - <tr> - <td>Monkey-patched <code>set()</code> in Constructor</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatGeckoDesktop("37")}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - </tr> - <tr> - <td><code>WeakMap()</code> without <code>new</code> throws</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatGeckoDesktop("42")}}</td> - <td>11</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - </tr> - </tbody> -</table> -</div> - -<div id="compat-mobile"> -<table class="compat-table"> - <tbody> - <tr> - <th>Característica</th> - <th>Android</th> - <th>Firefox Mobile (SpiderMonkey)</th> - <th>IE Mobile</th> - <th>Opera Mobile</th> - <th>Safari Mobile</th> - </tr> - <tr> - <td>Soporte básico</td> - <td>35</td> - <td>{{CompatGeckoMobile("6.0")}}</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>iOS 8</td> - </tr> - <tr> - <td><code>new WeakMap(iterable)</code></td> - <td>38</td> - <td>{{CompatGeckoMobile("36")}}</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - </tr> - <tr> - <td><code>clear()</code></td> - <td>35</td> - <td>{{CompatGeckoMobile("20.0")}}</td> - <td>{{CompatNo}}</td> - <td>{{CompatNo}}</td> - <td>iOS 8</td> - </tr> - <tr> - <td>Constructor argument: <code>new WeakMap(null)</code></td> - <td>{{CompatUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatGeckoMobile("37")}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - </tr> - <tr> - <td>Monkey-patched <code>set()</code> in Constructor</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatVersionUnknown}}</td> - <td>{{CompatGeckoMobile("37")}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - </tr> - <tr> - <td><code>WeakMap()</code> without <code>new</code> throws</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatGeckoMobile("42")}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - <td>{{CompatUnknown}}</td> - <td></td> - <td></td> - </tr> - </tbody> -</table> -</div> - -<h2 id="sect1"></h2> - -<h2 id="Ver_también">Ver también</h2> - -<ul> - <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=547941">WeakMap bug en Mozilla</a></li> - <li><a href="http://fitzgeraldnick.com/weblog/53/">Ocultando los detalles de implementación con los WeakMaps de ECMAScript </a>2015</li> - <li>{{jsxref("Map")}}</li> - <li>{{jsxref("Set")}}</li> - <li>{{jsxref("WeakSet")}}</li> -</ul> diff --git a/files/es/web/javascript/reference/global_objects/weakmap/index.md b/files/es/web/javascript/reference/global_objects/weakmap/index.md new file mode 100644 index 0000000000..b23b86c4fb --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/weakmap/index.md @@ -0,0 +1,147 @@ +--- +title: WeakMap +slug: Web/JavaScript/Reference/Global_Objects/WeakMap +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap +original_slug: Web/JavaScript/Referencia/Objetos_globales/WeakMap +browser-compat: javascript.builtins.WeakMap +--- +{{JSRef}} + +El objeto `WeakMap` es una colección de pares llave/valor en la que las llaves +deben ser objetos con valores de cualquier +[tipo de dato en JavaScript](/es/docs/Web/JavaScript/Data_structures#javascript_types), +y el cual no crea fuertes referencias a sus llaves. +Es decir, la presencia de un objeto como llave en un `WeakMap` no evita que el +objeto sea recolectado como basura. Una vez que se ha recopilado un objeto +utilizado como llave, sus valores correspondientes en cualquier `WeakMap` se +convierten en candidatos para la recolección de basura — siempre y cuando no se +les mencione fuertemente en otros lugares. + +`WeakMap` permite asociar datos a objectos de una manera que no impide que se +recopilen los objectos llaves, incluso si los valores hacen referencia a las llaves. +Sin embargo, un `WeakMap` no permite observar la vitalidad de sus llaves, por lo +que no permite la enumeración; Si un `WeakMap` expusiera algún método para obtener +una lista de sus llaves, la lista dependería del estado de la recolección de basura, +introduciendo indeterminismo. Si quieres una lista de llaves, +se debe usar un {{jsxref("Map")}} en lugar de un `WeakMap`. + +Puedes aprender más acerca de `WeakMap` en la sección de [objeto WeakMap](/es/docs/Web/JavaScript/Guide/Keyed_collections#weakmap_object) +de la guía [colecciónes con llaves](/es/docs/Web/JavaScript/Guide/Keyed_collections) + +## Descripción + +Las llaves de los WeakMaps solamente pueden ser del tipo `Object`. Los {{Glossary("Primitive", "Primitive data types")}} como claves no están permitidos (ej. un {{jsxref("Symbol")}} no pueden ser una clave de `WeakMap`). + +### ¿Por qué *Weak*Map? + +Una API de mapeo _podría_ ser implementada en JavaScript con dos arreglos (uno para las llaves, otro para los valores) compartidos por los cuatro métodos de la API. +Establecer elementos en este mapa implicaría colocar una llave y valor al final de cada uno de los arreglos simultáneamente. +Como resultado, los índices de la llave y el valor corresponderían a ambas matrices. +Obtener valores del mapa implicaría iterar a través de todas las llaves hasta encontrar una coincidencia, luego usar el índice de esta coincidencia para recuperar el valor correspondiente del arreglo de valores. + +Tal implementación tendría dos inconvenientes principales: + +1. El primero es una búsqueda *O(*n*)* (siendo _n_ el número de claves en el mapa) ya que ambas operaciones deben iterar a través de la lista de llaves para encontrar un valor coincidente. +2. El segundo inconveniente es un problema de pérdida de memoria por que los arreglos se aseguran que las referencias a cada llave y cada valor se mantengan indefinidamente. Estas referencias evitan que las llaves se recopilen como basura, incluso si no hay otras referencias al objeto. Esto también evitaría que los valores correspondientes se recopilen como basura. + +Por el contrario, en un `WeakMap`, un objeto llave se refiere fuertemente a su contenido siempre que la llave no se recolecte como basura, pero débilmente a partir de ese momento. Como tal, un `WeakMap`: + +- No evita la recolección de elementos no utilizados, lo que eventualmente elimina las referencias a la llave del objeto. +- Permite la recolección de basura de cualquier valor si no se hace referencia a sus objectos llave desde otro lugar que no sea un `WeakMap`. + +`WeakMap` puede ser una construcción particularmente útil cuando se asignan llaves a información sobre la llave que es valiosa _solo si_ la llave no ha sido recolectada como basura. + +Pero debido a que un `WeakMap` no permite observar la vida de sus llaves, sus llaves no son enumerables. No existe ningún método para obtener una lista de las llaves. Si lo hubiera, la lista dependería del estado de recolección de basura, introduciendo indeterminismo. Si desea tener una lista de llaves, debe usar {{jsxref("Map")}}. + +## Constructor + +- {{jsxref("WeakMap/WeakMap", "WeakMap()")}} + - : Crea un nuevo objeto `WeakMap`. + +## Métodos de instanciación + +- {{jsxref("WeakMap.delete", "WeakMap.prototype.delete(<var>key</var>)")}} + - : Elimina cualquier valor asociado a la `key`. `WeakMap.prototype.has(key)` regresará `false` después. +- {{jsxref("WeakMap.get", "WeakMap.prototype.get(<var>key</var>)")}} + - : Regresa el valor asociado a la `key`, o `undefined` si no hay ninguno. +- {{jsxref("WeakMap.has", "WeakMap.prototype.has(<var>key</var>)")}} + - : Devuelve un valor booleano que afirma si se ha asociado un valor a la `key` en el objeto `WeakMap` o no. +- {{jsxref("WeakMap.set", "WeakMap.prototype.set(<var>key</var>, <var>value</var>)")}} + - : Establece el `value` para la `key` en el objeto `WeakMap`. Devuelve el objeto `WeakMap`. + +## Ejemplos + +### Usando WeakMap + +```js +const wm1 = new WeakMap(), + wm2 = new WeakMap(), + wm3 = new WeakMap(); +const o1 = {}, + o2 = function () {}, + o3 = window; + +wm1.set(o1, 37); +wm1.set(o2, "azerty"); +wm2.set(o1, o2); // El valor puede ser cualquier cosa, incluyendo un objeto o una función +wm2.set(o3, undefined); +wm2.set(wm1, wm2); // Las llaves y los valores pueden ser cualquier objeto. ¡Incluso WeakMaps! + +wm1.get(o2); // "azerty" +wm2.get(o2); // undefined, porque no hay llave para `o2` en `wm2` +wm2.get(o3); // undefined, porque ese es el valor estabecido + +wm1.has(o2); // true +wm2.has(o2); // false +wm2.has(o3); // true (incluso si el valor en sí es 'undefined') + +wm3.set(o1, 37); +wm3.get(o1); // 37 + +wm1.has(o1); // true +wm1.delete(o1); +wm1.has(o1); // false +``` + +### Implementando una clase tipo-WeakMap con el método .clear() + +```js +class ClearableWeakMap { + constructor(init) { + this._wm = new WeakMap(init); + } + clear() { + this._wm = new WeakMap(); + } + delete(k) { + return this._wm.delete(k); + } + get(k) { + return this._wm.get(k); + } + has(k) { + return this._wm.has(k); + } + set(k, v) { + this._wm.set(k, v); + return this; + } +} +``` + +## Especificaciones + +{{Specifications}} + +## Compatibilidad con navegadores + +{{Compat}} + +## Véase también + +- [Polyfill de `WeakMap` en `core-js`](https://github.com/zloirock/core-js#weakmap) +- [Objetos WeakMap](/es/docs/Web/JavaScript/Guide/Keyed_collections#weakmap_object) en guía de [colecciónes con llaves](/es/docs/Web/JavaScript/Guide/Keyed_collections) +- [Ocultar detalles de implementación con ECMAScript 6 WeakMap](https://fitzgeraldnick.com/weblog/53/) +- {{jsxref("Map")}} +- {{jsxref("Set")}} +- {{jsxref("WeakSet")}} |