Segui su:
Programmazione Web Italia

JavaScript: this e lexical scope, differenze concettuali e funzionamento

Articolo javascript - JavaScript: this e lexical scope, differenze concettuali e funzionamento

Scopri le differenze tra this e lexical scope in JavaScript: funzioni, arrow function, closure, call, apply, bind ed esempi tipici dei colloqui tecnici. marco dice...

Che cosa sono this e lexical scope in JavaScript?

Prima di analizzare le differenze, è importante chiarire che this e lexical scope appartengono a due meccanismi distinti del linguaggio.

this è un riferimento disponibile all'interno di una funzione, il cui valore dipende principalmente dalle modalità con cui la funzione viene invocata. Nelle funzioni tradizionali, quindi, non è determinato semplicemente dal punto in cui la funzione viene dichiarata.

Il lexical scope, invece, riguarda le regole con cui JavaScript individua le variabili utilizzate da una funzione. La risoluzione dei nomi dipende dalla posizione in cui il codice viene scritto e dalla struttura degli ambienti lessicali che lo circondano.

In altre parole:

  • this: determina a quale contesto è associato il riferimento this durante l'esecuzione di una funzione.
  • Lexical scope: determina dove JavaScript deve cercare una variabile o un identificatore utilizzato nel codice.

La differenza fondamentale è quindi che this non segue normalmente le regole dello scope lessicale: nelle funzioni tradizionali, il suo valore dipende dalla modalità di invocazione, mentre le variabili vengono risolte in base alla struttura lessicale del programma.

Come funziona this in JavaScript

Il comportamento di this è uno degli aspetti più caratteristici di JavaScript. A differenza di quanto accade in alcuni linguaggi orientati agli oggetti, il valore di this non è necessariamente associato all'oggetto nel quale una funzione è stata definita.

Per comprendere il suo funzionamento, è necessario osservare il modo in cui la funzione viene chiamata.

this all'interno di un metodo di un oggetto

Quando una funzione viene invocata come metodo di un oggetto, this fa riferimento all'oggetto utilizzato per effettuare la chiamata.

const user = {
  name: 'Marco',

  sayHello() {
    console.log(`Ciao, sono ${this.name}`);
  }
};

user.sayHello();

// Output:
// Ciao, sono Marco

In questo caso, la chiamata user.sayHello() associa this all'oggetto user. Di conseguenza, this.name restituisce il valore della proprietà name dell'oggetto.

È importante osservare che il collegamento non dipende dal fatto che il metodo sia stato dichiarato all'interno dell'oggetto, ma dalla modalità con cui viene invocato.

this in una funzione tradizionale

Se una funzione tradizionale viene invocata come funzione autonoma, senza essere associata a un oggetto, il comportamento di this dipende dalla modalità strict.

function showThis() {
  console.log(this);
}

showThis();

In modalità strict, this assume il valore undefined.

'use strict';

function showThis() {
  console.log(this);
}

showThis();

// Output:
// undefined

In modalità non strict, invece, una chiamata autonoma a una funzione tradizionale applica il cosiddetto global this substitution: il valore di this viene convertito nell'oggetto globale dell'ambiente.

Nel browser questo oggetto è generalmente window, mentre in Node.js è globalThis. È comunque importante distinguere l'oggetto globale dal contesto di esecuzione del modulo: ad esempio, nei moduli JavaScript e nei moduli ES di Node.js il codice viene eseguito in modalità strict.

Il problema dell'estrazione di un metodo

Uno degli errori più comuni si verifica quando un metodo viene estratto dal proprio oggetto e successivamente invocato come funzione autonoma.

const user = {
  name: 'Marco',

  sayHello() {
    console.log(this.name);
  }
};

user.sayHello();

// Output:
// Marco

const hello = user.sayHello;

hello();

// Output in strict mode:
// TypeError: Cannot read properties of undefined

Il metodo sayHello non conserva automaticamente un riferimento a user. Quando viene invocato attraverso hello(), non esiste più il riferimento all'oggetto utilizzato nella chiamata originale.

Questo comportamento è particolarmente importante quando passi metodi come callback ad altre funzioni o quando utilizzi API che invocano autonomamente le funzioni ricevute.

Call, apply e bind: controllare il valore di this

JavaScript mette a disposizione tre metodi che permettono di controllare esplicitamente il valore di this quando si lavora con funzioni tradizionali: call(), apply() e bind().

Il metodo call()

call() invoca immediatamente una funzione, specificando il valore di this e passando gli eventuali argomenti individualmente.

function introduce(city, country) {
  console.log(
    `${this.name} vive a ${city}, ${country}`
  );
}

const user = {
  name: 'Marco'
};

