Eine Zeichenfolge in eine Ganzzahl konvertieren?

Question

Wie konvert ich eine Zeichenfolge in eine Ganzzahl in JavaScript?

Answer 1

Der einfachste Weg wäre, den Native zu verwenden Number Funktion:

var x = Number("1000")

Wenn das für Sie nicht funktioniert, gibt es die analysieren, Unary Plus, Parsefloat mit Boden, und Math.round Methoden.

Parseninter:

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])

Unary Plus, wenn Ihre Zeichenfolge bereits in Form einer Ganzzahl ist:

var x = +"1000";

Wenn Ihre Zeichenfolge ein Schwimmer ist oder sein kann 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 vergisst, den Radix beim Rufen von Parseint einzulegen, können Sie Parsefloat verwenden und ihn umrunden, wie Sie möchten. Hier benutze ich Boden.

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

Interessanterweise wird Math.Round (wie Math.Floor) eine String zur Zahl der Zahlenkonvertierung durchführen. Wenn Sie also die Nummer abgerundet möchten (oder wenn Sie eine Ganzzahl in der Zeichenfolge haben), ist dies ein großartiger Weg, vielleicht mein Favorit:

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

Answer 2

Versuchen Sie es mit einer Parseint -Funktion:

var number = parseInt("10");

Aber es gibt ein Problem. Wenn Sie versuchen, "010" mithilfe der ParseInt -Funktion umzuwandeln, erkennt sie als Oktalnummer und gibt die Nummer 8 zurück. Sie müssen also einen Radix 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 Ignoriert schlechte Daten, nachdem Sie etwas Gültiges analysiert haben.
Diese Guid wird als 51 analysieren:

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

Answer 3

Es gibt zwei Hauptmethoden, um eine Zeichenfolge in eine Zahl in JavaScript umzuwandeln. Eine Möglichkeit besteht darin, es zu analysieren, und die andere Möglichkeit besteht darin, ihren Typ in eine Zahl zu ändern. Alle Tricks in den anderen Antworten (z. B. Unary Plus) beinhalten implizit den Typ der Zeichenfolge zu einer Zahl. Sie können das Gleiche auch explizit mit der Zahlenfunktion tun.

Parsing

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

Parseint und Parsefloat sind die beiden Funktionen, die zum Parsen von Zeichenfolgen zu Zahlen verwendet werden. Das Parsen hört lautlos auf, wenn es einen Charakter trifft, den es nicht erkennt. Dies kann nützlich sein, um Strings wie "92px" zu analysieren, aber es ist auch etwas gefährlich, da es Ihnen keine Fehler bei schlechten Eingaben gibt, stattdessen Sie Sie stattdessen Ich werde Nan zurückholen, es sei denn, die Zeichenfolge beginnt mit einer Nummer. Whitespace am Anfang der Saite wird ignoriert. Hier ist ein Beispiel dafür, dass es etwas anderes tut als das, was Sie wollen, und keinen Hinweis darauf zu geben, dass etwas schief gelaufen ist:

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

Es ist eine gute Praxis, den Radix immer als zweites Argument anzugeben. In älteren Browsern, wenn die Saite mit einer 0 begann, würde sie als Oktal interpretiert, wenn der Radix nicht angegeben wäre, was viele Menschen überraschte. Das Verhalten für Hexadezimal wird ausgelöst, indem der Zeichenfolge mit 0x beginnt, wenn kein Radix angegeben ist, z. B. 0xff. Der Standard änderte sich tatsächlich mit ECMascript 5, sodass moderne Browser nicht mehr Oktal auslösen, wenn es eine führende 0 gibt, wenn kein Radix angegeben wurde. ParseInt versteht Radixe bis Basis 36. In diesem Fall werden sowohl obere als auch untere Fallbuchstaben als gleichwertig behandelt.

Ändern der Art einer Zeichenfolge in eine Zahl

Alle anderen oben genannten Tricks, die ParseInT nicht verwenden, beinhalten implizit die Zeichenfolge in eine Zahl. Ich mache das lieber explizit,

