Was ist der Unterschied zwischen parseInt () und Number ()?

Wie parseInt()und Number()anders verhalten , wenn Strings in Zahlen umzuwandeln?

Nun, sie sind semantisch verschieden , der NumberKonstruktor aufgerufen als eine Funktion führt eine Typumwandlung und parseIntführt das Parsen , zB:

// parsing:
parseInt("20px");       // 20
parseInt("10100", 2);   // 20
parseInt("2e1");        // 2

// type conversion
Number("20px");       // NaN
Number("2e1");        // 20, exponential notation

Beachten Sie, dass beim parseIntErkennen einer führenden Null in der Zeichenfolge die Zahl in Oktalbasis analysiert wird. Dies hat sich in ECMAScript 5, der neuen Version des Standards, geändert. Es dauert jedoch lange, bis Browser-Implementierungen verfügbar sind Bei einer Inkompatibilität mit ECMAScript 3) werden auch parseIntnachfolgende Zeichen ignoriert, die keiner Ziffer der aktuell verwendeten Basis entsprechen.

Der NumberKonstruktor erkennt keine Oktale:

Number("010");         // 10
parseInt("010");       // 8, implicit octal
parseInt("010", 10);   // 10, decimal radix used

Aber es kann Zahlen in hexadezimaler Notation verarbeiten, genau wie parseInt:

Number("0xF");   // 15
parseInt("0xF"); //15

Ein weit verbreitetes Konstrukt zur Durchführung der numerischen Typkonvertierung ist der Unäre +Operator (S. 72). Dies entspricht der Verwendung des NumberKonstruktors als Funktion:

+"2e1";   // 20
+"0xF";   // 15
+"010";   // 10

typeof parseInt("123") => number
typeof Number("123") => number
typeof new Number("123") => object (Number primitive wrapper object)

Die ersten beiden bieten eine bessere Leistung, da anstelle eines Objekts ein Grundelement zurückgegeben wird.

Wenn Sie nach Leistung suchen, erzielen Sie wahrscheinlich die besten Ergebnisse mit einer bitweisen Rechtsverschiebung "10">>0. Multiplizieren Sie auch ( "10" * 1) oder nicht ( ~~"10"). Alle von ihnen sind viel schneller von Numberund parseInt. Sie haben sogar "Feature", das 0 für Nicht-Zahlen-Argumente zurückgibt. Hier sind Leistungstests .

Ich fand zwei Links Leistung unter mehreren Möglichkeiten zu vergleichen , der Umwandlung stringzu int.

parseInt(str,10)    
parseFloat(str)
str << 0
+str
str*1 
str-0
Number(str)

http://jsben.ch/#/zGJHM

http://phrogz.net/js/string_to_number.html

Ein kleiner Unterschied ist, was sie konvertieren undefinedoder null,

Number() Or Number(null) // returns 0

während

parseInt() Or parseInt(null) // returns NaN

Zusammenfassung:

parseInt()::

• Nimmt eine Zeichenfolge als erstes Argument, den Radix (eine Ganzzahl, die die Basis eines Zahlensystems ist, z. B. Dezimalzahl 10 oder Binärzahl 2) als zweites Argument
• Die Funktion gibt eine Ganzzahl zurück, wenn das erste Zeichen nicht in eine Zahl konvertiert werden kann NaN wird dies zurückgegeben.
• Wenn die parseInt() Funktion auf einen nicht numerischen Wert stößt, wird der Rest der Eingabezeichenfolge abgeschnitten und der Teil nur bis zum nicht numerischen Wert analysiert.
• Wenn der Radix undefinedoder 0 ist, nimmt JS Folgendes an:
  • Wenn die Eingabezeichenfolge mit "0x" oder "0X" beginnt, der Radix 16 (hexadezimal) ist, wird der Rest der Zeichenfolge in eine Zahl analysiert.
  • Wenn der Eingabewert mit einer 0 beginnt, kann der Radix entweder 8 (oktal) oder 10 (dezimal) sein. Welcher Radix ausgewählt wird, hängt von der Implementierung der JS-Engine ab. ES5Gibt an, dass dann 10 verwendet werden soll. Dies wird jedoch nicht von allen Browsern unterstützt. Geben Sie daher immer radix an, wenn Ihre Zahlen mit einer 0 beginnen können.
  • Wenn der Eingabewert mit einer beliebigen Zahl beginnt, beträgt der Radix 10

