Types de données JavaScript

Types de données JavaScript

Types de données

Il existe 5 types de données simples (également appelés types de données de base) en JavaScript : Indéfini, Null, Booléen, Nombre et Chaîne. 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.

opérateur typeof

Étant donné que JavaScript est mal typé, il doit y avoir un moyen de détecter le type de données d'une variable donnée - typeof est l'opérateur chargé de fournir des informations côté fournisseur. L'utilisation de l'opérateur typeof sur une valeur peut renvoyer l'une des chaînes suivantes :

● "undefined" - si la valeur n'est pas définie

● "boolean" - si la valeur est une valeur booléenne ;

● "chaîne" - si la valeur est une chaîne;

● "numéro" - si la valeur est une valeur numérique

● "objet" - —Si cette valeur est un objet ou une valeur nulle ; Lorsqu'une variable est déclarée à l'aide de var mais non initialisée, la valeur de la variable n'est pas définie, par exemple :

var message;

alert(message == undefined) //true

Type Null

Le type Null est le deuxième type de données avec une seule valeur. Cette valeur spéciale est nulle. D'un point de vue logique, la valeur null représente un pointeur d'objet nul, et c'est pourquoi "object" est renvoyé lors de l'utilisation de l'opérateur typeof pour détecter null, par exemple :

var car = null;

alert(typeof car); // "object"

　Si la variable définie doit être utilisée pour enregistrer l'objet à l'avenir, il est préférable d'initialiser la variable à null au lieu d'un autre valeurs. De cette façon, vous pouvez savoir si la variable correspondante contient déjà une référence à un objet en détectant directement la valeur nulle, par exemple :

if(car != null)
{ -262 précise que le test de leur égalité doit renvoyer vrai.

　alert(undefined == null); //true

　Bien que null et indéfini aient une telle 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.

Type booléen

Ce type n'a que deux valeurs littérales : vrai et faux. Ces deux valeurs ne sont pas la même chose que les valeurs numériques, donc vrai n'est pas nécessairement égal à 1 et faux n'est pas nécessairement égal à 0.

Bien qu'il n'y ait que deux valeurs littérales de type booléen, tous les types de valeurs en JavaScript ont des valeurs équivalentes à ces deux valeurs booléennes. Pour convertir une valeur en valeur booléenne correspondante, vous pouvez appeler la fonction de conversion de type Boolean(), par exemple :

var message = 'Hello World'; var messageAsBoolean = Boolean(message);

Dans cet exemple, la chaîne message est convertie en une valeur booléenne, qui est stockée dans la variable messageAsBoolean. La fonction Boolean() peut être appelée sur une valeur de n'importe quel type de données et renverra toujours une valeur booléenne. Quant à savoir si la valeur renvoyée est vraie ou fausse, cela dépend du type de données de la valeur à convertir et de sa valeur réelle. Le tableau suivant donne les règles de conversion pour différents types de données et leurs objets.

Ces règles de conversion sont très importantes pour comprendre les instructions de contrôle de flux (telles que les instructions if) et effectuer automatiquement les conversions booléennes correspondantes, par exemple :

var message = 'Hello World';
    if(message)
    {
        alert("Value is true");
    }

Exécutez cet exemple, une boîte d'avertissement s'affichera car les caractères Le message sous forme de chaîne est automatiquement converti en la valeur booléenne correspondante (vrai). En raison de cette conversion booléenne effectuée automatiquement, il est crucial de savoir exactement quelles variables sont utilisées dans les instructions de contrôle de flux.

Type numérique

Ce type est utilisé pour représenter des entiers et des valeurs à virgule flottante, et il existe également une valeur spéciale, NaN (Not a Number). Cette valeur est utilisée pour indiquer qu'un opérande censé renvoyer une valeur ne renvoie pas de valeur (afin qu'une erreur ne soit pas générée). Par exemple, dans d'autres langages de programmation, diviser une valeur numérique par zéro entraîne une erreur qui arrête l'exécution du code. Mais en JavaScript, toute valeur divisée par 0 renverra NaN, cela n'affectera donc pas l'exécution d'un autre code.

NaN lui-même possède deux caractéristiques extraordinaires. 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 renvoie false.

alert(NaN == NaN); //false

Il existe une fonction isNaN() en JavaScript. Cette fonction accepte un paramètre, qui peut être de n'importe quel type, et la fonction nous aidera à déterminer si ce paramètre n'est "pas une valeur numérique". Après que isNaN() ait 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 fera que cette fonction retournera vrai. Par exemple :

alert(isNaN(NaN));    //true
    alert(isNaN(10));    //false(10是一个数值)
    alert(isNaN("10"));    //false(可能被转换为数值10)
    alert(isNaN("blue"));    //true(不能被转换为数值)
    alert(isNaN(true));    //false(可能被转换为数值1)

Il existe 3 fonctions qui peuvent convertir des valeurs non numériques en valeurs numériques : Number(), parseInt() et parseFloat(). La première fonction, 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 nombres. 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 :

　gi S'il s'agit d'une valeur booléenne, vrai et faux seront remplacés par 1 et 0 respectivement

● S'il s'agit d'une valeur numérique, transmettez simplement et retournez

● S'il s'agit d'une valeur nulle, renvoyez 0

● S'il n'est pas défini, renvoyez NaN

● S'il s'agit d'une chaîne, suivez les règles suivantes :

　○ Si la chaîne ne contient que des nombres, elle sera convertie en valeur décimale, c'est-à-dire que "1" deviendra 1, "123" deviendra 123, et "011" deviendra 11 (le 0 en tête est ignoré)

　○ Si la chaîne contient un format à virgule flottante valide, tel que "1.1", elle sera convertie en nombre à virgule flottante correspondant (de la même manière , le 0 en tête sera également ignoré)

