Convertir une chaîne en entier?
https://stackoverflow.com/questions/1133770
-
16-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Comment puis-je convertir une chaîne à un nombre entier en JavaScript?
La solution
La façon la plus simple serait d'utiliser la fonction native Number:
var x = Number("1000")
Si cela ne fonctionne pas pour vous, alors il y a parseInt , unaire , parseFloat avec plancher et Math.round méthodes.
parseInt:
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])
plus unaire si votre chaîne est déjà sous la forme d'un entier:
var x = +"1000";
si votre chaîne est ou peut-être un flotteur 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 le type qui oublie de mettre le radix lorsque vous appelez parseInt, vous pouvez utiliser parseFloat et autour d'elle comme bon vous semble. J'utilise ici étage.
var floor = Math.floor;
var x = floor(parseFloat("1000.01"));
Il est intéressant de Math.round (comme Math.floor) fera une chaîne à la conversion numérique, donc si vous voulez que le nombre arrondi (ou si vous avez un nombre entier dans la chaîne), c'est un excellent moyen, peut-être mon préféré :
var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)
Autres conseils
Fonction Essayez 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 que le nombre octal, et nombre de retour 8. Donc, vous devez spécifier un radix (de 2 à 36). Dans cette base de cas 10.
parseInt(string, radix)
Exemple:
var result = parseInt("010", 10) == 10; // Returns true
var result = parseInt("010") == 10; // Returns false
Notez que parseInt ne tient pas compte des données incorrectes après analyse quoi que ce soit valide.
Cette guid analysera 51:
var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true
Il existe deux façons de convertir une chaîne en nombre en javascript. La première consiste à analyser et l'autre est de changer le type d'un numéro. Toutes les astuces des autres réponses (par exemple de plus unaire) impliquent implicitement le type forçant de la chaîne à un certain nombre. Vous pouvez également faire la même chose explicitement avec la fonction Number.
Parsing
var parsed = parseInt("97", 10);
parseInt et parseFloat sont les deux fonctions utilisées pour l'analyse syntaxique des chaînes en nombres. Parsing s'arrêtera silencieusement si elle frappe un personnage qu'il ne reconnaît pas, ce qui peut être utile pour analyser des chaînes comme « 92px », mais il est aussi un peu dangereux, car il ne vous donnera aucune sorte d'erreur sur l'entrée mauvaise, au lieu que vous « ll retournons NaN à moins que la chaîne commence par un numéro. Blancs au début de la chaîne est ignorée. Voici un exemple de ce faire quelque chose de différent de ce que vous voulez, et donner aucune indication que quelque chose allait mal:
var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97
Il est bon de préciser toujours le radix comme second argument. Dans les anciens navigateurs, si la chaîne a commencé avec un 0, il serait interprété comme octal si le radix n'a pas été spécifié qui a pris beaucoup de gens par surprise. si aucun radix est spécifié pour le comportement hexadécimal est déclenché en ayant la chaîne commence par 0x, par exemple, 0xff. si aucun radix n'a été spécifiée La norme effectivement changé avec ECMAScript 5, pas de navigateurs modernes afin de déclencher plus octal quand il y a un 0. parseInt comprend grandes bases jusqu'à base 36, auquel cas les deux lettres majuscules et minuscules sont considérées comme équivalentes.
Modification du type d'une chaîne à un numéro
Toutes les autres trucs mentionnés ci-dessus qui n'utilisent pas parseInt, font intervenir implicitement la chaîne contraindre en nombre. Je préfère le faire explicitement,
var cast = Number("97");
a un comportement différent des méthodes d'analyse grammaticale (même si elle ne tient pas compte encore des espaces). Il est plus stricte: si elle ne comprend pas l'ensemble de la chaîne qu'il retourne NaN, donc vous ne pouvez pas l'utiliser pour des chaînes comme 97px. Puisque vous voulez un nombre primitif plutôt que d'un numéro objet d'emballage, assurez-vous que vous ne mettez pas new en face de la fonction Number.
De toute évidence, la conversion à un numéro vous donne une valeur qui pourrait être un flotteur plutôt que d'un nombre entier, donc si vous voulez un entier, vous avez besoin de le modifier. Il y a quelques 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 de bits (ici, je l'ai fait Bitwise ou, mais vous pouvez aussi faire double négation comme dans une réponse précédente ou bitshift) convertit la valeur à un nombre entier de 32 bits, et la plupart d'entre eux sera converti en un signé entier. Notez que ce ne voulez-vous voulez pour les grands entiers . Si l'entier ne peut pas être représenté dans 32bits, il se terminera.
~~"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 fonctionner correctement avec un plus grand nombre, vous devez utiliser les méthodes d'arrondissement
Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))
Gardez à l'esprit que toutes ces méthodes comprennent la notation exponentielle, donc 2e2 est 200 plutôt que NaN. En outre, numéro comprend « Infinity », alors que les méthodes d'analyse grammaticale ne le font pas.
Personnaliser
Il est peu probable que l'une de ces méthodes font exactement ce que vous voulez. Par exemple, en général, je veux une erreur levée si l'analyse syntaxique échoue, et je ne suis pas besoin d'un soutien pour Infinity, exponentielles ou menant des espaces. En fonction de votre usecase, parfois il est logique d'écrire une fonction de conversion personnalisée.
Il faut toujours vérifier que la sortie du numéro ou l'une des méthodes d'analyse est le genre de numéro que vous attendez. Vous voulez certainement d'utiliser isNaN pour vous assurer que le numéro est NaN (généralement la seule façon que vous trouvez que l'parse failed).
parseInt () et + sont différents
parseInt("10.3456") // returns 10
+"10.3456" // returns 10.3456
Bien une vieille question, mais peut-être cela peut être utile à quelqu'un.
J'utilise cette façon de convertir en chaîne 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 retourne automatiquement un numéro.
Mais comme il est indiqué ci-dessous, cela devrait être utilisé si vous êtes sûr que le str est un numéro (ou peut être représenté comme un nombre), sinon elle retournera NAN - pas un nombre
vous pouvez créer la fonction simple à utiliser, par exemple.
function toNumber(str) {
return str*1;
}
Essayez parseInt.
var number = parseInt("10", 10); //number will have value of 10.
le plus rapide
var x = "1000"*1;
test
Voici peu comparaison de la vitesse (Mac OS uniquement) ...:)
Pour chrome 'plus' et 'mul' sont les plus rapides (> 700,000,00 op / sec), 'Math.floor' est plus lent. Pour Firefox 'plus' est le plus lent (!) 'Mul' est le plus rapide (> 900.000.000 op / s). Dans « parseInt » Safari est Fastes, « numéro » est le plus lent (mais resulats sont assez similaires,> 13000000 <31000000). Donc Safari pour une chaîne de coulée à int est plus de 10 fois plus lent que les autres navigateurs. Ainsi, le gagnant est ' mul :)
Vous pouvez l'exécuter sur votre navigateur par ce lien https://jsperf.com/js-cast-str-to-number/ 1
Mise à jour
Je également tester var x = ~~"1000"; - sur Chrome et Safari est un peu plus lent que var x = "1000"*1 (<1%), Firefox est un peu plus rapide (<1%). Mettre à jour l'image ci-dessus et test
J'ai posté la mauvaise réponse ici, désolé. fixe.
Ceci est une vieille question, mais j'aime cette astuce:
~~"2.123"; //2
~~"5"; //5
La double négation tombe quoi que ce soit au niveau du bit après la virgule et le convertit en un format numérique. On m'a dit qu'il est un peu plus rapide que d'appeler des fonctions et ainsi de suite, mais je ne suis pas tout à fait convaincu.
EDIT: Une autre méthode que je viens de voir ici (une question sur le javascript >>> opérateur, qui est un remplissage zéro décalage vers la droite) qui montre que le déplacement d'un nombre par 0 avec cet opérateur convertit le nombre uint32 qui est bien si vous voulez aussi non signé . Encore une fois, cela se transforme en un entier non signé , ce qui peut conduire à des comportements étranges si vous utilisez un numéro signé.
"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5
Attention si vous utilisez parseInt pour convertir un flotteur en notation scientifique! Par exemple:
parseInt("5.6e-14")
entraînera
5
au lieu de
0
Aussi comme une note de côté. Mootools a la fonction toInt () qui est utilisé sur une chaîne native (ou flotteur (ou entier))
"2".toInt() // 2
"2px".toInt() // 2
2.toInt() // 2
Pour convertir une chaîne en entier, je recommande d'utiliser parseFloat et pas parseInt. Voici pourquoi:
Utilisation parseFloat:
parseFloat('2.34cms') //Output: 2.34
parseFloat('12.5') //Output: 12.5
parseFloat('012.3') //Output: 12.3
Utilisation parseInt:
parseInt('2.34cms') //Output: 2
parseInt('12.5') //Output: 12
parseInt('012.3') //Output: 12
Donc, si vous avez remarqué parseInt supprime les valeurs après les décimales, alors que parseFloat vous permet de travailler avec des nombres à virgule flottante et donc plus approprié si vous souhaitez conserver les valeurs après décimales. Utilisez parseInt si et seulement si vous êtes sûr que vous voulez que la valeur entière.
S'il vous plaît voir ci-dessous le example.It aidera à éclaircir vos doutes
Example Result
parseInt("4") 4
parseInt("5aaa") 5
parseInt("4.33333") 4
parseInt("aaa"); NaN (means "Not a Number")
en utilisant la fonction parseInt Il ne donnera op d'entier présent et non la chaîne
nous pouvons utiliser +(stringOfNumber) au lieu d'utiliser parseInt(stringOfNumber)
Ex.: +("21") retourne int 21 comme le parseInt("21")
nous pouvons utiliser ce unaire opérateur « + » pour l'analyse syntaxique trop flottant ...
Essayez str - 0 convertir string à 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 façons de convertir la chaîne en int
Il y a plusieurs façons de JavaScript pour convertir une chaîne en valeur numérique ... Tout simple et à portée de main, choisissez la façon dont on travaille pour vous:
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 une Math opération 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
Mon préfère chemin utilise signe +, qui est la façon élégante pour convertir une chaîne au numéro en JavaScript.
À mon avis, aucune réponse couvre tous les cas de pointe comme l'analyse d'un flotteur devrait se traduire par 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
Google m'a donné cette réponse comme résultat, alors ...
En fait, je avais besoin de « sauver » une chaîne comme un entier, pour une liaison entre C et JavaScript, donc je convertir la chaîne en une 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;
}
tous ci-dessus sont corrects. S'il vous plaît assurez-vous avant que ce soit un numéro dans une chaîne en faisant « typeot x === « nombre » » autre sage il renverra NaN
var num = "fsdfsdf242342";
typeof num => 'string';
var num1 = "12423";
typeof num1 => 'number';
+num1 = > 12423`
Une autre option consiste à doubler la valeur XOR avec lui-même:
var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));
Affichera:
i = 12.34
i ⊕ i ⊕ i = 12
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'utilise cette
String.prototype.toInt = function (returnval) {
var i = parseInt(this);
return isNaN(i) ? returnval !== undefined ? returnval : - 1 : i;
}
Ainsi je reçois toujours un int retour.
Je n'ajouté un plus (+) avant chaîne et c'est la solution!
+"052254" //52254
it helps;)
Résumant la multiplication des chiffres avec leur puissance respective de dix:
ex: 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;
}
Voici la solution la plus simple
let myNumber = "123" | 0;
La meilleure façon de vous assurer d'obtenir un nombre 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 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);
}