Number()::

• Der Number()Konstruktor kann jede eingegebene Argumentation in eine Zahl umwandeln. Wenn der Number()Konstruktor die Eingabe nicht in eine Zahl konvertieren kann,NaN wird sie zurückgegeben.
• Der Number()Konstruktor kann auch Hexadezimalzahlen verarbeiten, mit denen sie beginnen müssen 0x.

Beispiel:

console.log(parseInt('0xF', 16));  // 15

// z is no number, it will only evaluate 0xF, therefore 15 is logged
console.log(parseInt('0xFz123', 16));

// because the radix is 10, A is considered a letter not a number (like in Hexadecimal)
// Therefore, A will be cut off the string and 10 is logged
console.log(parseInt('10A', 10));  // 10

// first character isnot a number, therefore parseInt will return NaN
console.log(parseInt('a1213', 10));


console.log('\n');


// start with 0X, therefore Number will interpret it as a hexadecimal value
console.log(Number('0x11'));

// Cannot be converted to a number, NaN will be returned, notice that
// the number constructor will not cut off a non number part like parseInt does
console.log(Number('123A'));

// scientific notation is allowed
console.log(Number('152e-1'));  // 15.21

Ich benutze ParseInt immer, aber passen sie von führenden Nullen , die es in Kraft wird Oktal - Modus.

parseInt() -> Analysiert eine Zahl nach angegebenem Redix.

Number()-> Konvertiert den angegebenen Wert in sein numerisches Äquivalent oder NaN, wenn dies nicht der Fall ist.

Daher sollten wir zum Konvertieren eines nicht numerischen Werts in eine Zahl immer die Funktion Number () verwenden.

z.B.

Number("")//0
parseInt("")//NaN

Number("123")//123
parseInt("123")//123

Number("123ac") //NaN,as it is a non numeric string
parsInt("123ac") //123,it parse decimal number outof string

Number(true)//1
parseInt(true) //NaN

Bei parseInt()der Redix-Konvertierung gibt es verschiedene Eckfälle für Funktionen. Daher sollten wir die Verwendung der Funktion parseInt () für Koerzitionszwecke vermeiden.

Um zu überprüfen, ob der angegebene Wert numerisch ist oder nicht, sollten wir die native isNaN()Funktion verwenden

parseInt konvertiert in eine Ganzzahl, dh es werden Dezimalstellen entfernt. Number wird nicht in Integer konvertiert.

Es ist eine gute Idee, sich von parseInt fernzuhalten und Number und Math.round zu verwenden, es sei denn, Sie benötigen Hex oder Oktal. Beide können Zeichenfolgen verwenden. Warum sich davon fernhalten?

parseInt(0.001, 10)
0

parseInt(-0.0000000001, 10)
-1

parseInt(0.0000000001, 10)
1

parseInt(4000000000000000000000, 10)
4

Es schlachtet wirklich große oder sehr kleine Zahlen. Seltsamerweise funktioniert es normal, wenn diese Eingaben eine Zeichenfolge sind.

parseInt("-0.0000000001", 10)
0

parseInt("0.0000000001", 10)
0

parseInt("4000000000000000000000", 10)
4e+21

Anstatt das Risiko einzugehen, Fehler mit diesem und den anderen erwähnten Fallstricken zu finden, würde ich parseInt nur vermeiden, es sei denn, Sie müssen etwas anderes als Basis 10 analysieren. Number, Math.round, Math.foor und .toFixed (0) können alle Machen Sie die gleichen Dinge, für die parseInt verwendet werden kann, ohne diese Art von Fehlern zu haben.

Wenn Sie parseInt wirklich für einige seiner anderen Eigenschaften verwenden möchten oder müssen, verwenden Sie es niemals, um Floats in Ints umzuwandeln.