Conversion numérique Number(), parseInt() et parseFloat()

Il existe 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 auront 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 convertis respectivement en 1 et 0
S'il s'agit d'une valeur numérique, elle est simplement passée Enter et return
Si c'est une valeur nulle, renvoie 0
Si elle n'est pas définie, renvoie NaN
S'il s'agit d'une chaîne, suivez les règles suivantes :
Si la chaîne ne contient que des nombres, convertissez-la en valeurs décimales, "1" deviendra 1, "123" deviendra 123 et "011" deviendra 11 (le 0 initial est ignoré)
Si la chaîne ne contient que des valeurs flottantes valides formats de points, tels que "1.1", puis convertissez-le en valeur à virgule flottante correspondante (de même, les zéros non significatifs seront également ignorés)
Si la chaîne ne contient qu'un format hexadécimal valide, tel que "0xf", alors convertissez-la une valeur entière décimale de même taille
Si la chaîne est vide (ne contient aucun caractère), elle est convertie en 0
Si la chaîne contient des caractères autres que le format ci-dessus, elle est convertie en NaN
Si c'est un objet, appelez la méthode valueOf() de l'objet, puis convertissez la valeur renvoyée selon les règles précédentes. Si le résultat de la conversion est NaN, il est en effet un peu compliqué d'appeler la fonction toString() de l'objet pour convertir différents types de données en valeurs numériques. Voici quelques exemples spécifiques :

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

Tout d'abord, la chaîne "Hello world!" sera convertie en NaN car elle ne contient aucune valeur numérique significative. Les chaînes vides seront converties en 0. La chaîne "000011" est convertie en 11 car les zéros non significatifs sont ignorés. Enfin, la vraie valeur est convertie en 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 le premier caractère 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 (Number() renvoie 0 pour une chaîne vide). Si le premier caractère est un caractère numérique, parseInt() 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, « 123blue » serait converti en 1234 car « blue » serait complètement ignoré. De même, "22,5" sera converti 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). Autrement dit, si la chaîne commence par « 0x » et est suivie de caractères numériques, elle est traitée comme un entier hexadécimal ; si la chaîne commence par « 0 » et est suivie de caractères numériques, elle est traitée comme un entier octal. .

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("0xF") //15(十六进制)

Pour comprendre ces exemples, le plus important est de faire attention à parseInt() différentes manières d'analyser "070" et "70". À ce stade, les zéros non significatifs dans "070" indiquent qu'il s'agit d'une chaîne au format octal (et non décimal), donc le résultat est 56 (notez que ce résultat est différent de l'appel de la fonction Number()). Et "70", parce qu'il n'y a pas de zéro non significatif, est converti en 70. Afin d'éliminer la confusion ci-dessus qui peut survenir lors de l'utilisation de la fonction parseInt(), ECMAScript fournit également un deuxième paramètre pour cette fonction : la base utilisée pour la conversion (c'est-à-dire la base).

Si vous voulez savoir que la valeur à analyser est une chaîne au format hexadécimal, alors spécifier la base 16 comme deuxième paramètre peut garantir le résultat correct, par exemple :

var num = parseInt("0xAF", 16); //175
En fait, si 16 est spécifié comme deuxième paramètre, la chaîne peut être sans le "0x" précédent, comme indiqué ci-dessous :

var num1 = parseInt("AF", 16); //175
var num2 = parseInt("AF"); //NaN

La première conversion dans cet exemple réussit, mais la seconde échoue. La différence est que la première conversion passe dans la base, indiquant explicitement à parseInt() d'analyser une chaîne au format hexadécimal ; tandis que la deuxième conversion découvre que le premier caractère n'est pas un caractère numérique, elle se termine donc automatiquement.

La spécification de la base affectera le résultat de sortie de la conversion. Par exemple :

var num1 = parseInt("10", 2); //2
var num2 = parseInt("10", 8);  //8
var num3 = parseInt("10", 10); //10
var num4 = parseInt("10", 16); //16

Puisque ne pas spécifier la base signifie laisser parseInt() décider comment analyser la chaîne d'entrée, afin d'éviter une analyse incorrecte, nous vous recommandons de spécifier explicitement la base quelle que soit la situation. - Surtout lorsqu'il s'agit d'octal comme celui-ci :

var num1 = parseInt("010"); //8
var num2 = parseInt("010", 8); //8
var num2 = parseInt("010", 10); //10

　　在这个例子中，“010”会因为第二个参数不同而被转换成不同的值。第一行的转换很直观，即让parseInt()决定如何转换。由于第一个字符是 “0”而后面也是数字字符，因而parseInt()假设它是一个八进制数。实际上，parseInt()的这个默认行为域第二行转换中明确了基数行为是 一致的。第三行传入基数10，因此parseInt()就会忽略字符串中的前导零，而只解析其余的数字符。

　　多数情况下，我们要解析的都是十进制数值，因此始终将10作为第二个参数是非常必要的。

　　与parseInt()函数类似，parseFloat()也是从第一个字符（位置0）开始解析每个字符。而且也是一直解析到字符串末尾，或者解析 到遇见一个无效的浮点数字字符为止。也就是说，字符串中的第一个小数点是有效的，而第二个小数点是无效的，因此它后面的字符串将被忽略。举例来 说，“22.34.5”将会被转换为22.34。

　　除了第一个小数点有效之外，parseFloat()与parseInt()的第二个区别在于它始终都会忽略前导零。parseFloat()可以 识别前面讨论过的所有浮点数值格式，也包括十进制整数格式。但十六进制格式的字符串始终会被转换为0。由于parseFloat()只解析十进制值，因此 它没有用第二个参数指定基数的用法。最后还要注意一点：如果字符串包含的是一个可解析为整数的数（没有小数点，或者小数点后面都是 零），parseFloat()会返回整数。以下是使用parseFloat()转换数值的几个典型示例：

var num1 = parseFloat("1234blue"); //1234
var num1 = parseFloat("0xA"); //0
var num1 = parseFloat("22.5"); //22.5
var num1 = parseFloat("22.34.5"); //22.34
var num1 = parseFloat("0908.5"); //908.5
var num1 = parseFloat("3.125e7"); //31250000

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!