Explication détaillée des types de données js

Types de données simples ES5 (également appelés types de données de base) : Non défini, Null, Boolean, Number et String. Il existe également un type de données complexe : l'objet. L'objet est essentiellement composé d'un ensemble de paires nom-valeur non ordonnées. ECMAScript ne prend en charge aucun mécanisme de création de types personnalisés, et toutes les valeurs finiront par être l'un des 6 types de données mentionnés ci-dessus.

1. Opérateur typeof - détecte le type de données d'une variable donnée
L'utilisation de l'opérateur typeof sur une valeur peut renvoyer l'une des chaînes suivantes :
"indéfini" - si la valeur n'est pas Définition ;
"boolean" - si la valeur est une valeur booléenne ;
"string" - si la valeur est une chaîne
"number" - si la valeur est une valeur numérique
" ; " - si cette valeur est un objet ou null ;
"fonction" - si cette valeur est une fonction.
Voici plusieurs exemples d'utilisation de l'opérateur typeof :
var message = "some string";
alert(typeof message); // "string"
alert(typeof(message)); // "string"
alert(typeof 95); // "number"
Ces exemples illustrent que l'opérande de l'opérateur typeof peut être une variable ou un littéral numérique. Notez que typeof est un opérateur, pas une fonction, donc les parenthèses dans l'exemple ne sont pas obligatoires, bien qu'elles puissent être utilisées.

Parfois, l'opérateur typeof renvoie des valeurs confuses mais techniquement correctes. Par exemple, l'appel de typeof null renvoie "object" car la valeur spéciale null est considérée comme une référence d'objet vide. Safari 5 et versions antérieures et Chrome 7 et versions antérieures renvoient « fonction » lors de l'appel de l'opérateur typeof sur une expression régulière, tandis que d'autres navigateurs renvoient « objet » dans ce cas. Techniquement parlant, les fonctions dans ECMAScript sont des objets, pas un type de données. Cependant, les fonctions ont des propriétés spéciales, il est donc nécessaire de distinguer les fonctions des autres objets via l'opérateur typeof.

2.1 type non défini

le type non défini n'a qu'une seule valeur, qui est la valeur spéciale non définie. Cette valeur a été introduite pour distinguer formellement un pointeur d'objet nul d'une variable non initialisée. Pour les variables qui n'ont pas encore été déclarées, une seule opération peut être effectuée, qui consiste à utiliser l'opérateur typeof pour détecter son type de données. Jetez un œil à l'exemple suivant :

var message; // Une fois cette variable déclarée, elle a une valeur non définie par défaut
alert(typeof message); // "undefined"
alert(typeof age ); // "undefined"
Les résultats montrent que l'exécution de l'opérateur typeof sur des variables non initialisées et non déclarées renvoie une valeur non définie. Car bien que les deux variables soient essentiellement différentes d’un point de vue technique, il est en fait impossible d’effectuer des opérations réelles sur l’une ou l’autre variable.

2.2 Type nul

Le type nul est un type de données avec une seule valeur, et cette valeur spéciale est nulle. D'un point de vue logique, une valeur nulle représente un pointeur d'objet nul, c'est pourquoi « objet » est renvoyé lors de l'utilisation de l'opérateur typeof pour détecter une valeur nulle.
Si la variable définie doit être utilisée pour contenir des objets dans le futur, il est préférable d'initialiser la variable à null plutôt qu'à une autre valeur.
En fait, la valeur non définie est dérivée de la valeur nulle, donc ECMA-262 stipule que leur test d'égalité doit renvoyer vrai :
alert(null == undefined); //true
Ici, situé Le L'opérateur d'égalité (==) entre null et undefined renvoie toujours vrai, mais notez que cet opérateur convertit ses opérandes à des fins de comparaison.

Bien que nul et indéfini aient cette relation, leurs utilisations sont complètement différentes. En aucun cas il n'est nécessaire de définir explicitement la valeur d'une variable sur undefined, mais la même règle ne s'applique pas à null. En d’autres termes, tant qu’une variable destinée à contenir un objet ne contient pas réellement d’objet, vous devez explicitement laisser la variable contenir une valeur nulle. Cela reflète non seulement la convention de null en tant que pointeur d'objet nul, mais permet également de mieux distinguer null et indéfini.

2.3 Type booléen

Le type booléen n'a que deux valeurs littérales : true et false, qui sont sensibles à la casse.

Valeurs converties en false : false , "" (chaîne vide), 0 et NaN , null , non défini

