Explication détaillée du mappage faible de JavaScript et des connaissances faibles en matière de collection

En termes simples, si une variable ou un objet est « inaccessible », alors il n’est pas nécessaire que la variable ou l’objet continue à être stocké en mémoire et doit être recyclé.

Par exemple :

laissez xiaoming = {name:'xiaoming'}//Créez un objet et utilisez la variable xiaoming pour référencer xiaoming = null //Rendez la variable xiaoming vide, rendant l'objet {name:'xiaoming'} inaccessible//{ name:'xiaoming'} L'objet est recyclé

Si un objet est référencé par un tableau et d'autres objets, tant que le tableau et l'objet qui le référence existent dans le tableau, alors l'objet est considéré comme accessible.

Objets dans le tableau :

let xiaoming = {name:'xiaoming'}
laissez arr = [xiaoming]
xiaoming = null //Rendre la variable xiaoming vide //L'objet {name:'xiaoming'} ne sera pas libéré car il existe dans le tableau

De même, si nous utilisons un objet comme clé de Map , si Map existe. , alors L'objet ne sera pas recyclé par le moteur.

Objet clé dans Map :

let xiaoming = {name:'xiaoming'}
laissez map = new Map()
map.set (xiaoming, 'un garçon')
xiaoming = null //Rendre la variable xiaoming vide //L'objet {name:'xiaoming'} ne sera pas libéré car c'est la clé de la carte.

WeapMap est fondamentalement différent de Map dans le traitement de libération des objets clés. c'est simplement que WeapMap n'empêchera pas le garbage collection à cause des objets comme clés.

WeakMap

La différence entre WeakMap et Map peut être divisée en trois aspects :

1. WeakMap ne peut utiliser que des objets comme clés

let lowMap = new WeakMap()
laissez obj = {nom: 'obj'}
faibleMap.set(obj,'obj comme clé')
faibleMap.set('str','str as the key')//Les

résultats de l'exécution du code d'erreur sont les suivants :

On peut voir que lorsque nous utilisons des chaînes comme key , le programme ne peut pas s'exécuter normalement.

2. N'empêche pas le moteur de recycler la clé (objet).

Autrement dit, si un objet n'a pas d'autres références que WeakMap , alors l'objet sera recyclé par le système.

Par exemple :

laissez lowMap = new WeakMap()
laissez obj = {nom: 'obj'}
faibleMap.set(obj,'obj comme clé')
obj = null //Rendre la variable obj vide //À ce moment, l'objet {name:'obj'} sera recyclé

3. WeakMap prend en charge les méthodes limitées

• WeakMap ne prend pas en charge l'itération
• WeakMap ne prend pas en charge keys()
• WeakMap ne prend pas en charge values()
• WeakMap ne prend pas en charge entires()

, nous n'avons donc aucun moyen d'obtenir toutes les paires clé-valeur.

WeakMap ne peut utiliser que les méthodes suivantes :

• weakMap.get(key) Récupère la paire clé-valeur
• weakMap.set(key,val) Définit la paire clé-valeur
• weakMap.delete(key) Supprime la paire clé-valeur
• weakMap.has(key) Déterminer s'il

existe. La méthode d'accès aux données de WeakMap doit être restreinte car le moment où le moteur JavaScript libère l'objet ne peut pas être déterminé.

Lorsqu'un objet perd toutes ses références, JavaScript peut libérer immédiatement l'espace occupé par l'objet ou attendre un moment.

Ainsi, à un certain moment, le nombre d’éléments de WeakMap ne peut pas être déterminé. (Imaginez, si nous parcourons les éléments de WeakMap après qu'un objet a perdu toutes les références, nous pouvons obtenir des résultats différents.)

Cas d'utilisation de WeakMap

Le scénario d'application de WeakMap consiste généralement à stocker des données qui « appartiennent » à un objet lorsque l'objet n'en fait pas partie. Lorsqu'elles sont présentes, les données « appartenant » à cet objet doivent également être diffusées.

Il existe une histoire historique qui convient très bien à l'utilisation de WeakMap` : "Le lapin rusé meurt, les laquais sont cuits ; les oiseaux sont partis et le bon arc est caché."

Si nous décrivons cette histoire en code JavaScript , nous devrions utiliser WeakMap :

let lowMap = new WeakMap()
let Rabbit = {name:'rabbit'} //Le lapin rusé let runDog = {name:'runDog'} //Le chien qui court let flyBird = {name:'flyBird'} //L'oiseau volant let goodBow = {name :'goodBow'} //Liang Gong lowMap.set(lapin,runDog)
faibleMap.set (flyBird, goodBow)

lapin = null //Le lapin rusé meurt flyBird = null //Les oiseaux sont partis//Bientôt, les laquais et le bon arc seront relâchés, peut-être pas immédiatement //Cette histoire nous dit qu'il n'y a pas de bonne fin à être un laquais, peut-être pas immédiatement Tué par //, mais il sera tué tôt ou tard.

WeakSet

Set WeakSet différences suivantes :

1. WeakSet ne peut ajouter que des éléments d'objet
2. WeakSet n'empêche pas le système de recycler les éléments.
3. WeakSet prend en charge add() , has() , delete()
4. WeakSet ne prend pas en charge size et la méthode keys()

Nous pouvons utiliser WeakMap pour vérifier certaines informations d'existence, ou vérifier WeakMap statut tel que "oui/non". pour déterminer si l'utilisateur est en ligne :

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

fonction connexion (utilisateur) {
    ... ...
    onlineUser.add(utilisateur)
}

//Déterminez si l'utilisateur est en ligne, fonction isOnline(user){
    retourner onlineUser.has (utilisateur)
}

La limitation de WeakMap et WeakSet est qu'ils ne peuvent pas itérer et obtenir tous les éléments en même temps, ce qui n'affecte pas leur rôle important dans des endroits très critiques.

Résumé

1. WeakMap ne peut utiliser des objets que comme clés. Lorsque toutes les références externes à la clé sont perdues (aucune autre variable à l'exception de WeakMap ne fait référence à l'objet clé), WeakMap n'empêchera pas le moteur de recycler la valeur de la clé. Une fois recyclés, les éléments correspondants du WeakMap n’existent plus.
2. WeakSet ne peut stocker que des objets. Une fois que l'élément objet perd toutes les références externes (à l'exception de WeakSet , aucune autre variable ne fait référence à l'objet élément), WeakSet n'empêchera pas le moteur de recycler l'élément. Une fois recyclés, les éléments correspondants dans WeakSet disparaissent.
3. Leur avantage commun est qu’ils peuvent réduire l’empreinte mémoire des objets dans des scénarios appropriés.
4. Les méthodes telles que clear() , size , keys() , values() ne sont pas prises en charge

. WeakMap et WeakSet sont souvent utilisées pour stocker les structures de données associées à l'objet "main" Une fois que l'objet "main" perd sa signification, l'objet "main" correspondant. La structure de données associée est naturellement supprimée.