N'importe quel nombre, c'est un numéro. La chaîne ressemble à un nombre, c'est un nombre. Tout le reste, ça passe NaN.

'a' => NaN
'1' => 1
1 => 1

Autant que je sache, il y a 4 façons de le faire.

Number(x);
parseInt(x, 10);
parseFloat(x);
+x;

Par ce test rapide que j'ai fait, cela dépend en fait des navigateurs.

http://jsperf.com/best-of-string-to-number-conversion/2

Implicit marqué le plus rapide sur 3 navigateurs, mais cela rend le code difficile à lire… Alors choisissez ce que vous en avez envie!

Il existe au moins 5 façons de procéder:

Si vous souhaitez convertir uniquement en nombres entiers, un autre moyen rapide (et court) est le non double bit (c'est-à-dire en utilisant deux caractères tilde):

par exemple

~~x;

Référence: http://james.padolsey.com/cool-stuff/double-bitwise-not/

Les 5 méthodes courantes que je connais jusqu'à présent pour convertir une chaîne en un nombre ont toutes leurs différences (il y a plus d'opérateurs au niveau du bit qui fonctionnent, mais ils donnent tous le même résultat que ~~). Ce JSFiddle montre les différents résultats auxquels vous pouvez vous attendre dans la console de débogage: http://jsfiddle.net/TrueBlueAussie/j7x0q0e3/22/

var values = ["123",
          undefined,
          "not a number",
          "123.45",
          "1234 error",
          "2147483648",
          "4999999999"
          ];

for (var i = 0; i < values.length; i++){
    var x = values[i];

    console.log(x);
    console.log(" Number(x) = " + Number(x));
    console.log(" parseInt(x, 10) = " + parseInt(x, 10));
    console.log(" parseFloat(x) = " + parseFloat(x));
    console.log(" +x = " + +x);
    console.log(" ~~x = " + ~~x);
}

Console de débogage:

123
  Number(x) = 123
  parseInt(x, 10) = 123
  parseFloat(x) = 123
  +x = 123
  ~~x = 123
undefined
  Number(x) = NaN
  parseInt(x, 10) = NaN
  parseFloat(x) = NaN
  +x = NaN
  ~~x = 0
null
  Number(x) = 0
  parseInt(x, 10) = NaN
  parseFloat(x) = NaN
  +x = 0
  ~~x = 0
"not a number"
  Number(x) = NaN
  parseInt(x, 10) = NaN
  parseFloat(x) = NaN
  +x = NaN
  ~~x = 0
123.45
  Number(x) = 123.45
  parseInt(x, 10) = 123
  parseFloat(x) = 123.45
  +x = 123.45
  ~~x = 123
1234 error
  Number(x) = NaN
  parseInt(x, 10) = 1234
  parseFloat(x) = 1234
  +x = NaN
  ~~x = 0
2147483648
  Number(x) = 2147483648
  parseInt(x, 10) = 2147483648
  parseFloat(x) = 2147483648
  +x = 2147483648
  ~~x = -2147483648
4999999999
  Number(x) = 4999999999
  parseInt(x, 10) = 4999999999
  parseFloat(x) = 4999999999
  +x = 4999999999
  ~~x = 705032703

La ~~xversion donne un nombre dans les cas «plus», où d'autres aboutissent souvent undefined, mais échoue pour une entrée non valide (par exemple, elle retournera 0si la chaîne contient des caractères non numériques après un nombre valide).

Débordement

Remarque: un dépassement d'entier et / ou une troncature de bits peuvent se produire avec ~~, mais pas avec les autres conversions. Bien qu'il soit inhabituel d'entrer des valeurs aussi importantes, vous devez en être conscient. Exemple mis à jour pour inclure des valeurs beaucoup plus grandes.

Certains tests Perf indiquent que le standard parseIntet les parseFloatfonctions sont en fait les options les plus rapides, probablement hautement optimisées par les navigateurs, mais tout dépend de vos besoins car toutes les options sont assez rapides : http://jsperf.com/best-of-string-to -nombre-conversion / 37

Tout dépend de la façon dont les tests de performance sont configurés, car certains montrent que parseInt / parseFloat est beaucoup plus lent.

Ma théorie est:

• Mensonges
• Darn lignes
• Statistiques
• Résultats JSPerf :)

Préfixez la chaîne avec l' +opérateur.

console.log(+'a') // NaN
console.log(+'1') // 1
console.log(+1) // 1

Un moyen rapide de convertir des chaînes en entier est d'utiliser un bit au niveau du bit ou, comme ceci:

x | 0

Bien que cela dépende de la façon dont il est implémenté, en théorie, il devrait être relativement rapide (au moins aussi rapide que +x) car il sera d'abord converti xen un nombre, puis effectuera un ou.

Voici un moyen simple de le faire: var num = Number (str); dans cet exemple, str est la variable qui contient la chaîne. Vous pouvez tester et voir comment cela fonctionne ouvert: Outils de développement Google Chrome , puis accédez à la console et collez le code suivant. lisez les commentaires pour mieux comprendre comment la conversion est effectuée.

// Here Im creating my variable as a string
var str = "258";


// here im printing the string variable: str
console.log ( str );


// here Im using typeof , this tells me that the variable str is the type: string
console.log ("The variable str is type: " + typeof str);


// here is where the conversion happens
// Number will take the string in the parentesis and transform it to a variable num as type: number
var num = Number(str);
console.log ("The variable num is type: " + typeof num);

Je trouve que num * 1c'est simple, clair et fonctionne pour les entiers et les flottants ...

Ce n'est probablement pas si rapide, mais a l'avantage supplémentaire de s'assurer que votre numéro a au moins une certaine valeur (par exemple 0), ou au plus une certaine valeur:

Math.max(input, 0);

Si vous devez garantir une valeur minimale, vous feriez généralement

var number = Number(input);
if (number < 0) number = 0;

Math.max(..., 0) vous évite d'écrire deux déclarations.

Vous pouvez essayer d'utiliser UnitOf , une bibliothèque de conversion de types de mesures et de données que nous venons de publier officiellement! UnitOf est super rapide, de petite taille et efficace pour convertir n'importe quel type de données sans jamais générer d'erreur ou null / undefined. Les valeurs par défaut que vous définissez ou les valeurs par défaut de UnitOf sont renvoyées lorsqu'une conversion échoue.

//One liner examples
UnitOf.DataType("12.5").toFloat(); //12.5 of type Float is returned. 0 would be returned if conversion failed.
UnitOf.DataType("Not A Num").toInt(10); //10 of type Int is returned as the conversion failed.

//Or as a variable
var unit = UnitOf.DataType("12.5");
unit.toInt(5); //12.5 of type Float is returned. 5 would be returned if the conversion failed.
unit.toFloat(8); // 12 of type Int is returned. 8 would be returned if the conversion failed.

Le moyen le plus rapide est d'utiliser -0:

const num = "12.34" - 0;