Que sont-ils et comment les vérifiez-vous?

Comme pour presque tous les langues de programmation, JavaScript traite les différents types de valeurs différemment. Une chaîne comme «Hello World» est très différente d'un nombre comme 42. Mais quels types sont disponibles, et pourquoi importaient-ils?

Quels sont les types de données de JavaScript?

Chaque valeur en JavaScript a un type, l'un de ces neuf:

• Nombre

• Chaîne

• Booléen

• Nul

• Indéfini

• Grand

• Symbole

• Objet

• Fonction

Lorsque vous travaillez avec une valeur, la langue vérifie souvent qu'elle a le bon type. Selon le cas spécifique, une valeur avec un type différent peut être gérée automatiquement, ou elle peut générer une erreur.

Une variable qui n'a pas été attribuée de valeur aura la valeur non définie. Par exemple:

        > var foo
  undefined

    

Les valeurs booléennes sont vraies ou fausses et sont généralement utilisées dans la logique conditionnelle.

Les cordes stockent des valeurs de texte comme « Hello », « $$$ » et « quelques mots ». Les chaînes JavaScript sont stockées au format UTF-16. En pratique, cela signifie que vous pouvez utiliser des symboles Unicode, comme les emojis, dans vos littéraux de chaîne:

        alert("🙂")
    

Et tout fonctionnera comme prévu:

Contrairement à de nombreuses autres langues, JavaScript ne fait pas de distinction entre les entiers et les nombres à virgule flottante. 42 et 3.14 sont les deux types de nombres. BigInt, comme son nom l'indique, ne couvre que les entiers, et seuls ceux dont la valeur dépasse à quoi le nombre peut faire face.

        b = document.body, b.style.overflowWrap = "break-word",
 b.textContent = BigInt(2) ** BigInt(200000)
    

NULL est une valeur spéciale utilisée pour représenter «l'absence de toute valeur». Cela peut sembler contradictoire, mais il est utile dans la programmation orientée objet où les références d'objets peuvent représenter les relations:

        var anne = { name: "Anne", child: null };
var john = { name: "John", child: child }
    

Le symbole est une fonctionnalité obscure au niveau du langage que vous n'aurez probablement jamais besoin de comprendre. Si vous êtes curieux, consultez la documentation MDN sur le symbole.

Les fonctions et les objets sont des valeurs que vous pouvez créer en utilisant divers mécanismes, y compris la syntaxe littérale du langage:

        function my_function() { ... }
let my_object = {};
    

Vous pouvez également créer une valeur de fonction à l'aide d'une expression:

        my_function = function() { ... };
    

Et vous pouvez créer un objet à l'aide d'un constructeur:

        let answer = new Object(42);
    

Que fait un type?

Premièrement, il est important de noter que les valeurs de JavaScript ont des types fixes, mais les variables ne le font pas. Une variable JavaScript est tapée dynamiquement, il adopte donc quel que soit le type de sa valeur:

        > var foo = 1;
> typeof foo
  'number'
> foo = "hello"
> typeof foo
  'string'
    

L'un des plus grands impacts que les types peuvent avoir est de comparer deux valeurs. JavaScript a deux opérateurs d'égalité: == et ===. Ceux-ci vérifient respectivement l'égalité «lâche» et «stricte», et la différence est tout au sujet du type:

        function check_equals(a, b) {
    if (a === b) {
        console.log("a and b are strictly equal");
    } else if (a == b) {
        console.log("a and b are loosely equal");
    } else {
        console.log("a and b are not equal at all");
    }
}
    

Si vous appelez Check_equals (42, 42)vous verrez que les deux valeurs sont strictement égales: elles ont la même valeur et le même type. Mais Check_equals (42, « 42 ») démontrera que, bien qu'un nombre et une chaîne puissent évaluer à la même valeur, ils sont toujours de types différents, ils ne sont donc que vaguement égaux.

La vérification de l'égalité lâche est un exemple de coercition de type: la conversion automatique d'une valeur d'un type à un autre. Il s'agit d'une commodité qui évite d'avoir à convertir explicitement les valeurs.

JavaScript est assez agressif en matière de coercition. Un type peut souvent être converti silencieusement lorsque vous ne vous y attendiez pas. La plupart du temps, cela est utile; Par exemple:

        let person = { age: 21 };
if (person.age) {
    alert("person has been born!");
}
    

Dans ce cas, le type de personnage est «nombre» mais JavaScript le contraint à une valeur booléenne lors de l'évaluation de la partie de la condition de l'instruction IF. Presque chaque nombre, positif ou négatif, se convertira en «vrai» lorsqu'il est contraint à un booléen. Mais 0 se convertira en faux, donc la coercition est un raccourci utile pour éviter d'écrire if (personne.age! == 0).

Vous ne pouvez pas vous attendre à ce qu'un type soit contraint d'une certaine manière. Par exemple, () == «  » reviendra true car les deux valeurs sont contraints de booléen false. Les règles pour exactement les valeurs se convertissent auxquelles d'autres, dans diverses circonstances, sont longues et difficiles à retenir. Pour éviter d'avoir à utiliser === dans la mesure du possible.

Comment utilisez-vous les types dans le code JavaScript?

Si vous souhaitez vérifier le type d'une variable, vous pouvez utiliser le type d'opérateur. Par exemple:

        function reset_value(val) {
    switch (typeof val) {
        case "object":
            return {};
        case "string":
            return "";
        case "number":
            return 0;
    }
}
    

Vous vous demandez peut-être où les tableaux s'inscrivent dans le système de type JavaScript. Ils ressemblent à un type de valeur distinct:

        let myArray = ( "apple", "banana", "cherry" );
    

Cependant, JavaScript considère un tableau comme un type d'objet:

        > typeof ( 1, 2, 3 )
  'object'
    

Cela peut être gênant, mais vous pouvez vérifier si un objet est spécifiquement un tableau utilisant la méthode ISARRAY statique de la classe de tableau:

        > Array.isArray((1, 2, 3))
  true
    

La coercition de type est une source particulièrement riche de bugs et de malentendus. Par exemple:

        > "42" + "18"
'4218'
> "42" + 18
'4218'
> 42 + "18"
'4218'
    

Dans tous les cas, essayer d'ajouter deux nombres où l'on est une chaîne se traduira par une valeur de chaîne qui combine les deux en tant que chaînes. En effet, l'opérateur + est surchargé pour que les chaînes fonctionnent comme un opérateur de concaténation plutôt que comme un ajout arithmétique.

Cependant, cela ne tient pas pour la multiplication:

        > "42" * 2
84
> "42" * "2"
84
    

C'est le cas opposé: le * L'opérateur contraint toutes les valeurs de chaîne en nombres, à condition qu'ils ressemblent à des nombres.

La conversion de type est similaire à la coercition de type, mais elle convertit explicitement une valeur en un type différent. Une utilisation très courante est de convertir une chaîne en un nombre:

        > let pageNum = new URLSearchParams(document.location.search).get("page");
> pageNum
  '1'
> parseInt(pageNum)
  1
    

Vous pouvez également construire une valeur d'un type donné en utilisant les fonctions de wrapper intégrées pour chaque primitif (sauf null et indéfini): booléen, numéro, bigint, chaîne et symbole.

        > Number("42") + 18
  60