CKTIS / JavaScript
Object.prototype, descrittori di proprietà e accessor
Distingui dove si trova una proprietà nella catena dei prototipi da come si comporta: può memorizzare un valore o usare un getter o un setter.
Versione: ECMAScript 2024 and the current web platform; runtime support varies
Sintassi
Object.prototype
Object.getPrototypeOf(obj)
Object.hasOwn(obj, key)
Object.getOwnPropertyDescriptor(obj, key)
Object.defineProperty(obj, key, { value: 1, writable: true, enumerable: true, configurable: true })
Object.defineProperty(obj, key, { get() { return this._value; }, set(value) { this._value = value; }, configurable: true })Object.prototype è l’oggetto condiviso alla fine di molte catene di prototipi, tra cui quella di {}. Il suo prototipo è null. Un oggetto creato con Object.create(null) non eredita da esso. Per esaminare il prototipo diretto, usa Object.getPrototypeOf(obj) invece del vecchio accessor __proto__, che può essere assente o mascherato. Evita di aggiungere proprietà dell’applicazione a Object.prototype: altri oggetti potrebbero ereditarle.
Un descrittore indica gli attributi di una proprietà. Una proprietà dati memorizza un value; writable stabilisce se un’assegnazione può cambiarlo. Una proprietà accessor ha invece get e set, ciascuno una funzione oppure undefined. Entrambi i tipi hanno enumerable (che influisce, per esempio, sulla presenza di una chiave propria di tipo stringa in Object.keys) e configurable (che controlla l’eliminazione e limita le modifiche agli attributi). Un accessor è un tipo di proprietà, non un’alternativa al descrittore.
Negli oggetti ordinari, la lettura cerca prima tra le proprietà proprie, poi lungo la catena dei prototipi. Una proprietà dati restituisce il valore memorizzato; se obj.key usa un getter, questo riceve l’oggetto originale come this. Senza getter, la lettura restituisce undefined. Assegnare a un accessor ereditato invoca il setter con lo stesso this; assegnare a una proprietà dati ereditata e scrivibile crea una proprietà propria se l’oggetto è estensibile. Un setter mancante o writable: false blocca l’assegnazione: in modalità strict viene lanciato TypeError, altrimenti la proprietà resta invariata.
Object.hasOwn(obj, key) controlla solo le proprietà proprie; key in obj considera anche quelle ereditate. Object.getOwnPropertyDescriptor(obj, key) restituisce un oggetto distinto che descrive una proprietà propria, oppure undefined se non esiste. Su un oggetto ordinario non invoca il getter della proprietà esaminata. Modificare i campi del descrittore restituito non modifica la proprietà.
Object.defineProperty(obj, key, descriptor) definisce o aggiorna una proprietà propria senza invocare un setter ereditato. Per una nuova proprietà, i flag omessi writable (per i dati), enumerable e configurable valgono false per impostazione predefinita; in un aggiornamento che non cambia il tipo, gli attributi omessi mantengono i propri valori. Combinare value o writable con get o set, oppure tentare una ridefinizione non consentita, lancia TypeError anche fuori dalla modalità strict.
Esempi
(() => {
'use strict';
const proto = {
points: 2,
get score() { return this.points * 2; },
set score(value) { this.points = value / 2; }
};
const player = Object.create(proto);
const accessor = Object.getOwnPropertyDescriptor(proto, 'score');
console.log(`${'score' in player} ${Object.hasOwn(player, 'score')} ${typeof accessor.get}`);
player.score = 12;
console.log(`${player.score} ${player.points} ${proto.points}`);
Object.defineProperty(player, 'score', { value: 99 });
const data = Object.getOwnPropertyDescriptor(player, 'score');
console.log(`${player.score} ${player.points} ${data.writable} ${data.enumerable} ${data.configurable}`);
})();Risultato
true false function 12 6 2 99 6 false false false
Il setter di `score` scrive nella proprietà propria `player.points` senza cambiare `proto.points`. Poi `Object.defineProperty` maschera l’accessor con una proprietà dati propria senza invocare il setter.
Lezioni correlate
- JavaScript · Lezione 17 · Avanzato · Versione: 4