L'opérateur typeof

L'opérateur typeof renvoie une chaîne qui indique le type de son opérande.

Syntaxe

L'opérateur typeof est suivi de son opérande :

typeof opérande

Paramètre

opérande est une expression qui représente la valeur dont on souhaite obtenir le type.

Description

Le tableau qui suit liste les résultats possibles de l'opérateur typeof. Pour plus d'informations sur les types et valeurs primitives en JavaScript, voir la page sur les types et structures de données JavaScript.

Exemples

// Pour les nombres
typeof 37 === 'number';
typeof 3.14 === 'number';
typeof(42) === 'number';
typeof Math.LN2 === 'number';
typeof Infinity === 'number';
typeof NaN === 'number'; // Bien que littéralement ce soit "Not-A-Number"...
typeof Number(1) === 'number'; // cette forme ne doit pas être utilisée !


// Les chaînes de caractères
typeof "" === 'string';
typeof "bla" === 'string';
typeof "1" === 'string'; // on a ici un nombre écrit sous forme d'une chaîne
typeof (typeof 1) === 'string'; // typeof renvoie toujours une chaîne
typeof String("abc") === 'string'; // cette forme ne doit pas être utilisée !


// Les booléens
typeof true === 'boolean';
typeof false === 'boolean';
typeof Boolean(true) === 'boolean'; // cette forme ne doit pas être utilisée !


// Les symboles
typeof Symbol() === 'symbol'
typeof Symbol('foo') === 'symbol'
typeof Symbol.iterator === 'symbol'


// Indéfini
typeof undefined === 'undefined';
typeof blabla === 'undefined'; // pour une variable indéfinie


// Les objets
typeof {a:1} === 'object';

// Utiliser la méthode Array.isArray ou Object.prototype.toString.call
// afin de différencier les objets des tableaux
typeof [1, 2, 4] === 'object';

typeof new Date() === 'object';


// Les expressions suivantes sont source de confusion
// à ne pas utiliser sous cette forme
typeof new Boolean(true) === 'object'; 
typeof new Number(1) === 'object'; 
typeof new String("abc") === 'object';


// Les fonctions
typeof function(){} === 'function';
typeof class C {} === 'function';
typeof Math.sin === 'function';

null

// Cela est valable depuis les commencements de JavaScript
typeof null === 'object';

Lors de la première implémentation de JavaScript, les valeurs JavaScript étaient représentées avec une étiquette de type et une valeur. Pour les objets, l'étiquette de type était 0. null était représenté par la valeur NULL (0x00 pour la plupart des plates-formes). Par conséquent, l'étiquette de type de null valait 0, d'où le comportement de typeof (source).

Un correctif fut proposé pour ECMAScript mais il fut refusé. Avec cette version, on aurait eu typeof null === 'null'.

Utiliser l'opérateur new

// Tous les constructeurs doivent être employés
// avec le mot-clé "new"
var maChaine = new String("toto");
var monNombre = new Number(100);

typeof maChaine;  // renverra "object" 
typeof monNombre; // renverra "object"

// En revanche avec le constructeur Function,
// on aura : 
var maFonction = new Function();
typeof maFonction; // renverra "function"

Expressions rationnelles

Les expressions rationnelles qu'on peut appeler directement furent parfois ajoutées de façon non standard dans certains navigateurs.

typeof /s/ === 'function'; // Chrome 1 à 12 : Non conforme à ECMAScript 5.1
typeof /s/ === 'object';   // À partir de Firefox 5 : Conforme à ECMAScript 5.1

Exceptions

Tous les navigateurs actuels exposent un objet non-standard document.all dont le type est "undefined".

typeof document.all === "undefined";

Bien que la spécification requière que les objets exostiques aient des types différents, ces types doivent être des chaînes différentes des chaînes existantes pour les objets standards. À ce titre, le type de document.all représente une violation de ces règles.

Spécifications

Compatibilité des navigateurs

Notes spécifiques à IE

Pour les versions 6, 7 et 8 d'Internet Explorer, les objets de l'environnement hôte sont des objets et non des fonctions. Par exemple, on aura :

typeof alert === 'object'

Voir aussi

• L'opérateur instanceof