Notes d'étude sur le type de données JavaScript_compétences Javascript

Il existe 5 types de données simples dans ECMAscript, également appelés types de données de base : Indéfini, Null, Booléen, Nombre et Chaîne. Il existe également un type de données complexe : l'objet.

Type non défini

Lorsqu'une variable est déclarée à l'aide de var mais n'est pas initialisée, la valeur de la variable n'est pas définie. Tel que :

var number;
document.write(number); //undefined

Si la variable n'est pas déclarée, l'erreur suivante se produira. Tel que :

document.write(str); //错误

Mais lorsqu'elle est exécutée avec typeof, une valeur non définie sera renvoyée, qu'elle soit déclarée ou non. Tel que :

var num;
document.write(typeof num); //undefined
document.write(typeof str); //undefined

Type nul

Lors de l'utilisation de typeof pour détecter null, "object" sera renvoyé. Tel que :

var num = null;
document.write(typeof num); //object

En fait, la valeur indéfinie est dérivée de la valeur nulle, donc elles retourneront vrai si elles sont égales. Tel que :

alert(null == undefined); //true

Ce qu'il convient de noter ici, c'est que tant que la variable destinée à enregistrer l'objet n'a pas réellement enregistré l'objet, la variable doit être explicitement autorisée à enregistrer la valeur nulle. Cela aidera à distinguer null et indéfini. Tel que :

var num1 = null;
var num2;
document.write(typeof num1 + " " + typeof num2); //object undefined

Type booléen

Pour convertir une valeur en sa valeur booléenne correspondante, vous pouvez utiliser la fonction de conversion Boolean(). Tel que :

var str = "helloworld";
document.write(Boolean(str)); //true

Le chapitre 3.4.4 du livre "JavaScript Advanced Programming Design" donne un tableau des différents types de données et leurs règles de conversion correspondantes. Il existe probablement les types suivants :

• Lorsque le type de données est String, toute chaîne non vide sera convertie en vrai
• Lorsque le type de données est Nombre, sauf 0 et NaN qui seront convertis en faux, tout le reste sera converti en vrai
• Lorsque le type de données est Objet, sauf null, il sera converti en vrai
• Lorsque le type de données est Indéfini, n/a sera converti en vrai et undéfini sera converti en faux
  

Il convient de noter ici que les instructions if utilisent souvent des conversions booléennes qui exécutent automatiquement les réponses comme conditions. Tel que :

var str = "helloworld";
if (str){
  document.write("hellothere");
} //hellothere

Type de numéro

En plus d'être représentés en décimal, les entiers peuvent également être représentés par des valeurs littérales octales ou hexadécimales. Le premier bit de la valeur littérale octale doit être 0, suivi d'une séquence de chiffres octaux (0~7). Tel que :

var num1 = 070; //八进制的56
var num2 = 032; //八进制的32
var num3 = 079; //错误的八进制（>7）
var num4 = 09; //错误的八进制（>7）

Les deux premiers chiffres d'une valeur littérale hexadécimale doivent être 0x, suivis de n'importe quel chiffre hexadécimal (0~9 et A~F). Tel que :

var num1 = 0xA; //十六进制的10
var num1 = 0xa; //也是十六进制的10（字母不区分大小写）

Valeur à virgule flottante

La chose importante à noter ici est que vous ne devez jamais comparer des valeurs à virgule flottante spécifiques. Tel que :

var a = 0.1;
var b = 0.2;
if (a + b == 0.3){
  document.write("you are right")
} //因为0.1 加上0.2 实际上等于0.30000000000000004

Plage de valeurs

Les valeurs maximales et minimales que ECMAScript peut représenter sont stockées dans Number.MAX_VALUE et Number.MIN_VALUE. Pour déterminer si une valeur est finie, utilisez la fonction isFinite(). Tel que :

document.write(isFinite(Number.MAX_VALUE + Number.MAX_VALUE)); //false

NaN

0 divisé par 0 renverra NaN, le nombre positif divisé par 0 renverra l'infini et le nombre complexe renverra -Infini. Deuxièmement, NaN n’est égal à aucun nombre, y compris lui-même. De plus, la fonction isNaN() peut nous aider à déterminer si ce paramètre n'est "pas une valeur numérique". Tel que :

