ฉันจะแปลงสตริงเป็นจำนวนเต็มใน JavaScript ได้อย่างไร

วิธีที่ง่ายที่สุดคือการใช้Numberฟังก์ชั่นดั้งเดิม:

var x = Number("1000")

หากไม่ได้ผลสำหรับคุณแล้วมีparseInt , เอกบวก , parseFloat กับพื้นและ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])

บวกถ้าสตริงของคุณอยู่ในรูปของจำนวนเต็ม:

var x = +"1000";

ถ้าสตริงของคุณเป็นหรืออาจเป็นทศนิยมและคุณต้องการจำนวนเต็ม:

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

หรือถ้าคุณจะใช้ Math.floor หลายครั้ง:

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

หากคุณเป็นคนประเภทที่ลืมใส่เลขฐานในเมื่อคุณเรียกใช้ parseInt คุณสามารถใช้ parseFloat และปัดเศษตามที่คุณต้องการ ที่นี่ฉันใช้พื้น

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

ที่น่าสนใจคือ Math.round (เช่น Math.floor) จะทำการแปลงสตริงเป็นตัวเลขดังนั้นถ้าคุณต้องการปัดเศษตัวเลข (หรือถ้าคุณมีจำนวนเต็มในสตริง) นี่เป็นวิธีที่ยอดเยี่ยมบางทีฉันอาจชอบ:

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

ลองใช้ฟังก์ชัน parseInt:

var number = parseInt("10");

แต่มีปัญหา หากคุณพยายามแปลง "010" โดยใช้ฟังก์ชัน parseInt จะตรวจพบว่าเป็นเลขฐานแปดและจะส่งกลับหมายเลข 8 ดังนั้นคุณต้องระบุเลขฐาน (จาก 2 เป็น 36) ในกรณีนี้ฐาน 10

parseInt(string, radix)

ตัวอย่าง:

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

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

โปรดทราบว่าparseIntจะไม่สนใจข้อมูลที่ไม่ถูกต้องหลังจากแยกวิเคราะห์สิ่งที่ถูกต้อง
Guid นี้จะแยกวิเคราะห์เป็น 51:

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

มีสองวิธีหลักในการแปลงสตริงเป็นตัวเลขในจาวาสคริปต์ วิธีหนึ่งคือการแยกวิเคราะห์และวิธีอื่นคือเปลี่ยนชนิดเป็นตัวเลข เทคนิคทั้งหมดในคำตอบอื่น ๆ (เช่น unary plus) เกี่ยวข้องกับการบังคับชนิดของสตริงให้กับตัวเลขโดยปริยาย คุณสามารถทำสิ่งเดียวกันอย่างชัดเจนด้วยฟังก์ชัน Number

วจีวิภาค

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

parseInt และ parseFloat เป็นสองฟังก์ชันที่ใช้ในการแยกสตริงเป็นตัวเลข การแยกวิเคราะห์จะหยุดลงอย่างเงียบ ๆ หากพบอักขระที่ไม่รู้จักซึ่งอาจเป็นประโยชน์สำหรับการวิเคราะห์สตริงเช่น "92px" แต่ก็ค่อนข้างอันตรายเนื่องจากจะไม่ให้ข้อผิดพลาดใด ๆ จะรับ NaN กลับมาเว้นแต่ว่าสตริงจะขึ้นต้นด้วยตัวเลข ช่องว่างที่จุดเริ่มต้นของสตริงจะถูกละเว้น นี่คือตัวอย่างของการทำสิ่งที่แตกต่างกับสิ่งที่คุณต้องการและไม่ให้สิ่งบ่งชี้ว่ามีสิ่งผิดปกติเกิดขึ้น:

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

