Quel est le moyen le plus rapide de convertir une chaîne en un nombre en JavaScript ?

Question

N'importe quel numéro, c'est un numéro. Une chaîne de caractères ressemble à un nombre, c'est un nombre. Tout le reste, c'est NaN.

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

Answer 1

Pour autant que je sache, il existe 4 façons de procéder.

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

D'après ce test rapide que j'ai fait, cela dépend en fait des navigateurs.

https://jsben.ch/NnBKM

Implicit a marqué le plus rapide sur 3 navigateurs, mais il rend le code difficile à lire Donc choisissez ce que vous voulez !

Answer 2

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

Si vous souhaitez convertir uniquement en nombres entiers, une autre méthode rapide (et courte) consiste à utiliser la fonction pas en 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 de caractères en un nombre ont toutes leurs différences (il existe d'autres opérateurs binaires qui fonctionnent, mais ils donnent tous le même résultat). ~~ ). Cette 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

Le site ~~x donne lieu à un certain nombre de "plus" de cas, alors que d'autres donnent souvent lieu à des undefined mais il échoue en cas d'entrée invalide (par exemple, il renvoie le résultat suivant 0 si la chaîne contient des caractères non numériques après un numéro valide).

Débordement

Remarque : un dépassement de capacité des nombres entiers et/ou une troncature des bits peuvent se produire avec le système de gestion de l'information. ~~ mais pas les autres conversions. Bien qu'il soit inhabituel de saisir des valeurs aussi importantes, vous devez en être conscient. Exemple mis à jour pour inclure des valeurs beaucoup plus grandes.

Certains tests de Perf indiquent que la norme parseInt y parseFloat sont en fait les options les plus rapides, vraisemblablement optimisées par les navigateurs, mais tout dépend de vos besoins car tous Les options sont assez vite : http://jsperf.com/best-of-string-to-number-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 la suivante :

• Mensonges
• Mauvaises lignes
• Statistiques
• Résultats de JSPerf :)

Answer 3

Préfixe la chaîne de caractères avec le + opérateur.

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

Answer 4

Une façon rapide de convertir des chaînes de caractères en un nombre entier est d'utiliser un ou par bit, comme ceci :

x | 0

Bien que cela dépende de la manière dont il est mis en œuvre, en théorie, il devrait être relativement rapide (au moins aussi rapide que le programme +x ) puisqu'il lancera d'abord x à un nombre et ensuite effectuer un ou très efficace.

Answer 5

Voici un moyen simple de le faire : var num = Nombre(str) ; dans cet exemple str est la variable qui contient la chaîne de caractères. Vous pouvez tester et voir comment cela fonctionne ouvert : Outils de développement Google Chrome puis allez à la page console et collez le code suivant. Lisez les commentaires pour mieux comprendre comment la conversion est faite.

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