Type de nombre 2.4

type de nombre : valeurs entières et à virgule flottante.
Étant donné que l'enregistrement d'une valeur à virgule flottante nécessite deux fois plus d'espace mémoire que l'enregistrement d'une valeur entière, ECMAScript convertira la valeur à virgule flottante en valeur entière sans perdre aucune opportunité. Évidemment, si le point décimal n’est suivi d’aucun chiffre, la valeur peut alors être enregistrée sous forme de valeur entière.
var floatNum1 = 1.; // Aucun chiffre après la virgule décimale - analysé comme 1
var floatNum2 = 10.0; // Entier - analysé comme 10
La plus haute précision des valeurs à virgule flottante est 17 décimales, mais sa précision lors de l'exécution de calculs arithmétiques est bien inférieure à celle des nombres entiers.

Concernant le problème des erreurs d'arrondi causées par les calculs numériques à virgule flottante, une chose doit être claire : il s'agit d'un problème courant lors de l'utilisation de calculs à virgule flottante basés sur des valeurs numériques IEEE754, et ECMAScript est pas unique ; d'autres utilisent les mêmes valeurs numériques. Les langages de format ont également ce problème.

La fonction isFinite() peut déterminer si une valeur est finie (si elle est comprise entre les valeurs minimale et maximale). Cette fonction renvoie vrai si l'argument est compris entre les valeurs minimale et maximale.

