web-dev-qa-db-fra.com

Convertir une chaîne en un entier en JavaScript?

Comment convertir une chaîne en un entier en JavaScript?

1467

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)
1884
Nosredna

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
201
Zanoni

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é).

115
kybernetikos

ParseInt () et + sont différents

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456
50
Dalius I

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

enter image description here

34
dav

Essayez parseInt.

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

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
26
Ian Ooi

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

 enter image description here

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%).

26
Kamil Kiełczewski

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
18
tom

É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
15
Henrik Hansen

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

14
zeeshan

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.

14
Devner

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 ...

12

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

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

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

10
zangw

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.

8
Alireza

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;
}
7
lama12345

À 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
6
Michał Knapik

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`
1

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
1
BanksySan

Voici la solution la plus simple

let myNumber = "123" | 0;
0
Thanveer Shah

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
0
Ofir

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>

0
Majid Nayyeri

J'ai seulement ajouté un plus (+) avant string et c'était la solution!

+"052254" //52254

J'espère que ça aide ;)

0
ivahidmontazer
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
mhenry1384

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;

}

0

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.

0
Mike