Wie konvertiere ich eine Zeichenfolge in eine Ganzzahl in JavaScript?

Der einfachste Weg wäre, die native NumberFunktion zu verwenden:

var x = Number("1000")

Wenn das bei Ihnen nicht funktioniert, gibt es die Methoden parseInt , unary plus , parseFloat with floor und Math.round .

parseInt:

var x = parseInt("1000", 10); // you want to use radix 10
    // so you get a decimal number even with a leading 0 and an old browser ([IE8, Firefox 20, Chrome 22 and older][1])

unäres Plus, wenn Ihre Zeichenfolge bereits die Form einer Ganzzahl hat:

var x = +"1000";

Wenn Ihre Zeichenfolge ein Float ist oder sein könnte und Sie eine Ganzzahl möchten:

var x = Math.floor("1000.01"); //floor automatically converts string to number

oder, wenn Sie Math.floor mehrmals verwenden:

var floor = Math.floor;
var x = floor("1000.01");

Wenn Sie der Typ sind, der beim Aufrufen von parseInt vergisst, den Radix einzufügen, können Sie parseFloat verwenden und ihn nach Belieben runden. Hier benutze ich Boden.

var floor = Math.floor;
var x = floor(parseFloat("1000.01"));

Interessanterweise führt Math.round (wie Math.floor) eine Konvertierung von Zeichenfolgen in Zahlen durch. Wenn Sie also die Zahl runden möchten (oder wenn Sie eine Ganzzahl in der Zeichenfolge haben), ist dies eine großartige Möglichkeit, vielleicht mein Favorit:

var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)

Versuchen Sie die Funktion parseInt:

var number = parseInt("10");

Aber es gibt ein Problem. Wenn Sie versuchen, "010" mit der Funktion parseInt zu konvertieren, wird diese als Oktalzahl erkannt und gibt die Zahl 8 zurück. Sie müssen also einen Radix (von 2 bis 36) angeben. 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 parseIntfehlerhafte Daten nach dem Parsen von gültigen Daten ignoriert werden.
Diese Anleitung wird als 51 analysiert:

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

Es gibt zwei Möglichkeiten, eine Zeichenfolge in eine Zahl in Javascript umzuwandeln. Eine Möglichkeit besteht darin, es zu analysieren, und die andere darin, seinen Typ in eine Zahl zu ändern. Alle Tricks in den anderen Antworten (z. B. unäres Plus) beinhalten das implizite Erzwingen des Typs der Zeichenfolge zu einer Zahl. Sie können dasselbe auch explizit mit der Zahlenfunktion tun.

Parsing

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

parseInt und parseFloat sind die beiden Funktionen zum Parsen von Zeichenfolgen in Zahlen. Das Parsen wird stillschweigend gestoppt, wenn es auf ein Zeichen trifft, das es nicht erkennt. Dies kann nützlich sein, um Zeichenfolgen wie "92px" zu analysieren, ist aber auch etwas gefährlich, da es bei schlechten Eingaben keine Fehler gibt, sondern Sie Ich 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, wie Sie etwas anderes tun, 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 wird empfohlen, immer den Radix als zweites Argument anzugeben. Wenn in älteren Browsern die Zeichenfolge mit einer 0 beginnt, wird sie als oktal interpretiert, wenn der Radix nicht angegeben wird, was viele Leute überrascht hat. Das Verhalten für Hexadezimal wird ausgelöst, indem die Zeichenfolge mit 0x beginnt, wenn kein Radix angegeben ist, z 0xff. Der Standard hat sich mit Ecmascript 5 tatsächlich geändert, sodass moderne Browser kein Oktal mehr auslösen, wenn eine führende 0 vorhanden ist, wenn kein Radix angegeben wurde. parseInt versteht Radixe bis zur Basis 36, in diesem Fall werden sowohl Groß- als auch Kleinbuchstaben als gleichwertig behandelt.

