Object : méthode statique isFrozen()

const object = {
  foo: 42,
};

console.log(Object.isFrozen(object));
// Résultat attendu : false

Object.freeze(object);

console.log(Object.isFrozen(object));
// Résultat attendu : true

Object.isFrozen(obj)

//  Un nouvel objet créé est extensible et est donc dégelé
Object.isFrozen({}); // false

// Un objet vide et non extensible est gelé
const videGele = Object.preventExtensions({});
Object.isFrozen(videGele); // true

// Un nouvel objet avec une propriété est également extensible,
// et donc dégelé.
const uneProp = { p: 42 };
Object.isFrozen(uneProp); // false

// Empêcher l'extension de l'objet ne le rend toujours pas
// gelé, car la propriété est toujours
// configurable (et accessible en écriture).
Object.preventExtensions(uneProp);
Object.isFrozen(uneProp); // false

// Supprimer cette propriété rend l'objet trivialement gelé.
delete uneProp.p;
Object.isFrozen(uneProp); // true

// Un objet non-extensible et avec une propriété qui n'est pas accessible
// en écriture mais toujours configurable n'est pas gelé
const pasEcrivable = { e: "plep" };
Object.preventExtensions(pasEcrivable);
Object.defineProperty(pasEcrivable, "e", {
  writable: false,
}); // le rend non accessible en écriture
Object.isFrozen(pasEcrivable); // false

// Changer cette propriété en non-configurable rend alors l'objet gelé.
Object.defineProperty(pasEcrivable, "e", {
  configurable: false,
}); // le rend non-configurable
Object.isFrozen(pasEcrivable); // true

// Un objet non-extensible avec une propriété non-configurable
// mais accessible en écriture n'est pas gelé.
const nonConfigurable = { release: "le kraken !" };
Object.preventExtensions(nonConfigurable);
Object.defineProperty(nonConfigurable, "release", {
  configurable: false,
});
Object.isFrozen(nonConfigurable); // false

// Changer cette propriété comme ne pouvant pas être écrite
// rend alors l'objet gelé.
Object.defineProperty(nonConfigurable, "release", {
  writable: false,
});
Object.isFrozen(nonConfigurable); // true

// Un objet non-extensible avec un accesseur
// configurable n'est pas gelé
const accesseur = {
  get manger() {
    return "miam";
  },
};
Object.preventExtensions(accesseur);
Object.isFrozen(accesseur); // false

// Lorsque nous rendons cette propriété non configurable, elle est gelée.
Object.defineProperty(accesseur, "manger", {
  configurable: false,
});
Object.isFrozen(accesseur); // true

// Mais le moyen le plus simple de geler un objet
// est d'appeler la méthode Object.freeze sur celui-ci.
const gele = { 1: 81 };
Object.isFrozen(gele); // false
Object.freeze(gele);
Object.isFrozen(gele); // true

// Par définition, un objet gelé est non-extensible.
Object.isExtensible(gele); // false

// Par définition, un objet gelé est scellé.
Object.isSealed(gele); // true

Object.isFrozen(1);
// TypeError: 1 n'est pas un objet (code ES5)

Object.isFrozen(1);
// true                            (code ES2015)