Comment convertir une chaîne en nombre en javascript

Méthode de conversion : 1. Utilisez des opérateurs tels que "-", "*", "/", "%", "++", "--" 2. Utilisez l'instruction "Nombre (valeur)" ; . Utilisez l'instruction "parseInt(stringNum)" ; 4. Utilisez l'instruction "parseFloat(stringNum)".

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

javascript convertit les chaînes en nombres

Méthode 1 : utilisez des opérateurs tels que -、*、/、%、++, --, etc.

JavaScript convertira automatiquement les chaînes en nombres, et celles qui ne peuvent pas être converties en nombres seront converties en NaN. Par exemple :

alert("30"/5);   //除运算，结果为：6
alert("15"-5);   //减运算，结果为：10
alert("20"*"a"); //乘运算，结果为：NaN
alert("20"%"3"); //取模运算，结果为：2

var num1 = "6";
var num2 = "6";
var num3 = "a";
alert(++num1);  //将字符串转换为数字再进行++运算，结果为：7
alert(--num2);  //将字符串转换为数字再进行--运算，结果为：5
alert(++num3);  //字符串无法转换为数字，结果为：NaN

Méthode 2 : Utiliser la fonction Number()

La fonction Number() peut convertir le paramètre en nombre

Le format est le suivant :

Number(value)

Number() effectue une analyse globale conversion de la valeur du paramètre, lorsque Lorsque la valeur du paramètre contient un symbole qui ne peut être converti en nombre nulle part, la conversion échoue et NaN est renvoyé. Sinon, le nombre converti est renvoyé.

Number() suit les règles suivantes lors de la conversion des paramètres en nombres :

• Si le paramètre ne contient que des nombres, il sera converti en nombres décimaux, en ignorant les 0 et les espaces de début si le nombre est précédé de -, - ; will Conservé dans le résultat de la conversion ; si le nombre est précédé de +, le signe + sera supprimé après la conversion

• Si le paramètre contient un nombre à virgule flottante valide, il sera converti en nombre à virgule flottante correspondant, en ignorant le 0 et les espaces de début ; si Si le nombre est précédé de -, - sera conservé dans le résultat de la conversion ; si le nombre est précédé de +, le signe + sera supprimé après la conversion ; un nombre hexadécimal valide, il sera converti en décimal de la taille correspondante Nombre ;

• Si le paramètre est une chaîne vide, il sera converti en 0 

• Si le paramètre est une valeur booléenne, true sera sera converti en 1 et false sera converti en 0 ;

• Si le paramètre est nul, sera converti en 0

• Si le paramètre n'est pas défini, il sera converti en NaN ; le paramètre est un objet Date, il sera converti en nombre de millisecondes à partir du 1er janvier 1970 jusqu'au moment où la conversion est effectuée

• Si le paramètre est une fonction, un objet tableau contenant plus de deux éléments, et d'autres objets à l'exception des objets Date, il sera converti en NaN

• Si le paramètre contient d'autres symboles spéciaux à l'exception des espaces, + et - ou des caractères non numériques, ou des symboles spéciaux ou des caractères non numériques comprenant des espaces, +, et - au milieu du paramètre, sera converti en NaN.

Exemple de conversion :

• alert(Number("0010"));  //去掉两个前导0，结果为：10
  alert(Number("+010"));  //去掉前导0和+，结果为：10
  alert(Number("-10"));  //转换后保留“-”号，结果为：-10
  alert(Number(''));      //空字符串的转换结果为：0
  alert(Number(true));   //布尔值true的转换结果为：1
  alert(Number(null));   //null值的转换结果为：0
  var d = new Date();      //创建一个Date对象
  alert(Number(d));     //转换Date对象，结果为1970.1.1至执行转换时的毫秒数：1511351635179
  alert(Number("100px"));   //参数中包含了不能转换为数字的字符px，结果为：NaN
  alert(Number("100 01"));  //参数中包含了空格，导致整个参数不能转换，结果为：NaN
  alert(Number("100-123")); //参数中包含了“-”，导致整个参数不能转换，结果为：NaN
  var a;                   //声明变量
  alert(Number(a));     //变量a没有赋值，因而a的值为undefined,转换undefined的结果为：NaN
  var fn = function (){alert(1);}; //创建一个函数对象
  alert(Number(fn));     //转换函数，结果为:NaN
  alert(Number(window)); //转换window对象，结果为:NaN

  Dans l'exemple ci-dessus, nous pouvons également voir que Number() est converti dans son ensemble et que tout caractère illégal contenu à n'importe quel endroit entraînera l'échec de la conversion. La différence entre les deux fonctions qui seront présentées ensuite et Number() est que la conversion est effectuée bit par bit de gauche à droite. Lorsqu'un bit ne peut pas être converti, la conversion s'arrête immédiatement et la valeur convertie avec succès est renvoyée.

Méthode 3 : utilisez la fonction parseInt()