Ändern des Typs einer Zeichenfolge in eine Zahl

Bei allen anderen oben genannten Tricks, bei denen parseInt nicht verwendet wird, wird die Zeichenfolge implizit in eine Zahl gezwungen. Ich mache das lieber explizit,

var cast = Number("97");

Dies hat ein anderes Verhalten als die Analysemethoden (obwohl Leerzeichen immer noch ignoriert werden). Es ist strenger: Wenn es nicht die gesamte Zeichenfolge versteht, als es zurückgibt NaN, können Sie es nicht für Zeichenfolgen wie verwenden 97px. Da Sie eine primitive Zahl anstelle eines Number-Wrapper-Objekts möchten, stellen Sie sicher, dass Sie nicht newvor die Number-Funktion stellen.

Wenn Sie in eine Zahl konvertieren, erhalten Sie natürlich einen Wert, der möglicherweise eher ein Float als eine Ganzzahl ist. Wenn Sie also eine Ganzzahl möchten, müssen Sie diese ändern. Hierfür gibt es einige 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 einer Bitverschiebung durchführen) konvertiert den Wert in eine 32-Bit-Ganzzahl, und die meisten von ihnen konvertieren in eine vorzeichenbehaftete Ganzzahl. Beachten Sie, dass dies nicht für große Ganzzahlen gewünscht wird . 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 mit größeren Zahlen richtig zu arbeiten, sollten Sie die Rundungsmethoden verwenden

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

Beachten Sie, dass alle diese Methoden Exponentialnotation verstehen, so 2e2ist 200statt NaN. Außerdem versteht Number "Unendlichkeit", während die Analysemethoden dies nicht tun.

Benutzerdefiniert

Es ist unwahrscheinlich, dass eine dieser Methoden genau das tut, was Sie wollen. Normalerweise möchte ich beispielsweise, dass ein Fehler ausgelöst wird, wenn das Parsen fehlschlägt, und ich benötige keine Unterstützung für Infinity, Exponentiale oder führende Leerzeichen. Abhängig von Ihrem Anwendungsfall ist es manchmal sinnvoll, eine benutzerdefinierte Konvertierungsfunktion zu schreiben.

Überprüfen Sie immer, ob die Ausgabe von Number oder einer der Analysemethoden der Art von Nummer entspricht, die Sie erwarten. Mit ziemlicher Sicherheit möchten Sie sicherstellen isNaN, dass die Nummer nicht NaN ist (normalerweise ist dies 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 für jemanden hilfreich sein.

Ich verwende diese Art der Konvertierung von Zeichenfolgen in int- Zahlen

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 verwendet werden, wenn Sie sicher sind, dass stres sich um eine Zahl handelt (oder als Zahl dargestellt werden kann). Andernfalls wird NaN zurückgegeben - keine Zahl.

Sie können eine einfache Funktion erstellen, z

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

Am schnellsten

var x = "1000"*1;

Prüfung

Hier ist ein kleiner Vergleich der Geschwindigkeit (nur Mac Os) ... :)

Für Chrom sind 'plus' und 'mul' am schnellsten (> 700.000,00 op / sec), 'Math.floor' am langsamsten. Für Firefox ist 'plus' am langsamsten (!) 'Mul' ist am schnellsten (> 900.000.000 op / sec). In Safari ist 'parseInt' Fasten, 'Zahl' ist am langsamsten (aber die Ergebnisse sind ziemlich ähnlich,> 13.000.000 <31.000.000). Safari für Cast String to Int ist also mehr als 10x langsamer als andere Browser. Der Gewinner ist also ' mul ' :)

Sie können es in Ihrem Browser über diesen Link https://jsperf.com/js-cast-str-to-number/1 ausführen

Aktualisieren

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

Versuchen Sie es mit 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 Dezimalpunkt ab UND konvertiert es in ein Zahlenformat. Mir wurde gesagt, dass es etwas schneller ist als das Aufrufen von Funktionen und so weiter, aber ich bin nicht ganz überzeugt.

