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 operande
typeof(operande)

Paramètre

operande

Une expression représentant l'objet ou la valeur primitive 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.

Type Résultat
indéfini "undefined"
nul "object" (voir ci-après)
booléen "boolean"
nombre "number"
grand entier (nouveauté d'ECMAScript 2020) "bigint"
chaîne de caractère "string"
symbole (nouveauté d'ECMAScript 6 / 2015) "symbol"
objet Function (au sens ECMA-262, un objet qui implémente [[Call]]) "function"
Tout autre objet "object"

Exemples

Usage simple

// 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'; // Number essaie de convertir l'argument en nombre
typeof Number('chaussure') === 'number'; // cela vaut également pour les valeurs qui ne peuvent pas être converties


// Grand entier
typeof 42n === 'bigint';

// Les chaînes de caractères
typeof "" === 'string';
typeof "bla" === 'string';
typeof `gabarit de chaîne` === '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(1) === 'string'; // String convertit n'importe quelle valeur en chaîne

// Les booléens
typeof true === 'boolean';
typeof false === 'boolean';
typeof Boolean(1) === 'boolean'; // Boolean convertit n'importe quelle valeur en son équivalent logique
typeof !!(1) === 'boolean'; // deux appels à l'opérateur ! (le NON logique) sont équivalents à Boolean()

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

// Indéfini
typeof undefined === 'undefined';
typeof variableDeclareeMaisIndefinie === 'undefined';
typeof variableNonDeclaree === 'undefined';

// 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';
typeof /regex/ === 'object'; // Voir la section sur les expressions rationnelles

// 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';

typeof 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"
let maChaine = new String("toto");
let monNombre = new Number(100);

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

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

Utilisation des parenthèses

// Les parenthèses peuvent s'avérer utile pour
// déterminer le type de données d'une expression
// complète

let maDonnee = 99;

typeof maDonnee + ' Toto';   // renverra 'number Toto'
typeof (maDonnee + ' Toto'); // renverra 'string'

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

Erreurs et zone morte temporaire (Temporal Dead Zone / TDZ)

Avant ECMAScript 2015 (ES6), typeof retournait toujours une chaîne de caractères, quel que soit l'opérande utilisé. On ne pouvait pas avoir d'erreur en utilisant typeof.

Avec l'apparition des opérateurs let et const, si on utilise typeof sur des variables déclarées avec ces opérateurs (ou avec une classe) avant leur déclaration, cela déclenchera une erreur ReferenceError. Si on utilise typeof sur une variable déclarée avec var avant la déclaration, cela renverra undefined. Les variables déclarées avec let et const sont en fait placées dans une *zone morte temporaire *entre le début du bloc et leur initialisation et dans cette zone, tout accès à la variable produit une erreur.

typeof variableGlobaleNonDeclaree === "undefined";

typeof variableLet; // ReferenceError
let variableLet;

typeof constante;   // ReferenceError
const constante = "coucou";

typeof maClasse; // ReferenceError
class maClasse{};

Exceptions

Tous les navigateurs actuels exposent un objet non-standard document.all (en-US) dont le type est undefined.

typeof document.all === "undefined";

Bien que la spécification requière que les objets exotiques 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 « volontaire » du standard ECMAScript original.

Spécifications

Specification
ECMAScript Language Specification (ECMAScript)
# sec-typeof-operator

Compatibilité des navigateurs

BCD tables only load in the browser

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'

Certaines propriétés non-standard d'IE renvoient d'autres valeurs (tc39/ecma262#1440 (commentaire)):

typeof window.external.AddSearchProvider === "unknown";
typeof window.external.IsSearchProviderInstalled === "unknown";

Voir aussi