6.1 Creazione di oggetti
Oggetti sono uno dei principali tipi di dati in JavaScript e vengono ampiamente utilizzati per memorizzare e gestire i dati. Un oggetto è una collezione di proprietà, dove ogni proprietà è costituita da una chiave (nome) e un valore. In questa lezione esamineremo la creazione di oggetti, così come l'accesso alle loro proprietà e metodi.
1. Oggetto letterale
Il modo più comune per creare un oggetto in JavaScript è usare un oggetto letterale.
In questo esempio abbiamo creato un oggetto person con quattro proprietà: name, age, isStudent e greet.
let person = {
name: 'John',
age: 30,
isStudent: false,
greet: function() {
return 'Hello!';
}
};
2. Costruttore Object
Gli oggetti possono anche essere creati usando il costruttore Object().
Questo metodo è equivalente alla creazione di un oggetto usando un letterale di oggetto, ma è più verboso:
let person = new Object();
person.name = 'John';
person.age = 30;
person.isStudent = false;
person.greet = function() {
return 'Hello!';
};
3. Funzione costruttore
La funzione costruttore consente di creare più istanze di oggetti con le stesse proprietà e metodi.
In questo esempio, la funzione costruttore Person() viene utilizzata per creare gli oggetti john e jane con le stesse proprietà e metodi:
function Person(name, age, isStudent) {
this.name = name;
this.age = age;
this.isStudent = isStudent;
this.greet = function() {
return 'Hello!';
};
}
let john = new Person('John', 30, false);
let jane = new Person('Jane', 25, true);
4. Metodo Object.create()
Il metodo Object.create() crea un nuovo oggetto e gli assegna subito un prototipo: un altro oggetto in cui il nuovo cercherà le proprietà e i metodi che non possiede.
In questo esempio l'oggetto john viene creato a partire dal prototipo personPrototype:
let personPrototype = {
greet: function() {
return 'Hello!';
}
};
let john = Object.create(personPrototype);
john.name = 'John';
john.age = 30;
john.isStudent = false;
console.log(john.name); // Visualizza: John
console.log(john.greet()); // Visualizza: Hello!
Da notare l'ultima riga. L'oggetto john non ha un metodo greet proprio: vi abbiamo scritto solo name, age e isStudent. Eppure john.greet() funziona: quando si accede a una proprietà, JavaScript la cerca prima nell'oggetto stesso e, se non la trova, sale al prototipo. Questo percorso di ricerca si chiama catena dei prototipi.
La differenza tra una proprietà propria e una ereditata è facile da vedere:
console.log(john.hasOwnProperty('name')); // Visualizza: true
console.log(john.hasOwnProperty('greet')); // Visualizza: false
console.log('greet' in john); // Visualizza: true
hasOwnProperty() risponde alla domanda «l'oggetto possiede questa proprietà per conto suo?», mentre l'operatore in risponde «la proprietà è raggiungibile, magari risalendo la catena dei prototipi?». Da qui le risposte diverse per greet.
Punto importante: le proprietà del prototipo non vengono copiate nel nuovo oggetto. personPrototype resta un oggetto a sé, e john si limita a farvi riferimento. Per questo un solo prototipo può essere condiviso da centinaia di oggetti, con greet conservato in memoria una volta sola. Da confrontare con la funzione costruttore dell'esempio 3: lì ogni oggetto creato riceveva la propria copia di greet.
Il secondo argomento: proprietà con impostazioni
Object.create() accetta un secondo argomento facoltativo: un oggetto che descrive le proprietà da creare subito. Non si definiscono con un semplice valore, ma con un descrittore, un insieme di impostazioni:
value— il valore della proprietà stessawritable— se il valore può essere modificato (per impostazione predefinitafalse)enumerable— se la proprietà compare infor...ineObject.keys()(per impostazione predefinitafalse)configurable— se la proprietà può essere eliminata o se ne possono cambiare le impostazioni (per impostazione predefinitafalse)get/set— un getter e un setter al posto di un valore ordinario. Il getter scatta alla lettura, il setter alla scrittura
Mettendo tutto insieme:
let john = Object.create(personPrototype, {
name: {
value: 'John',
writable: true, // il valore può essere modificato
enumerable: true // proprietà visibile in for...in
},
id: {
value: 1001,
writable: false, // sola lettura
enumerable: true
},
info: {
enumerable: true,
get: function() { // getter: scatta alla lettura
return this.name + ' #' + this.id;
},
set: function(value) { // setter: scatta alla scrittura
this.name = value;
}
}
});
console.log(john.info); // Visualizza: John #1001
john.name = 'Johnny'; // funziona
john.id = 2002; // non fa nulla, in silenzio
console.log(john.info); // Visualizza: Johnny #1001
Da notare: tutti e tre i flag valgono false per impostazione predefinita, quindi usando il secondo argomento vanno quasi sempre indicati esplicitamente. L'assegnazione a una proprietà con writable: false fallisce in silenzio in modalità normale e solleva un TypeError in modalità strict ('use strict').
Un altro caso utile è Object.create(null). Un oggetto simile non ha alcun prototipo: niente toString(), niente hasOwnProperty(), nessun metodo ereditato. Diventa così un comodo «dizionario pulito», in cui ogni chiave è sicuramente la tua e non ereditata da Object.prototype.
6.2 Accesso alle proprietà e ai metodi
1. Accesso tramite punto
Il modo più comune per accedere alle proprietà e ai metodi di un oggetto è attraverso il punto:
let person = {
name: 'John',
age: 30,
greet: function() {
return 'Hello!';
}
};
console.log(person.name); // Visualizza: John
console.log(person.age); // Visualizza: 30
console.log(person.greet()); // Visualizza: Hello!
2. Accesso tramite parentesi quadre
Le proprietà di un oggetto possono essere anche chiamate usando le parentesi quadre. Questo metodo è utile se il nome della proprietà è memorizzato in una variabile o contiene spazi o caratteri speciali:
let person = {
'first name': 'John',
age: 30,
greet: function() {
return 'Hello!';
}
};
console.log(person['first name']); // Visualizza: John
console.log(person['age']); // Visualizza: 30
let propertyName = 'greet';
console.log(person[propertyName]()); // Visualizza: Hello!
3. Modifica e aggiunta di proprietà
Le proprietà dell'oggetto possono essere modificate o aggiunte in qualsiasi momento:
let person = {
name: 'John',
age: 30
};
// Modifica di una proprietà esistente
person.age = 31;
console.log(person.age); // Visualizza: 31
// Aggiunta di una nuova proprietà
person.isStudent = false;
console.log(person.isStudent); // Visualizza: false
4. Eliminazione di proprietà
Le proprietà di un oggetto possono essere cancellate usando l'operatore delete:
let person = {
name: 'John',
age: 30,
isStudent: false
};
delete person.isStudent;
console.log(person.isStudent); // Visualizza: undefined
6.3 Iterazione sulle proprietà dell'oggetto
1. Ciclo for...in
Il ciclo for...in permette di scorrere tutte le proprietà enumerabili di un oggetto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
for (let key in person) {
console.log(`${key}: ${person[key]}`);
}
// Visualizza:
// name: John
// age: 30
// isStudent: false
2. Metodo Object.keys()
Il metodo Object.keys() restituisce un array di tutte le proprietà enumerabili di un oggetto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let keys = Object.keys(person);
console.log(keys); // Visualizza: ['name', 'age', 'isStudent']
3. Metodo Object.values()
Il metodo Object.values() restituisce un array di valori di tutte le proprietà enumerabili di un oggetto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let values = Object.values(person);
console.log(values); // Visualizza: ['John', 30, false]
4. Metodo Object.entries()
Il metodo Object.entries() restituisce un array di coppie [chiave, valore] per tutte le proprietà enumerabili di un oggetto:
let person = {
name: 'John',
age: 30,
isStudent: false
};
let entries = Object.entries(person);
console.log(entries); // Visualizza: [['name', 'John'], ['age', 30], ['isStudent', false]]
6.4 Verifica delle proprietà
1. Operatore in
L'operatore in permette di verificare la presenza di una proprietà in un oggetto:
let person = {
name: 'John',
age: 30
};
console.log('name' in person); // Visualizza: true
console.log('isStudent' in person); // Visualizza: false
2. Metodo hasOwnProperty()
Il metodo hasOwnProperty() verifica se un oggetto ha una specifica proprietà come propria (non ereditata):
let person = {
name: 'John',
age: 30
};
console.log(person.hasOwnProperty('name')); // Visualizza: true
console.log(person.hasOwnProperty('isStudent')); // Visualizza: false
GO TO FULL VERSION