Réponses:
La manière la plus simple serait d'utiliser la Number
fonction 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)
'4'>>0
et '4'>>>0
.
parseInt
et parseFloat
accepte heureusement des lettres. Seulement Number
retourne NaN
régulièrement.
NaN
pour 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 2
et une Number('')
contrainte à 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 parseInt
qu'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
parseInt('0asdf', 10)
produit 0
.
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 new
devant 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 2e2
est 200
plutô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 isNaN
pour vous assurer que le nombre n'est pas NaN (généralement la seule façon de savoir que l'analyse a échoué).
97,8,00
et 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 ...
.replace(/[^0-9.]/g, "")
, sinon "1.05" deviendra "105".
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
, nous obtenons un string
(à cause de la .toFixed
méthode) au lieu d'un number
(entier). Si nous voulons l'entier arrondi, il vaut probablement mieux utiliser simplementMath.round("97.654");
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 str
est 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;
}
var x = "1000"*1;
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
parseInt
ne fonctionnerait pas correctement pour un flotteur. parseFloat
fonctionne correctement dans ce cas.
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
SyntaxError
, vous devez utiliser un double point, par exemple: 2..toInt();
le premier point mettra fin à la représentation d'un Number
littéral et le deuxième point est l'accesseur de propriété.
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 ...
+
?
parseInt
. Une implémentation courante const myNumber = +myNumberAsAString
ressemble à 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.
Essayez str - 0
de vous 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 façons de convertir une chaîne en entier
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;
}
int2str
fonction s'arrête si un octet est égal à 0, ce qui pourrait être un élément légitime dans la valeur, donc le if
... break
devrait être supprimé afin que vous obteniez une valeur complète de 4 octets retournée.
À 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
parseInteger
pas 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 null
au lieu de NaN
, si Not A Number est trompeur.
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`
var num1 = "12423"; typeof num1;
retourne string
.
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;
}
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>
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