BEARBEITEN: Eine andere Methode, die ich gerade hier gesehen habe (eine Frage zum Javascript >>> -Operator, bei dem es sich um eine Rechtsverschiebung mit Nullfüllung handelt ), die zeigt, dass das Verschieben einer Zahl um 0 mit diesem Operator die Zahl in eine uint32 konvertiert, was nett ist, wenn Sie will es auch ohne Vorzeichen . Dies wird wiederum in eine vorzeichenlose Ganzzahl 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

Seien Sie vorsichtig, wenn Sie parseInt verwenden, um einen Float in wissenschaftliche Notation umzuwandeln! Zum Beispiel:

parseInt("5.6e-14") 

wird darin enden, dass

5 

anstatt

0

Um einen String in eine Ganzzahl umzuwandeln, empfehle ich die Verwendung von parseFloat und NOT parseInt. 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

Verwenden von parseInt:

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

Wenn Sie also bemerkt haben, dass parseInt die Werte nach den Dezimalstellen verwirft, können Sie mit parseFloat mit Gleitkommazahlen arbeiten und sind daher besser geeignet, wenn Sie die Werte nach den Dezimalstellen beibehalten möchten. Verwenden Sie parseInt genau dann, wenn Sie sicher sind, dass Sie den ganzzahligen Wert möchten.

Auch als Randnotiz: Mootools hat die Funktion toInt (), die für jede native Zeichenfolge (oder float (oder Ganzzahl)) verwendet wird.

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

Bitte sehen Sie sich das folgende Beispiel an. Es wird Ihnen helfen, Ihre Zweifel auszuräumen

Example                  Result

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

Mit der Parseint-Funktion wird nur die vorhandene Ganzzahl op angegeben, nicht die Zeichenfolge

wir können verwenden +(stringOfNumber)anstatt zu verwendenparseInt(stringOfNumber)

Beispiel: +("21")Gibt int von 21 wie das zurück parseInt("21").

Wir können diesen unären "+" - Operator auch zum Parsen von float verwenden ...

Versuchen Sie str - 0zu konvertieren stringzu number.

> 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 ... Wählen Sie einfach und praktisch 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

Auch jede mathematische Operation konvertiert sie in Zahlen, 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 +Zeichen. Dies ist die elegante Methode, um eine Zeichenfolge in JavaScript in Zahlen umzuwandeln.

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

Ich musste tatsächlich eine Zeichenfolge als Ganzzahl "speichern", um eine Bindung zwischen C und JavaScript herzustellen, also konvertierte ich die Zeichenfolge in einen Ganzzahlwert:

/*
    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 Randfä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

Hier ist die einfachste Lösung

let myNumber = "123" | 0;

Einfachere Lösung

let myNumber = +"123";

Alle oben genannten sind korrekt. Bitte stellen Sie vorher sicher, dass dies eine Zahl in einer Zeichenfolge 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 Möglichkeit besteht darin, den Wert mit sich selbst zu verdoppeln:

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

Dies wird Folgendes ausgeben:

i = 12.34
i ⊕ i ⊕ i = 12

Ich habe nur ein Pluszeichen (+) vor dem String hinzugefügt und das war die Lösung!

+"052254" //52254

Ich hoffe es hilft ;)

Summieren der Multiplikation von Ziffern mit ihrer jeweiligen Zehnerpotenz:

dh: 123 = 100 + 20 + 3 = 1 * 100 + 2 + 10 + 3 * 1 = 1 * (10 ^ 2) + 2 * (10 ^ 1) + 3 * (10 ^ 0)

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

Auf diese Weise bekomme ich immer ein int zurück.

Der sicherste Weg, um sicherzustellen, 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

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

Sie können plus verwenden, zum Beispiel =>

var personAge = '24'; var personAge1 = (+ personAge)

dann können Sie sehen, dass der Typ der PersonAge die Nummer ist