Vraag Hoe converteer ik een tekenreeks naar een geheel getal in JavaScript?


Hoe converteer ik een string in een integer in JavaScript?


1372
2017-07-15 20:22


oorsprong


antwoorden:


De eenvoudigste manier zou zijn om de native te gebruiken Number functie:

var x = Number("1000")

Als dat niet voor u werkt, dan zijn er de parseInt, unaire plus, parseFloat met floor, en Math.round methoden.

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

unaire plus als je string al in de vorm van een integer is:

var x = +"1000";

als je string een float is of zou kunnen zijn en je een integer wilt:

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

of, als je Math.floor meerdere keren gaat gebruiken:

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

Als je het type bent dat de radix vergeet in te voeren wanneer je parseInt aanroept, kun je parseFloat gebruiken en er omheen spelen zoals je wilt. Hier gebruik ik de vloer.

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

Interessant is dat Math.round (zoals Math.floor) een string naar nummerconversie zal doen, dus als je het aantal afgerond wilt hebben (of als je een integer in de string hebt), is dit een geweldige manier, misschien mijn favoriet:

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

1747
2017-07-15 20:28



Probeer de parseInt-functie:

var number = parseInt("10");

Maar er is een probleem. Als u "010" probeert te converteren met de functie parseInt, wordt het als octaal getal gedetecteerd en wordt nummer 8 geretourneerd. U moet dus een radix opgeven (van 2 tot 36). In dit geval basis 10.

parseInt(string, radix)

Voorbeeld:

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

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

192
2017-07-15 20:23



Er zijn twee belangrijke manieren om een ​​string naar een getal te converteren in javascript. Eén manier is om het te ontleden en de andere manier is om het type in een getal te veranderen. Alle trucs in de andere antwoorden (bijvoorbeeld unaire plus) impliceren impliciet dwingen het type van de reeks tot een aantal. U kunt ook expliciet hetzelfde doen met de functie Nummer.

Parsing

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

parseInt en parseFloat zijn de twee functies die worden gebruikt voor het parseren van tekenreeksen in getallen. Parsing stopt stil als het een karakter raakt dat het niet herkent, wat handig kan zijn voor het parseren van tekenreeksen zoals "92px", maar het is ook enigszins gevaarlijk, omdat het je geen enkele fout geeft bij slechte invoer, in plaats daarvan Ik krijg NaN terug tenzij de string begint met een nummer. Whitespace aan het begin van de reeks wordt genegeerd. Hier is een voorbeeld van dat het iets anders doet dan wat je wilt, en geen indicatie geeft dat er iets fout is gegaan:

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

Het is een goede gewoonte om altijd de radix als het tweede argument op te geven. In oudere browsers zou de string, als deze met een 0 werd gestart, als octaal worden geïnterpreteerd als de radix niet was opgegeven en er veel mensen waren verrast. Het gedrag voor hexadecimaal wordt getriggerd doordat de tekenreeks begint met 0x als er geen radix is ​​opgegeven, bijvoorbeeld 0xff. De standaard is eigenlijk veranderd met ecmascript 5, dus moderne browsers triggeren niet langer octaal als er 0 is als er geen radix is ​​opgegeven. parseInt begrijpt radixen tot en met base 36, in welk geval zowel hoofdletters als kleine letters als gelijkwaardig worden behandeld.

Het type string wijzigen in een nummer

Alle andere hierboven genoemde trucs die geen parseInt gebruiken, impliceren impliciet het dwingen van de reeks in een getal. Ik geef dit de voorkeur om dit expliciet te doen,

var cast = Number("97");

Dit heeft een ander gedrag dan de ontleedmethoden (hoewel het nog steeds witruimte negeert). Het is strenger: als het de hele snaar niet begrijpt dan keert het terug NaN, dus je kunt het niet gebruiken voor snaren zoals 97px. Aangezien u een primitief getal in plaats van een object Number wrapper wilt, moet u ervoor zorgen dat u het niet plaatst new voor de nummerfunctie.