introduce.call(user, 'Roma', 'Italia');

// Output:
// Marco vive a Roma, Italia

Il metodo apply()

apply() ha un comportamento analogo a call(), ma gli argomenti della funzione vengono passati attraverso un array o un oggetto array-like.

function introduce(city, country) {
  console.log(
    `${this.name} vive a ${city}, ${country}`
  );
}

const user = {
  name: 'Marco'
};

introduce.apply(user, ['Roma', 'Italia']);

// Output:
// Marco vive a Roma, Italia

Il metodo bind()

A differenza di call() e apply(), bind() non invoca immediatamente la funzione. Restituisce una nuova funzione nella quale il valore di this è associato in modo permanente al valore specificato.

const user = {
  name: 'Marco',

  sayHello() {
    console.log(`Ciao, sono ${this.name}`);
  }
};

const hello = user.sayHello.bind(user);

hello();

// Output:
// Ciao, sono Marco

Questa tecnica è utile quando devi passare un metodo come callback senza perdere il riferimento all'oggetto originale.

Una volta creata la funzione tramite bind(), un successivo utilizzo di call() o apply() non può modificare il this già associato.

Come funziona il lexical scope in JavaScript

Il lexical scope, chiamato anche scope lessicale, è il meccanismo attraverso il quale JavaScript determina quali variabili sono accessibili all'interno di una determinata porzione di codice.

Il termine lexical indica che la visibilità delle variabili dipende dalla struttura del codice sorgente, ovvero da dove le funzioni e i blocchi vengono dichiarati.

JavaScript utilizza diversi tipi di scope:

  • Global scope: permette di accedere agli identificatori dichiarati nell'ambiente globale, nei limiti delle regole di visibilità applicabili.
  • Function scope: riguarda le variabili dichiarate con var all'interno di una funzione.
  • Block scope: riguarda le variabili dichiarate con let e const all'interno di un blocco.

Scope e visibilità delle variabili

Consideriamo un esempio in cui una funzione accede a una variabile dichiarata in un contesto esterno:

const message = 'Hello';

function sayHello() {
  console.log(message);
}

sayHello();

// Output:
// Hello

La funzione sayHello() non dichiara una variabile chiamata message. JavaScript cerca quindi l'identificatore nell'ambiente lessicale esterno e lo individua nello scope globale.

La ricerca degli identificatori segue una catena di ambienti lessicali, comunemente chiamata scope chain. Se una variabile non viene trovata nell'ambiente corrente, la ricerca prosegue negli ambienti esterni fino a raggiungere l'ambiente globale. Se l'identificatore non viene trovato, viene generato un ReferenceError.

Function scope e block scope

Una distinzione importante riguarda il comportamento delle dichiarazioni var, let e const.

function example() {
  if (true) {
    var first = 'var';
    let second = 'let';
    const third = 'const';
  }

  console.log(first);  // var

  console.log(second); // ReferenceError
  console.log(third);  // ReferenceError
}

example();

La variabile first è accessibile anche fuori dal blocco if perché var ha function scope.

Le variabili second e third, invece, sono accessibili soltanto all'interno del blocco nel quale sono state dichiarate, perché let e const utilizzano il block scope.

Questa distinzione è importante anche per comprendere il comportamento delle closure e la gestione delle variabili all'interno di cicli e callback.

Closure: il legame tra lexical scope e funzioni

Uno dei concetti più importanti legati al lexical scope è quello di closure.

Una closure si verifica quando una funzione mantiene accesso alle variabili presenti nell'ambiente lessicale nel quale è stata creata, anche quando la funzione viene eseguita al di fuori di quell'ambiente.

Consideriamo questo esempio:

function createCounter() {
  let count = 0;

  return function increment() {
    count++;
    console.log(count);
  };
}

const counter = createCounter();

counter(); // 1
counter(); // 2
counter(); // 3

La funzione createCounter() termina la propria esecuzione dopo aver restituito la funzione increment(). Nonostante questo, la funzione restituita continua ad avere accesso alla variabile count.

Questo accade perché la funzione mantiene un riferimento all'ambiente lessicale nel quale è stata creata. La variabile non viene quindi eliminata semplicemente perché la funzione esterna ha terminato la propria esecuzione.

Le closure sono utilizzate frequentemente per implementare incapsulamento, stato privato, factory function e callback che devono mantenere informazioni tra un'esecuzione e l'altra.

Arrow function: il collegamento tra this e lexical scope

Le arrow function, introdotte con ECMAScript 2015 (ES6), hanno introdotto un comportamento particolarmente importante per comprendere la differenza tra this e lexical scope.

