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. 
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 riferimentothisdurante 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
varall'interno di una funzione. -
Block scope: riguarda le variabili dichiarate
con
leteconstall'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
- MDN - this : documentazione sul comportamento di this nei diversi contesti di esecuzione.
- MDN - Closures : guida approfondita sul lexical scope e sul funzionamento delle closure.
- MDN - Arrow functions : approfondimento sulle funzioni freccia e sulle differenze rispetto alle funzioni tradizionali.
- MDN - Function.prototype.bind() : documentazione sul binding esplicito del valore di this.
- MDN - Function.prototype.call() : approfondimento sull'invocazione delle funzioni con un this specifico.
- MDN - Function.prototype.apply() : documentazione sul passaggio degli argomenti tramite array.