เป็นวิธีปฏิบัติที่ดีที่จะระบุ radix เป็นอาร์กิวเมนต์ที่สองเสมอ ในเบราว์เซอร์รุ่นเก่าถ้าสตริงเริ่มต้นด้วย 0 มันจะถูกตีความว่าเป็นเลขฐานแปดหากไม่ได้ระบุ Radix ซึ่งทำให้ผู้คนจำนวนมากประหลาดใจ พฤติกรรมเลขฐานสิบหกจะถูกเรียกโดยมีจุดเริ่มต้นสตริงกับ 0x 0xffหากไม่มีรากที่ระบุไว้เช่น มาตรฐานเปลี่ยนไปจริง ๆ ด้วย ecmascript 5 ดังนั้นเบราว์เซอร์สมัยใหม่จึงไม่เรียกเลขฐานแปดเมื่อมีค่านำหน้า 0 หากไม่มีการระบุ Radix parseInt เข้าใจ radixes จนถึงฐาน 36 ซึ่งในกรณีนี้ตัวอักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็กจะถือว่าเท่าเทียมกัน

การเปลี่ยนประเภทของสตริงเป็นตัวเลข

เทคนิคอื่น ๆ ทั้งหมดที่กล่าวถึงข้างต้นที่ไม่ได้ใช้ parseInt เกี่ยวข้องกับการบังคับสตริงโดยนัยเป็นตัวเลข ฉันชอบทำสิ่งนี้อย่างชัดเจน

var cast = Number("97");

สิ่งนี้มีพฤติกรรมที่แตกต่างกันในวิธีการวิเคราะห์คำ (แม้ว่าจะยังคงละเว้นช่องว่าง) มันเข้มงวดมากขึ้น: ถ้ามันไม่เข้าใจสตริงทั้งหมดมากกว่าที่จะส่งคืนNaNดังนั้นคุณจะไม่สามารถใช้มันสำหรับสตริง97pxได้ เนื่องจากคุณต้องการหมายเลขดั้งเดิมไม่ใช่อ็อบเจกต์ Number wrapper ตรวจสอบให้แน่ใจว่าคุณไม่ได้ใส่newฟังก์ชั่น Number

เห็นได้ชัดว่าการแปลงเป็นตัวเลขให้ค่าที่อาจเป็นทศนิยมแทนที่จะเป็นจำนวนเต็มดังนั้นหากคุณต้องการจำนวนเต็มคุณจะต้องแก้ไข มีสองสามวิธีในการทำสิ่งนี้:

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

ตัวดำเนินการ bitwise ใด ๆ (ที่นี่ฉันได้ทำ bitwise หรือ แต่คุณสามารถทำการปฏิเสธสองครั้งในคำตอบก่อนหน้าหรือ bithift) จะแปลงค่าเป็นจำนวนเต็ม 32 บิตและส่วนใหญ่จะแปลงเป็นจำนวนเต็มที่ลงนาม หมายเหตุที่ว่านี้จะไม่ต้องการที่คุณต้องการสำหรับจำนวนเต็มขนาดใหญ่ หากจำนวนเต็มไม่สามารถแทนได้ใน 32 บิตจะเป็นการตัด

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

ในการทำงานอย่างถูกต้องด้วยจำนวนที่มากขึ้นคุณควรใช้วิธีการปัดเศษ

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

โปรดจำไว้ว่าวิธีการเหล่านี้ทั้งหมดเข้าใจสัญลักษณ์แบบเอ็กซ์โปเนนเชียลดังนั้นจึง2e2เป็น200มากกว่า NaN นอกจากนี้ Number ยังเข้าใจ "Infinity" ในขณะที่วิธีการวิเคราะห์คำไม่สามารถทำได้

กำหนดเอง

ไม่น่าเป็นไปได้ว่าวิธีใดวิธีหนึ่งเหล่านี้ทำสิ่งที่คุณต้องการอย่างแน่นอน ตัวอย่างเช่นโดยปกติฉันต้องการให้เกิดข้อผิดพลาดหากการวิเคราะห์คำล้มเหลวและฉันไม่ต้องการการสนับสนุน Infinity, exponentials หรือช่องว่างนำหน้า บางครั้งการเขียนฟังก์ชั่นการแปลงแบบกำหนดเองนั้นขึ้นอยู่กับ usecase ของคุณ

