Hoe converteer ik een string naar een geheel getal in JavaScript?

Antwoord 1, autoriteit 100%

De eenvoudigste manier is om de native functie Numberte gebruiken:

var x = Number("1000")

Als dat niet voor u werkt, zijn er de parseInt, unary plus, parseFloat met verdiepingen Math.roundmethoden.

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 de vorm heeft van een geheel getal:

var x = +"1000";

als je string een float is of zou kunnen zijn en je een geheel getal 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 jij het type bent dat vergeet de radix in te voeren wanneer je parseInt aanroept, kun je parseFloat gebruiken en er omheen draaien zoals je wilt. Hier gebruik ik vloer.

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

Interessant is dat Math.round (zoals Math.floor) een string-naar-getalconversie uitvoert, dus als je het getal wilt afronden (of als je een geheel getal 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)

Antwoord 2, autoriteit 10%

Probeer de parseInt-functie:

var number = parseInt("10");

Maar er is een probleem. Als u “010” probeert te converteren met de functie parseInt, wordt dit gedetecteerd als een octaal getal 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

Houd er rekening mee dat parseIntslechte gegevens negeert na het ontleden van iets geldigs.
Deze gids zal ontleden als 51:

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

Antwoord 3, autoriteit 5%

Er zijn twee manieren om een string om te zetten in een getal in javascript. Een manier is om het te ontleden en de andere manier is om het type te veranderen in een getal. Bij alle trucs in de andere antwoorden (bijv. unair plus) wordt impliciet het type string tot een getal gedwongen. Je kunt hetzelfde expliciet doen met de nummerfunctie.

Ontcijferen

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

parseInt en parseFloat zijn de twee functies die worden gebruikt voor het ontleden van tekenreeksen naar getallen. Parsing stopt stil als het een teken raakt dat het niet herkent, wat handig kan zijn voor het ontleden van strings zoals “92px”, maar het is ook enigszins gevaarlijk, omdat het je geen enkele fout geeft bij slechte invoer, in plaats daarvan moet je krijg NaN terug, tenzij de string begint met een getal. Witruimte aan het begin van de tekenreeks wordt genegeerd. Hier is een voorbeeld waarin het iets anders doet dan je wilt, en geen indicatie geeft dat er iets mis is gegaan:

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

Het is een goede gewoonte om altijd de radix op te geven als het tweede argument. Als in oudere browsers de tekenreeks met een 0 begon, zou deze als octaal worden geïnterpreteerd als de radix niet was gespecificeerd, wat veel mensen verraste. Het gedrag voor hexadecimaal wordt geactiveerd door de tekenreeks te laten beginnen met 0x als er geen radix is opgegeven, b.v. 0xff. De standaard is eigenlijk veranderd met ecmascript 5, dus moderne browsers activeren niet langer octaal wanneer er een voorloop 0 is als er geen radix is opgegeven. parseInt begrijpt radixen tot en met 36, in welk geval zowel hoofdletters als kleine letters als equivalent worden behandeld.

Het type van een tekenreeks wijzigen in een getal

Alle andere hierboven genoemde trucs die geen gebruik maken van parseInt, omvatten het impliciet dwingen van de string in een getal. Ik doe dit liever expliciet,

var cast = Number("97");

Dit heeft een ander gedrag dan de ontledingsmethoden (hoewel het nog steeds witruimte negeert). Het is strenger: als het de hele tekenreeks niet begrijpt, retourneert het NaN, dus je kunt het niet gebruiken voor tekenreeksen zoals 97px. Aangezien u een primitief getal wilt in plaats van een Number-wrapperobject, moet u ervoor zorgen dat u newniet voor de Number-functie plaatst.

Natuurlijk krijg je bij het converteren naar een getal een waarde die misschien een float is in plaats van een geheel getal, dus als je een geheel getal wilt, moet je dit 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 bitsgewijze operator (hier heb ik een bitsgewijze of gedaan, maar je zou ook dubbele ontkenning kunnen doen zoals in een eerder antwoord of een bitshift) zal de waarde converteren naar een 32-bits geheel getal, en de meeste zullen worden geconverteerd naar een ondertekende geheel getal. Merk op dat dit niet wil 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 met grotere getallen te werken, moet u de afrondingsmethoden gebruiken

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