document.write(isNaN("a")); //true;
document.write(isNaN("324")); //false;
document.write(isNaN(true)); //false;
document.write(isNaN(false)); //false;
document.write(isNaN(NaN)); //true;

Conversion numérique

Il existe trois fonctions qui peuvent convertir des valeurs non numériques en valeurs numériques : Number(), parseInt() et parseFloat().

Les règles de conversion de Number() sont les suivantes :

S'il s'agit d'une valeur booléenne, vrai et faux seront convertis en 1 et 0.
S'il s'agit d'une valeur numérique, elle reste inchangée.
S'il s'agit d'une valeur nulle, elle est convertie en 0.
S'il n'est pas défini, renvoie NaN.
S'il s'agit d'une chaîne, suivez les règles suivantes :

• S'il n'y a que des nombres, convertissez-les en valeurs décimales.
• S'il est au format virgule flottante, convertissez-le en la valeur à virgule flottante correspondante. Les zéros non significatifs sont également ignorés.
• S'il est au format hexadécimal, il sera converti en nombre décimal.
• Si la chaîne est vide, elle sera convertie en 0.
• Les autres cas seront convertis en NaN.

Voir l'exemple ci-dessous pour plus de détails :

document.write(Number(true)); //1
document.write(Number(false)); //0
document.write(Number("789")); //789
document.write(Number(null)); //0
document.write(Number(undefined)); //NaN
document.write(Number("02.0942")); //2.0942
document.write(Number(0xa)); //10
document.write(Number("")); //0
document.write(Number("fdsa")); //NaN

parseInt()的转换规则如下：

• 如果第一个字符不是数字字符或者符号，parseInt()会返回NaN。
• 用parseInt()转换空字符串会返回NaN。
• 如果第一个字符是数字字符，它会继续解析第二个字符，直到遇到了一个非数字字符.
  

下面是具体的例子：

document.write(parseInt("fds")); //NaN
document.write(parseInt("")); //NaN
document.write(parseInt("1111112abc")); //1111112
document.write(parseInt("-1111112abc")); //-1111112
document.write(parseInt("+1111112abc")); //-1111112
document.write(parseInt("0xa")); //10
document.write(parseInt("0022.00009")); //22
document.write(parseInt("070")); //ECMAScript 3认为是56（八进制）， ECMAScript 5认为是70（十进制）

另外需要注意的是，ECMAScript 5已经不具备解析八进制值的能力了所以为了消除这个问题，可以为这个函数提供第二个参数：转换时使用的基数（多少进制），具体如下：

document.write(parseInt("070",10)); //70
document.write(parseInt("070",8)); //56
document.write(parseInt("070",16)); //112

多数情况下，最好默认设置成10进制。

parseFloat()的转换规则如下：

• 与parseInt()类似，不同的是字符串第一个小数点是有效的，而从第二个小数点开始包括第二个小数点是无效的。
• 他不能解析十六进制数值！！！
• 他只能解析十进制数值！！！
• 他没有用第二个基数来指定进制的用法。
  

下面是具体的例子：

document.write(parseFloat("421")); //421
document.write(parseFloat("0421.32.1")); //421.32
document.write(parseFloat("0xaafd")); //0
document.write(parseFloat("070")); //70
document.write(parseFloat("070abc")); //70
document.write(parseFloat("")); //NaN
document.write(parseFloat("abc")); //NaN

String 类型

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

document.write((533).toString(10)); //"533"
document.write((0xa).toString(10)); //"10"
document.write((0xa).toString(2)); //"1010"
document.write((true).toString(10)); //"true"
document.write((false).toString(10)); //"false"

另外需要注意的是，null 和 undefined 不能转换。

document.write((null).toString(10)); //
document.write((undefined).toString(10)); //

如果不知道需要转换的数值是否是null 或者undefined 则应该使用转型函数String()，如果是null 会返回"null"如果是undefined 会返回"undefined"。如下：

document.write(String(null)); //"null"
document.write(String(undefined)); //"undefined"

另外在下一篇文章中再详细介绍Object 类型。

以上就是关于JavaScript数据类型的简单介绍，希望对大家学习JavaScript数据类型有所帮助。