Come cancellare le proprietà di un oggetto in Javascript

Nelle lezioni precedenti abbiamo visto che gli oggetti sono aggregati di proprietà nome/valore dinamici. A runtime è possibile aggiungere nuove proprietà e modificare quelle esistenti. In questa lezione vediamo, invece, come cancellare una proprietà di un oggetto.

Operatore delete

L'operatore delete ha lo scopo di cancellare una proprietà di un oggetto e richiede come operando un'espressione di accesso. Per comprendere meglio, guardiamo il seguente esempio:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// persona è un oggetto con tre proprietà: 'nome', 'cognome' e 'città'
let persona = {
    nome: "Mario",
    cognome: "Rossi",
    città: "Roma"
};

// Con l'operatore delete eliminiamo la proprietà 'città'
delete persona.città;

console.log(persona.città); // Output: undefined

In questo caso abbiamo usato la dot notation. Avremmo potuto usare anche la notazione di accesso ad Array:

// Le seguenti righe sono equivalenti
delete persona.città;
delete persona["città"];

Quando si cancella una proprietà, bisogna tener presente che l'operatore delete elimina soltanto le own properties e non quelle ereditate dal prototipo. Infatti, esaminiamo il seguente stralcio di codice:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

let A = {
    x: 1
};

let B = Object.create(A);

// Eseguendo questa riga non si ottiene nessun effetto
delete B.x;

// Infatti l'output di questa riga di codice è 1
console.log(B.x); // Output: 1

Nell'esempio, anche se abbiamo inserito la riga delete B.x essa non avrà effetto perché x non è una own property di B.

Valore di ritorno di delete

L'operatore delete, oltre a cancellare una proprietà di un oggetto, restituisce un valore booleano. Questo valore è true nei casi seguenti:

• Se cancella con successo una proprietà.
• Se non ha effetto perché è stato richiamato su una property inesistente.
• Se non ha effetto perché è stato richiamato su una property del prototipo.
• Se richiamato su di una espressione che non è di accesso ad una property.

Guardiamo l'esempio:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

let A = {
    x: 1
};

let B = Object.create(A);
B.y = 2;

delete B.y;    // true -> y è una proprietà di B (own property)
delete B.z;    // true -> z non è una proprietà di B
delete B.x;    // true -> x non è una own property di B
delete 42;     // true -> 42 non è un'espressione di accesso.

Sorge a questo punto la domanda: Quand'è che delete restituisce false?

La risposta è: solo in un caso. In particolare, delete restituisce false solo quando richiamato su una proprietà definita con attributo configurable impostato a false. Più avanti vedremo come definire gli attributi delle proprietà. Per il momento basta sapere che molte delle proprietà degli oggetti built-in, come ad esempio Object, hanno l'attributo configurable impostato a false.

Altra cosa importante da notare è che se siamo in strict mode, quando applichiamo delete ad una proprietà non configurable non otterremo false, bensì verrà lanciata un eccezione di tipo TypeError.

Per comprendere meglio guardiamo l'esempio:

1
2
3
4
5
6
7

try {
    let result = delete Object.prototype;
    console.log(`Non siamo in strict mode. Risultato: ${result}`);
}
catch (exception) {
    console.log("Siamo in strict mode");
}

Nell'esempio, proviamo a cancellare la proprietà prototype dell'oggetto Object, cioè una proprietà non configurable. L'operatore delete è racchiuso in un try. Se siamo in strict mode verrà lanciata un'eccezione, per cui verrà eseguito il codice racchiuso nella clausola catch. Viceversa, se siamo in sloppy mode verrà eseguita la riga immediatamente successiva al delete.

Riassumendo

In questa lezione abbiamo visto come cancellare le proprietà di un oggetto attraverso l'operatore delete. Abbiamo visto che delete richiede come operando un'espressione di accesso alle proprietà e restituisce un risultato booleano che risulta essere false solo nel caso in cui la proprietà da cancellare è non configurable.

Nella prossima lezione vedremo come verificare la presenza o meno di una proprietà in un oggetto.