WeakSet - JavaScript | MDN

Basculer la barre latérale

Thème

Automatique
Clair
Sombre

Français

Se souvenir de la langue En savoir plus

WeakSet

Baseline Large disponibilité *

Cette fonctionnalité est bien établie et fonctionne sur de nombreux appareils et versions de navigateurs. Elle est disponible sur tous les navigateurs depuis septembre 2015.

* Certaines parties de cette fonctionnalité peuvent bénéficier de prise en charge variables.

Un objet WeakSet est une collection de valeurs pouvant être collectées par le ramasse-miette (garbage collector en anglais), incluant des objets et des symboles non enregistrés. Une valeur dans le WeakSet ne peut apparaître qu'une seule fois. Elle est unique dans la collection du WeakSet.

Dans cet article

Description

Les valeurs d'un WeakSet doivent pouvoir être collectées par le ramasse-miette. La plupart des types de données primitives peuvent être créées arbitrairement et n'ont pas de durée de vie, elles ne peuvent donc pas être stockées. Les objets et les symboles non enregistrés peuvent être stockés car ils sont collectables par le ramasse-miette.

Les principales différences avec l'objet Set sont :

Les WeakSet sont des collections uniquement d'objets et de symboles. Ils ne peuvent pas contenir des valeurs de n'importe quel type, contrairement aux Set.
Le WeakSet est faible, ce qui signifie que les références aux objets dans un WeakSet sont maintenues faiblement. Si aucune autre référence à une valeur stockée dans le WeakSet n'existe, ces valeurs peuvent être collectées par le ramasse-miette.

Note : Cela signifie également qu'il n'existe pas de liste des valeurs actuellement stockées dans la collection. Les WeakSet ne sont pas énumérables.

Égalité des clés

Comme pour un Set, l'égalité des valeurs est basée sur l'algorithme SameValueZero, qui est équivalent à l'opérateur === car un WeakSet ne peut contenir que des objets et des symboles. Cela signifie que pour les objets, l'égalité est basée sur l'identité de l'objet. Ils sont comparés par référence, et non par valeur.

Constructeur

WeakSet()

Crée un nouvel objet WeakSet.

Propriétés d'instance

Ces propriétés sont définies sur le WeakSet.prototype et partagées par toutes les instances de WeakSet.

WeakSet.prototype.constructor

La fonction constructeur qui a créé l'objet instance. Pour les instances de WeakSet, la valeur initiale est le constructeur WeakSet.

WeakSet.prototype[Symbol.toStringTag]

La valeur initiale de la propriété [Symbol.toStringTag] est la chaîne de caractères "WeakSet". Cette propriété est utilisée dans Object.prototype.toString().

Méthodes des instances

WeakSet.prototype.add()

Ajoute valeur à l'ensemble WeakSet.

WeakSet.prototype.delete()

Retire valeur de l'ensemble WeakSet. Suite à cette opération, WeakSet.prototype.has(valeur) renverra false.

WeakSet.prototype.has()

Retourne un booléen indiquant si valeur est (ou non) au sein de l'ensemble WeakSet.

Exemples

Utiliser un objet WeakSet

js
const ws = new WeakSet();
const toto = {};
const truc = {};

ws.add(toto);
ws.add(truc);

ws.has(toto); // true
ws.has(truc); // true

ws.delete(toto); // retire toto de l'ensemble
ws.has(toto); // false, toto a été enlevé
ws.has(truc); // toujours true

On notera que toto !== truc. Bien que ce soient des objets similaires, ce ne sont pas les mêmes objets. Aussi, les deux sont ajoutés à l'ensemble.

Détecter les références circulaires

Les fonctions récursives doivent faire attention aux structures de données circulaires qu'elles consommeraient. Les objets WeakSets peuvent être utilisés pour ça :

js
// Appeler un callback sur ce qui est stocké dans un objet
function execRecursively(fn, subject, _refs = new WeakSet()) {
  // On évite une récursion infinie
  if (_refs.has(subject)) {
    return;
  }

  fn(subject);
  if (typeof subject === "object" && subject) {
    _refs.add(subject);
    for (const key in subject) {
      execRecursively(fn, subject[key], _refs);
    }
    _refs.delete(subject);
  }
}

const toto = {
  toto: "Toto",
  truc: {
    truc: "Truc",
  },
};

toto.truc.machin = toto; // Référence circulaire !
execRecursively((obj) => console.log(obj), toto);

Ici, on a un objet WeakSet qui est créé lors de la première exécution et qui est passé ensuite à chaque appel qui suit (via l'argument interne _refs).

Le nombre d'objets ou l'ordre de parcours n'a pas d'importance et un objet WeakSet est donc plus adapté (y compris en termes de performances) qu'un Set, notamment si un grand nombre d'objets sont concernés.

Aider à améliorer MDN

Cette page vous a-t-elle été utile ?

Oui Non

Apprendre à contribuer

Cette page a été modifiée le 6 oct. 2025 par les contributeur·ice·s du MDN.

Voir cette page sur GitHub • Signaler un problème avec ce contenu

Objets natifs standards
WeakSet
Constructeur
1. Constructeur WeakSet()
Méthodes d'instance
Héritage
Object/Function
Méthodes statiques
Propriétés statiques
Méthodes d'instance
Propriétés d'instance
1. Object.prototype.__proto__
2. Object.prototype.constructor