Types de données JavaScript

Types de données en JavaScript

Les types de données spécifient essentiellement quel type de données peut être stocké et manipulé dans un programme.

Il existe six types de données de base en JavaScript qui peuvent être divisés en trois catégories principales : les types de données primitifs (ou primaires ), composés (ou de référence ) et spéciaux . String, Number et Boolean sont des types de données primitifs. Object, Array et Function (qui sont tous des types d'objets) sont des types de données composés. Alors que Undefined et Null sont des types de données spéciaux.

Les types de données primitifs ne peuvent contenir qu'une seule valeur à la fois, tandis que les types de données composites peuvent contenir des collections de valeurs et des entités plus complexes. Discutons de chacun d'eux en détail.

Le type de données String (Chaîne)

Le type de données String est utilisé pour représenter des données textuelles (c'est-à-dire des séquences de caractères). Les chaînes sont créées à l'aide de guillemets simples ou doubles entourant un ou plusieurs caractères, comme indiqué ci-dessous :

var a = 'Bonjour le monde!'; /* simples guillemets */
var b = "Bonjour le monde!";  /* double guillemets */

Vous pouvez inclure des guillemets à l'intérieur de la chaîne tant qu'ils ne correspondent pas aux guillemets englobants.

var a = "L'ordinateur est allumé"; /* simple guillemet dans double */
var b = 'il a dit : "Pas ici", et voilà';  /* double guillemets dans simple */
var c = 'J\'aime le javascript.';     /* echapper avec un antislash */

Vous en apprendrez plus sur les chaînes dans le chapitre sur les chaînes JavaScript .

Le type de données numérique

Le type de données number est utilisé pour représenter des nombres positifs ou négatifs avec ou sans décimale, ou des nombres écrits en notation exponentielle, par exemple 1,5e-4 (équivalent à 1,5x10 -4 ).

var a = 25;         // entier
var b = 80.5;       // décimal
var c = 4.25e+6;    // notation exponentielle, équivaut à 4.25e6 ou 4250000
var d = 4.25e-6;    // notation exponentielle, équivaut à 0.00000425

Le type de données Number inclut également certaines valeurs spéciales qui sont : Infinity, -Infinity et NaN. Infinity représente l'infini mathématique ∞, qui est supérieur à n'importe quel nombre. -Infinity est le résultat de la division d'un nombre différent de zéro par 0, comme illustré ci-dessous :

alert(16 / 0);  /* Affiche: Infinity */
alert(-16 / 0); /* Affiche: -Infinity */
alert(16 / -0); /* Affiche: -Infinity */

NaN représente une valeur spéciale Not-a-Number. C'est le résultat d'une opération mathématique invalide ou indéfinie, comme prendre la racine carrée de -1 ou diviser 0 par 0, etc.

alert("Du texte" / 2);       /* Affiche: NaN */

alert("Du texte" / 2 + 10);  /* Affiche: NaN */

alert(Math.sqrt(-1));         // Affiche: NaN

Vous en apprendrez plus sur les nombres dans le chapitre sur les nombres en JavaScript .

Le type de données booléen

Le type de données booléen ne peut contenir que deux valeurs : true ou false. Il est généralement utilisé pour stocker des valeurs telles que oui ( true) ou non ( false), activé ( true) ou désactivé ( false), etc., comme illustré ci-dessous :

var isReading = true;   /* oui, entrain de lire */
var isSleeping = false; // non, pas entrain de dormir

Les valeurs booléennes sont également le résultat de comparaisons dans un programme. L'exemple suivant compare deux variables et affiche le résultat dans une boîte de dialogue d'alerte :

var a = 2, b = 5, c = 10;
alert(b > a) /* Affiche: true */
alert(b > c) // Affiche: false

Vous en apprendrez plus sur les comparaisons dans le chapitre JavaScript if/else .

Le type de données indéfini

Le type de données indéfini ne peut avoir qu'une seule valeur, la valeur spéciale undefined. Si une variable a été déclarée, mais n'a pas reçu de valeur, a la valeur undefined.

var a;
var b = "Hello World!"
 
alert(a) /* Affiche: undefined */
alert(b) // Affiche: Hello World!

Le type de données nul

Il s'agit d'un autre type de données spécial qui ne peut avoir qu'une seule valeur, la valeur null. Une valeur null signifie qu'il n'y a pas de valeur. Ce n'est pas équivalent à une chaîne vide ( "") ou 0, c'est tout simplement rien.

Une variable peut être explicitement vidée de son contenu actuel en lui attribuant la valeur null.

var a = null;
alert(a); /* Affiche: null */
 
var b = "Hello World!"
alert(b); /* Affiche: Hello World! */
 
b = null;
alert(b) // Affiche: null

Le type de données d'objet

L'object est un type de données complexe qui vous permet de stocker des collections de données.

Un objet contient des propriétés, définies comme une paire clé-valeur. Une clé de propriété (nom) est toujours une chaîne, mais la valeur peut être n'importe quel type de données, comme des chaînes, des nombres, des booléens ou des types de données complexes comme des tableaux, des fonctions et d'autres objets. Vous en apprendrez plus sur les objets dans les prochains chapitres.

L'exemple suivant vous montrera la manière la plus simple de créer un objet en JavaScript.

var emptyObject = {};
var person = {"name": "Clark", "surname": "Kent", "age": "36"};
 
var car = {
    "modal": "BMW X3",
    "color": "white",
    "doors": 5
}

Vous pouvez omettre les guillemets autour du nom de la propriété si le nom est un nom JavaScript valide. Cela signifie que les guillemets sont obligatoires pour "first-name" mais facultatifs pour firstname. Ainsi, l'objet car dans l'exemple ci-dessus peut également être écrit comme suit :

var car = {
    modal: "BMW X3",
    color: "white",
    doors: 5
}

Vous en apprendrez plus sur les objets dans le chapitre sur les objets en JavaScript .

Le type de données tableau(Array)

Un tableau (Array) est un type d'objet utilisé pour stocker plusieurs valeurs dans une seule variable. Chaque valeur (également appelée élément) dans un tableau a une position numérique, connue sous le nom d'index, et elle peut contenir des données de n'importe quel type de données, des nombres, des chaînes, des booléens, des fonctions, des objets et même d'autres tableaux. L'index du tableau commence à 0, de sorte que le premier élément du tableau n'est pas arr[1] mais arr[0].

Le moyen le plus simple de créer un tableau consiste à spécifier les éléments du tableau sous forme de liste séparée par des virgules entre crochets, comme illustré dans l'exemple ci-dessous :

var colors = ["Red", "Yellow", "Green", "Orange"];
var cities = ["London", "Paris", "New York"];
 
alert(colors[0]);   /* Affiche: Red */
alert(cities[2]);   // Affiche: New York

Vous en apprendrez plus sur les tableaux dans le chapitre : Tableaux en JavaScript .

Le type de données function

La fonction est un objet appelable qui exécute un bloc de code. Les fonctions étant des objets, il est donc possible de les affecter à des variables, comme le montre l'exemple ci-dessous :

var greeting = function(){ 
    return "Hello World!"; 
}
 
/* Verifier le type de la variable greeting */
alert(typeof greeting) /* Affiche: function */
alert(greeting());     // Affiche: Hello World!

En fait, les fonctions peuvent être utilisées à n'importe quel endroit où n'importe quelle autre valeur peut être utilisée. Les fonctions peuvent être stockées dans des variables, des objets et des tableaux. Les fonctions peuvent être transmises en tant qu'arguments à d'autres fonctions et les fonctions peuvent être renvoyées à partir de fonctions. Considérez la fonction suivante :

function createGreeting(name){
    return "Hello, " + name;
}
function displayGreeting(greetingFunction, userName){
    return greetingFunction(userName);
}
var result = displayGreeting(createGreeting, "Peter");
alert(result); /* Affiche: Hello, Peter */

Vous en apprendrez plus sur les fonctions dans le chapitre sur les fonctions en JavaScript.

 L'opérateur typeof

L'opérateur typeof peut être utilisé pour savoir quel type de données contient une variable ou un opérande. Il peut être utilisé avec ou sans parenthèses ( typeof(x) ou typeof x).

L'opérateur typeof est particulièrement utile dans les situations où vous devez traiter différemment les valeurs de différents types, mais vous devez être très prudent, car il peut produire un résultat inattendu dans certains cas, comme le montre l'exemple suivant :

// Numbers
typeof 15;  /* Returne : "number" */
typeof 42.7;  /* Returne : "number" */
typeof 2.5e-4; /* Returne : "number" */
typeof Infinity;  /* Returne : "number" */
typeof NaN;  /* Returne : "number" même si c'est un Not-a-Numner */
 
// Strings
typeof '';  /* Returne : "string" */
typeof 'hello';  /* Returne : "string" */
typeof '12';  /* Returne : "string" */
 
// Booleans
typeof true;  /* Returne : "boolean" */
typeof false;  /* Returne : "boolean" */
 
// Undefined
typeof undefined; /* Returne : "undefined" */
typeof undeclaredVariable; /* Retourne : "undefined" */
 
// Null
typeof Null; /* Retourne : "object" */
 
// Objects
typeof {name: "John", age: 18};  /* Retourne : "object" */
 
// Arrays
typeof [1, 2, 4];  /* Retourne : "object" */
 
// Functions
typeof function(){};  /* Retourne : "function" */

Comme vous pouvez le voir clairement dans l'exemple ci-dessus lorsque nous testons la valeur  null à l'aide de l'opérateur typeof, il a renvoyé "object" au lieu de "null".

Il s'agit d'un bogue de longue date dans JavaScript, mais comme de nombreux codes sur le Web sont écrits autour de ce comportement, et donc le corriger créerait beaucoup plus de problèmes, donc l'idée de résoudre ce problème a été rejetée par le comité qui conçoit et maintient JavaScript.