A differenza delle funzioni tradizionali, le arrow function non possiedono un proprio binding di this. Quando all'interno di un'arrow function viene utilizzato this, il riferimento viene recuperato dall'ambiente lessicale esterno.

In altre parole, il valore di this viene determinato dal contesto lessicale nel quale l'arrow function è stata creata, non dal modo in cui viene successivamente invocata.

Un esempio pratico con una funzione tradizionale

Consideriamo un oggetto che contiene un metodo e una funzione tradizionale annidata:

const user = {
  name: 'Marco',

  sayHello() {
    function greet() {
      console.log(this.name);
    }

    greet();
  }
};

user.sayHello();

// Output in strict mode:
// undefined

Il metodo sayHello() viene invocato attraverso user, quindi il suo this fa riferimento all'oggetto.

La funzione interna greet(), però, è una funzione tradizionale invocata autonomamente. Di conseguenza, in modalità strict il suo this è undefined. Il valore di this del metodo esterno non viene ereditato automaticamente.

Risolvere il problema con un'arrow function

Sostituendo la funzione interna con un'arrow function, il comportamento cambia:

const user = {
  name: 'Marco',

  sayHello() {
    const greet = () => {
      console.log(this.name);
    };

    greet();
  }
};

user.sayHello();

// Output:
// Marco

L'arrow function non crea un proprio this. Quando viene eseguita, utilizza quello del metodo sayHello(), che in questo caso corrisponde all'oggetto user.

Questo comportamento è particolarmente utile quando devi utilizzare callback annidate e vuoi mantenere il riferimento al contesto esterno senza ricorrere a variabili intermedie o a bind().

Un caso in cui l'arrow function può creare problemi

Proprio perché non possiede un proprio this, un'arrow function non è generalmente adatta a essere utilizzata come metodo di un oggetto quando ti aspetti che this faccia riferimento all'oggetto stesso.

const user = {
  name: 'Marco',

  sayHello: () => {
    console.log(this.name);
  }
};

user.sayHello();

In questo esempio, this non fa riferimento a user, nonostante la funzione venga invocata attraverso user.sayHello(). L'arrow function recupera invece il this dall'ambiente esterno nel quale è stata definita.

Se vuoi realizzare un metodo che utilizzi le proprietà dell'oggetto attraverso this, una funzione tradizionale è generalmente la scelta più appropriata.

this e lexical scope: un confronto diretto

A questo punto possiamo riassumere le differenze principali tra i due meccanismi.

Caratteristica this Lexical scope
Funzione Identifica il contesto associato al riferimento this. Determina la visibilità e la risoluzione delle variabili.
Determinazione Dipende dalla modalità di invocazione nelle funzioni tradizionali. Dipende dalla struttura del codice sorgente.
Funzioni tradizionali Possiedono un proprio binding di this. Accedono alle variabili degli ambienti lessicali esterni.
Arrow function Ereditano this dall'ambiente lessicale esterno. Utilizzano normalmente lo scope lessicale in cui sono definite.
Modificabilità Può essere controllato con call(), apply() e bind() nelle funzioni tradizionali. Non può essere modificato cambiando il punto di invocazione della funzione.

La tabella evidenzia un aspetto importante: this non è una variabile dello scope lessicale. È un binding specifico del contesto di esecuzione, con regole differenti a seconda del tipo di funzione.

Le domande più frequenti durante un colloquio JavaScript

La differenza tra this e lexical scope è un argomento ricorrente nei colloqui tecnici JavaScript, soprattutto per posizioni mid-level e senior.

Spesso non viene chiesto soltanto di definire i due concetti, ma di analizzare un frammento di codice e prevederne il risultato.

1. Qual è la differenza tra this e lexical scope?

Risposta: this è un riferimento il cui valore, nelle funzioni tradizionali, dipende dalla modalità di invocazione. Il lexical scope determina invece la visibilità delle variabili sulla base della posizione in cui il codice viene dichiarato.

Le arrow function rappresentano un'eccezione importante rispetto al comportamento tradizionale di this, perché non possiedono un binding proprio e utilizzano quello dell'ambiente lessicale esterno.

2. Che cosa stampa questo codice?

const name = 'Global';

const user = {
  name: 'Marco',

  sayHello() {
    console.log(this.name);
  }
};

const greet = user.sayHello;

user.sayHello();
greet();

Risposta: la prima chiamata stampa Marco, perché il metodo viene invocato attraverso user.

La seconda chiamata dipende dalla modalità di esecuzione. In modalità strict, this è undefined e l'accesso a this.name genera un TypeError. In modalità non strict, invece, this viene associato all'oggetto globale e il risultato dipende dall'ambiente e dalle dichiarazioni globali.

3. Le arrow function hanno un proprio this?

