Oggetti

Frontend SELF IT
Livello 36, Lezione 0
Disponibile

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.

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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à stessa
  • writable — se il valore può essere modificato (per impostazione predefinita false)
  • enumerable — se la proprietà compare in for...in e Object.keys() (per impostazione predefinita false)
  • configurable — se la proprietà può essere eliminata o se ne possono cambiare le impostazioni (per impostazione predefinita false)
  • 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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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:

JavaScript
    
      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):

JavaScript
    
      let person = {
        name: 'John',
        age: 30
      };

      console.log(person.hasOwnProperty('name')); // Visualizza: true
      console.log(person.hasOwnProperty('isStudent')); // Visualizza: false
    
  
1
Compito
Frontend SELF IT, livello 36, lezione 0
Bloccato
Proprietà dell'oggetto
Proprietà dell'oggetto
1
Compito
Frontend SELF IT, livello 36, lezione 0
Bloccato
Modifica delle proprietà
Modifica delle proprietà
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION