Comment convertir une chaîne en entier en JavaScript?


Réponses:


2154

La manière la plus simple serait d'utiliser la Numberfonction native :

var x = Number("1000")

Si cela ne fonctionne pas pour vous, il existe les méthodes parseInt , unary plus , parseFloat with floor et Math.round .

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])

unaire 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 flottant et que vous voulez un entier:

var x = Math.floor("1000.01"); //floor automatically converts string to number

ou, si vous utilisez plusieurs fois Math.floor:

var floor = Math.floor;
var x = floor("1000.01");

Si vous êtes le type qui oublie de mettre la radix lorsque vous appelez parseInt, vous pouvez utiliser parseFloat et l'arrondir comme vous le souhaitez. Ici, j'utilise le sol.

var floor = Math.floor;
var x = floor(parseFloat("1000.01"));

Fait intéressant, Math.round (comme Math.floor) fera une conversion de chaîne en nombre, donc si vous voulez que le nombre soit arrondi (ou si vous avez un 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)

1
jsperf.com/performance-of-parseint/29 , hy @jedierikb j'ai été éditer le lien jsperf. Ajout '4'>>0et '4'>>>0.
emaniacs

6
Mise à jour vers 2015: à partir d'ECMAScript 5, les chaînes avec un zéro de début "0" obtiennent également le radix 10 par défaut, au lieu de 8. La spécification explicite du radix 10 n'est nécessaire que pour les navigateurs plus anciens. kangax.github.io/compat-table/es5/…
Grilse

20
Notez que Number ('') réussit (retourne 0), même si la plupart des gens ne considèrent pas la chaîne vide comme représentant un nombre valide. Et parseInt ('3q') réussit (retourne 3) même si la plupart des gens ne considéreraient pas '3q' comme un nombre valide.
Dave Pacheco

3
La tête haute. Les deux parseIntet parseFloataccepte heureusement des lettres. Seulement Numberretourne NaNrégulièrement.
Karl Pokus

2
À mon avis, l'analyse d'un entier devrait résulter avec exception / NaNpour chaque valeur qui n'est pas exactement un entier. Par conséquent, aucun de ces éléments ne fonctionne comme une Number('2.2')contrainte 2et une Number('')contrainte à 0.
Michał Knapik

225

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 comme nombre octal et renverra le numéro 8. Donc, vous devez spécifier un radix (de 2 à 36). Dans ce cas, la base 10.

parseInt(string, radix)

Exemple:

var result = parseInt("010", 10) == 10; // Returns true

var result = parseInt("010") == 10; // Returns false

Notez parseIntqu'ignore les mauvaises données après avoir analysé tout ce qui est valide.
Ce guide analysera 51:

var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true

4
Radix n'est plus requis en 2016.

7
Ce n'est peut-être pas pour les navigateurs plus récents, mais radix est toujours requis pour la compatibilité descendante.
Professeur de programmation

Qu'en est-il de '', ou '02 "ou" 02 + 1 ", ou" 03,12 "ou" 03.12 "?
stackdave

3
Notez que cela ignore les mauvaises données après le numéro. Par exemple, parseInt('0asdf', 10)produit 0.
Sam

121

Il existe deux façons principales de convertir une chaîne en nombre en javascript. Une façon consiste à l'analyser et l'autre consiste à changer son type en nombre. Toutes les astuces des autres réponses (par exemple, unaire plus) impliquent de contraindre implicitement 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 les chaînes en nombres. L'analyse s'arrêtera silencieusement si elle frappe un caractère qu'il ne reconnaît pas, ce qui peut être utile pour analyser des chaînes comme "92px", mais c'est aussi quelque peu dangereux, car il ne vous donnera aucune sorte d'erreur sur une mauvaise entrée, à la place vous récupérera 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 qu'il fait quelque chose de différent de ce que vous voulez et ne donne aucune indication que quelque chose s'est mal passé:

var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97