var cast = Number("97");

Dies hat ein anderes Verhalten in den Parse -Methoden (obwohl es immer noch Whitespace ignoriert). Es ist strenger: Wenn es nicht die gesamte Zeichenfolge versteht, als es zurückkehrt NaN, Sie können es also nicht für Strings wie verwenden 97px. Da Sie eine primitive Zahl anstelle eines Zahlen -Wrapper -Objekts wünschen, stellen Sie sicher, dass Sie nicht einfügen new Vor der Zahlfunktion.

Wenn Sie auf eine Zahl konvertiert werden, können Sie natürlich einen Wert haben, der eher ein Schwimmer als eine Ganzzahl sein kann. Wenn Sie also eine Ganzzahl wünschen, müssen Sie ihn ändern. Es gibt ein paar Möglichkeiten, dies zu tun:

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 eine bitweise oder Sie können auch doppelte Negation wie in einer früheren Antwort oder in einer Bitverschiebung durchführen) den Wert in eine 32 -Bit -Ganzzahl umwandeln, und die meisten von ihnen werden in eine signierte Ganzzahl konvertiert. Beachten Sie das Ich möchte nicht, dass Sie für große ganze Zahlen wollen. Wenn die Ganzzahl nicht in 32Bits dargestellt werden kann, wird er eingewickelt.

~~"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 korrekt 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 all diese Methoden die exponentielle Notation verstehen, also 2e2 ist 200 eher als nan. Außerdem versteht die Zahl "Infinity", während die Parse -Methoden nicht tun.

Brauch

Es ist unwahrscheinlich, dass eine dieser Methoden genau das tut, was Sie wollen. Normalerweise möchte ich beispielsweise einen Fehler geworfen, wenn das Parsen fehlschlägt, und ich brauche keine Unterstützung für Unendlichkeit, Exponentiale oder führende Weiße. Abhängig von Ihrer Usecase ist es manchmal sinnvoll, eine benutzerdefinierte Konvertierungsfunktion zu schreiben.

Überprüfen Sie immer, ob die Ausgabe der Zahl oder einer der Parse -Methoden die Art von Zahl ist, die Sie erwarten. Sie werden mit ziemlicher Sicherheit verwenden wollen isNaN Um sicherzustellen, dass die Nummer nicht NAN ist (normalerweise die einzige Möglichkeit, dass der Analyse fehlgeschlagen ist).

Answer 4

ParseInt () und + sind unterschiedlich

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Answer 5

Obwohl eine alte Frage, aber vielleicht kann dies für jemanden hilfreich sein.

Ich benutze diese Art der Konvertierung von String zu int Nummer

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

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

Aber wie unten gezeigt wird, sollte dies verwendet werden, wenn Sie sicher sind, dass die str ist eine Nummer (oder kann als Zahl dargestellt werden), andernfalls gibt sie NAN zurück - keine Zahl.

Sie können eine einfache Funktion erstellen, z. B. zB, z. B.

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

Answer 6

Versuchen Sie es mit Parseint.

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

Answer 7

Am schnellsten

var x = "1000"*1;

Prüfen

Hier ist wenig Vergleich der Geschwindigkeit (nur Mac OS) ... :)

Für Chrome 'Plus' und 'Mul' sind 'Mul' am schnellsten (> 700.000,00 OP/Sec), 'Math.Floor' ist am langsamsten. Für Firefox ist 'Plus' am langsamsten (!) 'Mul' am schnellsten (> 900.000.000 OP/Sec). In Safari ist 'Parseint' Fasten, 'Zahl' ist am langsamsten (aber Resulats sind ziemlich ähnlich,> 13.000.000 <31.000.000). Die Safari für Gussschnur zu int ist also mehr als 10x langsamer als andere Browser. Der Gewinner ist also ''Mul' :)

Sie können es auf Ihrem Browser mit diesem Link ausführenhttps://jsperf.com/js-cast-str-number/1

Aktualisieren

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

Answer 8

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

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

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