Houd er rekening mee dat coeercion exponentiële notatie en oneindigheid begrijpt, dus 2e2is 200in plaats van NaN, terwijl de ontledingsmethoden dat niet doen.

Aangepast

Het is onwaarschijnlijk dat een van deze methoden precies doet wat u wilt. Meestal wil ik bijvoorbeeld dat er een fout wordt gegenereerd als het parseren mislukt, en ik heb geen ondersteuning nodig voor oneindigheid, exponentiële getallen of leidende witruimte. Afhankelijk van uw gebruikssituatie is het soms zinvol om een aangepaste conversiefunctie te schrijven.

Controleer altijd of de uitvoer van Number of een van de ontledingsmethoden het soort nummer is dat u verwacht. U zult vrijwel zeker isNaNwillen gebruiken om er zeker van te zijn dat het nummer niet NaN is (meestal de enige manier om erachter te komen dat de parse is mislukt).

Antwoord 4, autoriteit 2%

ParseInt() en + zijn verschillend

parseInt("10.3456") // returns 10
+"10.3456" // returns 10.3456

Antwoord 5, autoriteit 2%

Snelste

var x = "1000"*1;

Test

Hier is een kleine vergelijking van snelheid (alleen Mac Os)… 🙂

Voor chrome zijn ‘plus’ en ‘mul’ het snelst (>700.000,00 op/sec), ‘Math.floor’ is het langzaamst. Voor Firefox is ‘plus’ het langzaamst (!) ‘mul’ het snelst (>900.000.000 op/sec). In Safari is ‘parseInt’ het snelst, ‘nummer’ is het langzaamst (maar de resultaten zijn vrij gelijkaardig, >13.000.000 <31.000.000). Dus Safari voor cast string naar int is meer dan 10x langzamer dan andere browsers. Dus de winnaar is ‘mul‘ 🙂

Je kunt het via deze link in je browser uitvoeren
https://jsperf.com/js-cast-str-to-number/1

Bijwerken

Ik test ook var x = ~~"1000";– in Chrome en Safari is iets langzamer dan var x = "1000"*1(&lt ;1%), in Firefox is iets sneller (<1%). Ik update bovenstaande foto en test

Antwoord 6, autoriteit 2%

Hoewel een oude vraag, maar misschien kan iemand hier iets aan hebben.

Ik gebruik deze manier om string te converteren naar intgetal

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

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

Maar zoals hieronder wordt getoond, moet dit worden gebruikt als u zeker weet dat de streen getal is (of kan worden weergegeven als een getal), anders wordt NaN geretourneerd – geen getal .

u kunt een eenvoudige functie maken om te gebruiken, bijv.

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

Antwoord 7

Probeer parseInt.

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

Antwoord 8

Ik heb hier het verkeerde antwoord gepost, sorry. opgelost.

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

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

De dubbele bitsgewijze min laat alles achter de komma vallen EN converteert het naar een getalnotatie. Er is mij verteld dat het iets sneller is dan het aanroepen van functies en zo, maar ik ben niet helemaal overtuigd.

EDIT: een andere methode die ik zojuist heb gezien hier(een vraag over de javascript >>>-operator, wat een nul-vul-rechtsverschuiving is) die laat zien dat het verschuiven van een getal met 0 met deze operator het getal omzet in een uint32wat fijn is als je het ook unsignedwilt. Nogmaals, dit wordt omgezet in een niet-ondertekend geheel getal, wat kan leiden tot vreemd gedrag als u een ondertekend getal gebruikt.

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

Antwoord 9

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

Antwoord 10

Om een tekenreeks naar een geheel getal te converteren, raad ik aan om parseFloat en NOTparseInt te gebruiken. Dit is waarom:

ParseFloat gebruiken:

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

ParseInt gebruiken:

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

