Konvertieren Sie eine Zeichenfolge in eine Ganzzahl in JavaScript?

Testen Sie die parseInt-Funktion:

var number = parseInt("10");

Aber es gibt ein Problem. Wenn Sie versuchen, "010" mit der parseInt-Funktion zu konvertieren, wird die Oktalzahl erkannt und die Zahl 8 zurückgegeben. Sie müssen also eine Basis angeben (von 2 bis 36). In diesem Fall Basis 10.

parseInt(string, radix)

Beispiel:

var result = parseInt("010", 10) == 10; // Returns true

var result = parseInt("010") == 10; // Returns false

Beachten Sie, dass parseInt fehlerhafte Daten nach dem Analysieren von gültigen Werten ignoriert.
Diese Guid wird als 51 parsen:

var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true

Es gibt zwei Möglichkeiten, eine Zeichenfolge in JavaScript in eine Zahl umzuwandeln. Eine Möglichkeit besteht darin, sie zu analysieren, und die andere Möglichkeit besteht darin, ihren Typ in eine Zahl zu ändern. Alle Tricks in den anderen Antworten (z. B. unäres Plus) beinhalten implizit das Erzwingen des Typs der Zeichenfolge in eine Zahl. Sie können dasselbe auch explizit mit der Number-Funktion tun.

Analyse

var parsed = parseInt("97", 10);

parseInt und parseFloat sind die beiden Funktionen, die zum Analysieren von Zeichenfolgen in Zahlen verwendet werden. Das Parsen stoppt im Stillen, wenn ein nicht erkannter Charakter getroffen wird. Dies kann zum Parsen von Strings wie "92px" nützlich sein, ist aber auch etwas gefährlich, da es bei fehlerhaften Eingaben keine Fehler gibt bekomme NaN zurück, es sei denn, die Zeichenfolge beginnt mit einer Zahl. Leerzeichen am Anfang der Zeichenfolge werden ignoriert. Hier ist ein Beispiel dafür, dass Sie etwas anderes machen, als Sie möchten, und keinen Hinweis darauf geben, dass etwas schief gelaufen ist:

var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97

Es ist empfehlenswert, die Radix immer als zweites Argument anzugeben. Wenn in älteren Browsern die Zeichenfolge mit einer 0 begann, würde sie als Oktal interpretiert, wenn die Basis nicht angegeben wurde, was viele Leute überraschte. Das Verhalten für Hexadezimalzeichen wird dadurch ausgelöst, dass die Zeichenfolge mit 0x beginnt, wenn keine Basis angegeben ist, z. 0xff. Mit ecmascript 5 wurde der Standard tatsächlich geändert, sodass moderne Browser keine Oktalzeichen mehr auslösen, wenn es eine führende 0 gibt, wenn keine Basis angegeben wurde. parseInt versteht Radixe bis zur Basis 36, wobei Groß- und Kleinbuchstaben als gleichwertig behandelt werden.

Ändern des Typs einer Zeichenfolge in eine Zahl

Bei allen anderen oben genannten Tricks, bei denen parseInt nicht verwendet wird, muss der String implizit in eine Zahl umgewandelt werden. Ich ziehe es vor, dies explizit zu tun,

var cast = Number("97");

Dies hat ein anderes Verhalten als die Parsemethoden (obwohl Leerzeichen immer noch ignoriert werden). Es ist strenger: Wenn die gesamte Zeichenfolge nicht verstanden wird, wird NaN zurückgegeben, sodass sie nicht für Zeichenfolgen wie 97px verwendet werden kann. Stellen Sie sicher, dass Sie keine new vor die Number-Funktion stellen, da Sie eine primitive Zahl anstelle eines Number-Wrapper-Objekts wünschen.

Wenn Sie in eine Zahl konvertieren, erhalten Sie natürlich einen Wert, der eher ein Float als eine Ganzzahl sein kann. Wenn Sie also eine Ganzzahl benötigen, müssen Sie diese ändern. Dafür gibt es mehrere Möglichkeiten:

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

Jeder bitweise Operator (hier habe ich ein bitweises oder, aber Sie könnten auch eine doppelte Negation wie in einer früheren Antwort oder Bitverschiebung ausführen) konvertiert den Wert in eine 32-Bit-Ganzzahl, und die meisten von ihnen konvertieren in eine vorzeichenbehaftete Ganzzahl. Beachten Sie, dass dies Sie nicht für große Ganzzahlen will . Wenn die Ganzzahl nicht in 32 Bit dargestellt werden kann, wird sie umgebrochen. 