La fonction parseInt() peut convertir le paramètre en un entier

Le format est le suivant :

parseInt(stringNum,[radix])

le paramètre stringNum est la chaîne qui doit être convertie en un entier ; le paramètre radix est 2~ Le nombre entre 36 représente le numéro de base du paramètre stringNum, qui peut être omis lorsque la valeur est 10. parseInt() est utilisé pour analyser le paramètre de chaîne stringNum avec la base comme base en un nombre décimal. Si la chaîne stringNum ne commence pas par un caractère légal, NaN sera renvoyé ; si un caractère illégal est rencontré pendant le processus d'analyse, l'analyse s'arrêtera immédiatement et la valeur analysée sera renvoyée.

parseInt() suit les règles suivantes lors de l'analyse d'une chaîne en un entier :

Lors de l'analyse d'une chaîne, les espaces avant et après la chaîne seront ignorés si la chaîne est précédée de -, - seront conservés dans le ; résultat de la conversion ; if Si le nombre est précédé de +, le signe + sera supprimé après la conversion

Si la chaîne est précédée de symboles spéciaux autres que des espaces, + et - ou des caractères non numériques sauf a～f ( ou A～F), La chaîne ne sera pas analysée et le résultat sera NaN

• Lorsque la chaîne contient des symboles spéciaux ou des caractères non numériques tels que des espaces, +, - et des points décimaux ".", l'analyse rencontrera ces caractères. Arrêtez et renvoyez le résultat analysé

• Si la chaîne est une chaîne vide, le résultat renvoyé est NaN.

• Exemple de conversion :

  alert(parseInt("1101",2));  //以2为基数的1101字符串解析后的结果为：13
  alert(parseInt("a37f",16)); //以16为基数的a37f字符串解析后的结果为：41855
  alert(parseInt("123"));     //以10为基数的123字符串解析后的结果为：123
  alert(parseInt("  123"));   //字符串前面的空格会被忽略，结果为：123
  alert(parseInt("12 3"));    //字符串中包含了空格，解析到空格时停止，结果为12
  alert(parseInt("12.345")); //字符串中包含了小数点，解析到小数点时停止，结果为12
  alert(parseInt("xy123"));  //字符串前面包含了非数字字符“x”，无法解析，返回结果为：NaN
  alert(parseInt("123xy4")); //字符串中包含了非数字字符“xy”，解析到“x”时停止，结果为：123

Dans l'exemple ci-dessus, nous pouvons voir que lorsque parseInt() analyse les nombres à virgule flottante, la partie décimale des données sera tronquée. Dans ce cas, vous devez utiliser parseFloat(), qui sera présenté ci-dessous, à la place de parseInt ().

• Méthode 4 : Utilisez la fonction parseFloat()

La fonction parseFloat() peut convertir le paramètre en un nombre à virgule flottante

Le format est le suivant :

parseFloat(stringNum)

stringNum Le paramètre est une chaîne qui doit être analysé en un nombre à virgule flottante.

parseFloat() 的作用是将首位为数字的字符串转解析成浮点型数。若 stringNum 字符串不是以合法的字符开头，则返回 NaN；解析过程中如果遇到不合法的字符，将马上停止解析，并返回已经解析的值。

parseFloat() 在解析字符串为整数时，遵循以下规则：

• 解析字符串时，会忽略字符串前后的空格；如果字符串前面为-，-会保留在转换结果中；如果数字前面为+，转换后将删掉+号；如果字符串前面为小数点.转换结果会在小数点前面添加 0；

• 如果字符串前面为除空格、+、-和。以外的特殊符号，字符串将不会被解析，返回结果为 NaN；

• 在字符串中包含了空格、+和-等特殊符号或非数字的字符时，解析将在遇到这些字符时停止，并返回已解析的结果；

• 在字符串中包含两个以上为小数点时，解析到第二个小数点时将停止解析，并返回已解析的结果；

• 如果字符串是空字符串，返回结果为 NaN。

转换示例：

alert(parseFloat("312.456"));//结果为：312.456
alert(parseFloat("-3.12"));//字符串前面的“-”将保留，结果为：-3.12
alert(parseFloat("+3.12"));//字符串前面的“-”将保留，结果为：3.12
alert(parseFloat(".12"));//在小数点前面添加0，结果为：0.12
alert(parseFloat("  3.12"));//截掉字符串前面的空格，结果为：3.12
alert(parseFloat("312.4A56"));//字符串中包含非数字字符A，解析到A时停止，结果为：312.4
alert(parseFloat("31 2.4A56"));//字符串中包含空格，解析到空格时停止，结果为：31
alert(parseFloat("31.2.5"));//字符串中包含两个小数点，解析到第二个小数点时停止，结果为：31.2
alert(parseFloat("a312.456"));//字符串前面为非数字字符a，解析无法进行，结果为：NaN

【推荐学习：javascript高级教程】

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!