Comment convertir une chaîne en entier en JavaScript?

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)

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

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

ParseInt () et + sont différents

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

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

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

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

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

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

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.

É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

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

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

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

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.

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

À 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

Voici la solution la plus simple

let myNumber = "123" | 0;

Solution plus simple

let myNumber = +"123";

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`

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

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

+"052254" //52254

J'espère que cela aide ;)

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;

}

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.

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

vous pouvez utiliser plus, par exemple =>

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

alors vous pouvez voir le type de personne