Het is duidelijk dat het converteren naar een getal je een waarde geeft die eerder een float dan een integer is, dus als je een geheel getal wilt, moet je het wijzigen. Er zijn een paar manieren om dit te doen:

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

Elke bitwise-operator (hier heb ik een beetje bitsgewijs gedaan of, maar je kunt ook dubbele negatie gebruiken zoals in een eerder antwoord of een bitshift) converteert de waarde naar een 32-bits integer, en de meeste zullen in een geheel getal worden geconverteerd. Merk op dat dit zal niet willen dat je wilt voor grote gehele getallen. Als het gehele getal niet kan worden weergegeven in 32 bits, wordt het ingepakt.

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

Om correct te werken met grotere aantallen, moet u de afrondingsmethoden gebruiken

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

Houd in gedachten dat al deze methoden de exponentiële notatie begrijpen, dus 2e2 is 200 in plaats van NaN. Number begrijpt ook "Infinity", terwijl de ontleedmethoden dit niet doen.

gewoonte

Het is onwaarschijnlijk dat beide methoden precies doen wat u wilt. Meestal wil ik bijvoorbeeld dat er een fout wordt gegenereerd als het parseren mislukt en ik geen ondersteuning nodig heb voor Infinity, exponentials of leading witruimte. Afhankelijk van uw usecase is het soms verstandig om een ​​aangepaste conversiefunctie te schrijven.

Controleer altijd of de uitvoer van Number of een van de ontleedmethoden het soort nummer is dat u verwacht. Je zult bijna zeker willen gebruiken isNaN om er zeker van te zijn dat het nummer geen NaN is (meestal is dit de enige manier om te achterhalen dat de parsering mislukt is).


107
2017-12-11 07:47



ParseInt () en + zijn verschillend

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

50
2018-03-14 09:54



Hoewel een oude vraag, maar misschien kan dit nuttig zijn voor iemand.

Ik gebruik deze manier van het converteren van tekenreeks naar int aantal

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

Dus bij vermenigvuldiging met 1 verandert de waarde niet, maar js retourneert automatisch een getal.

Maar zoals hieronder wordt weergegeven, moet dit worden gebruikt als u zeker weet dat het str is een getal (of kan worden weergegeven als een getal), anders zal het NaN retourneren - geen getal.

u kunt een eenvoudige functie maken om te gebruiken, bijvoorbeeld

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

enter image description here


35
2018-03-16 18:24



Probeer parseInt.

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

31
2017-07-15 20:23



Ik heb hier het verkeerde antwoord geplaatst, sorry. vast.

Dit is een oude vraag, maar ik ben dol op deze truc:

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

Het dubbele bitsgewijze negatief valt na het decimaalteken af ​​EN zet het om naar een getalnotatie. Er is mij verteld dat het iets sneller is dan het aanroepen van functies en zo, maar ik ben er niet helemaal van overtuigd.

EDIT: Een andere methode die ik net heb gezien hier (een vraag over de javascript >>> -operator, een verschuiving naar rechts met een nul-vulling) die laat zien dat het verplaatsen van een getal met 0 door deze operator het getal omzet naar een uint32 dat is leuk als je het ook wilt ongetekend. Nogmaals, dit wordt geconverteerd naar een niet-ondertekend integer, wat tot vreemd gedrag kan leiden als u een ondertekend nummer gebruikt.

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

25
2018-01-16 09:51



Pas op als je parseInt gebruikt om een ​​float in wetenschappelijke notatie om te zetten! Bijvoorbeeld:

parseInt("5.6e-14") 

zal resulteren in

5 

in plaats van

0

18
2017-07-01 06:48



Ook als een kanttekening: Mootools heeft de functie toInt () die wordt gebruikt op elke native string (of float (of geheel getal)).

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

16
2017-07-16 20:05