ตรวจสอบเสมอว่าเอาต์พุตของ Number หรือหนึ่งในวิธีการวิเคราะห์คำเป็นประเภทของหมายเลขที่คุณคาดหวัง คุณเกือบจะต้องการใช้isNaNเพื่อให้แน่ใจว่าหมายเลขไม่ใช่ NaN (โดยทั่วไปแล้วเป็นวิธีเดียวที่คุณจะพบว่าการแยกวิเคราะห์ล้มเหลว)

ParseInt () และ + แตกต่างกัน

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

ที่เร็วที่สุด

var x = "1000"*1;

ทดสอบ

นี่เป็นการเปรียบเทียบความเร็วเล็กน้อย (สำหรับ Mac Os เท่านั้น) ... :)

สำหรับ chrome 'plus' และ 'mul' นั้นเร็วที่สุด (> 700,000,00 op / วินาที) 'Math.floor' จะช้าที่สุด สำหรับ Firefox 'plus' ช้าที่สุด (!) 'mul' เร็วที่สุด (> 900,000,000 op / sec) ใน Safari 'parseInt' เป็น fastes 'number' ช้าที่สุด (แต่ resulats นั้นค่อนข้างคล้ายกัน> 13,000,000 <31,000,000) ดังนั้น Safari สำหรับการส่งสตริงไปยัง int นั้นช้ากว่าเบราว์เซอร์อื่น ๆ มากกว่า 10x ดังนั้นผู้ชนะคือ ' mul ' :)

คุณสามารถเรียกใช้ได้บนเบราว์เซอร์ของคุณโดยลิงค์นี้ https://jsperf.com/js-cast-str-to-number/1

ปรับปรุง

ฉันยังทดสอบvar x = ~~"1000";- บน Chrome และ Safari ช้ากว่าvar x = "1000"*1(<1%) เล็กน้อยใน Firefox จะเร็วขึ้นเล็กน้อย (<1%) ฉันอัปเดตรูปภาพและการทดสอบข้างต้น

แม้ว่าจะเป็นคำถามเก่า แต่บางทีนี่อาจเป็นประโยชน์กับใครบางคน

ฉันใช้วิธีนี้ในการแปลงสตริงเป็นจำนวนint

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

ดังนั้นเมื่อคูณด้วย 1 ค่าจะไม่เปลี่ยน แต่ js จะส่งกลับตัวเลขโดยอัตโนมัติ

แต่ตามที่แสดงด้านล่างนี้ควรใช้หากคุณแน่ใจว่าstrเป็นตัวเลข (หรือสามารถแสดงเป็นตัวเลข) มิฉะนั้นจะส่งคืน NaN - ไม่ใช่ตัวเลข

คุณสามารถสร้างฟังก์ชั่นที่ใช้งานง่ายเช่น

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

ลองแยกวิเคราะห์

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

ฉันโพสต์คำตอบที่ผิดที่นี่ขอโทษ แก้ไขแล้ว.

นี่เป็นคำถามเก่า แต่ฉันชอบเคล็ดลับนี้:

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

ค่าลบที่เป็นค่าบิตสองเท่าจะลดลงทุกอย่างหลังจากจุดทศนิยมและแปลงเป็นรูปแบบตัวเลข ฉันบอกว่ามันเร็วกว่าฟังก์ชั่นการโทรและอะไรก็ตาม แต่ฉันก็ไม่มั่นใจ

แก้ไข: วิธีอื่นที่ฉันเพิ่งเห็นที่นี่ (คำถามเกี่ยวกับตัวดำเนินการ javascript >>> ซึ่งเป็น shift-zero right shift) ซึ่งแสดงให้เห็นว่าการขยับตัวเลขด้วย 0 ด้วยตัวดำเนินการนี้จะแปลงตัวเลขเป็นuint32ซึ่งดีถ้าคุณ ยังต้องการมันไม่ได้ลงนาม อีกครั้งนี้แปลงเป็นจำนวนเต็มไม่ได้ลงนามซึ่งสามารถนำไปสู่พฤติกรรมที่แปลกถ้าคุณใช้หมายเลขที่ลงนาม

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

ระวังถ้าคุณใช้การแยกวิเคราะห์เพื่อแปลงลอยในสัญกรณ์ทางวิทยาศาสตร์! ตัวอย่างเช่น:

parseInt("5.6e-14") 

