Type de JavaScript
En JavaScript, il existe 5 types de données différents pouvant contenir des valeurs :
stringnumberbooleanobjectfunction
Il existe 6 types d'objets :
ObjectDateArrayStringNumberBoolean
Et 2 types de données qui ne peuvent pas contenir de valeurs :
nullundefined
Le type d'opérateur
Vous pouvez utiliser l' typeofopérateur pour trouver le type de données d'une variable JavaScript.
Exemple
typeof "John"
// Returns "string"
typeof 3.14
// Returns "number"
typeof NaN
// Returns "number"
typeof false
// Returns "boolean"
typeof [1,2,3,4] // Returns
"object"
typeof {name:'John', age:34}
// Returns "object"
typeof new Date()
// Returns "object"
typeof function () {} // Returns
"function"
typeof myCar
// Returns "undefined" *
typeof null
// Returns "object"
Veuillez observer :
- Le type de données de NaN est le nombre
- Le type de données d'un tableau est un objet
- Le type de données d'une date est un objet
- Le type de données de null est un objet
- Le type de données d'une variable indéfinie est indéfini *
- Le type de données d'une variable à laquelle aucune valeur n'a été affectée est également indéfini *
Vous ne pouvez pas utiliser typeofpour déterminer si un objet JavaScript est un tableau (ou une date).
Données primitives
Une valeur de données primitive est une valeur de données simple unique sans propriétés ni méthodes supplémentaires.
L' typeofopérateur peut renvoyer l'un de ces types primitifs :
stringnumberbooleanundefined
Exemple
typeof "John" // Returns
"string"
typeof 3.14 // Returns
"number"
typeof true // Returns
"boolean"
typeof false // Returns
"boolean"
typeof x
// Returns "undefined" (if x has no value)
Données complexes
L' typeofopérateur peut renvoyer l'un des deux types complexes suivants :
functionobject
L' typeofopérateur renvoie "object" pour les objets, les tableaux et null.
L' typeofopérateur ne renvoie pas "object" pour les fonctions.
Exemple
typeof {name:'John', age:34} // Returns "object"
typeof [1,2,3,4]
// Returns "object" (not "array", see note below)
typeof null // Returns
"object"
typeof function myFunc(){} // Returns "function"
L' typeofopérateur renvoie " object" pour les tableaux car en JavaScript les tableaux sont des objets.
Le type de données de typeof
L' typeofopérateur n'est pas une variable. C'est un opérateur. Les opérateurs ( + - * / ) n'ont aucun type de données.
Mais, l' typeofopérateur renvoie toujours une chaîne (contenant le type de l'opérande).
La propriété constructeur
La constructorpropriété renvoie la fonction constructeur pour toutes les variables JavaScript.
Exemple
"John".constructor
// Returns function String() {[native code]}
(3.14).constructor
// Returns function Number() {[native code]}
false.constructor // Returns
function Boolean() {[native code]}
[1,2,3,4].constructor
// Returns function Array() {[native code]}
{name:'John',age:34}.constructor
// Returns function Object() {[native code]}
new Date().constructor
// Returns function Date() {[native code]}
function () {}.constructor // Returns
function Function(){[native code]}
Vous pouvez vérifier la propriété du constructeur pour savoir si un objet est un Array
(contient le mot "Array") :
Exemple
function isArray(myArray) {
return myArray.constructor.toString().indexOf("Array") > -1;
}
Ou encore plus simple, vous pouvez vérifier si l'objet est une fonction Array :
Exemple
function isArray(myArray) {
return myArray.constructor
=== Array;
}
Vous pouvez vérifier la propriété du constructeur pour savoir si un objet est un
Date(contient le mot "Date") :
Exemple
function isDate(myDate) {
return myDate.constructor.toString().indexOf("Date") > -1;
}
Ou encore plus simple, vous pouvez vérifier si l'objet est une fonction Date :
Exemple
function isDate(myDate) {
return myDate.constructor === Date;
}
Indéfini
En JavaScript, une variable sans valeur a la valeur undefined. Le genre est aussi undefined.
Exemple
let car; // Value is undefined,
type is undefined
Toute variable peut être vidée, en définissant la valeur sur undefined. Le type sera également undefined.
Exemple
car = undefined; // Value is undefined,
type is undefined
Valeurs vides
Une valeur vide n'a rien à voir avec undefined.
Une chaîne vide a à la fois une valeur légale et un type.
Exemple
let car = ""; //
The value is
"", the typeof is "string"
Nul
En JavaScript null, c'est "rien". C'est censé être quelque chose qui n'existe pas.
Malheureusement, en JavaScript, le type de données de nullest un objet.
Vous pouvez le considérer comme un bogue dans JavaScript qui typeof nullest un objet. Ça devrait être null.
Vous pouvez vider un objet en le définissant sur null:
Exemple
let person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
person = null; //
Now value is null,
but type is still an object
Vous pouvez également vider un objet en le définissant sur undefined:
Exemple
let person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
person = undefined; //
Now both value and type is undefined
Différence entre indéfini et nul
undefinedet nullsont de valeur égale mais de type différent :
typeof undefined
// undefined
typeof null
// object
null === undefined
// false
null == undefined
// true