NaN, c'est-à-dire Not a Number (Not a Number) est une valeur spéciale. Cette valeur est utilisée pour indiquer qu'un opérande qui était censé renvoyer une valeur ne renvoie pas de valeur (afin qu'aucune erreur ne soit obtenue). est lancé). Par exemple, dans ECMAScript, diviser un nombre par 0 renvoie NaN et n'affecte donc pas l'exécution d'un autre code. NaN lui-même présente deux caractéristiques inhabituelles. Premièrement, toute opération impliquant NaN (telle que NaN/10) renverra NaN, ce qui peut poser des problèmes dans les calculs en plusieurs étapes. Deuxièmement, NaN n’est égal à aucune valeur, y compris NaN lui-même. Par exemple, le code suivant renverra false : alert(NaN == NaN); //false
isNaN() Après avoir reçu une valeur, il essaiera de convertir la valeur en valeur numérique. Certaines valeurs qui ne sont pas numériques sont converties directement en valeurs numériques, comme la chaîne « 10 » ou une valeur booléenne. Toute valeur qui ne peut pas être convertie en valeur numérique entraînera le retour vrai de cette fonction. Veuillez consulter l'exemple suivant :
alert(isNaN(NaN)); //true alert(isNaN("10")); //false (peut être converti en la valeur 10)
alert(isNaN(" blue ")); //true (ne peut pas être converti en valeur numérique) alert(isNaN(true)); //false (peut être converti en valeur numérique 1)

isNaN() s'applique également aux objets. Lorsque la fonction isNaN() est appelée en fonction d'un objet, la méthode valueOf() de l'objet est d'abord appelée, puis il est déterminé si la valeur renvoyée par la méthode peut être convertie en valeur numérique. Sinon, appelez la méthode toString() en fonction de cette valeur de retour, puis testez la valeur de retour. Ce processus constitue également le flux d'exécution général des fonctions et opérateurs intégrés dans ECMAScript.

Conversion numérique : Il existe 3 fonctions qui peuvent convertir des valeurs non numériques en valeurs numériques : Number(), parseInt() et parseFloat().
La fonction de conversion Number() peut être utilisée pour n'importe quel type de données, tandis que les deux autres fonctions sont spécifiquement utilisées pour convertir des chaînes en valeurs numériques. Ces trois fonctions renverront des résultats différents pour la même entrée.
Les règles de conversion de la fonction Number() sont les suivantes :
 S'il s'agit d'une valeur booléenne, true et false seront convertis respectivement en 1 et 0.
 S'il s'agit d'une valeur numérique, elle est simplement transmise et renvoyée.
 S'il s'agit d'une valeur nulle, renvoie 0.
 S'il n'est pas défini, renvoie NaN.
 S'il s'agit d'une chaîne, suivez les règles suivantes :
 Si la chaîne ne contient que des nombres (y compris ceux précédés d'un signe positif ou négatif), elle sera convertie en valeur décimale, c'est-à-dire " 1" deviendra 1, "123" deviendra 123 et "011" deviendra 11 (remarque : les zéros non significatifs sont ignorés) ;
 Si la chaîne contient un format à virgule flottante valide, tel que "1.1", alors convertissez-le en valeur à virgule flottante correspondante (de plus, les zéros non significatifs seront ignorés);
 Si la chaîne contient un format hexadécimal valide, tel que "0xf", convertissez-la à la même taille La valeur entière décimale  Si la chaîne est vide (ne contient aucun caractère), elle est convertie en 0 ;
 Si la chaîne contient des caractères autres que le format ci-dessus, elle est convertie en NaN.
 S'il s'agit d'un objet, appelez la méthode valueOf() de l'objet, puis convertissez la valeur renvoyée selon les règles précédentes. Si le résultat de la conversion est NaN, appelez la méthode toString() de l'objet, puis convertissez à nouveau la valeur de chaîne renvoyée selon les règles précédentes.
Donnons quelques exemples spécifiques ci-dessous.
var num1 = Number("Bonjour tout le monde !"); //NaN
var num2 = Number(""); //0
var num3 = Number("000011"); //11
var num4 = Number(true); //1
La fonction parseInt() est plus couramment utilisée pour traiter des entiers. Lorsque la fonction parseInt() convertit une chaîne, elle ignore les espaces devant la chaîne jusqu'à ce qu'elle trouve le premier caractère autre qu'un espace. Si le premier caractère n'est pas un caractère numérique ou un signe négatif, parseInt() renverra NaN ; autrement dit, l'utilisation de parseInt() pour convertir une chaîne vide renverra NaN (Number() renvoie 0 pour les caractères nuls). Si le premier caractère est un caractère numérique, parseInt() continuera à analyser le deuxième caractère jusqu'à ce que tous les caractères suivants aient été analysés ou qu'un caractère non numérique soit rencontré. Par exemple, « 1234blue » sera converti en 1234, car « blue » sera complètement ignoré. De même, "22,5" sera converti en 22 car le point décimal n'est pas un caractère numérique valide.
Si le premier caractère de la chaîne est un caractère numérique, parseInt() peut également reconnaître différents formats d'entiers. Si la chaîne commence par « 0x » et est suivie de caractères numériques, elle sera interprétée comme un entier hexadécimal ; si la chaîne commence par « 0 » et est suivie de caractères numériques, elle sera interprétée comme un nombre octal.
Afin de mieux comprendre les règles de conversion de la fonction parseInt(), quelques exemples sont donnés ci-dessous :
var num1 = parseInt("1234blue"); // 1234 var num2 = parseInt(""); / NaN
var num3 = parseInt("0xA"); // 10 (nombre hexadécimal) var num4 = parseInt(22.5); // 22
var num5 = parseInt("070"); nombre octal) var num6 = parseInt("70"); // 70 (nombre décimal)
var num7 = parseInt("0xf"); // 15 (nombre hexadécimal)
var num = parseInt("070 ");//Dans le moteur JavaScript ES5, parseInt() n'a plus la capacité d'analyser les valeurs octales
La fonction parseInt() fournit le deuxième paramètre : la base utilisée pour la conversion (c'est-à-dire quelle base) .
var num = parseInt("0xAF", 16); //175 var num1 = parseInt("AF", 16); //175
Si 16 est spécifié comme deuxième paramètre, la chaîne peut être With en tête "0x".
Semblable à la fonction parseInt(), parseFloat() analyse également chaque caractère en commençant par le premier caractère (position 0). Et il est analysé jusqu'à la fin de la chaîne ou jusqu'à ce qu'un caractère numérique à virgule flottante non valide soit rencontré. Autrement dit, le premier point décimal de la chaîne est valide, mais le deuxième point décimal n'est pas valide, donc la chaîne qui le suit sera ignorée. "22.34.5" sera converti en 22.34.
En plus de la première virgule décimale valide, la deuxième différence entre parseFloat() et parseInt() est qu'elle ignore toujours les zéros non significatifs. parseFloat() reconnaît tous les formats numériques à virgule flottante évoqués précédemment, y compris les formats d'entiers décimaux. Mais les chaînes au format hexadécimal seront toujours converties en 0. Puisque parseFloat() analyse uniquement les valeurs décimales, il ne sert à rien de spécifier la base avec le deuxième argument. Une dernière chose à noter : si la chaîne contient un nombre qui peut être analysé comme un entier (pas de point décimal ou tous des zéros après le point décimal), parseFloat() renverra un entier. Voici quelques exemples typiques d'utilisation de parseFloat() pour convertir des valeurs numériques.
var num1 = parseFloat("1234blue"); //1234 (entier) var num2 = parseFloat("0xA"); //0
var num3 = parseFloat("22.5"); //22.5 var num4 = parseFloat("22.34.5"); //22.34
var num5 = parseFloat("0908.5"); //908.5 var num6 = parseFloat("3.125e7"); //31250000

2.5 Les types de chaînes

Les chaînes dans ECMAScript sont immuables , c'est-à-dire qu'une fois les chaînes créées, leurs valeurs ne peuvent pas être modifiées. Par exemple :
var lang = "Java";
lang = lang + "Script";
La variable lang dans l'exemple ci-dessus contient initialement la chaîne "Java". La deuxième ligne de code redéfinit la valeur de lang en "JavaScript". Le processus de mise en œuvre de cette opération est le suivant : créez d'abord une nouvelle chaîne pouvant contenir 10 caractères, puis remplissez cette chaîne avec "Java" et "Script", et la dernière étape consiste à détruire la chaîne d'origine "Java" et "String". " Script" car ces deux chaînes ne sont plus utiles.
var age = 11; var ageAsString = age.toString(); // String "11"
var found = true; var foundAsString = found.toString(); // String "true"
Numérique , les valeurs booléennes, d'objet et de chaîne (oui, chaque chaîne a également une méthode toString(), qui renvoie une copie de la chaîne) ont toutes des méthodes toString(). Mais les valeurs nulles et indéfinies n'ont pas cette méthode.
Lorsque vous ne savez pas si la valeur à convertir est nulle ou indéfinie, vous pouvez également utiliser la fonction de conversion String(). Cette fonction peut convertir n'importe quel type de valeur en chaîne. La fonction String() suit les règles de conversion suivantes :
 Si la valeur a une méthode toString(), appelez la méthode (sans paramètres) et retournez le résultat correspondant
 Si la valeur est nulle, retournez " ; null";
 Si la valeur n'est pas définie, renvoie "undefined".
Comme null et undefined n'ont pas de méthode toString(), la fonction String() renvoie les valeurs littérales de ces deux valeurs.
Astuce : Pour convertir une valeur en chaîne, vous pouvez utiliser l'opérateur plus pour l'ajouter à une chaîne ("").

2.6 Type d'objet

Les objets dans ECMAScript sont en fait une collection de données et de fonctions. Créer : var o = new Object();
Chaque instance d'Object a les propriétés et méthodes suivantes.
 constructeur : enregistre la fonction utilisée pour créer l'objet actuel. Pour l'exemple précédent, le constructeur est Object().
 hasOwnProperty(propertyName) : utilisé pour vérifier si la propriété donnée existe dans l'instance d'objet actuelle. Parmi eux, le nom de la propriété (propertyName) en tant que paramètre doit être spécifié sous forme de chaîne (par exemple : o.hasOwnProperty("name")).
 isPrototypeOf(object) : utilisé pour vérifier si l'objet entrant est le prototype de l'objet entrant.
 propertyIsEnumerable(propertyName) : utilisé pour vérifier si une propriété donnée peut être énumérée à l'aide d'une instruction for-in. Comme pour la méthode hasOwnProperty(), le nom de la propriété en tant que paramètre doit être spécifié sous forme de chaîne.
 toLocaleString() : renvoie la représentation sous forme de chaîne de l'objet, qui correspond à la région de l'environnement d'exécution.
 toString() : renvoie la représentation sous forme de chaîne de l'objet.
 valueOf() : renvoie la représentation chaîne, numérique ou booléenne de l'objet. Généralement identique à la valeur de retour de la méthode toString().
Puisque Object est la base de tous les objets dans ECMAScript, tous les objets ont ces propriétés et méthodes de base.

Techniquement parlant, le comportement des objets dans ECMA-262 ne s'applique pas nécessairement aux autres objets en JavaScript. Les objets de l'environnement du navigateur, tels que les objets de la nomenclature et du DOM, sont des objets hôtes car ils sont fournis et définis par l'implémentation de l'hôte. ECMA-262 n'est pas responsable de la définition des objets hôtes, donc les objets hôtes peuvent ou non hériter d'Object.

3. Remarque

(1) Si un opérande est comparé à NaN, le résultat sera faux.
(2) null == undefined renverra true car ce sont des valeurs similaires ; mais null === undefined renverra false car ce sont des types de valeurs différents.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!