Classi e puntatori

Classi

Le classi sono fondamentali per costruire strutture dati. Un’analogia utile è pensare a una classe come a uno stampino per biscotti (cookie cutter): definisce la forma, mentre le istanze sono i biscotti creati.

Creare una classe

Quando crei una classe, il nome va sempre capitalizzato. Ogni classe ha un constructor, che crea le nuove istanze:

1
class Cookie {
2
  constructor(color) {
3
    this.color = color
4
  }
5
}

Il costruttore riceve i parametri (in questo caso color) e li assegna all’istanza usando this. this si riferisce all’istanza specifica che stiamo creando.

Creare istanze

Per creare nuove istanze, usiamo la parola chiave new:

1
let cookie1 = new Cookie('green')
2
let cookie2 = new Cookie('blue')

cookie1 è un’istanza specifica di Cookie con colore verde. cookie2 è un’altra istanza con colore blu. Il this nel costruttore si riferisce all’istanza specifica che viene creata.

Getters e setters

Le classi hanno due categorie principali di metodi: getters (per leggere) e setters (per modificare):

1
class Cookie {
2
  constructor(color) {
3
    this.color = color
4
  }
5

6
  getColor() {
7
    return this.color
8
  }
9

10
  setColor(color) {
11
    this.color = color
12
  }
13
}

Esempio d’uso:

1
let cookie1 = new Cookie('green')
2
cookie1.getColor()  // 'green'
3

4
cookie1.setColor('yellow')
5
cookie1.getColor()  // 'yellow'

Classi per strutture dati

Tutte le strutture dati che costruiremo useranno classi. Ad esempio, una linked list avrebbe questa struttura:

1
class LinkedList {
2
  constructor(value) {
3
    // Crea il primo nodo della linked list
4
  }
5

6
  push(value) {
7
    // Aggiunge un elemento alla fine
8
  }
9

10
  unshift(value) {
11
    // Aggiunge un elemento all'inizio
12
  }
13

14
  insert(index, value) {
15
    // Inserisce un elemento a un indice specifico
16
  }
17

18
  remove(index) {
19
    // Rimuove un elemento a un indice specifico
20
  }
21

22
  pop() {
23
    // Rimuove l'ultimo elemento
24
  }
25

26
  shift() {
27
    // Rimuove il primo elemento
28
  }
29
}

Uso della classe:

1
let myLinkedList = new LinkedList(23)
2
myLinkedList.push(7)
3
myLinkedList.unshift(3)
4
myLinkedList.insert(1, 11)
5
myLinkedList.remove(1)
6
myLinkedList.pop()
7
myLinkedList.shift()

Le classi ci permettono di creare strutture dati con metodi specifici per manipolare i dati in modo organizzato e riutilizzabile.

Puntatori

I puntatori sono fondamentali per capire come funzionano gli oggetti in JavaScript. Il comportamento è diverso tra valori primitivi e oggetti.

Valori primitivi (senza puntatori)

Con valori primitivi come numeri, quando assegniamo una variabile a un’altra, copiamo il valore:

1
let num1 = 5
2
let num2 = num1
3

4
num1 = 10
5
console.log(num1)  // 10
6
console.log(num2)  // 5 (non è cambiato)

Quando impostiamo num2 = num1, stiamo solo copiando il valore 5 al momento della dichiarazione. Se poi cambiamo num1, num2 non viene influenzato perché non c’è un collegamento permanente.

Oggetti (con puntatori)

Con gli oggetti, quando assegniamo una variabile a un oggetto, stiamo creando un puntatore all’oggetto in memoria:

1
let obj1 = { value: 11 }
2
let obj2 = obj1

Quando facciamo obj2 = obj1, non stiamo creando un nuovo oggetto con gli stessi valori. Stiamo dicendo a obj2 di puntare allo stesso oggetto in memoria a cui punta obj1.

1
let obj1 = { value: 11 }
2
let obj2 = obj1
3

4
obj1.value = 22
5
console.log(obj1)  // { value: 22 }
6
console.log(obj2)  // { value: 22 } (anche questo è cambiato!)

Entrambi gli oggetti mostrano value: 22 perché puntano allo stesso oggetto in memoria. Modificare uno significa modificare l’altro.

Spostare i puntatori

I puntatori possono essere spostati per puntare a oggetti diversi:

1
let obj1 = { value: 11 }
2
let obj2 = obj1
3
let obj3 = { value: 33 }
4

5
obj2 = obj3  // obj2 ora punta a obj3
6
obj1 = obj3  // obj1 ora punta a obj3

Ora obj1 e obj2 puntano entrambi a obj3, mentre l’oggetto originale { value: 11 } non ha più puntatori che lo referenziano.

Garbage collection

Se un oggetto non ha più variabili che lo referenziano, non possiamo più accedervi. JavaScript periodicamente rimuove questi oggetti inutilizzati attraverso un processo chiamato garbage collection, liberando memoria.

Questo è importante quando lavoriamo con strutture dati: dobbiamo assicurarci di non perdere i riferimenti agli oggetti che vogliamo mantenere, altrimenti verranno rimossi dalla memoria.