Types de données des notes d'étude JavaScript

Les types de données Javascript sont très simples, comprenant uniquement les types de données indéfinis, nuls, chaînes, booléens, nombres et objets. Aujourd'hui, nous allons expliquer ces types de données un par un pour faciliter la compréhension et la mémoire de chacun.

1. Classification

Types de données de base : non défini, nul, chaîne, booléen, nombre

Complexe Type de données : objet

Les attributs de l'objet sont définis sous la forme de paires nom et valeur non ordonnées (nom : valeur)

2. Explication détaillée

1. undéfini : Le type undéfini n'a qu'une seule valeur : undéfini. Lorsqu'une variable est déclarée à l'aide de var mais non initialisée, la valeur de cette variable est indéfinie.

Une variable contenant. une valeur non définie est la même que les variables non définies sont différentes. L'exemple suivant peut illustrer :

var demo1;//声明但未初始化
alert(demo1);//undefined
alert(demo2);//报错，demo2 is not defined

2 null : Le type nul n'a qu'une seule valeur : null. d'un point de vue, la valeur nulle Représente un pointeur d'objet nul.

Si la variable définie doit être utilisée pour contenir un objet dans le futur, il est préférable d'initialiser la variable à null plutôt qu'à une autre valeur . De cette façon, tant que la valeur nulle est directement détectée, vous pouvez savoir si la variable correspondante a enregistré une référence à un objet, par exemple :

 if(car != null)
    {
        //对car对象执行某些操作
    }

En fait, la valeur non définie est dérivée de la valeur nulle, donc ECMA -262 spécifie que le test de leur égalité doit renvoyer vrai.

alert(undefined == null); //true

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.

3. Booléen :

Le type booléen a deux valeurs : vrai et faux. Ces deux valeurs​​ne sont pas la même chose que le numérique. valeurs, donc vrai Il n'est pas nécessairement égal à 1, et faux n'est pas nécessairement égal à 0.

Il convient de noter que la valeur littérale du type booléen est sensible à la casse, c'est-à-dire que True et False (et d'autres formes de casse mixte) ne sont pas des valeurs booléennes, juste des identifiants.

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 sa 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, le message sous forme de chaîne est converti 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)//相当于if(Boolean(message)==true) {
        alert("Value is true");//Value is true
}

En raison de l'existence de cette conversion booléenne s'exécute automatiquement, il est donc crucial de savoir exactement quelles variables sont utilisées dans les instructions de contrôle de flux.

4. Nombre : entier et virgule flottante

4.1 Entier : lors des calculs, tous les nombres octaux et hexadécimaux seront convertis en décimaux

4.2 Virgule flottante : La précision la plus élevée des valeurs à virgule flottante est de 17 chiffres, sa précision est donc bien inférieure aux nombres entiers dans les calculs arithmétiques. Par exemple : le résultat de 0,1 0,2 n'est pas 0,3, mais 0,30000000000000004. Par exemple :

a=0.2;
b=0.1;
if(a+b==0.3){
alert("hello");
}
else{
alert("hi");
}

Le résultat apparaîtra « salut », alors ne testez pas une valeur à virgule flottante spécifique.

4.3 NaN : Pas un nombre. Cette valeur est utilisée pour indiquer qu'un opérande qui était censé renvoyer une valeur numérique n'a pas renvoyé de valeur numérique (afin qu'une erreur ne soit pas générée).

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 :

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 le paramètre n'est "pas un numérique". valeur". 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("bule123")); //ture(不能被转换为数值)
alert(isNaN(true));    //false(可能被转换为数值1)

possède trois 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 :

● S'il s'agit d'une valeur booléenne, true et false 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 :

　　　○ 如果字符串中只包含数字，则将其转换为十进制数值，即”1“会变成1，”123“会变成123，而”011“会变成11（前导的0被忽略）

　　　○ 如果字符串中包含有效的浮点格式，如”1.1“，则将其转换为对应的浮点数（同样，也会忽略前导0）

　　　○ 如果字符串中包含有效的十六进制格式，例如”0xf“，则将其转换为相同大小的十进制整数值

　　　○ 如果字符串是空的，则将其转换为0

　　　○ 如果字符串中包含除了上述格式之外的字符，则将其转换为NaN

● 如果是对象，则调用对象的valueOf()方法，然后依照前面的规则转换返回的值。如果转换的结果是NaN，则调用对象的toString()方法，然后再依次按照前面的规则转换返回的字符串值。

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

由于Number()函数在转换字符串时比较复杂而且不够合理，因此在处理整数的时候更常用的是parseInt()函数，而处理浮点数的时候常用parseFloat()函数。

5、String

String类型用于表示由零或多个16位Unicode字符组成的字符序列，即字符串。字符串可以由单引号(')或双引号(")表示。

var str1 = "Hello";
var str2 = 'Hello';

任何字符串的长度都可以通过访问其length属性取得

alert(str1.length);        //输出5

要把一个值转换为一个字符串有两种方式。第一种是使用几乎每个值都有的toString()方法。

var age = 11;
var ageAsString = age.toString();    //字符串"11"
var found = true;
var foundAsString = found.toString();    //字符串"true"

数值、布尔值、对象和字符串值都有toString()方法。但null和undefined值没有这个方法。

多数情况下，调用toString()方法不必传递参数。但是，在调用数值的toString()方法时，可以传递一个参数：输出数值的基数。

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"

通过这个例子可以看出，通过指定基数，toString()方法会改变输出的值。而数值10根据基数的不同，可以在输出时被转换为不同的数值格式。

在不知道要转换的值是不是null或undefined的情况下，还可以使用转型函数String()，这个函数能够将任何类型的值转换为字符串。

String()函数遵循下列转换规则：

● 如果值有toString()方法，则调用该方法（没有参数）并返回相应的结果

● 如果值是null，则返回"null"

● 如果值是undefined，则返回”undefined“

6、object

对象其实就是一组数据和功能的集合。对象可以通过执行new操作符后跟要创建的对象类型的名称来创建。而创建Object类型的实例并为其添加属性和（或）方法，就可以创建自定义对象。

var o = new Object();

object类型所具有的任何属性和方法也同样存在于更具体的对象中，Object的每个实例都具有下列属性和方法：

● constructor（构造函数）——保存着用于创建当前对象的函数

● hasOwnProperty(propertyName)——用于检查给定的属性在当前对象实例中（而不是在实例的原型中）是否存在。其中，作为参数的属性名(propertyName)必须以字符串形式指定（例如：o.hasOwnProperty("name")）

● isPrototypeOf(object)——用于检查传入的对象是否是另一个对象的原型

● propertyIsEnumerable(propertyName)——用于检查给定的属性是否能够使用for-in语句来枚举

● toString()——返回对象的字符串表示

● valueOf()——返回对象的字符串、数值或布尔值表示。通常与toString()方法的返回值相同。

三、小测试

typeof(NaN)
typeof(Infinity)
typeof(null)
typeof(undefined)

很多面试都会问到上面几个小问题哒~~

以上就是这6种javascript数据类型的介绍了，小伙伴们是否了解清楚了呢，希望看完本文后大家能有所提高。更多相关教程请访问JavaScript视频教程！