Der doppelte bitweise negative Abfall lässt nach dem Dezimalpunkt irgendetwas ab und konvertiert es in ein Zahlenformat. Mir wurde gesagt, dass es etwas schneller ist, als Funktionen anzurufen 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 dem es sich um eine rechte Verschiebung der Null-Fill handelt.) Uint32 Was ist schön, wenn Sie es auch wollen ohne Vorzeichen. Wieder wandelt sich dies zu einem Unsigned Ganzzahl, was zu seltsamem Verhalten führen kann, wenn Sie eine signierte Nummer verwenden.

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

Answer 9

Vorsicht, wenn Sie Parseint verwenden, um einen Float in wissenschaftlicher Notation zu konvertieren! Zum Beispiel:

parseInt("5.6e-14") 

wird darin enden, dass

5 

Anstatt von

0

Answer 10

Auch als Randnotiz: Mootools hat die Funktion toint (), die an einer nativen Zeichenfolge verwendet wird (oder Schwimmer (oder Ganzzahl)).

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

Answer 11

Um eine Zeichenfolge in Ganzzahl umzuwandeln, empfehle ich die Verwendung von Parsefloat und NICHT analysieren. Hier ist der Grund:

Mit Parsefloat:

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

Mit 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 absetzt, während Sie Parsefloat mit schwimmenden Punktzahlen arbeiten und daher besser geeignet sind, wenn Sie die Werte nach Dezimalstellen beibehalten möchten. Verwenden Sie Parseint, wenn Sie nur sicher sind, dass Sie den Ganzzahlwert möchten.

Answer 12

Bitte beachten Sie das folgende Beispiel. Es hilft Ihnen dabei, Ihren Zweifel zu löschen

Example                  Result

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

Durch die Verwendung von ParseInt -Funktion wird nur OP von Ganzzahl vorhanden und nicht die Zeichenfolge vorhanden

Answer 13

wir können benutzen +(stringOfNumber) anstatt zu verwenden parseInt(stringOfNumber)

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

Wir können diesen unären "+" -Personal auch für das Parsen von Float verwenden ...

Answer 14

Versuchen str - 0 umwandeln string zu 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 mehrerer Möglichkeiten zum Konvertieren von String in INT zu vergleichen

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

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

Answer 15

Es gibt viele Möglichkeiten in JavaScript, eine Zeichenfolge in einen Zahlenwert zu konvertieren ... alles einfache und praktische, wählen Sie die Art und Weise, wie man 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 alle Mathematik Die Operation wandelt sie zum Beispiel in die Anzahl um ...

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

Mein bevorzugter Weg ist es, zu verwenden + Zeichen, das ist die elegante Möglichkeit, eine Zeichenfolge in JavaScript in die Anzahl zu konvertieren.

Answer 16

Meiner Meinung nach deckt keine Antwort alle Kantenfälle ab, da das Parsen eines Schwimmers 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

Answer 17

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

Ich musste tatsächlich eine Zeichenfolge als Ganzzahl "speichern", für eine Bindung zwischen C und JavaScript, daher konvertiere 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;
}

Answer 18

Alle oben genannten sind korrekt. Bitte stellen Sie sicher, dass dies eine Zahl in einer Zeichenfolge ist, indem Sie "Typeot x === 'Nummer'" andere weise, es wird NAN zurückgeben

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

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

Answer 19

Eine andere Option 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 ausgeben:

i = 12.34
i ⊕ i ⊕ i = 12

Answer 20

function doSth(){
  var a = document.getElementById('input').value;
  document.getElementById('number').innerHTML = toNumber(a) + 1;
}
function toNumber(str){
  return +str;
}

<input id="input" type="text">
<input onclick="doSth()" type="submit">
<span id="number"></span>

Answer 21

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.

Answer 22

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

+"052254" //52254

Ich hoffe es hilft ;)

Answer 23

Summieren der Multiplikation von Ziffern mit ihrer jeweiligen Kraft von zehn:

IE: 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;

}

Answer 24

Hier ist die einfachste Lösung

let myNumber = "123" | 0;

Answer 25

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

Answer 26

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