Une valeur en JavaScript est toujours d'un certain type. Par exemple, une chaîne ou un nombre.
Il existe huit types de données de base en JavaScript. Ici, nous les aborderons en général et dans les prochains chapitres, nous parlerons de chacun d'eux en détail.
Nous pouvons mettre n'importe quel type dans une variable. Par exemple, une variable peut à un moment être une chaîne puis stocker un nombre :
// pas d'erreur let message = "bonjour" ; message = 123456 ;
Les langages de programmation qui permettent de telles choses, comme JavaScript, sont appelés « typés dynamiquement », ce qui signifie qu'il existe des types de données, mais que les variables ne sont liées à aucun d'entre eux.
soit n = 123 ; n = 12,345 ;
Le type numérique représente à la fois des nombres entiers et des nombres à virgule flottante.
Il existe de nombreuses opérations sur les nombres, par exemple multiplication * , division / , addition + , soustraction - , etc.
Outre les nombres normaux, il existe ce que l'on appelle des « valeurs numériques spéciales » qui appartiennent également à ce type de données : Infinity , -Infinity et NaN .
Infinity représente l'infini mathématique ∞. Il s'agit d'une valeur spéciale supérieure à n'importe quel nombre.
Nous pouvons l'obtenir en divisant par zéro :
alerte( 1 / 0 ); // Infini
Ou référencez-le simplement directement :
alerte(Infini); // Infini
NaN représente une erreur de calcul. C'est le résultat d'une opération mathématique incorrecte ou non définie, par exemple :
alert( "pas un numéro" / 2 ); // NaN, cette division est erronée
NaN est collant. Toute autre opération mathématique sur NaN renvoie NaN :
alerte( NaN + 1 ); // NaN alerte( 3 * NaN ); // NaN alert( "pas un numéro" / 2 - 1 ); // NaN
Ainsi, s'il y a un NaN quelque part dans une expression mathématique, il se propage à l'ensemble du résultat (il n'y a qu'une seule exception à cela : NaN ** 0 vaut 1 ).
Les opérations mathématiques sont sûres
Faire des mathématiques est « sûr » en JavaScript. Nous pouvons tout faire : diviser par zéro, traiter les chaînes non numériques comme des nombres, etc.
Le script ne s'arrêtera jamais avec une erreur fatale (« mourir »). Au pire, nous obtiendrons NaN comme résultat.
Les valeurs numériques spéciales appartiennent formellement au type « nombre ». Bien entendu, il ne s’agit pas de chiffres au sens commun du terme.
Nous en verrons plus sur le travail avec les nombres dans le chapitre Nombres.
En JavaScript, le type « nombre » ne peut pas représenter en toute sécurité des valeurs entières supérieures à (2 53 -1) (soit 9007199254740991 ), ou inférieures à -(2 53 -1) pour les valeurs négatives.
Pour être vraiment précis, le type « nombre » peut stocker des entiers plus grands (jusqu'à 1.7976931348623157 * 10 308 ), mais en dehors de la plage d'entiers de sécurité ±(2 53 -1) il y aura une erreur de précision, car tous les chiffres ne correspondent pas. dans le stockage fixe de 64 bits. Une valeur « approximative » peut donc être stockée.
Par exemple, ces deux nombres (juste au-dessus de la plage de sécurité) sont identiques :
console.log(9007199254740991 + 1); // 9007199254740992 console.log(9007199254740991 + 2); // 9007199254740992
Pour ainsi dire, tous les entiers impairs supérieurs à (2 53 -1) ne peuvent pas du tout être stockés dans le type « nombre ».
Dans la plupart des cas, la plage ±(2 53 -1) est tout à fait suffisante, mais nous avons parfois besoin de la plage entière de très grands entiers, par exemple pour la cryptographie ou les horodatages à la microseconde près.
Le type BigInt a été récemment ajouté au langage pour représenter des entiers de longueur arbitraire.
Une valeur BigInt est créée en ajoutant n à la fin d'un entier :
// le "n" à la fin signifie que c'est un BigInt const bigInt = 1234567890123456789012345678901234567890n;
Comme les numéros BigInt sont rarement nécessaires, nous ne les abordons pas ici, mais leur consacrons un chapitre séparé BigInt. Lisez-le lorsque vous avez besoin de chiffres aussi importants.
Une chaîne en JavaScript doit être entourée de guillemets.
let str = "Bonjour";
let str2 = 'Les guillemets simples sont également acceptables';
let phrase = `peut intégrer un autre ${str}` ;En JavaScript, il existe 3 types de guillemets.
Guillemets doubles : "Hello" .
Guillemets simples : 'Hello' .
Backticks : `Hello` .
Les guillemets doubles et simples sont des guillemets « simples ». Il n'y a pratiquement aucune différence entre eux en JavaScript.
Les backticks sont des citations de « fonctionnalités étendues ». Ils nous permettent d'intégrer des variables et des expressions dans une chaîne en les enveloppant dans ${…} , par exemple :
laissez nom = "Jean" ;
// incorpore une variable
alert( `Bonjour, ${name}!` ); // Bonjour, Jean !
// incorpore une expression
alert( `le résultat est ${1 + 2}` ); // le résultat est 3 L'expression à l'intérieur ${…} est évaluée et le résultat devient une partie de la chaîne. Nous pouvons y mettre n'importe quoi : une variable comme name ou une expression arithmétique comme 1 + 2 ou quelque chose de plus complexe.
Veuillez noter que cela ne peut être fait qu'en backticks. Les autres devis n'ont pas cette fonctionnalité d'intégration !
alert( "le résultat est ${1 + 2}" ); // le résultat est ${1 + 2} (les guillemets doubles ne font rien)Nous aborderons les chaînes plus en détail dans le chapitre Chaînes.
Il n'y a pas de type de caractère .
Dans certaines langues, il existe un type « caractère » spécial pour un seul caractère. Par exemple, en langage C et en Java, cela s’appelle « char ».
En JavaScript, ce type n’existe pas. Il n'y a qu'un seul type : string . Une chaîne peut être composée de zéro caractère (être vide), d'un caractère ou de plusieurs caractères.
Le type booléen n'a que deux valeurs : true et false .
Ce type est couramment utilisé pour stocker des valeurs oui/non : true signifie « oui, correct » et false signifie « non, incorrect ».
Par exemple:
laissez nameFieldChecked = true; // oui, le champ nom est coché laissez ageFieldChecked = false; // non, le champ âge n'est pas coché
Les valeurs booléennes résultent également de comparaisons :
soit isGreater = 4 > 1 ; alert( estPlus Grand ); // vrai (le résultat de la comparaison est "oui")
Nous aborderons les booléens plus en profondeur dans le chapitre Opérateurs logiques.
La valeur null spéciale n’appartient à aucun des types décrits ci-dessus.
Il forme un type distinct qui contient uniquement la valeur null :
soit âge = nul ;
En JavaScript, null n'est pas une « référence à un objet inexistant » ou un « pointeur nul » comme dans certains autres langages.
C'est juste une valeur spéciale qui représente « rien », « vide » ou « valeur inconnue ».
Le code ci-dessus indique que age est inconnu.
La valeur particulière undefined se démarque également. Il crée son propre type, tout comme null .
La signification de undefined est « la valeur n’est pas attribuée ».
Si une variable est déclarée, mais non affectée, alors sa valeur undefined :
laissez vieillir; alerte (âge); // affiche "non défini"
Techniquement, il est possible d'attribuer explicitement undefined à une variable :
soit âge = 100 ; // change la valeur en non défini âge = indéfini ; alerte (âge); // "non défini"
…Mais nous ne recommandons pas de faire cela. Normalement, on utilise null pour attribuer une valeur « vide » ou « inconnue » à une variable, tandis que undefined est réservé comme valeur initiale par défaut pour les éléments non attribués.
Le type object est spécial.
Tous les autres types sont appelés « primitifs » car leurs valeurs ne peuvent contenir qu'une seule chose (que ce soit une chaîne, un nombre ou autre). En revanche, les objets sont utilisés pour stocker des collections de données et des entités plus complexes.
Étant donné leur importance, les objets méritent un traitement spécial. Nous les traiterons plus tard dans le chapitre Objets, après en avoir appris davantage sur les primitives.
Le type symbol est utilisé pour créer des identifiants uniques pour les objets. Nous devons le mentionner ici par souci d'exhaustivité, mais aussi reporter les détails jusqu'à ce que nous connaissions les objets.
L'opérateur typeof renvoie le type de l'opérande. C'est utile lorsque nous voulons traiter différemment des valeurs de différents types ou simplement effectuer une vérification rapide.
Un appel à typeof x renvoie une chaîne avec le nom du type :
type de non défini // "non défini"
type de 0 // "numéro"
type de 10n // "bigint"
typeof true // "booléen"
type de "foo" // "string"
typeofSymbole("id") // "symbole"
type de Math // "objet" (1)
typeof null // "objet" (2)
type d'alerte // "fonction" (3)Les trois dernières lignes peuvent nécessiter des explications supplémentaires :
Math est un objet intégré qui fournit des opérations mathématiques. Nous l'apprendrons dans le chapitre Nombres. Ici, il sert simplement d’exemple d’objet.
Le résultat de typeof null est "object" . Il s'agit d'une erreur officiellement reconnue dans typeof , venant des tout premiers jours de JavaScript et conservée pour des raisons de compatibilité. Décidément, null n'est pas un objet. Il s’agit d’une valeur spéciale avec un type distinct qui lui est propre. Le comportement de typeof est faux ici.
Le résultat de typeof alert est "function" , car alert est une fonction. Nous étudierons les fonctions dans les prochains chapitres où nous verrons également qu'il n'y a pas de type « fonction » spécial en JavaScript. Les fonctions appartiennent au type d'objet. Mais typeof les traite différemment, renvoyant "function" . Cela vient également des débuts de JavaScript. Techniquement, un tel comportement n’est pas correct, mais peut s’avérer pratique en pratique.
La syntaxe typeof(x)
Vous pouvez également rencontrer une autre syntaxe : typeof(x) . C'est la même chose que typeof x .
Pour être clair : typeof est un opérateur, pas une fonction. Les parenthèses ici ne font pas partie de typeof . C'est le genre de parenthèses utilisées pour le regroupement mathématique.
Habituellement, ces parenthèses contiennent une expression mathématique, telle que (2 + 2) , mais ici elles ne contiennent qu'un seul argument (x) . Syntaxiquement, ils permettent d'éviter un espace entre le typeof d'opérateur et son argument, et cela plaît à certains.
Certaines personnes préfèrent typeof(x) , bien que la syntaxe typeof x soit beaucoup plus courante.
Il existe 8 types de données de base en JavaScript.
Sept types de données primitifs :
number pour les nombres de toute sorte : entier ou à virgule flottante, les entiers sont limités par ±(2 53 -1) .
bigint pour les nombres entiers de longueur arbitraire.
string pour chaînes. Une chaîne peut contenir zéro ou plusieurs caractères, il n'existe pas de type distinct à un seul caractère.
boolean pour true / false .
null pour les valeurs inconnues – un type autonome qui a une seule valeur null .
undefined pour les valeurs non attribuées – un type autonome qui a une seule valeur undefined .
symbol pour les identifiants uniques.
Et un type de données non primitif :
object pour des structures de données plus complexes.
L'opérateur typeof nous permet de voir quel type est stocké dans une variable.
Habituellement utilisé comme typeof x , mais typeof(x) est également possible.
Renvoie une chaîne avec le nom du type, comme "string" .
Pour null renvoie "object" - c'est une erreur dans le langage, ce n'est pas réellement un objet.
Dans les prochains chapitres, nous nous concentrerons sur les valeurs primitives et une fois familiarisées avec elles, nous passerons aux objets.
importance : 5
Quel est le résultat du script ?
laissez nom = "Ilya" ;
alert( `bonjour ${1}` ); // ?
alert( `bonjour ${"nom"}` ); // ?
alert( `bonjour ${name}` ); // ?
Les backticks intègrent l'expression à l'intérieur ${...} dans la chaîne.
laissez nom = "Ilya" ;
// l'expression est un nombre 1
alert( `bonjour ${1}` ); // bonjour 1
// l'expression est une chaîne "nom"
alert( `bonjour ${"nom"}` ); // bonjour nom
// l'expression est une variable, intégrez-la
alert( `bonjour ${name}` ); // bonjour Ilya