Recherche du type de variable en JavaScript

Question

En Java, vous pouvez utiliser instanceOf ou getClass() sur une variable pour connaître son type.

Comment trouver le type d'une variable en JavaScript qui n'est pas fortement typé?

Par exemple, comment savoir si bar est un Boolean ou un Number ou un String ?

 function foo(bar) {
    // what do I do here?
}
 

Answer 1

Utiliser typeof:

> typeof "foo"
"string"
> typeof true
"boolean"
> typeof 42
"number"

De sorte que vous pouvez faire:

if(typeof bar === 'number') {
   //whatever
}

Attention, si vous définissez ces primitives avec leurs wrappers d'objets (que vous ne devriez jamais faire, utilisez les littéraux dans la mesure du possible):

> typeof new Boolean(false)
"object"
> typeof new String("foo")
"object"
> typeof new Number(42)
"object"

Le type d'un tableau est toujours object. Ici, vous avez vraiment besoin de l' instanceof de l'opérateur.

Mise à jour:

Une autre façon intéressante consiste à examiner la sortie de l' Object.prototype.toString:

> Object.prototype.toString.call([1,2,3])
"[object Array]"
> Object.prototype.toString.call("foo bar")
"[object String]"
> Object.prototype.toString.call(45)
"[object Number]"
> Object.prototype.toString.call(false)
"[object Boolean]"
> Object.prototype.toString.call(new String("foo bar"))
"[object String]"

Avec qui vous n'auriez pas à distinguer entre les valeurs primitives et les objets.

Answer 2

typeof n'est utile que pour renvoyer les types "primitifs", nombre, booléen, objet, chaîne. Vous pouvez également utiliser instanceof pour tester si un objet est d'un type spécifique.

 function MyObj(prop) {
  this.prop = prop;
}

var obj = new MyObj(10);

console.log(obj instanceof MyObj && obj instanceof Object); // outputs true
 

Answer 3

Utilisation de type :

 // Numbers
typeof 37                === 'number';
typeof 3.14              === 'number';
typeof Math.LN2          === 'number';
typeof Infinity          === 'number';
typeof NaN               === 'number'; // Despite being "Not-A-Number"
typeof Number(1)         === 'number'; // but never use this form!

// Strings
typeof ""                === 'string';
typeof "bla"             === 'string';
typeof (typeof 1)        === 'string'; // typeof always return a string
typeof String("abc")     === 'string'; // but never use this form!

// Booleans
typeof true              === 'boolean';
typeof false             === 'boolean';
typeof Boolean(true)     === 'boolean'; // but never use this form!

// Undefined
typeof undefined         === 'undefined';
typeof blabla            === 'undefined'; // an undefined variable

// Objects
typeof {a:1}             === 'object';
typeof [1, 2, 4]         === 'object'; // use Array.isArray or Object.prototype.toString.call to differentiate regular objects from arrays
typeof new Date()        === 'object';
typeof new Boolean(true) === 'object'; // this is confusing. Don't use!
typeof new Number(1)     === 'object'; // this is confusing. Don't use!
typeof new String("abc") === 'object';  // this is confusing. Don't use!

// Functions
typeof function(){}      === 'function';
typeof Math.sin          === 'function';
 

Answer 4

En Javascript, vous pouvez le faire en utilisant la fonction typeof

 function foo(bar){
  alert(typeof(bar));
}
 

Answer 5

Pour être un peu plus ECMAScript-5.1-précise que les autres réponses (certains pourraient dire pédant):

En JavaScript, les variables (et propriétés) n'ont pas de types: les valeurs ne. De plus, il y a seulement 6 types de valeurs: Undefined, Null, Booléen, Chaîne de caractères, Nombre, et de l'Objet. (Techniquement, il y a également 7 "spécification de types", mais vous ne pouvez pas stocker des valeurs de ces types de propriétés d'objets ou de valeurs des variables--ils sont utilisés uniquement à l'intérieur de la spécification elle-même, pour définir comment la langue fonctionne. Les valeurs que vous pouvez manipuler explicitement ne sont que 6 types que j'ai énumérés.)

La spécification utilise la notation de Type "(x)" quand on veut parler de "le type de x". Ce n'est qu'une notation utilisée dans le spec: il n'est pas une caractéristique de la langue.

Comme d'autres réponses, dans la pratique, vous pouvez vouloir en savoir plus que le type d'une valeur--surtout quand le type en est l'Objet. Quelle que soit, et pour être complet, voici un simple JavaScript mise en œuvre de Type(x) tel qu'il est utilisé dans les specs:

function Type(x) { 
    if (x === null) {
        return 'Null';
    }

    switch (typeof x) {
    case 'undefined': return 'Undefined';
    case 'boolean'  : return 'Boolean';
    case 'number'   : return 'Number';
    case 'string'   : return 'String';
    default         : return 'Object';
    }
}