Résumé des types, valeurs et compétences variables_javascript JavaScript

Avant-propos : les types de données JavaScript sont divisés en deux catégories : les types primitifs et les types d'objets. 5 types primitifs : nombre, chaîne, valeur booléenne, null (vide), non défini (non défini). Un objet est une collection d'attributs, et chaque attribut est composé d'une « paire nom/valeur » (la valeur peut être une valeur primitive ou un objet). Trois objets spéciaux : objets globaux, tableaux et fonctions. Le cœur du langage JavaScript définit également trois classes utiles : la classe date (Date), la classe régulière (RegExp) et la classe d'erreur (Error).

　1 Numéro

JavaScript ne fait pas de distinction entre les valeurs entières et les valeurs à virgule flottante. JavaScript peut reconnaître les littéraux entiers décimaux (les soi-disant littéraux sont des valeurs de données directement utilisées dans le programme) et les valeurs hexadécimales (préfixées par 0x ou 0X, qui est le chiffre 0 et non la lettre o. Pensez-y si c'est la lettre o Si c'est le cas, alors la valeur hexadécimale devient un identifiant.) Bien que la norme ECMAScript ne prenne pas en charge les littéraux octaux, certaines implémentations de JavaScript peuvent utiliser la forme octale pour représenter des entiers (préfixés par le chiffre 0). L'auteur utilise l'octal pour représenter un entier dans les trois navigateurs IE, Chrome et FF sur mon ordinateur. L'affectation des variables ne pose aucun problème non plus. Cependant, dans le mode strict d'ECMAScript6, les littéraux octaux sont explicitement interdits.

Il existe deux façons d'écrire des littéraux à virgule flottante. ① Manière traditionnelle d'écrire les nombres réels : elle se compose d'une partie entière, d'un point décimal et d'une partie décimale ; ② Méthode de comptage des exposants : c'est-à-dire que le nombre réel est suivi de la lettre e ou E, suivie d'un signe positif ou négatif ; , puis suivi d'un exposant entier.

　1.1 Débordement d'opérations arithmétiques

Les opérations arithmétiques en JavaScript ne signaleront pas les erreurs en cas de débordement, de sous-débordement ou de division par 0.

Débordement : lorsque le résultat de l'opération dépasse la limite supérieure du nombre que JavaScript peut représenter, le résultat est l'infini positif ou l'infini négatif-Infini. Les caractéristiques comportementales des valeurs infinies sont également conformes à la réalité : les résultats des opérations d'addition, de soustraction, de multiplication et de division basées sur celles-ci sont toujours des valeurs infinies (en conservant bien sûr leurs signes sous-dépassés : lorsque le résultat de l'opération est infini) ; proche de zéro et est inférieur à la plus petite valeur que JavaScript peut représenter. Que s'est-il passé lorsque la valeur était encore petite. Dans ce cas, 0 sera renvoyé. La valeur spéciale "zéro négatif" est renvoyée lorsqu'un nombre négatif dépasse le plafond. Le zéro négatif et le zéro entier sont essentiellement égaux (peuvent même être testés en utilisant l'égalité stricte ===), sauf en tant que diviseurs :

var zero = 0;  //正零值
var negz = -0;  //负零值
zero === negz  //表达式返回值为true
1/zero === 1/negz  
//表达式返回值false，等价于判断正无穷大和负无穷大是否严格相等

