À propos de Vérification de types
Savoir quel est le type d'une donnée est souvent très important pour que le code tourne correctement, sans erreurs.
JavaScript propose plusieurs façons de vérifier le type d'une valeur ou d'un objet.
Les mécanismes de vérification de type de JavaScript peuvent être assez peu fiables.
Pour une meilleure sûreté de type et des types plus forts, tu devrais sans doute utiliser TypeScript, un langage construit sur JavaScript, mais avec la syntaxe de typage d'un langage à typage statique.
L'opérateur typeof
L'opérateur typeof renvoie le type de son opérande.
La sortie est une string qui correspond au nom de l'un des types de données primitifs, sauf pour "null".
Elle peut aussi être "function" ou "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"
Pour des [raisons historiques][typeof null is "object"].
L'opérateur instanceof
Pour vérifier le type d'un objet, tu peux utiliser l'opérateur instanceof.
Il donne un boolean selon que le second opérande appartient ou non à la chaîne de prototypes du premier opérande.
Pour être plus clair, instanceof indique si le premier opérande est une instance du second opérande ou de l'une de ses classes filles.
instanceof ne fonctionne que sur les objets.
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 possède une méthode appelée Array.isArray() qui vérifie si son argument est un tableau.
Alors que instanceof Array ne fonctionnera pas avec un tableau créé dans un autre contexte d'exécution, comme une iframe dans une page web, Array.isArray() fonctionnera.
En effet, la classe Array a un constructeur différent dans chaque contexte d'exécution, et chaque iframe possède son propre contexte d'exécution, ce qui signifie que la fonction dans la chaîne de prototypes sera différente, et fera donc échouer instanceof Array.
Array.isArray() sait ignorer ce problème et devrait toujours être utilisé quand c'est possible.
Il permet également d'éviter les faux positifs, lorsqu'un objet n'est pas réellement un Array et possède simplement Array dans sa chaîne de prototypes.
({ __proto__: Array.prototype }) instanceof Array
// => true
Array.isArray({ __proto__: Array.prototype })
// => false
L'opérateur in
L'opérateur in indique si le premier opérande est une propriété du second opérande.
Il ne vérifie pas que la propriété a une valeur définie.
Une propriété définie à undefined sera quand même détectée par 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 renvoie true pour les propriétés et méthodes héritées.
"coolDown" in espresso
// => true
"constructor" in espresso
// => true
Pour éviter cela, utilise plutôt Object.hasOwn()
La fonction Object.hasOwn()
La méthode Object.hasOwn() indique si l'objet spécifié possède réellement la propriété donnée (elle n'est pas héritée et n'est pas une méthode).
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 exercice
Apprends Vérification de types