~~"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

Um korrekt mit größeren Zahlen zu arbeiten, sollten Sie die Rundungsmethoden verwenden

Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))

Denken Sie daran, dass alle diese Methoden die Exponentialnotation verstehen, sodass 2e2200 und nicht NaN ist. Number versteht auch "Infinity", während die Analyse-Methoden dies nicht tun.

Brauch

Es ist unwahrscheinlich, dass eine dieser Methoden genau das tut, was Sie möchten. Zum Beispiel würde ich normalerweise einen Fehler werfen wollen, wenn das Parsing fehlschlägt, und ich brauche keine Unterstützung für Infinity, Exponentiale oder führende Leerzeichen. Je nach Anwendungsfall ist es manchmal sinnvoll, eine benutzerdefinierte Konvertierungsfunktion zu schreiben.

Vergewissern Sie sich immer, dass die Ausgabe von Number oder einer der Analysemethoden die Art von Nummer ist, die Sie erwarten. Sie werden fast sicher isNaN verwenden wollen, um sich zu vergewissern, dass die Zahl nicht NaN ist (normalerweise der einzige Weg, um herauszufinden, dass die Analyse fehlgeschlagen ist).

ParseInt () und + sind unterschiedlich

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Obwohl eine alte Frage, aber vielleicht kann dies jemandem helfen.

Ich verwende diese Art der Umwandlung von String in int Nummer

var str = "25";       // string
var number = str*1;   // number

Wenn Sie also mit 1 multiplizieren, ändert sich der Wert nicht, aber js gibt automatisch eine Zahl zurück.

Wie unten gezeigt, sollte dies jedoch verwendet werden, wenn Sie sicher sind, dass str eine Zahl ist (oder als Zahl dargestellt werden kann). Andernfalls wird NaN zurückgegeben - keine Zahl.

sie können einfache Funktionen erstellen, z.

function toNumber(str) {
   return str*1;
}

Versuchen Sie parseInt.

var number = parseInt("10", 10); //number will have value of 10.

Ich habe hier die falsche Antwort gepostet, sorry. Fest.

Dies ist eine alte Frage, aber ich liebe diesen Trick:

~~"2.123"; //2
~~"5"; //5

Das doppelte bitweise Negativ fällt nach dem Komma ab und konvertiert es in ein Zahlenformat. Ich habe gehört, es ist etwas schneller als das Aufrufen von Funktionen und so weiter, aber ich bin nicht ganz überzeugt.

BEARBEITEN: Eine andere Methode, die ich gerade gesehen habe hier (eine Frage zum Javascript >>> -Operator, bei der es sich um eine Verschiebung nach rechts um Null handelt), die zeigt, dass die Verschiebung einer Zahl um 0 mit diesem Operator die Zahl in umwandelt ein uint32 welches schön ist wenn du es auch willst ohne Vorzeichen . Dies wird wiederum in eine Ganzzahl ohne Vorzeichen konvertiert, was zu seltsamen Verhaltensweisen führen kann, wenn Sie eine vorzeichenbehaftete Zahl verwenden.

"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5

Am schnellsten

var x = "1000"*1;

Prüfung

Hier ist ein kleiner Geschwindigkeitsvergleich (nur Mac OS) ... :)

Bei Chrom sind "Plus" und "Mul" am schnellsten (> 700.000,00 Op/Sek), "Math.floor" ist am langsamsten. Bei Firefox ist "Plus" am langsamsten (!) "Mul" am schnellsten (> 900.000.000 Op/Sek). In Safari ist 'parseInt' fastes, 'number' ist am langsamsten (aber Ergebnisse sind ziemlich ähnlich,> 13.000.000 <31.000.000). Daher ist Safari für die Umwandlung von Zeichenfolgen in int mehr als zehnmal langsamer als andere Browser. Der Gewinner ist also "mul" :)

Sie können es über diesen Link in Ihrem Browser ausführen https://jsperf.com/casttonumber

Update

Ich teste auch var x = ~~"1000"; - auf Chrome und Safari ist etwas langsamer als var x = "1000"*1 (<1%), unter Firefox ist es etwas schneller (<1%).

Passen Sie auf, wenn Sie mit parseInt einen Float in wissenschaftliche Notation konvertieren!

parseInt("5.6e-14") 