La divisibilité par 0 renverra l'infini positif ou l'infini négatif. Mais diviser 0 par 0 renverra NaN (la valeur de la propriété NaN de l'objet prédéfini JavaScript Number). Il existe quatre situations dans lesquelles NaN est renvoyé : ① 0 divisé par 0 ② l'infini divisé par l'infini ③ effectuer une opération racine carrée sur tout nombre négatif ④ lorsque les opérateurs arithmétiques sont utilisés avec des opérandes qui ne sont pas des nombres ou ne peuvent pas être convertis en nombres.

Il y a quelque chose de spécial dans la valeur NaN : elle n'est égale à aucune valeur, y compris elle-même. Il existe deux façons de juger si une variable x est NaN : ① Utilisez la fonction isNaN() ② Utilisez x != x pour juger Le résultat de l'expression est vrai si et seulement si x est NaN. Il existe une fonction similaire isFinite() en JavaScript, qui renvoie true lorsque le paramètre n'est pas NaN, Infinity ou -Infinity.

　1.2 Nombres binaires à virgule flottante et erreurs d'arrondi

Il existe d'innombrables nombres réels, mais JavaScript ne peut en représenter qu'un nombre limité sous forme de nombres à virgule flottante. En d’autres termes, lorsque vous utilisez des nombres réels en JavaScript, ils ne constituent souvent qu’une représentation approximative d’une valeur réelle. JavaScript utilise la représentation numérique à virgule flottante IEEE-754, qui est une représentation binaire qui peut représenter avec précision des fractions telles que 1/2, 1/8 et 1/1024, mais les fractions décimales 1/10, 1/10, etc. ne peuvent pas être exprimées. avec précision. Par exemple :

var x = 0.3 -0.2;  //x=0.09999999999999998
var y = 0.2 - 0.1;  // y=0.1
x == y       //false
x == 0.1      //false
y == 0.1      //true
0.1 == 0.1     //true
var z = x + y;   //z=0.19999999999999998

　　2 文本

　　2.1 字符串、字符集

　　字符串（string）是一组由16位值组成的不可变的有序序列，每个字符通常来自于Unicode字符集。字符串的长度（length）是其所含16位值得个数。JavaScript通过字符串类型来表示文本。注意：JavaScript中并没有表示单个字符的“字符型”。要表示一个16位值，只需将其赋值给字符串变量即可。

　　JavaScript采用UTF-16编码的Unicode字符集，JavaScript字符串是由一组无符号的16位值组成的序列。那些不能表示为16位的Unicode字符则遵循UTF-16编码规则——用两个16位值组成一个序列（或称作“代理项对”）表示。这意味着一个长度为2的JavaScript字符串有可能表示一个Unicode字符。注意：JavaScript定义的各式字符串的操作方法均作用于16位值，而非字符，且不会对代理项对做单独处理。书看到这里，又结合http://www.alloyteam.com/2013/12/js-calculate-the-number-of-bytes-occupied-by-a-string/上面所述，终于对Unicode字符集、UTF-8、UTF-16稍有理解。

　　字符串的定界符可以是单引号或者双引号。这两种形式的定界符可以嵌套，但是不能多层嵌套（比如，双引号可以包含单引号，这时单引号中不能再包含双引号了）。正如上篇所说，一个字符串值可以拆分为数行，每行必须以反斜线（\)结束，这时反斜线和行结束符都不算是字符串内容，即字符串本身并非是多行，只是写成了多行的形式。

　　注意：①在JavaScript中字符串是固定不变的（除非重新赋值），类似replace（）和toUpperCase（）的方法都返回新字符串，原字符串本身并没有变化；②字符串可以当做只读数组，除了使用charAt（）方法来查询一个单一字符，也可以使用方括号的方式来访问字符串中的单个字符（16位值），例如：

　　　　s = "hello, world";
　　　　s[0] 　　//=>"h"

　2.2 Caractère d'échappement

Signification du caractère d'échappement
o Caractère NUL (u0000)
b Caractère d'espacement arrière (u0008)
t Onglet horizontal (u0009)
n caractère de nouvelle ligne (u000A)
v Onglet vertical (u000B)
f caractère de saut de page (u000C)
r retour chariot (u000D)
" Guillemets doubles (u0022)
'Apostrophe ou guillemet simple (u0027)
\ Barre oblique inverse (u005C)
xXX Caractère Latin-1 spécifié par le nombre hexadécimal à deux chiffres XX
uXXXX Caractère Unicode spécifié par un nombre hexadécimal à 4 chiffres XXXX
                                                                                                                                                                                                      Remarque : Si le caractère "" précède un caractère non répertorié dans le tableau, le caractère "" est ignoré. Par exemple, « # » et « # » sont équivalents. N'oubliez pas que les barres obliques inverses jouent également un rôle dans l'utilisation de barres obliques inverses à la fin de chaque ligne dans les chaînes multilignes. 

　3 Valeur booléenne

Les valeurs en JavaScript peuvent être converties en valeurs booléennes. Parmi elles, null, undefined, 0, -0, NaN, "" (chaîne vide), ces 6 valeurs seront converties en false, false et ces six valeurs sont parfois appelées "fausses valeurs" ; les autres valeurs, y compris les objets (tableaux), seront converties en vrai, et en vrai et ces valeurs sont appelées « vraies valeurs ». Remarque : Boolean contient la méthode toString(), vous pouvez donc utiliser cette méthode pour convertir une chaîne en "true" ou "false", mais elle ne contient pas d'autres méthodes utiles.

Ce qui précède représente l’intégralité du contenu de cet article, j’espère que vous l’aimerez tous.