javascript -valeur de type numéro

Introduction générale

JavaScript utilise le format IEEE754 en interne pour représenter les nombres, il ne fait donc pas de distinction entre les nombres entiers et les nombres à virgule flottante et est stocké sous la forme de 64 Nombres à virgule flottante de 1 à 2 bits. C’est-à-dire qu’à l’intérieur de JavaScript, il n’y a aucune décimale. Cependant, certaines opérations doivent être effectuées avec des entiers, c'est pourquoi JavaScript convertit parfois les nombres à virgule flottante de 64 bits en entiers de 32 bits avant d'effectuer des opérations.

Entier

JavaScript fournit quatre méthodes de représentation pour les entiers :

1. valeurs avec le préfixe 0b, une erreur sera signalée si un nombre autre que 0 ou 1 apparaît

2. Octal : Valeurs avec le préfixe 0o, ou 0 suivi d'un nombre (0-7 ). S'il dépasse la plage numérique mentionnée précédemment, le premier chiffre 0 sera ignoré et traité comme un nombre décimal

Remarque : les littéraux octaux ne sont pas valides en mode strict et entraîneront une erreur des moteurs JavaScript prenant en charge ce mode.

3. Hexadécimal : il y a un préfixe de 0x, suivi de n'importe quel chiffre hexadécimal (0~9 et A~F). Les lettres peuvent être majuscules ou minuscules. Si la plage est dépassée, une erreur sera générée. rapporté

4. Décimal

var num2 = 0b11;
 console.log(num2); //3
 var num2 = 0b12;
 console.log(num2); //报错
 var num8 = 0o76;
 console.log(num8); //02
 var num8 = 0o78;
 console.log(num8); //报错
 var num16 = 0x2a;
 console.log(num16); //42
 var num16 = 0x2h;
 console.log(num16) //报错

Nombre à virgule flottante

Le nombre dit à virgule flottante, c'est-à-dire que la valeur doit contenir un point décimal et qu'il doit y avoir au moins un chiffre après le point décimal. Différent des nombres entiers, les nombres à virgule flottante ne peuvent être exprimés qu'en décimal.

La précision des nombres à virgule flottante est bien inférieure à celle des nombres entiers, vous devez donc être prudent lors de la conception d'opérations avec des nombres à virgule flottante

Par exemple :

 console.log(0.1 + 0.2 == 0.3); //false 0.30000000000000004
 console.log(0.6/0.2); //2.9999999999999996

Notation scientifique

Pour ceux extrêmement valeurs petites et extrêmement petites, elle peut être représentée par e Une représentation numérique à virgule flottante exprimée en notation scientifique. La valeur exprimée en notation e est égale à la valeur devant e multipliée par la puissance exponentielle de 10

Dans les deux cas suivants, JavaScript convertira automatiquement la valeur en notation scientifique. Dans les autres cas, il le fera. être exprimé directement sous forme littérale.

1. Il y a plus de 21 chiffres avant la virgule décimale

 console.log(1234567890123456789012);// 1.2345678901234568e+21
 console.log(123456789012365648787); //123456789012365660000　

2. plus de 5 chiffres après la virgule décimale Bits

 console.log(0.0000006);//6e-7
 console.log(0.000006); //0.000006

Plage de valeurs

En raison de limitations de mémoire, ECMAScript ne peut pas enregistrer toutes les valeurs du monde, il y a donc des valeurs maximales et minimales

La valeur minimale est stockée dans Number.MIN_VALUE, cette valeur est 5e-324

La valeur maximale est stockée dans Number.MAX_VALUE , cette valeur est 1.7976931348623157e 308

 console.log(Number.MIN_VALUE) //5e-324
 console.log(Number.MAX_VALUE); //1.7976931348623157e+308

Si le nombre dépasse la valeur maximale, javascript renverra Infinity, appelé débordement direct ; s'il est égal ou supérieur à la valeur négative minimale -1023 (c'est-à-dire très proche de 0), JavaScript convertira directement ce nombre en 0, ce qui est appelé débordement négatif (underflow)

Si vous voulez être sûr de vérifier si une valeur numérique est finie, vous pouvez utiliser la fonction isFinite(). Cette fonction renvoie vrai lorsque l'argument est compris entre les valeurs minimale et maximale

 var result = Number.MAX_VALUE + Number.MAX_VALUE;
 console.log(isFinite(result)); //false

Valeurs spéciales

1, 0 et -0

Ces deux 0 sont équivalents dans le cas des grands logarithmes

 -0 === +0; //true
 0 === -0; //true
 0 === +0; //true

Mais il est différent lorsqu'il est utilisé comme dénominateur

1/-0 == 1/ 0; //false

2.

Infini signifie « infini » et est utilisé pour représenter deux scénarios. L’une est qu’une valeur positive est trop grande ou qu’une valeur négative est trop petite pour être représentée ; l’autre est qu’une valeur non nulle est divisée par 0 pour obtenir l’infini.

 Math.pow(2,Math.pow(2,100));//Infinity
 1/0;//Infinity

