JavaScript
Types de données en Javascript

Type de

typeof est la fonction "officielle" que l'on utilise pour obtenir le type en javascript, mais dans certains cas, cela peut donner des résultats inattendus ...

1. cordes

typeof "String" ou
typeof Date(2011,01,01)

"chaîne"

2. Nombres

typeof 42

"nombre"

3. Bool

typeof true (valeurs valides true et false )

"booléen"

4. objet

typeof {} ou
typeof [] ou
typeof null ou
typeof /aaa/ ou
typeof Error()

"objet"

5. fonction

typeof function(){}

"fonction"

6. indéfini

var var1; typeof var1

"indéfini"

Obtenir le type d'objet par nom de constructeur

Quand on avec typeof opérateur on obtient de type object tombe dans la catégorie un peu ... tu étais

En pratique, vous devrez peut-être vous limiter à quel type d'objet il s'agit et utiliser un nom de constructeur d'objet pour savoir quelle est l'objet de l'objet: Object.prototype.toString.call(yourObject)

1. ficelle

Object.prototype.toString.call("String")

"[chaîne d'objets]"

2. nombre

Object.prototype.toString.call(42)

"[Numéro d'objet]"

3. Bool

Object.prototype.toString.call(true)

"[objet booléen]"

4. objet

Object.prototype.toString.call(Object()) ou
Object.prototype.toString.call({})

"[objet Objet]"

5. fonction

Object.prototype.toString.call(function(){})

"[Fonction d'objet]"

6. date

Object.prototype.toString.call(new Date(2015,10,21))

"[objet date]"

7. Regex

Object.prototype.toString.call(new RegExp()) ou
Object.prototype.toString.call(/foo/);

"[objet RegExp]"

8. tableau

Object.prototype.toString.call([]);

"[objet Array]"

9. Null

Object.prototype.toString.call(null);

"[objet Null]"

10. indéfini

Object.prototype.toString.call(undefined);

"[objet non défini]"

11. erreur

Object.prototype.toString.call(Error());

"[Erreur d'objet]"

Trouver la classe d'un objet

Pour savoir si un objet a été construit par un constructeur donné ou par un constructeur, vous pouvez utiliser la commande instanceof :

//We want this function to take the sum of the numbers passed to it
//It can be called as sum(1, 2, 3) or sum([1, 2, 3]) and should give 6
function sum(...arguments) {
    if (arguments.length === 1) {
        const [firstArg] = arguments
        if (firstArg instanceof Array) { //firstArg is something like [1, 2, 3]
            return sum(...firstArg) //calls sum(1, 2, 3)
        }
    }
    return arguments.reduce((a, b) => a + b)
}

console.log(sum(1, 2, 3))   //6
console.log(sum([1, 2, 3])) //6
console.log(sum(4))         //4

Notez que les valeurs primitives ne sont considérées comme des instances d'aucune classe:

console.log(2 instanceof Number)        //false
console.log('abc' instanceof String)    //false
console.log(true instanceof Boolean)    //false
console.log(Symbol() instanceof Symbol) //false

Chaque valeur de JavaScript, à part null et undefined possède également une propriété constructor qui stocke la fonction utilisée pour la construire. Cela fonctionne même avec les primitives.

//Whereas instanceof also catches instances of subclasses,
//using obj.constructor does not
console.log([] instanceof Object, [] instanceof Array)           //true true
console.log([].constructor === Object, [].constructor === Array) //false true

function isNumber(value) {
    //null.constructor and undefined.constructor throw an error when accessed
    if (value === null || value === undefined) return false
    return value.constructor === Number
}
console.log(isNumber(null), isNumber(undefined))                  //false false
console.log(isNumber('abc'), isNumber([]), isNumber(() => 1))     //false false false
console.log(isNumber(0), isNumber(Number('10.1')), isNumber(NaN)) //true true true