wird darin enden, dass

5 

anstatt

0

Auch als Randbemerkung: Mootools hat die Funktion toInt (), die für einen beliebigen nativen String (oder Float (oder Integer)) verwendet wird.

"2".toInt()   // 2
"2px".toInt() // 2
2.toInt()     // 2

Bitte sehen Sie sich das Beispiel unten an. Es hilft, Ihre Zweifel zu klären

Example                  Result

parseInt("4")            4
parseInt("5aaa")         5
parseInt("4.33333")      4
parseInt("aaa");         NaN (means "Not a Number")

mit der parseint-Funktion Es wird nur die Op mit Ganzzahl und nicht die Zeichenfolge angegeben

Um einen String in Integer zu konvertieren, empfehle ich die Verwendung von parseFloat undNICHTparseInt. Hier ist der Grund:

Verwenden von parseFloat:

parseFloat('2.34cms')  //Output: 2.34
parseFloat('12.5')     //Output: 12.5
parseFloat('012.3')    //Output: 12.3

parseInt verwenden:

parseInt('2.34cms')  //Output: 2
parseInt('12.5')     //Output: 12
parseInt('012.3')    //Output: 12

Wenn Sie bemerkt haben, dass parseInt die Werte nach den Dezimalstellen verwirft, können Sie mit ParseFloat mit Fließkommazahlen arbeiten und daher besser geeignet sein, wenn Sie die Werte nach Dezimalstellen beibehalten möchten. Verwenden Sie parseInt nur dann, wenn Sie sicher sind, dass Sie den ganzzahligen Wert wünschen.

wir können +(stringOfNumber) anstelle von parseInt(stringOfNumber) verwenden.

Bsp .: +("21") gibt int von 21 zurück wie parseInt("21").

wir können diesen unären "+" - Operator auch zum Analysieren von Float verwenden ...

Versuchen Sie str - 0, um string in number zu konvertieren.

> 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

Hier sind zwei Links, um die Leistung verschiedener Möglichkeiten zum Konvertieren von Zeichenfolgen in int zu vergleichen

https://jsperf.com/number-vs-parseint-vs-plus

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

In JavaScript gibt es viele Möglichkeiten, eine Zeichenfolge in einen Zahlenwert umzuwandeln. Alles in allem einfach und praktisch, wählen Sie die Art und Weise, wie eine für Sie funktioniert:

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

Jede Math -Operation wandelt sie in eine Zahl um, zum Beispiel ...

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

Meine bevorzugte Methode ist die Verwendung von + sign. Dies ist die elegante Art, eine Zeichenfolge in eine Zahl in eine Zahl umzuwandeln.

Google gab mir diese Antwort als Ergebnis, also ...

Ich musste eigentlich eine Zeichenfolge als Ganzzahl "speichern", um eine Bindung zwischen C und JavaScript herzustellen, daher konvertiere ich die Zeichenfolge in eine Ganzzahl:

/*
    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;
}

Meiner Meinung nach deckt keine Antwort alle Edge-Fälle ab, da das Parsen eines Floats zu einem Fehler führen sollte.

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

alle oben genannten sind richtig. Bitte stellen Sie sicher, dass dies eine Zahl in einem String ist, indem Sie "typeot x === 'number'" ausführen. Andernfalls wird NaN zurückgegeben

 var num = "fsdfsdf242342";
 typeof num => 'string';

 var num1 = "12423";
 typeof num1 => 'number';
 +num1 = > 12423`

Eine andere Option ist das Verdoppeln XOR des Wertes mit sich selbst

var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));

Dies wird ausgegeben:

i = 12.34
i ⊕ i ⊕ i = 12

Hier ist die einfachste Lösung

let myNumber = "123" | 0;

So stellen Sie sicher, dass Sie eine gültige Ganzzahl erhalten:

let integer = (parseInt(value, 10) || 0);

Beispiele:

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

Ich habe nur ein Pluszeichen (+) vor der Zeichenfolge hinzugefügt und das war Lösung!

+"052254" //52254

Ich hoffe es hilft ;)

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

Summieren der Multiplikation von Ziffern mit ihrer jeweiligen Zehnerpotenz:

d.h.

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;

}

Ich benutze das

String.prototype.toInt = function (returnval) { 
    var i = parseInt(this);
    return isNaN(i) ? returnval !== undefined ? returnval : - 1  :      i; 
}

so bekomme ich immer ein int zurück.