Comment convertir des données en entier en javascript

Comment convertir des entiers à l'aide de JavaScript : 1. Utilisez la fonction parseInt() avec la syntaxe "parseInt("valeur à convertir")". 2. Utilisez des opérateurs de bits, tels que "~~123.45". 3. Utilisez la syntaxe "Math.floor(value)" et "Math.ceil(value)".

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

Méthode 1 : fonction parseInt()

parseInt() est une méthode globale qui peut convertir une valeur en entier. Le processus de conversion est le suivant :

• Le caractère en position 0 est analysé en premier. S'il ne s'agit pas d'un nombre valide, NaN est renvoyé directement.

• Si le caractère en position 0 est un nombre ou peut être converti en un nombre valide, continuez à analyser le caractère en position 1. S'il ne s'agit pas d'un nombre valide, renvoyez le caractère valide caractère à la position 0 directement.

• Et ainsi de suite, en analysant chaque caractère un par un de gauche à droite jusqu'à trouver un caractère non numérique.

• parseInt() convertira tous les caractères numériques légaux analysés précédemment en valeurs numériques et les renverra.

console.log(parseInt("123abc"));  //返回数字123
console.log(parseInt("1.73"));   //返回数字1
console.log(parseInt(".123"));   //返回值NaN

Les points dans les nombres à virgule flottante sont des caractères illégaux pour parseInt(), donc la partie décimale de la valeur n'est pas convertie.

S'il s'agit d'une chaîne numérique commençant par 0, parseInt() la traitera comme un nombre octal : convertissez-la d'abord en valeur octale, puis convertissez-la en nombre décimal et renvoyez-la.

S'il s'agit d'une chaîne numérique commençant par 0x, parseInt() la traitera comme un nombre hexadécimal : convertissez-la d'abord en valeur hexadécimale, puis convertissez-la en nombre décimal et renvoyez-la.

var d = 010;  //八进制数字字符串
var e = 0x10;  //十六进制数字字符串
console.log(parseInt(d));  //返回十进制数字8
console.log(parseInt(e));  //返回十进制数字16

parseInt() prend également en charge le mode base, qui peut convertir des chaînes numériques dans différentes bases telles que binaire, octale et hexadécimale en entiers. Le mode de base est spécifié par le deuxième paramètre de la fonction parseInt().

Exemple 1

Le code suivant convertit la chaîne de chiffres hexadécimaux "123abc" en un entier décimal.

var a = "123abc";  
console.log(parseInt(a,16));  //返回十进制整数1194684

Exemple 2

Le code suivant convertit les chaînes de chiffres binaires, octales et décimales en entiers décimaux.

console.log(parseInt("10",2));  //把二进制数字 10 转换为十进制整数，为 2
console.log(parseInt("10",8));  //把八进制数字 10 转换为十进制整数，为 8
console.log(parseInt("10",10));  //把十进制数字 10 转换为十进制整数，为 10

Exemple 3

Si le premier paramètre est une valeur décimale, incluant le préfixe 0, afin d'éviter d'être compris comme un nombre octal, le deuxième paramètre doit être spécifié La valeur du paramètre est 10, ce qui signifie que le mode de base est explicitement défini au lieu du mode de base par défaut.

console.log(parseInt("010"));  //把默认基模式数字 010 转换为十进制整数为 10
console.log(parseInt("010",8));  //把八进制数字 010 转换为十进制整数为 8
console.log(parseInt("010",10));  //把十进制数字 010 转换为十进制整数为 10

Méthode 2 : opérateurs de bits

console.log(0 | "123.45")//123
console.log(0 | 123.45)//123
console.log(0 ^ 123.45)//123
console.log(~~123.45)//123

Principe : JavaScript n'a pas de concept d'entiers et tous les types numériques sont à virgule flottante double précision des chiffres. Lors de l'utilisation d'opérateurs au niveau du bit, ils convertiront d'abord les opérandes en nombres entiers pour faciliter les opérations. Le XOR ou le OU au niveau du bit de 0 et d'autres valeurs ne modifieront pas la valeur de l'opération

Méthode 3 : Math.floor et Math.ceil

Exemple

console.log(Math.floor(2.3))//2
console.log(Math.floor(-2.3))//-3
console.log(Math.ceil(2.3))//3
console.log(Math.ceil(-2.3))//-2

Les deux sont insuffisants :

Math.floor obtient le plus petit entier du nombre tandis que Math.ceil obtient le plus grand entier. Par conséquent, si nous arrondissons -2,3, nous obtiendrons -2, mais en utilisant Math.floor, nous obtiendrons -3. Et 2.3 utilise Math.ceil pour obtenir 3, mais ce que nous voulons, c'est 2.

Solution :

//自行定义一个函数
function getInt(val){
return val>0 ? Math.floor(val):Math.ceil(val);
}

[Recommandations associées : Tutoriel d'apprentissage 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!