　○ Si la chaîne contient un format hexadécimal valide, tel que "0xf", alors convertissez-la en une valeur entière décimale de la même taille

　○ Si la chaîne est vide, alors convertissez-la en 0

　○ Si la chaîne contient des caractères autres que le format ci-dessus, convertissez-la en NaN

　 ● S'il s'agit d'un objet, appelez la valeur valueOf() méthode de l'objet, puis suivez La règle précédente transforme la valeur renvoyée. Si le résultat de la conversion est NaN, la méthode toString() de l'objet est appelée, puis la valeur de chaîne renvoyée est convertie selon les règles précédentes.

 var num1 = Number("Hello World");    //NaN
    var num2 = Number("");                //0
    var num3 = Number("000011");        //11
    var num4 = Number(true);            //1

Étant donné que la fonction Number() est complexe et déraisonnable lors de la conversion de chaînes, la fonction parseInt() est plus couramment utilisée lors du traitement d'entiers. Lorsque la fonction parseInt() convertit une chaîne, cela dépend davantage de sa conformité au modèle numérique. Il ignore les espaces de début de la chaîne jusqu'à ce qu'il trouve le premier caractère autre qu'un espace. Si la première chaîne 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. Si le premier caractère est un caractère numérique, praseInt() 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 et « 22,5 » 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 divers formats d'entiers (c'est-à-dire décimal, octal, hexadécimal). 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（十六进制）
    var num4 = parseInt("22.5");        //22
    var num5 = parseInt("070");            //56（八进制）
    var num6 = parseInt("70");            //70
    var num7 = parseInt("10",2);        //2（按二进制解析）
    var num8 = parseInt("10",8);        //8(按八进制解析)
    var num9 = parseInt("10",10);        //10（按十进制解析）
    var num10 = parseInt("10",16);        //16（按十六进制解析）
    var num11 = parseInt("AF");            //56（八进制）
    var num12 = parseInt("AF",16);        //175

Semblable à la fonction parseInt(), parseFloat() part également de le premier caractère (position 0) commence l'analyse de chaque caractère. 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é. C'est-à-dire que 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. Par exemple, « 22.34.5 » sera converti en 22.34.

La deuxième différence entre parseFloat() et parseInt() est qu'il ignore toujours les zéros non significatifs. Étant donné que les valeurs parseFloat() analysent les valeurs décimales, il n'a aucune utilité de spécifier la base avec le deuxième argument.

  var num1 = parseFloat("1234blue");    //1234
    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

Type de chaîne

Le type de chaîne est utilisé pour représenter des caractères composés de zéro ou plusieurs caractères Unicode 16 bits Séquence, c'est-à-dire chaîne. Les chaînes peuvent être représentées par des guillemets simples (') ou des guillemets doubles (").

var str1 = "Bonjour"; var str2 = 'Bonjour';

N'importe quelle chaîne La longueur peut être obtenu en accédant à son attribut length

Alert(str1.length); //Output 5

Il existe deux façons de convertir une valeur en chaîne. la méthode toString() qui est disponible pour presque toutes les valeurs. var age = 11; var ageAsString = age.toString(); //String "11"

var found = true ; ; //String "true"

Les valeurs numériques, booléennes, d'objet et de chaîne ont toutes la méthode toString(), mais les valeurs nulles et non définies n'ont pas cette méthode <🎜. >

Dans la plupart des cas, vous n'avez pas besoin de passer de paramètres lors de l'appel de la méthode toString() d'une valeur :

var num = 10;
    alert(num.toString());      //"10"
    alert(num.toString(2));     //"1010"
    alert(num.toString(8));     //"12"
    alert(num.toString(10));    //"10"
    alert(num.toString(16));    //"a"

On peut voir dans cet exemple qu'en spécifiant la base, la méthode toString() modifiera la valeur de sortie. La valeur 10 peut être convertie en différents formats numériques lors de la sortie en fonction de la base.

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(), la méthode est appelée (sans paramètres) et le résultat correspondant est renvoyé

● Si la valeur est nulle, puis renvoie "null"

● Si la valeur n'est pas définie, renvoie "undéfini"

  var value1 = 10;    var value2 = true;    var value3 = null;    var value4;
    alert(String(value1));    //"10"
    alert(String(value2));    //"true"
    alert(String(value3));    //"null"
    alert(String(value4));    //"undefined"

Type d'objet

Un objet est en fait un ensemble de données et de fonctions. Les objets peuvent être créés en exécutant l'opérateur new suivi du nom du type d'objet à créer. Vous pouvez créer un objet personnalisé en créant une instance du type Objet et en y ajoutant des propriétés et/ou des méthodes.

var o = new Object();

Chaque instance d'Object a les propriétés et méthodes suivantes :

● constructeur - contient l'objet utilisé pour créer le Fonctions d'objet actuelles

　 hasOwnProperty(propertyName) - utilisées pour vérifier si la propriété donnée existe dans l'instance d'objet actuelle (pas dans le prototype de l'instance). Parmi eux, le nom de la propriété (propertyName) en tant que paramètre doit être spécifié sous la forme d'une chaîne (par exemple : o.hasOwnProperty("name"))

　Quantity isPrototypeOf(object) - utilisé pour vérifier si l'objet entrant est Le prototype d'un autre objet

● propertyIsEnumerable(propertyName) - utilisé pour vérifier si la propriété donnée peut être énumérée à l'aide d'une instruction for-in

● toString() - renvoie le Représentation sous forme de chaîne de l'objet

　 ● valueOf() - Renvoie la représentation sous forme de chaîne, numérique ou booléenne de l'objet. Généralement identique à la valeur de retour de la méthode toString().