Explicación detallada del mapeo débil de JavaScript y el conocimiento de colección débil

En pocas palabras, si una variable u objeto es "inalcanzable", entonces no es necesario que la variable u objeto continúe almacenado en la memoria y debe reciclarse.

Por ejemplo:

let xiaoming = {name:'xiaoming'}//Crea un objeto y usa la variable xiaoming para hacer referencia a xiaoming = null //Deja la variable xiaoming en blanco, haciendo que el objeto {name:'xiaoming'} sea inalcanzable//{ nombre: 'xiaoming'} El objeto se recicla

Si una matriz y otros objetos hacen referencia a un objeto, siempre que la matriz y el objeto que hace referencia a él existan en la matriz, entonces el objeto se considera accesible.

Objetos en la matriz:

let xiaoming = {name:'xiaoming'}
let arr = [xiaoming]
xiaoming = null //Dejar la variable xiaoming en blanco //El objeto {nombre:'xiaoming'} no se liberará porque existe en la matriz.

De manera similar, si usamos un objeto como clave Map , si Map existe

Entonces el objeto no será reciclado por el motor.

Objeto clave en Map :

let xiaoming = {name:'xiaoming'}
dejar mapa = nuevo mapa()
map.set(xiaoming,'un niño')
xiaoming = null // Deje la variable xiaoming en blanco // El objeto {nombre: 'xiaoming'} no se liberará porque es la clave del mapa.

WeapMap es fundamentalmente diferente de Map en el procesamiento de liberación de objetos clave. Simplemente, WeapMap no evitará la recolección de basura debido a objetos como claves.

WeakMap

La diferencia entre WeakMap y Map se puede dividir en tres aspectos:

1. WeakMap solo puede usar objetos como claves

letweakMap = new WeakMap()
let obj = {nombre:'obj'}
débilMap.set(obj,'obj como clave')
débilMap.set('str','str as the key')// Los

resultados de la ejecución del código de error son los siguientes:

Se puede ver que cuando usamos cadenas como key , el programa no puede ejecutarse normalmente.

2. No impide que el motor recicle la clave (objeto).

En otras palabras, si un objeto no tiene otras referencias excepto WeakMap , el sistema reciclará el objeto.

Por ejemplo:

let débilMap = nuevo WeakMap()
let obj = {nombre:'obj'}
débilMap.set(obj,'obj como clave')
obj = null //Hacer la variable obj vacía //En este momento, el objeto {nombre:'obj'} será reciclado

3. WeakMap admite métodos limitados

• WeakMap no admite iteración
• WeakMap no admite keys()
• WeakMap no admite values()
• WeakMap no admite entires()

, por lo que no tenemos forma de obtener todos los pares clave-valor.

WeakMap solo puede usar los siguientes métodos:

• weakMap.get(key) Obtener el par clave-valorweakMap.set
• weakMap.set(key,val) Establecer el par clave-valorwelowMap.delete
• weakMap.delete(key) Eliminar el par clave-valorweakMap.has
• weakMap.has(key) Determinar si

existe El método de acceso a datos de WeakMap debe restringirse porque no se puede determinar el momento en que el motor JavaScript libera el objeto.

Cuando un objeto pierde todas las referencias, JavaScript puede liberar el espacio ocupado por el objeto inmediatamente o puede esperar un tiempo.

Por lo tanto, en un momento determinado, no se puede determinar la cantidad de elementos de WeakMap . (Imagínese, si recorremos los elementos de WeakMap después de que un objeto pierde todas las referencias, podemos obtener resultados diferentes).

Casos de uso de WeakMap

El escenario de aplicación de WeakMap generalmente es almacenar datos que "pertenecen" a un objeto cuando el objeto no. Cuando estén presentes, los datos "pertenecientes" a este objeto también deben divulgarse.

Hay una historia histórica que es muy adecuada para usar WeakMap`: "El conejo astuto muere, los lacayos son cocinados; los pájaros se han ido y el buen arco se esconde".

Si describimos esta historia en código JavaScript , deberíamos usar WeakMap :

let débilMap = new WeakMap()
let Rabbit = {name:'rabbit'} //El conejo astuto let runDog = {name:'runDog'} //El perro que corre let flyBird = {name:'flyBird'} //El pájaro volador let goodBow = {name :'goodBow'} //Liang Gong débilMap.set(conejo,runDog)
mapa débil.set(flyBird,goodBow)

conejo = null //El astuto conejo muere flyBird = null //Los pájaros se han ido//Pronto, los lacayos y el arco bueno serán liberados, tal vez no de inmediato //Esta historia nos dice que no hay un buen final para ser un lacayo, tal vez no sea eliminado inmediatamente por //, pero lo será tarde o temprano.

WeakSet

Set WeakSet siguientes diferencias:

1. WeakSet solo puede agregar elementos de objeto
2. WeakSet add()
3. WeakSet evita que el sistema recicle elementos.
4. add() , has() , delete()
5. WeakSet no admite size ni el método keys() .

WeakMap usar WeakMap para verificar cierta información de existencia o verificar el estado como "sí/no". para determinar si el usuario está en línea:

let onlineUser = new WeakMap()
let zhangSan = {nombre:'Zhang San'}
let liSi = {nombre:'李思'}
let wangEr = {nombre:'王二'}
let maZi = {nombre:'Mazi'}

inicio de sesión de función (usuario) {
    ... ...
    usuario en línea.add(usuario)
}

//Determinar si el usuario está en línea function isOnline(user){
    volver en líneaUser.has(usuario)
}

La limitación de WeakMap y WeakSet es que no pueden iterar y obtener todos los elementos a la vez, lo que no afecta su importante papel en lugares muy críticos.

Resumen

1. WeakMap solo puede usar objetos como claves. Cuando se pierden todas las referencias externas a la clave (ninguna otra variable excepto WeakMap hace referencia al objeto clave), WeakMap no impedirá que el motor recicle el valor de la clave. Una vez reciclados, los elementos correspondientes del WeakMap ya no existen.
2. WeakSet solo puede almacenar objetos Una vez que el elemento del objeto pierde todas las referencias externas (excepto WeakSet , ninguna otra variable se refiere al objeto del elemento), WeakSet no impedirá que el motor recicle el elemento. Una vez reciclados, los elementos correspondientes en WeakSet desaparecen.
3. Su ventaja común es que pueden reducir la huella de memoria de los objetos en escenarios apropiados.
4. Los métodos como clear() , size , keys() y values() no son compatibles

. WeakMap y WeakSet se utilizan a menudo para almacenar estructuras de datos asociadas con el objeto "principal". Una vez que el objeto "principal" pierde su significado, el correspondiente. La estructura de datos asociada se elimina naturalmente.