Introduzione
Sapere qual è il tipo di un dato è spesso molto importante per far funzionare il codice 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 una tipizzazione più forte, 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 [ragioni storiche][typeof null is "object"].
L'operatore instanceof
Per controllare il tipo di un oggetto, puoi usare l'operatore instanceof.
Restituisce un valore boolean a seconda che il secondo operando sia incluso nella catena di prototipi del primo operando.
Per chiarire, instanceof restituirà se il primo operando è un'istanza del secondo operando o di una delle sue classi figlie.
instanceof funziona solo con gli 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 funzionerà con un array creato in un ambiente di esecuzione diverso, come un iframe in una pagina web, Array.isArray() sì.
Questo perché la classe Array ha un costruttore diverso in ogni ambiente di esecuzione, e ogni iframe ha il proprio ambiente di esecuzione, il che significa che la funzione nella catena di prototipi sarà diversa, facendo fallire instanceof Array.
Array.isArray() è in grado di ignorarlo, e dovrebbe sempre essere usato quando possibile.
Può anche sopravvivere ai falsi positivi in cui un oggetto non è in realtà un Array, e 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 su undefined verrà 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 restituirà true per proprietà e metodi ereditati.
"coolDown" in espresso
// => true
"constructor" in espresso
// => true
Per evitare questo, usa invece Object.hasOwn()
La funzione Object.hasOwn()
Il metodo Object.hasOwn() restituisce se l'oggetto specificato possiede la proprietà indicata (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
Istruzioni
Istruzioni
Ti hanno assunto in un centro di riciclaggio.
Per mancanza di spazio, tutti i prodotti finiscono sullo stesso nastro trasportatore, ma così materiali diversi si mescolano tra loro e diventano inutilizzabili.
Per risolvere il problema, il tuo compito è scrivere funzioni che identifichino il tipo di un prodotto.
1. Verifica se un valore è un booleano
Implementa la funzione isBoolean, che verifica se un valore è un booleano.
isBoolean(true);
// => true
isBoolean(null);
// => false
2. Verifica se un valore è un numero
Implementa la funzione isNumber, che verifica se un valore è un number o un bigint finito, cioè se non è NaN né Infinity.
A volte il dispositivo che legge gli ID si guasta e legge un valore non numerico come NaN (Not a Number) o Infinity.
Anche la funzione deve saper gestire correttamente questo caso.
isNumber(42);
// => true
isNumber('Hello, World!');
// => false
isNumber(42n);
// => true
isNumber(NaN);
// => false
3. Verifica se un valore è un oggetto
Implementa la funzione isObject, che verifica se il valore è un oggetto.
Sul nastro trasportatore, null non è nulla e non è considerato un oggetto.
isObject({ greeting: 'Hello' });
// => true
isObject(25n);
// => false
4. Verifica se una stringa è numerica
Implementa la funzione isNumericString, che verifica se il valore è una stringa composta solo da cifre, oppure da un segno meno seguito da cifre, a indicare un numero negativo.
Vanno considerati solo i numeri interi: per questo controllo del robot di riciclaggio i decimali non sono considerati numerici.
isNumericString(42);
// => false
isNumericString('42');
// => true
isNumericString('Hi!');
// => false
5. Verifica se un oggetto è elettronico
Implementa la funzione isElectronic, che verifica se un oggetto è un'istanza della classe ElectronicDevice fornita o di una delle sue classi figlie.
class Duck {
//...
}
class WashingMachine extends ElectronicDevice {
//...
}
isElectronic(new Duck());
// => false
isElectronic(new WashingMachine());
// => true
6. Verifica se un valore è un array non vuoto
Implementa la funzione isNonEmptyArray, che verifica se un valore è un array non vuoto.
isNonEmptyArray([1, 2, 3]);
// => true
isNonEmptyArray([]);
// => false
7. Verifica se un valore è un array vuoto
Implementa la funzione isEmptyArray, che verifica se un valore è un array vuoto.
isEmptyArray([1, 2, 3]);
// => false
isEmptyArray([]);
// => true
8. Verifica se un oggetto ha una proprietà o un metodo type
Implementa la funzione hasType, che verifica se un oggetto ha una proprietà o un metodo type.
class Keyboard(){
type(){
// ...
}
}
hasType({ type:"car", color:"red" })
// => true
hasType({ color:"green" })
// => false
hasType(new Keyboard())
// => true
9. Lancia un errore se un oggetto non ha una proprietà o un metodo id
Implementa la funzione assertHasId, che lancia un Error se a un oggetto manca la proprietà id.
Se un oggetto ha la proprietà id, la funzione non deve restituire nulla.
assertHasId({ id: 42, color: 'red' });
// => undefined
assertHasId({ color: 'green' });
// Error: "Object is missing the 'id' property"
10. Verifica se un oggetto ha una proprietà id
Implementa la funzione hasIdProperty, che verifica se un oggetto ha una proprietà id.
class SimpleData {
constructor() {
this.number = '42';
this.id = 'BC269327FE1D9B95';
}
}
class StealingData extends SimpleData {}
class MethodData {
constructor() {
this.number = '42';
this._id = 'BC269327FE1D9B95';
}
get id() {
return this._id;
}
}
hasIdProperty(new SimpleData());
// => true
hasIdProperty(new MethodData());
// => false
hasIdProperty(new StealingData());
// => false
11. Verifica se un oggetto ha una proprietà type definita
Implementa la funzione hasDefinedType, che verifica se un oggetto ha una proprietà type che non è undefined.
hasDefinedType({ type: undefined, color: 'red' });
// => false
hasDefinedType({ type: 'car', color: 'green' });
// => true
Esercizio di apprendimento
