Convertir une chaîne en un entier en JavaScript?
Comment convertir une chaîne en un entier en JavaScript?
Le moyen le plus simple serait d'utiliser la fonction native Number:
var x = Number("1000")
Si cela ne fonctionne pas pour vous, alors il existe les méthodes parseInt , unary plus , parseFloat avec floor et Math.round .
analyse:
var x = parseInt("1000", 10); // you want to use radix 10
// so you get a decimal number even with a leading 0 and an old browser ([IE8, Firefox 20, Chrome 22 and older][1])
unary plus si votre chaîne est déjà sous la forme d'un entier:
var x = +"1000";
si votre chaîne est ou pourrait être un float et que vous voulez un entier:
var x = Math.floor("1000.01"); //floor automatically converts string to number
ou, si vous allez utiliser Math.floor plusieurs fois:
var floor = Math.floor;
var x = floor("1000.01");
Si vous êtes du type qui oublie de mettre la base lorsque vous appelez parseInt, vous pouvez utiliser parseFloat et le arrondir comme bon vous semble. Ici, j'utilise le sol.
var floor = Math.floor;
var x = floor(parseFloat("1000.01"));
Fait intéressant, Math.round (comme Math.floor) effectuera une conversion chaîne en nombre, donc si vous souhaitez arrondir le nombre (ou si vous avez un entier dans la chaîne), voici un excellent moyen, peut-être mon préféré:
var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)
Essayez la fonction parseInt:
var number = parseInt("10");
Mais il y a un problème. Si vous essayez de convertir "010" en utilisant la fonction parseInt, il détecte un nombre octal et renvoie le nombre 8. Vous devez donc spécifier une base (de 2 à 36). Dans ce cas, base 10.
parseInt(string, radix)
Exemple:
var result = parseInt("010", 10) == 10; // Returns true
var result = parseInt("010") == 10; // Returns false
Notez que parseInt ignore les données incorrectes après l’analyse d’une valeur valide.
Ce guide analysera comme 51:
var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true
Il existe deux manières principales de convertir une chaîne en un nombre en javascript. L’une des méthodes consiste à l’analyser, et l’autre, à changer son type en nombre. Toutes les astuces des autres réponses (par exemple unaire plus) impliquent implicitement de forcer le type de la chaîne à un nombre. Vous pouvez également faire la même chose explicitement avec la fonction Number.
Analyse
var parsed = parseInt("97", 10);
parseInt et parseFloat sont les deux fonctions utilisées pour analyser des chaînes en nombres. L’analyse s’arrêtera en silence si elle frappe un caractère qu’elle ne reconnaît pas, ce qui peut être utile pour analyser des chaînes telles que "92px", mais c’est aussi un peu dangereux, car cela ne vous donnera pas le moindre type d’erreur sur une mauvaise entrée. Je récupérerai NaN à moins que la chaîne ne commence par un nombre. Les espaces au début de la chaîne sont ignorés. Voici un exemple montrant que vous faites quelque chose de différent de ce que vous voulez, sans rien indiquer que quelque chose a mal tourné:
var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97
C'est une bonne pratique de toujours spécifier la base comme deuxième argument. Dans les anciens navigateurs, si la chaîne commençait par 0, cela serait interprété comme octal si la base n'était pas spécifiée, ce qui a pris beaucoup de monde par surprise. Le comportement de l'hexadécimal est déclenché lorsque la chaîne commence par 0x si aucune base n'est spécifiée, par exemple. 0xff. La norme a en fait changé avec ecmascript 5, donc les navigateurs modernes ne déclenchent plus d’octal s’il ya un 0 devant si aucun radix n’a été spécifié. parseInt comprend les radix jusqu’à la base 36, auquel cas les lettres majuscules et minuscules sont traitées comme équivalentes.
Changer le type d'une chaîne en un nombre
Toutes les autres astuces mentionnées ci-dessus qui n'utilisent pas parseInt impliquent implicitement de forcer la chaîne en un nombre. Je préfère le faire explicitement,
var cast = Number("97");
Cela a un comportement différent de celui des méthodes d'analyse (même s'il ignore toujours les espaces). C'est plus strict: s'il ne comprend pas la totalité de la chaîne qu'il renvoie NaN, vous ne pouvez donc pas l'utiliser pour des chaînes telles que 97px. Puisque vous voulez un nombre primitif plutôt qu'un objet d'encapsuleur Number, veillez à ne pas placer new devant la fonction Number.
Évidemment, la conversion en nombre vous donne une valeur qui peut être un float plutôt qu'un entier. Si vous voulez un entier, vous devez le modifier. Il y a plusieurs façons de le faire:
var rounded = Math.floor(Number("97.654")); // other options are Math.ceil, Math.round
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
var bitwised = Number("97.654")|0; // do not use for large numbers
Tout opérateur au niveau des bits (ici, je l'ai fait au niveau des bits ou, mais vous pouvez également effectuer une double négation comme dans une réponse précédente ou un décalage en bits) convertira la valeur en un entier de 32 bits et la plupart d'entre eux se convertiront en un entier signé. Notez que ne voudra pas que vous vouliez des entiers de grande taille. Si le nombre entier ne peut pas être représenté sur 32 bits, il sera bouclé.
~~"3000000000.654" === -1294967296
// This is the same as
Number("3000000000.654")|0
"3000000000.654" >>> 0 === 3000000000 // unsigned right shift gives you an extra bit
"300000000000.654" >>> 0 === 3647256576 // but still fails with larger numbers
Pour travailler correctement avec des nombres plus grands, vous devez utiliser les méthodes d'arrondi.
Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))
N'oubliez pas que toutes ces méthodes comprennent la notation exponentielle. 2e2 est donc 200 plutôt que NaN. En outre, Number comprend "Infinity", contrairement aux méthodes d'analyse.
Douane
Il est peu probable que l'une ou l'autre de ces méthodes fasse exactement ce que vous voulez. Par exemple, en général, je voudrais une erreur si l'analyse échoue et je n'ai pas besoin de la prise en charge d'Infinity, des exponentielles ou des espaces. En fonction de votre cas d'utilisation, il est parfois utile d'écrire une fonction de conversion personnalisée.
Vérifiez toujours que le résultat de Number ou l’une des méthodes d’analyse correspond au type de nombre que vous attendez. Vous voudrez presque certainement utiliser isNaN pour vous assurer que le nombre n'est pas NaN (généralement le seul moyen de savoir que l'analyse a échoué).
ParseInt () et + sont différents
parseInt("10.3456") // returns 10
+"10.3456" // returns 10.3456
Bien que vieille question, mais peut-être que cela peut être utile à quelqu'un.
J'utilise cette façon de convertir une chaîne en int nombre
var str = "25"; // string
var number = str*1; // number
Ainsi, lors de la multiplication par 1, la valeur ne change pas, mais js renvoie automatiquement un nombre.
Mais comme indiqué ci-dessous, utilisez-le si vous êtes sûr que la variable str est un nombre (ou peut être représentée sous la forme d'un nombre), sinon elle retournera NaN - pas un nombre.
vous pouvez créer une fonction simple à utiliser, par exemple.
function toNumber(str) {
return str*1;
}
Essayez parseInt.
var number = parseInt("10", 10); //number will have value of 10.
J'ai posté la mauvaise réponse ici, désolé. fixé.
C'est une vieille question, mais j'adore cette astuce:
~~"2.123"; //2
~~"5"; //5
Le double négatif au niveau des bits supprime tout ce qui suit le point décimal ET le convertit au format numérique. On m'a dit que c'était un peu plus rapide que d'appeler des fonctions ou autres, mais je ne suis pas entièrement convaincu.
EDIT: Une autre méthode que je viens de voir here (une question sur l’opérateur javascript >>>, qui correspond à un décalage à zéro du remplissage à droite) indique que le fait de décaler un nombre de 0 avec cet opérateur convertit le nombre en uint32, ce qui est bien si vous le souhaitez également unsigned. Encore une fois, cela se convertit en un entier unsigned, ce qui peut entraîner des comportements étranges si vous utilisez un nombre signé.
"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5
Le plus rapide
var x = "1000"*1;
Tester
Voici une petite comparaison de vitesse (Mac Os uniquement) ... :)
Pour le chrome, "plus" et "mul" sont les plus rapides (> 700 000,00 op/s), "Math.floor" est le plus lent. Pour Firefox, "plus" est le plus lent (!) "Mul" est le plus rapide (> 900 000 000 op/s). Dans Safari, "parseInt" signifie "vite", "nombre" est le plus lent (mais les résultats sont assez similaires,> 13 000 000 <31 000 000). Donc, Safari pour la chaîne de caractères vers int est plus de 10 fois plus lent que les autres navigateurs. Donc, le gagnant est 'mul' :)
Vous pouvez le lancer sur votre navigateur en suivant ce lien https://jsperf.com/casttonumber
Mettre à jour
Je teste également var x = ~~"1000"; - sur Chrome et Safari est un peu plus lent que var x = "1000"*1 (<1%), sur Firefox est un peu plus rapide (<1%).
Faites attention si vous utilisez parseInt pour convertir un float en notation scientifique! Par exemple:
parseInt("5.6e-14")
aura pour résultat
5
au lieu de
0
Également en note de bas de page: Mootools a la fonction toInt () qui est utilisée sur toute chaîne native (ou float (ou entier)).
"2".toInt() // 2
"2px".toInt() // 2
2.toInt() // 2
S'il vous plaît voir l'exemple ci-dessous.Il aidera à effacer votre doute
Example Result
parseInt("4") 4
parseInt("5aaa") 5
parseInt("4.33333") 4
parseInt("aaa"); NaN (means "Not a Number")
en utilisant la fonction parseint Elle ne donnera que l'op de l'entier présent et non la chaîne
Pour convertir une chaîne en Integer, je vous recommande d’utiliser parseFloat etNOTparseInt. Voici pourquoi:
Utilisation de parseFloat:
parseFloat('2.34cms') //Output: 2.34
parseFloat('12.5') //Output: 12.5
parseFloat('012.3') //Output: 12.3
Utilisation de parseInt:
parseInt('2.34cms') //Output: 2
parseInt('12.5') //Output: 12
parseInt('012.3') //Output: 12
Donc, si vous avez remarqué que parseInt ignore les valeurs après les décimales, alors que parseFloat vous permet de travailler avec des nombres à virgule flottante et est donc plus approprié si vous souhaitez conserver les valeurs après les décimales. Utilisez parseInt si et seulement si vous êtes sûr de vouloir la valeur entière.
nous pouvons utiliser +(stringOfNumber) au lieu d'utiliser parseInt(stringOfNumber)
Ex: +("21") renvoie un entier int de 21 comme le parseInt("21").
nous pouvons aussi utiliser cet opérateur "+" unaire pour analyser float ...
Essayez str - 0 pour convertir string en number.
> str = '0'
> str - 0
0
> str = '123'
> str - 0
123
> str = '-12'
> str - 0
-12
> str = 'asdf'
> str - 0
NaN
> str = '12.34'
> str - 0
12.34
Voici deux liens pour comparer les performances de plusieurs manières de convertir une chaîne en int
Il existe plusieurs façons en JavaScript de convertir une chaîne en valeur numérique ... Tout simple et pratique, choisissez la méthode qui vous convient:
var num = Number("999.5"); //999.5
var num = parseInt("999.5", 10); //999
var num = parseFloat("999.5"); //999.5
var num = +"999.5"; //999.5
Aussi toute opération Math les convertit en nombre, par exemple ...
var num = "999.5" / 1; //999.5
var num = "999.5" * 1; //999.5
var num = "999.5" - 1 + 1; //999.5
var num = "999.5" - 0; //999.5
var num = Math.floor("999.5"); //999
var num = ~~"999.5"; //999
Je préfère utiliser le signe +, qui est le moyen élégant de convertir une chaîne en nombre en JavaScript.
Google m'a donné cette réponse comme résultat, alors ...
En fait, j'avais besoin de "sauvegarder" une chaîne sous forme d'entier, pour une liaison entre C et JavaScript, aussi je convertis la chaîne en valeur entière
/*
Examples:
int2str( str2int("test") ) == "test" // true
int2str( str2int("t€st") ) // "t¬st", because "€".charCodeAt(0) is 8364, will be AND'ed with 0xff
Limitations:
max 4 chars, so it fits into an integer
*/
function str2int(the_str) {
var ret = 0;
var len = the_str.length;
if (len >= 1) ret += (the_str.charCodeAt(0) & 0xff) << 0;
if (len >= 2) ret += (the_str.charCodeAt(1) & 0xff) << 8;
if (len >= 3) ret += (the_str.charCodeAt(2) & 0xff) << 16;
if (len >= 4) ret += (the_str.charCodeAt(3) & 0xff) << 24;
return ret;
}
function int2str(the_int) {
var tmp = [
(the_int & 0x000000ff) >> 0,
(the_int & 0x0000ff00) >> 8,
(the_int & 0x00ff0000) >> 16,
(the_int & 0xff000000) >> 24
];
var ret = "";
for (var i=0; i<4; i++) {
if (tmp[i] == 0)
break;
ret += String.fromCharCode(tmp[i]);
}
return ret;
}
À mon avis, aucune réponse ne couvre tous les cas Edge, car l'analyse d'un float devrait entraîner une erreur.
function parseInteger(value) {
if(value === '') return NaN;
const number = Number(value);
return Number.isInteger(number) ? number : NaN;
}
parseInteger("4") // 4
parseInteger("5aaa") // NaN
parseInteger("4.33333") // NaN
parseInteger("aaa"); // NaN
toutes les réponses sont bonnes. Assurez-vous avant que ceci soit un nombre dans une chaîne en faisant "typeot x === 'nombre'", sinon vous retournerez NaN
var num = "fsdfsdf242342";
typeof num => 'string';
var num1 = "12423";
typeof num1 => 'number';
+num1 = > 12423`
Une autre option consiste à doubler XOR la valeur avec elle-même:
var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));
Cela produira:
i = 12.34
i ⊕ i ⊕ i = 12
Voici la solution la plus simple
let myNumber = "123" | 0;
Le moyen le plus sûr de vous assurer d'obtenir un entier valide:
let integer = (parseInt(value, 10) || 0);
Exemples:
// Example 1 - Invalid value:
let value = null;
let integer = (parseInt(value, 10) || 0);
// => integer = 0
// Example 2 - Valid value:
let value = "1230.42";
let integer = (parseInt(value, 10) || 0);
// => integer = 1230
// Example 3 - Invalid value:
let value = () => { return 412 };
let integer = (parseInt(value, 10) || 0);
// => integer = 0
function doSth(){
var a = document.getElementById('input').value;
document.getElementById('number').innerHTML = toNumber(a) + 1;
}
function toNumber(str){
return +str;
}<input id="input" type="text">
<input onclick="doSth()" type="submit">
<span id="number"></span>J'ai seulement ajouté un plus (+) avant string et c'était la solution!
+"052254" //52254
J'espère que ça aide ;)
function parseIntSmarter(str) {
// ParseInt is bad because it returns 22 for "22thisendsintext"
// Number() is returns NaN if it ends in non-numbers, but it returns 0 for empty or whitespace strings.
return isNaN(Number(str)) ? NaN : parseInt(str, 10);
}
Résumer la multiplication des chiffres avec leur puissance respective de dix:
c'est-à-dire: 123 = 100 + 20 + 3 = 1 * 100 + 2 + 10 + 3 * 1 = 1 * (10 ^ 2) + 2 * (10 ^ 1) + 3 * (10 ^ 0)
function atoi(array) {
// use exp as (length - i), other option would be to reverse the array.
// multiply a[i] * 10^(exp) and sum
let sum = 0;
for (let i = 0; i < array.length; i++) {
let exp = array.length-(i+1);
let value = array[i] * Math.pow(10,exp);
sum+=value;
}
return sum;
}
Je l'utilise
String.prototype.toInt = function (returnval) {
var i = parseInt(this);
return isNaN(i) ? returnval !== undefined ? returnval : - 1 : i;
}
de cette façon, je reçois toujours un int.