Informazioni su Controllo dei tipi
Sapere qual è il tipo di un dato è spesso molto importante perché il codice funzioni senza intoppi e senza errori.
Javascript ha diversi modi per controllare il tipo di un valore o di un oggetto.
I meccanismi di controllo dei tipi di Javascript possono essere alquanto inaffidabili.
Per una maggiore sicurezza dei tipi e tipi più forti, probabilmente dovresti usare TypeScript, un linguaggio che si basa su JavaScript, ma con la sintassi dei tipi di un linguaggio a tipizzazione statica.
L'operatore typeof
L'operatore typeof restituisce il tipo del suo operando.
L'output è una stringa che corrisponde al nome di uno dei tipi di dati primitivi, tranne che per "null".
Può anche essere "function" o "object".
typeof undefined;
// => "undefined"
typeof true;
// => "boolean"
typeof 42;
// => "number"
typeof 'Hello, World!';
// => "string"
typeof function () {
return 'Hello, World';
};
// => "function"
typeof [1, 2, 3, 4];
// => "object"
typeof { city: 'Stockholm', country: 'Sweden' };
// => "object"
Per [motivi storici][typeof null is "object"].
L'operatore instanceof
Per controllare il tipo di un oggetto, puoi usare l'operatore instanceof.
Restituisce un boolean a seconda che il secondo operando sia incluso nella catena di prototipi del primo operando.
Per chiarire, instanceof restituisce se il primo operando è un'istanza del secondo operando o di una delle sue classi figlie.
instanceof funziona solo sugli oggetti.
class Beverage {
// ...
}
// The Coffee class is a child of the Beverage class.
class Coffee extends Beverage {
// ...
}
const java = new Coffee();
java instanceof Coffee;
// => true
java instanceof Beverage;
// => true
La classe Array ha un metodo chiamato Array.isArray() che controlla se il suo argomento è un array.
Mentre instanceof Array non funziona con un array creato in un realm diverso, come un iframe in una pagina web, Array.isArray() sì.
Questo perché la classe Array ha un costruttore diverso in ogni realm, e ogni iframe ha il proprio realm: la funzione nella catena di prototipi sarà diversa, il che fa fallire instanceof Array.
Array.isArray() è in grado di ignorare tutto questo e va usata sempre quando è possibile.
Può anche resistere ai falsi positivi, dove un oggetto non è davvero un Array, ma ha semplicemente Array nella sua catena di prototipi.
({ __proto__: Array.prototype }) instanceof Array
// => true
Array.isArray({ __proto__: Array.prototype })
// => false
L'operatore in
L'operatore in restituisce se il primo operando è una proprietà del secondo operando.
Non controlla che la proprietà abbia un valore definito.
Una proprietà impostata a undefined viene comunque rilevata da in.
class Coffee {
constructor() {
this.temperature = 'hot';
this.isDarkMatter = undefined;
}
coolDown() {
this.temperature = 'warm';
}
}
const espresso = new Coffee();
'temperature' in espresso;
// => true
'color' in espresso;
// => false
'isDarkMatter' in espresso;
// => true
in restituisce true anche per le proprietà e i metodi ereditati.
"coolDown" in espresso
// => true
"constructor" in espresso
// => true
Per evitarlo, usa Object.hasOwn()
La funzione Object.hasOwn()
Il metodo Object.hasOwn() restituisce se l'oggetto specificato possiede la proprietà data (non è ereditata e non è un metodo).
class Coffee {
constructor() {
this.temperature = 'hot';
}
coolDown() {
this.temperature = 'warm';
}
}
const cappuccino = new Coffee();
Object.hasOwn(cappucino, 'temperature');
// => true
Object.hasOwn(cappucino, 'constructor');
// => false
Object.hasOwn(cappucino, 'coolDown');
// => false
1 esercizio
Impara Controllo dei tipi