Le résultat de l'opération Infinity ne peut être que lui-même, 0 ou NaN

* Infinity;//Infinity
- Infinity;//-Infinity
+ Infinity;//Infinity
/ Infinity;//0
 Infinity / 2;//Infinity
 Infinity * Infinity;//Infinity
 Infinity - Infinity;//NaN
 Infinity + Infinity;//Infinity
 Infinity / Infinity;//NaN

3.NaN

Cette valeur représente un opérande censé renvoyer une valeur. . Cas où aucune valeur numérique n'est renvoyée

NaN n'est égal à aucune valeur, y compris elle-même, et toute opération impliquant NaN renvoie NaN

 5 - 'x'; //NaN
 Math.acos(2); //NaN
 0 / 0; //NaN
 NaN == NaN;//false
 NaN == Infinity;//false

.

NaN n'est pas un type de données indépendant, mais une valeur spéciale. Son type de données appartient toujours à Number

 typeof NaN; //number

La méthode isNaN peut être utilisée. Déterminez si une valeur est NaN, cependant, isNaN n'est valable que pour les valeurs numériques. Si d'autres valeurs sont transmises, elles seront d'abord converties en valeurs numériques. Par exemple, lorsqu'une chaîne est transmise, la chaîne sera d'abord convertie en NaN, donc true sera renvoyé à la fin. Cela doit faire l'objet d'une attention particulière. En d’autres termes, la valeur pour laquelle isNaN est vrai ne peut pas être NaN, mais une chaîne.

 isNaN('Hello') // true
 // 相当于
 isNaN(Number('Hello')) // true

Une façon plus fiable de juger NaN est de tirer parti du fait que NaN est la seule valeur en javascript qui n'est pas égal à lui-même. Portez un jugement

 function isNaN(value){
 return value != value;
 }

Conversion du système numérique

Il existe 3 fonctions qui peuvent convertir des valeurs non numériques en valeurs numériques : Number(), parseInt() et parseFloat(). Parmi eux, Number() peut convertir n'importe quel type de valeur en valeur numérique, tandis que parseInt() et parseFloat() ne sont utilisés que pour convertir des chaînes en nombres

Number()

Règles de conversion :

1 S'il s'agit d'une valeur booléenne, vrai et faux seront convertis respectivement en 1 et 0

2. une valeur nulle, 0

3、如果是undefined，返回NaN

4、如果是字符串，遵循以下规则：

（1）若字符串只包含十进制或十六进制数字，则转成十进制的数字

注意：Number()不识别八进制数字的字符串，会按照十进制数字处理

字符串'1.2.'不会报错，但数字1.2.会报错

（2）若字符串为空字符串或空格字符串，则转成0

（3）其他情况的字符串，则转成NaN

Number(true) //1
 Number(null) //0
 Number(undefined) //NaN
 Number("0123") //123
 Number("0x123") //291
 Number("0.2") //0.2
 Number("") //0
 Number("asd") //NaN

parseInt()

parseInt()专门用于把字符串转换成整数。在转换字符串时，会忽略字符串前面的空格，直到找到第一个非空格字符。如果第一个字符不是数字字符或者负号，parseInt()就会返回NaN。如果是，则继续解析，直到解析完成或者遇到非数字字符

 console.log(parseInt(' 123.8px'));//123
 console.log(parseInt(' 123.8 '));//123
 console.log(parseInt(' -123.8px'));//-123
 console.log(parseInt('a123.8px'));//NaN
 console.log(parseInt('0 123.8px'));//0

注意：在ECMAScript5中，parseInt()已经不具备解析八进制的能力。例如八进制“070”，会忽略前面的“0”，得到十进制的70

为了消除在使用parseInt()函数时可能导致的上述困惑，可以为这个函数提供第二个参数：转换时使用的基数（多少进制）

 parseInt("070") //70
 parseInt("070",8) //56

parseFloat()

parseFloat()专门用于字符串转换浮点数。同样地，解析时会忽略字符串前面的空格，直到找到第一个非空格字符，然后一直解析到字符串末尾或一个无效的浮点数字字符为止

console.log(parseFloat(' 0123.px'));//123
 console.log(parseFloat(' 123.px'));//123
 console.log(parseFloat(' 123.1px'));//123.1
 console.log(parseFloat(' 123.1.2px '));//123.1
 console.log(parseFloat(' -123.0px'));//-123
 console.log(parseFloat('.123.1px'));//0.123
 console.log(parseFloat('0 123px'));//0

注意：parseFloat()只解析十进制，所以十六进制的字符串始终会被转换成0。因此也没有第二个参数用来指定基数

 parseFloat("0xA") //0

注意：Number('')的结果是0，parseInt('')和parseFloat('')的结果是NaN

更多Number类型值相关文章请关注PHP中文网！