จะส่งผลให้

5 

แทน

0

ในการแปลงสตริงเป็นจำนวนเต็มฉันแนะนำให้ใช้ parseFloat และไม่ parseInt นี่คือเหตุผล:

ใช้ parseFloat:

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

ใช้ parseInt:

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

ดังนั้นถ้าคุณสังเกตเห็น parseInt จะทิ้งค่าหลังจากทศนิยมในขณะที่ parseFloat ช่วยให้คุณทำงานกับตัวเลขจุดลอยตัวและดังนั้นจึงเหมาะสมกว่าถ้าคุณต้องการเก็บค่าหลังจากทศนิยม ใช้ parseInt หากว่าคุณแน่ใจว่าคุณต้องการค่าจำนวนเต็ม

นอกจากนี้ยังเป็นหมายเหตุด้าน: Mootools มีฟังก์ชั่น toInt () ซึ่งจะใช้กับสตริงพื้นเมืองใด ๆ (หรือลอยตัว (หรือจำนวนเต็ม))

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

โปรดดูตัวอย่างด้านล่างมันจะช่วยล้างข้อสงสัยของคุณ

Example                  Result

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

โดยใช้ฟังก์ชั่น parseint มันจะให้ op ของจำนวนเต็มปัจจุบันและไม่สตริง

เราสามารถใช้+(stringOfNumber)แทนการใช้parseInt(stringOfNumber)

เช่น+("21")คืนค่า int จาก 21 เช่นparseInt("21").

เราสามารถใช้โอเปอเรเตอร์ "+" unary นี้สำหรับการวิเคราะห์โฟลตด้วย ...

JavaScript มีหลายวิธีในการแปลงสตริงเป็นค่าตัวเลข ... ทั้งหมดที่ง่ายและสะดวกเลือกวิธีที่เหมาะกับคุณ:

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

นอกจากนี้การดำเนินการทางคณิตศาสตร์ใด ๆแปลงให้เป็นตัวเลขเช่น ...

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

วิธีที่ฉันชอบคือการใช้+เครื่องหมายซึ่งเป็นวิธีที่สวยงามในการแปลงสตริงเป็นตัวเลขใน JavaScript

ลองstr - 0แปลงไปstringnumber

> 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

ต่อไปนี้เป็นสองลิงก์เพื่อเปรียบเทียบประสิทธิภาพการทำงานหลายวิธีในการแปลงสตริงเป็น int

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

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

Google ให้คำตอบนี้กับฉันดังนั้น ...

ฉันต้องการ "บันทึก" สตริงเป็นจำนวนเต็มสำหรับการโยงระหว่าง C และ JavaScript ดังนั้นฉันจึงแปลงสตริงเป็นค่าจำนวนเต็ม:

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

ในความคิดของฉันไม่มีคำตอบครอบคลุมกรณีขอบทั้งหมดเนื่องจากการแยกลอยจะทำให้เกิดข้อผิดพลาด

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

นี่คือทางออกที่ง่ายที่สุด

let myNumber = "123" | 0;

ทางออกที่ง่ายขึ้น

let myNumber = +"123";

ถูกต้องทั้งหมด โปรดตรวจสอบให้แน่ใจก่อนว่านี่เป็นตัวเลขในสตริงด้วยการทำ "typeot x ===" number "" อย่างอื่นที่ฉลาดมันจะคืนค่า NaN

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

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

ตัวเลือกอื่นคือการ XOR สองเท่าของค่าด้วยตัวมันเอง:

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

สิ่งนี้จะออก:

i = 12.34
i ⊕ i ⊕ i = 12

ฉันเพิ่งเพิ่มหนึ่งบวก (+) ก่อนที่จะสตริงและนั่นคือทางออก!

+"052254" //52254

หวังว่ามันจะช่วย;)

การรวมการคูณตัวเลขด้วยกำลังของพวกเขาสิบ:

เช่น: 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;

}

ฉันใช้สิ่งนี้

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

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

คุณสามารถใช้เครื่องหมายบวกเช่น =>

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

จากนั้นคุณสามารถเห็น typeof personAge เป็นตัวเลข