Risposta: no. Le arrow function non creano un proprio binding di this. Recuperano il riferimento dall'ambiente lessicale esterno nel quale sono state definite.

Per questo motivo, call(), apply() e bind() non possono modificarne il valore di this.

4. Che cosa succede quando estrai un metodo da un oggetto?

Risposta: il metodo non mantiene automaticamente il riferimento all'oggetto originale. Se viene assegnato a una variabile e invocato autonomamente, il suo this viene determinato dalle nuove modalità di chiamata.

Per mantenere il riferimento originale puoi utilizzare bind() oppure creare una funzione wrapper che invochi il metodo attraverso l'oggetto.

5. Che cos'è una closure?

Risposta: una closure è una funzione che mantiene accesso all'ambiente lessicale nel quale è stata creata, anche quando viene eseguita al di fuori di quell'ambiente.

Le closure permettono di conservare stato privato, implementare factory function e creare funzioni che mantengono riferimenti a variabili esterne.

6. Le arrow function possono essere utilizzate come metodi di un oggetto?

Risposta: sì, ma bisogna prestare attenzione al comportamento di this. Un'arrow function assegnata a una proprietà di un oggetto non utilizza automaticamente quell'oggetto come contesto.

Se il metodo deve accedere alle proprietà dell'oggetto attraverso this, è generalmente preferibile utilizzare una funzione tradizionale.

7. Qual è la differenza tra scope e closure?

Risposta: lo scope definisce quali identificatori sono accessibili in una determinata porzione di codice. La closure è il comportamento per cui una funzione conserva l'accesso al proprio ambiente lessicale esterno anche dopo che la funzione che lo ha creato ha terminato l'esecuzione.

Altri aspetti da conoscere per un colloquio tecnico

Una buona conoscenza di this e lexical scope dovrebbe comprendere anche alcuni comportamenti meno immediati, che possono emergere durante un colloquio per una posizione JavaScript di livello intermedio o avanzato.

this nei costruttori e con new

Quando una funzione tradizionale viene invocata attraverso l'operatore new, JavaScript crea un nuovo oggetto e lo associa a this durante l'esecuzione del costruttore.

function User(name) {
  this.name = name;
}

const user = new User('Marco');

console.log(user.name);

// Output:
// Marco

Questo comportamento è alla base del funzionamento delle funzioni costruttrici. Le arrow function, invece, non possono essere utilizzate come costruttori e generano un TypeError se invocate con new.

this nelle classi JavaScript

Le classi JavaScript introducono una sintassi più strutturata per definire costruttori e metodi. Anche in questo caso, this fa riferimento all'istanza quando un metodo viene invocato attraverso l'oggetto.

class User {
  constructor(name) {
    this.name = name;
  }

  sayHello() {
    console.log(`Ciao, sono ${this.name}`);
  }
}

const user = new User('Marco');

user.sayHello();

// Output:
// Ciao, sono Marco

È importante ricordare che i metodi delle classi vengono eseguiti in strict mode. Se un metodo viene estratto dall'istanza e invocato autonomamente, this non viene automaticamente associato all'istanza originale.

this e super nelle arrow function

Le arrow function non possiedono neppure un binding proprio di super. Quando utilizzano super, il riferimento viene risolto attraverso l'ambiente lessicale esterno, analogamente a quanto avviene per this. Lo stesso principio si applica a arguments e new.target: le arrow function non ne creano una propria versione.

Questo aspetto è importante quando si utilizzano arrow function all'interno di metodi di classi o funzioni costruttrici.

Conclusioni

this e lexical scope sono due meccanismi fondamentali di JavaScript, ma rispondono a esigenze differenti. Il primo determina il contesto associato a una funzione, mentre il secondo stabilisce quali variabili sono accessibili in base alla struttura del codice.

Nelle funzioni tradizionali, il valore di this dipende principalmente dalla modalità di invocazione. Le arrow function, invece, non possiedono un proprio binding e recuperano this dall'ambiente lessicale esterno. Questa caratteristica le rende particolarmente utili nelle callback e nelle funzioni annidate.

Il lexical scope è inoltre alla base delle closure, uno dei meccanismi più importanti del linguaggio, utilizzato per mantenere stato e riferimenti a variabili esterne anche dopo la conclusione della funzione che le ha create.

Comprendere queste differenze permette di evitare errori legati al contesto delle funzioni, gestire correttamente callback e metodi degli oggetti e scrivere codice JavaScript più prevedibile e manutenibile.

Se c'è un concetto da ricordare, è questo: lo scope dipende da dove il codice viene scritto, mentre il valore di this nelle funzioni tradizionali dipende da come vengono chiamate.

Link utili