Introduction
Savoir quel est le type d'une donnée est souvent très important pour que le code s'exécute correctement, sans erreur.
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 stricts, tu devrais sans doute utiliser TypeScript, un langage construit sur JavaScript, mais qui reprend la syntaxe de typage d'un langage à typage statique.
L'opérateur typeof
L'opérateur typeof renvoie le type de son opérande.
Le résultat est une string correspondant au nom de l'un des types de données primitifs, sauf pour "null".
Il peut aussi valoir "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 s'évalue en un boolean selon que le second opérande figure ou non dans la chaîne de prototypes du premier opérande.
Pour préciser : instanceof renvoie si le premier opérande est une instance du second opérande ou de l'une de ses classes dérivées.
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 fonctionne pas avec un tableau créé dans un autre realm, comme une iframe dans une page web, Array.isArray() y parvient.
En effet, la classe Array a un constructeur différent dans chaque realm, et chaque iframe possède son propre realm, ce qui signifie que la fonction de la chaîne de prototypes diffère, et fait donc échouer instanceof Array.
Array.isArray() sait ignorer ce problème et devrait toujours être utilisée quand c'est possible.
Elle résiste aussi aux faux positifs, là où 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 renvoie si le premier opérande est une propriété du second opérande.
Il ne vérifie pas que la propriété possède 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() renvoie si l'objet spécifié possède la propriété donnée (elle n'est pas héritée et ce 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
Instructions
Instructions
Tu as été recruté par un centre de recyclage.
Par manque de place, tous les produits sont placés sur le même convoyeur, ce qui a fini par mélanger les différents matériaux et les rendre inutilisables.
Pour y remédier, on t'a confié la mission d'écrire des fonctions permettant d'identifier le type d'un produit.
1. Vérifie si une valeur est un booléen
Implémente la fonction isBoolean, qui vérifie si une valeur est un booléen.
isBoolean(true);
// => true
isBoolean(null);
// => false
2. Vérifie si une valeur est un nombre.
Implémente la fonction isNumber, qui vérifie si une valeur est un number ou un bigint fini, c'est-à-dire ni NaN ni Infinity.
Il arrive que le dispositif de lecture des identifiants tombe en panne et lise une valeur non numérique comme NaN (« pas un nombre ») ou Infinity.
Ta fonction doit aussi pouvoir gérer correctement ce cas.
isNumber(42);
// => true
isNumber('Hello, World!');
// => false
isNumber(42n);
// => true
isNumber(NaN);
// => false
3. Vérifie si une valeur est un objet
Implémente la fonction isObject, qui doit vérifier si la valeur est un objet.
Sur le convoyeur, null n'est rien et n'est pas considéré comme un objet.
isObject({ greeting: 'Hello' });
// => true
isObject(25n);
// => false
4. Vérifie si une string est numérique
Implémente la fonction isNumericString, qui doit vérifier si la valeur est une string composée uniquement de chiffres, ou d'un signe moins suivi de chiffres indiquant un nombre négatif.
Seuls les entiers doivent être pris en compte ; les nombres décimaux ne sont pas considérés comme numériques pour cette vérification du robot de recyclage.
isNumericString(42);
// => false
isNumericString('42');
// => true
isNumericString('Hi!');
// => false
5. Vérifie si un objet est électronique
Implémente la fonction isElectronic, qui vérifie si un objet est une instance de la classe ElectronicDevice fournie ou de l'une de ses classes filles.
class Duck {
//...
}
class WashingMachine extends ElectronicDevice {
//...
}
isElectronic(new Duck());
// => false
isElectronic(new WashingMachine());
// => true
6. Vérifie si une valeur est un tableau non vide
Implémente la fonction isNonEmptyArray, qui vérifie si une valeur est un tableau non vide.
isNonEmptyArray([1, 2, 3]);
// => true
isNonEmptyArray([]);
// => false
7. Vérifie si une valeur est un tableau vide
Implémente la fonction isEmptyArray, qui vérifie si une valeur est un tableau vide.
isEmptyArray([1, 2, 3]);
// => false
isEmptyArray([]);
// => true
8. Vérifie si un objet possède une propriété ou une méthode type
Implémente la fonction hasType, qui vérifie si un objet possède une propriété ou une méthode type.
class Keyboard(){
type(){
// ...
}
}
hasType({ type:"car", color:"red" })
// => true
hasType({ color:"green" })
// => false
hasType(new Keyboard())
// => true
9. Lève une erreur si un objet ne possède pas de propriété ou de méthode id
Implémente la fonction assertHasId, qui lèvera une Error si un objet ne possède pas la propriété id.
Si un objet possède bien la propriété id, elle ne doit rien renvoyer.
assertHasId({ id: 42, color: 'red' });
// => undefined
assertHasId({ color: 'green' });
// Error: "Object is missing the 'id' property"
10. Vérifie si un objet possède une propriété id
Implémente la fonction hasIdProperty, qui vérifie si un objet possède une propriété 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. Vérifie si un objet possède une propriété type définie
Implémente la fonction hasDefinedType, qui vérifie si un objet possède une propriété type qui n'est pas undefined.
hasDefinedType({ type: undefined, color: 'red' });
// => false
hasDefinedType({ type: 'car', color: 'green' });
// => true
Exercice d'apprentissage
