Beliebige Nummer, es ist Nummer. String sieht aus wie eine Zahl, es ist eine Zahl. Alles andere geht es NaN.

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

Soweit ich weiß, gibt es vier Möglichkeiten.

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

Durch diesen schnellen Test, den ich gemacht habe, kommt es tatsächlich auf Browser an.

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

Implicit In 3 Browsern als am schnellsten markiert, aber der Code ist schwer zu lesen. Wählen Sie also, wie Sie möchten!

Es gibt mindestens 5 Möglichkeiten, dies zu tun:

Wenn Sie nur in Ganzzahlen konvertieren möchten, ist ein weiterer schneller (und kurzer) Weg das Doppelbitweise nicht (dh die Verwendung von zwei Tilde-Zeichen):

z.B

~~x;

Referenz: http://james.padolsey.com/cool-stuff/double-bitwise-not/

Die 5 gängigen Methoden, die ich bisher kenne, um eine Zeichenfolge in eine Zahl umzuwandeln, haben alle ihre Unterschiede (es gibt mehr bitweise Operatoren, die funktionieren, aber alle liefern das gleiche Ergebnis wie ~~ ). Diese JSFiddle zeigt die verschiedenen Ergebnisse, die Sie in der Debug-Konsole erwarten können: 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);
}

Debug-Konsole:

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

Das ~~x Version führt zu einer Zahl in "mehr" Fällen, in denen andere häufig dazu führen undefined, schlägt jedoch bei ungültiger Eingabe fehl (z. B. wird zurückgegeben, 0wenn die Zeichenfolge nach einer gültigen Zahl Zeichen enthält, die keine Zahlen sind).

Überlauf

Bitte beachten Sie: Bei ~~den anderen Konvertierungen können ganzzahlige Überläufe und / oder Bitkürzungen auftreten , nicht jedoch. Während es ungewöhnlich ist, so große Werte einzugeben, müssen Sie sich dessen bewusst sein. Beispiel aktualisiert, um viel größere Werte einzuschließen.

Einige Perf-Tests zeigen, dass der Standard parseIntund die parseFloatFunktionen tatsächlich die schnellsten Optionen sind, die vermutlich von Browsern stark optimiert wurden. Dies hängt jedoch von Ihren Anforderungen ab, da alle Optionen schnell genug sind : http://jsperf.com/best-of-string-to -Nummernumwandlung / 37

Dies hängt alles davon ab, wie die Perf-Tests konfiguriert sind, da einige zeigen, dass parseInt / parseFloat viel langsamer ist.

Meine Theorie lautet:

• Lügen
• Verdammte Linien
• Statistiken
• JSPerf Ergebnisse :)

Stellen Sie dem +Operator den String voran.

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

Eine schnelle Möglichkeit, Zeichenfolgen in eine Ganzzahl umzuwandeln, besteht darin, eine bitweise oder wie folgt zu verwenden:

x | 0

Während es davon abhängt, wie es implementiert wird, sollte es theoretisch relativ schnell sein (mindestens so schnell wie +x), da es zuerst xin eine Zahl umgewandelt wird und dann ein sehr effizientes oder ausführt.

Hier ist eine einfache Möglichkeit: var num = Number (str); In diesem Beispiel ist str die Variable, die den String enthält. Sie können testen und sehen, wie es geöffnet funktioniert: Google Chrome-Entwicklertools. Gehen Sie dann zur Konsole und fügen Sie den folgenden Code ein. Lesen Sie die Kommentare, um besser zu verstehen, wie die Konvertierung durchgeführt wird.

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

Ich finde das num * 1einfach, klar und funktioniert für ganze Zahlen und Gleitkommazahlen ...

Dies ist wahrscheinlich nicht so schnell, hat aber den zusätzlichen Vorteil, dass sichergestellt ist, dass Ihre Nummer mindestens einen bestimmten Wert (z. B. 0) oder höchstens einen bestimmten Wert hat:

Math.max(input, 0);

Wenn Sie einen Mindestwert sicherstellen müssen, tun Sie dies normalerweise

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

Math.max(..., 0) erspart Ihnen das Schreiben von zwei Aussagen.

Sie können UnitOf verwenden , eine Mess- und Datentypkonvertierungsbibliothek, die wir gerade offiziell veröffentlicht haben! UnitOf ist superschnell, klein und kann jeden Datentyp effizient konvertieren, ohne jemals einen Fehler oder null / undefiniert auszulösen. Von Ihnen definierte Standardwerte oder die Standardeinstellungen von UnitOf werden zurückgegeben, wenn eine Konvertierung nicht erfolgreich ist.

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

Der schnellste Weg ist die Verwendung von -0:

const num = "12.34" - 0;