Dus als je hebt gemerkt dat parseInt de waarden achter de decimalen weggooit, terwijl parseFloat je laat werken met drijvende-kommagetallen en daarom geschikter is als je de waarden na decimalen wilt behouden. Gebruik parseInt als en alleen als u zeker weet dat u de integerwaarde wilt.

Antwoord 11

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

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

Antwoord 12

Bekijk het onderstaande voorbeeld. Het zal u helpen uw twijfel weg te nemen

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

door gebruik te maken van de parseint-functie Het geeft alleen een op van integer present en niet de string

Antwoord 13

we kunnen +(stringOfNumber)gebruiken in plaats van parseInt(stringOfNumber)

Bijvoorbeeld: +("21")retourneert int van 21 zoals de parseInt("21").

we kunnen deze unaire “+” operator ook gebruiken voor het ontleden van float…

Antwoord 14

Er zijn veel manieren in JavaScript om een tekenreeks om te zetten in een getalswaarde… Allemaal eenvoudig en handig, kies de manier die voor u werkt:

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

Ook elke Mathbewerking converteert ze naar een getal, bijvoorbeeld…

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

Mijn voorkeur gaat uit naar het gebruik van het teken +, wat de elegante manier is om een tekenreeks in JavaScript om te zetten in een getal.

Antwoord 15

Probeer str - 0om stringom te zetten in 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 zijn twee links om de prestaties te vergelijken van verschillende manieren om string naar int te converteren

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

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

Antwoord 16

Naar mijn mening dekt geen enkel antwoord alle randgevallen, aangezien het ontleden van een float tot een fout zou moeten leiden.

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

Antwoord 17

Hier is de gemakkelijkste oplossing

let myNumber = "123" | 0;

Eenvoudigere oplossing

let myNumber = +"123";

Antwoord 18

Google gaf me dit antwoord als resultaat, dus…

Ik moest een string eigenlijk “opslaan” als een geheel getal, voor een binding tussen C en JavaScript, dus converteer ik de string naar een geheel getal:

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

Antwoord 19

Een andere optie is om de XOR-waarde met zichzelf te verdubbelen:

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

Dit levert het volgende op:

i = 12.34
i ⊕ i ⊕ i = 12

Antwoord 20

Ik heb maar één plus(+) voor string toegevoegd en dat was de oplossing!

+"052254" //52254

Hopelijk helpt het 😉

Antwoord 21

De vermenigvuldiging van cijfers optellen met hun respectievelijke macht van tien:

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

}

Antwoord 22

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

Antwoord 23

U kunt plus gebruiken.
Bijvoorbeeld:

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

dan kun je het type van de nieuwe variabele zien doortypeof personAge1; dat is Number.

Antwoord 24

In Javascript kunt u het volgende doen:-

ParseInt

parseInt("10.5") //returns 10

Vermenigvuldigen met 1

var s = "10";
s = s*1;  //returns 10

Unaire operator (+) gebruiken

var s = "10";
s = +s;  //returns 10

Bitgewijze operator gebruiken

(Opmerking: het begint te breken na 2140000000. Bijvoorbeeld:- ~~"2150000000" = -2144967296)

var s= "10.5";
s = ~~s; //returns 10

Math.floor() of Math.ceil() gebruiken

var s = "10";
s = Math.floor(s) || Math.ceil(s); //returns 10

Antwoord 25

al het bovenstaande is correct. Zorg ervoor dat dit een getal in een tekenreeks is door “typeot x === ‘nummer'” te doen, anders wordt NaN geretourneerd

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

Antwoord 26

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>

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

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

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

"1a2b3c" === 123
"198some text2hello world!30" === 198230
// ...

var str = '3a9b0c3d2e9f8g'
function extractInteger(str) {
  var result = 0;
  var factor = 1
  for (var i = str.length; i > 0; i--) {
    if (!isNaN(str[i - 1])) {
      result += parseInt(str[i - 1]) * factor
      factor *= 10
    }
  }
  return result
}
console.log(extractInteger(str))