Il est recommandé de toujours spécifier le radix comme deuxième argument. Dans les navigateurs plus anciens, si la chaîne commençait par un 0, elle serait interprétée comme octale si le radix n'était pas spécifié, ce qui prenait beaucoup de monde par surprise. Le comportement pour hexadécimal est déclenché en faisant commencer la chaîne par 0x si aucun radix n'est spécifié, par exemple 0xff. La norme a en fait changé avec ecmascript 5, donc les navigateurs modernes ne déclenchent plus d'octal quand il y a un 0 en tête si aucun radix n'a été spécifié. parseInt comprend les radix jusqu'à la base 36, auquel cas les majuscules et les minuscules sont traitées comme équivalentes.

Changer le type d'une chaîne en nombre

Toutes les autres astuces mentionnées ci-dessus qui n'utilisent pas parseInt impliquent de forcer implicitement la chaîne en un nombre. Je préfère le faire explicitement,

var cast = Number("97");

Cela a un comportement différent des méthodes d'analyse (bien qu'il ignore toujours les espaces blancs). C'est plus strict: s'il ne comprend pas la totalité de la chaîne qu'il ne retourne NaN, vous ne pouvez donc pas l'utiliser pour des chaînes comme 97px. Puisque vous voulez un nombre primitif plutôt qu'un objet wrapper Number, assurez-vous de ne pas le placer newdevant la fonction Number.

Évidemment, la conversion en un nombre vous donne une valeur qui peut être un flottant plutôt qu'un entier, donc si vous voulez un entier, vous devez le modifier. Il existe plusieurs façons de procéder:

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 du bit (ici, j'ai fait un bitwise ou, mais vous pouvez également faire une double négation comme dans une réponse précédente ou un décalage de bits) convertira la valeur en un entier 32 bits, et la plupart d'entre eux se convertiront en un entier signé. Notez que cela ne vous donnera pas envie de gros nombres entiers . Si l'entier ne peut pas être représenté en 32 bits, il sera encapsulé.

~~"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 importants, vous devez utiliser les méthodes d'arrondi

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 2e2est 200plutôt que NaN. De plus, Number comprend "Infinity", contrairement aux méthodes d'analyse.

Douane

Il est peu probable que l'une de ces méthodes fasse exactement ce que vous voulez. Par exemple, je voudrais généralement qu'une erreur soit renvoyée si l'analyse échoue, et je n'ai pas besoin de la prise en charge d'Infinity, des exponentielles ou des espaces blancs de tête. Selon votre cas d'utilisation, il est parfois judicieux d'écrire une fonction de conversion personnalisée.

Vérifiez toujours que la sortie de Number ou l'une des méthodes d'analyse est le type de nombre que vous attendez. Vous voudrez certainement utiliser isNaNpour vous assurer que le nombre n'est pas NaN (généralement la seule façon de savoir que l'analyse a échoué).


6
Cela dépend si vous voulez que votre code accepte également 97,8,00et similaire ou non. Une astuce simple consiste à faire un .replace(/[^0-9]/g, "")qui supprimera tous les non chiffres de votre chaîne, puis effectuera la conversion par la suite. Bien sûr, cela ignorera toutes sortes de chaînes folles sur lesquelles vous devriez probablement faire une erreur plutôt que de simplement analyser ...
kybernetikos

6
@kybernetikos devrait probablement l'être .replace(/[^0-9.]/g, ""), sinon "1.05" deviendra "105".
J.Steve

Bien sûr, même si je n'utiliserais pas quelque chose comme ça pour du code important de toute façon - il y a tellement de façons qu'il peut laisser passer quelque chose que vous ne voulez vraiment pas laisser passer.
kybernetikos

2
J'ai trouvé l'utilisation de Number beaucoup plus lisible dans le code, alors merci de l'avoir indiqué comme solution.
carlin.scott

