JavaScript - Opérateur typeof

Bienvenue, aspirants programmeurs ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde de JavaScript, en explorant spécifiquement l'opérateur typeof. Ne vous inquiétez pas si vous êtes nouveau dans le domaine de la programmation ; je vais vous guider à travers ce concept étape par étape, tout comme j'ai fait pour des centaines d'étudiants au fil des ans. Alors, prenez votre boisson favorite, asseyez-vous confortablement, et plongons dedans !

L'Opérateur typeof

Imaginez que vous êtes un détective dans le monde de JavaScript, et que votre travail est d'identifier le type de différents morceaux de données. C'est exactement ce que fait l'opérateur typeof ! C'est comme une loupe qui nous aide à déterminer le type d'une valeur ou d'une expression en JavaScript.

Syntaxe

Utiliser l'opérateur typeof est aussi simple que manger un morceau de tarte (et qui n'aime pas la tarte ?). Voici comment vous pouvez le faire :

typeof operande
// ou
typeof(operande)

Les deux formes fonctionnent de la même manière, donc choisissez celle qui vous paraît plus jolie. Personnellement, je préfère la première car il y a moins à écrire, et soyons francs, les programmeurs sont tous des adeptes de l'efficacité !

Types Retournés par l'Opérateur typeof

Maintenant, regardons les différents types que typeof peut identifier. C'est comme un menu des saveurs de données en JavaScript :

Type	typeof Retourne
Nombre	"number"
Chaîne	"string"
Booleen	"boolean"
Symbole	"symbol"
Indéfini	"undefined"
Null	"object"
Objet	"object"
Fonction	"function"
BigInt	"bigint"

Ne vous inquiétez pas si certains de ces types vous semblent familiers. Nous explorerons chacun d'eux avec des exemples qui vous feront dire "Ah ha !"

Opérateur typeof de JavaScript pour Vérifier le Type Number

Commençons par les nombres. En JavaScript, les nombres sont comme les blocs de construction des opérations mathématiques.

console.log(typeof 42);        // "number"
console.log(typeof 3.14);      // "number"
console.log(typeof -10);       // "number"
console.log(typeof Infinity);  // "number"
console.log(typeof NaN);       // "number"

Surprise ! Même Infinity et NaN (Not-a-Number) sont considérés comme des nombres en JavaScript. C'est comme appeler un hot-dog un sandwich - un peu inattendu, mais c'est ainsi que JavaScript fonctionne !

Opérateur typeof de JavaScript pour Vérifier le Type String

Les chaînes de caractères sont comme les emballages des données - elles contiennent du contenu textuel.

console.log(typeof "Hello, World!");  // "string"
console.log(typeof '42');             // "string"
console.log(typeof ``);               // "string"

Notez comment '42' entre guillemets est une chaîne, et non un nombre. C'est comme habiller un nombre en costume de texte !

Opérateur typeof de JavaScript pour Vérifier le Type Boolean

Les booléens sont les oui/non, vrai/faux de la programmation. Ils sont comme des interrupteurs - soit allumés, soit éteints.

console.log(typeof true);   // "boolean"
console.log(typeof false);  // "boolean"
console.log(typeof (1 > 2)); // "boolean"

Le dernier exemple montre que les comparaisons résultent en des booléens. C'est comme demander "1 est-il plus grand que 2?" et obtenir un "Non !" (faux) en retour.

Opérateur typeof de JavaScript pour Vérifier le Type Symbol

Les symboles sont des identifiants uniques, comme des étiquettes de nom à une fête où chacun a un nom différent.

console.log(typeof Symbol('unique'));  // "symbol"

Ne vous inquiétez pas trop des symboles pour l'instant. Ils sont les enfants branchés de ES6, mais nous ne les voyons pas à toutes les fêtes JavaScript.

Opérateur typeof de JavaScript pour Vérifier les Types Undefined et Null

Voici où les choses deviennent un peu compliquées, comme un tour de magie dans le monde de la programmation.

console.log(typeof undefined);  // "undefined"
console.log(typeof null);       // "object"

Attendez, qu'est-ce que c'est ? null est un objet ? C'est en fait un bug de longue date dans JavaScript, mais il a été là depuis si longtemps que le corriger pourrait casser du code existant. C'est comme cette table branlante dans votre café préféré - énervante, mais changerait pourrait énerver les habitués.

Opérateur typeof de JavaScript pour Vérifier le Type Object

Les objets sont comme des conteneurs qui peuvent contenir diverses propriétés et méthodes.

console.log(typeof {});           // "object"
console.log(typeof []);           // "object"
console.log(typeof new Date());   // "object"

Oui, les tableaux sont aussi des objets ! C'est comme dire qu'une liste d'achats est un type de document - techniquement vrai, même si cela semble un peu étrange.

Opérateur typeof de JavaScript pour Vérifier le Type Function

Les fonctions sont comme les verbes de la programmation - elles font des choses !

console.log(typeof function() {});  // "function"
console.log(typeof console.log);    // "function"

Les fonctions ont leur propre type spécial. C'est comme si JavaScript disait, "Vous êtes spéciaux, fonctions. Vous avez votre propre catégorie !"

Opérateur typeof de JavaScript pour Vérifier le Type BigInt

BigInt est le nouveau venu dans le quartier, introduit pour gérer de très grands nombres.

console.log(typeof 1n);  // "bigint"
console.log(typeof BigInt(1));  // "bigint"

Pensez à BigInt comme au champion lourd des nombres - quand les nombres réguliers ne suffisent pas !

Opérateur typeof de JavaScript dans le Développement en Temps Réel

Dans le développement en monde réel, typeof est souvent utilisé pour vérifier les types avant les opérations. C'est comme vérifier si vous avez les bons ingrédients avant de commencer à cuisiner.

function safeAdd(a, b) {
if (typeof a === "number" && typeof b === "number") {
return a + b;
} else {
return "Erreur : Les deux arguments doivent être des nombres";
}
}

console.log(safeAdd(5, 10));  // 15
console.log(safeAdd("5", 10));  // "Erreur : Les deux arguments doivent être des nombres"

Cette fonction vérifie si les deux entrées sont des nombres avant de les additionner. C'est comme un videur dans un club "Seulement les nombres" !

Tableaux JavaScript et Opérateur typeof

Voici un moment où il faut être vigilant - souvenez-vous que les tableaux sont des objets ? Voyons-le en action :

console.log(typeof [1, 2, 3]);  // "object"

Alors comment vérifions-nous les tableaux ? Nous utilisons une méthode spéciale :

console.log(Array.isArray([1, 2, 3]));  // true
console.log(Array.isArray({a: 1}));     // false

C'est comme avoir un détecteur spécial pour les objets en forme de tableau !

Et voilà, les amis ! Nous avons fait le tour du pays des typeof en JavaScript. Souvenez-vous, la pratique rend parfait, alors jouez avec ces exemples. Avant de savoir, vous serez vérifiant les types comme un pro ! Bon codage, et puissent vos variables toujours être du type que vous attendez !

Credits: Image by storyset