1
@kybernetikos Dans var fixed = Number("97.654").toFixed(0); // rounded rather than truncated, nous obtenons un string(à cause de la .toFixedméthode) au lieu d'un number(entier). Si nous voulons l'entier arrondi, il vaut probablement mieux utiliser simplementMath.round("97.654");
Edu Zamora

50

ParseInt () et + sont différents

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

36

C'est une vieille question, mais cela peut être utile à quelqu'un.

J'utilise cette façon de convertir la chaîne en nombre entier

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, cela devrait être utilisé si vous êtes sûr que le strest un nombre (ou peut être représenté comme un nombre), sinon il renverra NaN - pas un nombre.

vous pouvez créer une fonction simple à utiliser, par exemple

function toNumber(str) {
   return str*1;
}

entrez la description de l'image ici


36

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 / sec), «Math.floor» est le plus lent. Pour Firefox, «plus» est le plus lent (!) «Mul» est le plus rapide (> 900 000 000 op / sec). Dans Safari, "parseInt" est des jeûnes, "nombre" est le plus lent (mais les résultats sont assez similaires,> 13 000 000 <31 000 000). Donc, Safari pour la chaîne cast en int est plus de 10 fois plus lent que les autres navigateurs. Le gagnant est donc ' mul ' :)

Vous pouvez l'exécuter sur votre navigateur par ce lien https://jsperf.com/js-cast-str-to-number/1

entrez la description de l'image ici

Mise à 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%). Je mets à jour l'image ci-dessus et teste


Il n'y a pas de différence significative entre les résultats des tests A, B, E et F - ils sont tous essentiellement les mêmes,
Alf Eaton

33

Essayez parseInt.

var number = parseInt("10", 10); //number will have value of 10.

4
Vous voudrez probablement aussi inclure le radix avec cela: var number = parseInt ("10", 10);
Joel Coehoorn

27

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 du bit supprime tout ce qui suit le séparateur décimal ET le convertit en un format numérique. On m'a dit que c'est un peu plus rapide que d'appeler des fonctions et ainsi de suite, mais je ne suis pas entièrement convaincu.

EDIT: Une autre méthode que je viens de voir ici (une question sur l'opérateur javascript >>>, qui est un décalage vers la droite de remplissage nul) qui montre que le décalage d'un nombre de 0 avec cet opérateur convertit le nombre en uint32, ce qui est bien si vous veulent également qu'il ne soit pas signé . Encore une fois, cela se convertit 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

19

Attention si vous utilisez parseInt pour convertir un flotteur en notation scientifique! Par exemple:

parseInt("5.6e-14") 

aura pour résultat

5 

au lieu de

0

14
L'utilisation parseIntne fonctionnerait pas correctement pour un flotteur. parseFloatfonctionne correctement dans ce cas.
benekastah

16

Pour convertir une chaîne en entier, je recommande d'utiliser parseFloat et NOT parseInt. 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 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 les décimales. Utilisez parseInt si et seulement si vous êtes sûr de vouloir la valeur entière.


6
La question était "Comment convertir une chaîne en entier en javascript"
Pierre Arlaud

15

Également comme remarque: Mootools a la fonction toInt () qui est utilisée sur n'importe quelle chaîne native (ou float (ou entier)).

"2".toInt()   // 2
"2px".toInt() // 2
2.toInt()     // 2

7
Le troisième exemple provoque un SyntaxError, vous devez utiliser un double point, par exemple: 2..toInt();le premier point mettra fin à la représentation d'un Numberlittéral et le deuxième point est l'accesseur de propriété.
CMS

2
cette question ne concerne pas les mootools, elle concerne JavaScript.
Liam

14

Veuillez voir l'exemple ci-dessous qui vous aidera à lever 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 Il ne donnera que l'op du nombre entier présent et non la chaîne


12

nous pouvons utiliser +(stringOfNumber)au lieu d'utiliserparseInt(stringOfNumber)

Ex: +("21")retourne un entier de 21 comme le parseInt("21").

nous pouvons aussi utiliser cet opérateur unaire "+" pour analyser float ...


1
Mais vous ne pouvez pas l'utiliser dans des formules! C'est-à-dire (1 + ("21")) * 10 === 1210!
Alexander Vasilyev du

2
@AlexanderVasilyev Je pense que vous le pouvez, n'utilisez-vous pas simplement une parenthèse supplémentaire autour du +?
NiCk Newman

@NiCkNewman Je reçois + ("21") de l'exemple dans la réponse que nous commentons.
Alexander Vasilyev

Je n'aime vraiment pas cette solution. Ce n'est pas explicite commeparseInt . Une implémentation courante const myNumber = +myNumberAsAStringressemble à un standard +=ou à un =+opérateur à première vue. En outre, s'il est utilisé de manière incorrecte, il peut entraîner des erreurs de concaténation. Cette solution est basée sur le fait que 0 est considéré comme le côté gauche quand aucun nombre n'est fourni.
Storm Muller

10

Essayez str - 0de vous convertir stringen 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 une chaîne en entier

https://jsperf.com/number-vs-parseint-vs-plus

http://phrogz.net/js/string_to_number.html


1
@AlexanderYau, par ce document , le '1'sera converti en 1par ToNumber, 1 - 0serait alors1
zangw

10

Il existe de nombreuses façons en JavaScript de convertir une chaîne en une valeur numérique ... Tout simple et pratique, 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 tous les mathématiques opération les convertit également 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

Ma façon préférée utilise le +signe, qui est la manière élégante de convertir une chaîne en nombre en JavaScript.


8

Google m'a donné cette réponse comme résultat, alors ...

J'avais en fait besoin de "sauvegarder" une chaîne sous forme d'entier, pour une liaison entre C et JavaScript, donc je convertis 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;
}

4
C'est une façon intéressante de stocker et de récupérer des valeurs sur 4 octets. Il ne répond pas à l'interprétation conventionnelle de la question: comment convertir une représentation sous forme de chaîne d'un nombre en une valeur entière. Quoi qu'il en soit, votre int2strfonction s'arrête si un octet est égal à 0, ce qui pourrait être un élément légitime dans la valeur, donc le if... breakdevrait être supprimé afin que vous obteniez une valeur complète de 4 octets retournée.
Suncat2000

8

À mon avis, aucune réponse ne couvre tous les cas marginaux car l'analyse d'un flottant 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

1
Renvoyer Not A Number est un peu agressif pour un flotteur, vous ne pensez pas?
Thomas Ayoub

2
Ce n'est parseIntegerpas le cas parseNumber. Je suppose que toutes les solutions sont une solution de contournement puisque JS ne prend pas en charge les entiers et les flottants en tant que types distincts. Nous pourrions revenir nullau lieu de NaN, si Not A Number est trompeur.
Michał Knapik

4

Voici la solution la plus simple

let myNumber = "123" | 0;

Solution plus simple

let myNumber = +"123";

2

Toutes les réponses sont bonnes. Veuillez vous assurer avant que ce soit un nombre dans une chaîne en faisant "typeot x === 'nombre'" sinon il renverra NaN

 var num = "fsdfsdf242342";
 typeof num => 'string';

 var num1 = "12423";
 typeof num1 => 'number';
 +num1 = > 12423`

Dans le nœud v8.5.0, var num1 = "12423"; typeof num1;retourne string.
Edu Zamora

2

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

2

Je n'ai ajouté qu'un plus (+) avant la chaîne et c'était la solution!

+"052254" //52254

J'espère que cela aide ;)


2

Additionnant la multiplication des chiffres avec leur puissance respective de dix:

soit: 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;

}


1

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>


1

J'utilise ceci

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.


1

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

1
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);
}

0

vous pouvez utiliser plus, par exemple =>

var personAge = '24'; var personAge1 = (+ personAge)

alors vous pouvez voir le type de personne

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.