Apa perbedaan antara parseInt () dan Number ()?

Bagaimana parseInt()dan Number()berperilaku berbeda ketika mengubah string menjadi angka?

Yah, mereka secara semantik berbeda , Numberkonstruktor yang disebut sebagai fungsi melakukan konversi jenis dan parseIntmelakukan penguraian , misalnya:

// parsing:
parseInt("20px");       // 20
parseInt("10100", 2);   // 20
parseInt("2e1");        // 2

// type conversion
Number("20px");       // NaN
Number("2e1");        // 20, exponential notation

Perlu diingat bahwa jika parseIntmendeteksi nol terdepan pada string, itu akan menguraikan angka dalam basis oktal, ini telah berubah pada ECMAScript 5, versi baru standar, tetapi akan membutuhkan waktu lama untuk mendapatkan implementasi browser (itu ketidakcocokan dengan ECMAScript 3), juga parseIntakan mengabaikan karakter tambahan yang tidak sesuai dengan angka apa pun dari basis yang saat ini digunakan.

The Numberkonstruktor tidak mendeteksi octals:

Number("010");         // 10
parseInt("010");       // 8, implicit octal
parseInt("010", 10);   // 10, decimal radix used

Tetapi dapat menangani angka dalam notasi heksadesimal, seperti parseInt:

Number("0xF");   // 15
parseInt("0xF"); //15

Selain itu, konstruk yang banyak digunakan untuk melakukan konversi tipe Numeric, adalah Unary +Operator (p. 72) , itu setara dengan menggunakan Numberkonstruktor sebagai fungsi:

+"2e1";   // 20
+"0xF";   // 15
+"010";   // 10

typeof parseInt("123") => number
typeof Number("123") => number
typeof new Number("123") => object (Number primitive wrapper object)

Dua yang pertama akan memberi Anda kinerja yang lebih baik karena mengembalikan primitif daripada objek.

Jika Anda mencari kinerja maka hasil terbaik mungkin Anda dapatkan dengan bitwise shift kanan "10">>0. Juga gandakan ( "10" * 1) atau tidak ( ~~"10"). Semuanya jauh lebih cepat Numberdan parseInt. Mereka bahkan memiliki "fitur" mengembalikan 0 untuk bukan nomor argumen. Berikut adalah tes Kinerja .

Saya menemukan dua link kinerja membandingkan antara beberapa cara untuk mengkonversi stringke int.

parseInt(str,10)    
parseFloat(str)
str << 0
+str
str*1 
str-0
Number(str)

http://jsben.ch/#/zGJHM

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

Satu perbedaan kecil adalah apa yang mereka konversi undefinedatau null,

Number() Or Number(null) // returns 0

sementara

parseInt() Or parseInt(null) // returns NaN

Ringkasan:

parseInt():

• Mengambil string sebagai argumen pertama, radix (bilangan bulat yang merupakan dasar dari sistem angka misalnya desimal 10 atau biner 2) sebagai argumen kedua
• Fungsi mengembalikan angka integer, jika karakter pertama tidak dapat dikonversi ke angka NaNakan dikembalikan.
• Jika parseInt()fungsi menemukan nilai non numerik, itu akan memotong sisa string input dan hanya menguraikan bagian sampai nilai non numerik.
• Jika radix adalah undefinedatau 0, JS akan menganggap berikut:
  • Jika string input dimulai dengan "0x" atau "0X", radix adalah 16 (heksadesimal), sisa string diurai menjadi angka.
  • Jika nilai input dimulai dengan 0, radix dapat berupa 8 (oktal) atau 10 (desimal). Radix mana yang dipilih tergantung pada implementasi mesin JS. ES5menetapkan bahwa 10 harus digunakan kemudian. Namun, ini tidak didukung oleh semua browser, oleh karena itu selalu tentukan radix jika angka Anda dapat dimulai dengan 0.
  • Jika nilai input dimulai dengan angka apa pun, radix akan menjadi 10

Number():

• The Number()konstruktor dapat mengkonversi input argumen ke nomor. Jika Number()konstruktor tidak dapat mengubah input menjadi angka, NaNakan dikembalikan.
• The Number()konstruktor juga dapat menangani sejumlah heksadesimal, mereka harus mulai dengan 0x.

Contoh:

console.log(parseInt('0xF', 16));  // 15

// z is no number, it will only evaluate 0xF, therefore 15 is logged
console.log(parseInt('0xFz123', 16));

// because the radix is 10, A is considered a letter not a number (like in Hexadecimal)
// Therefore, A will be cut off the string and 10 is logged
console.log(parseInt('10A', 10));  // 10

// first character isnot a number, therefore parseInt will return NaN
console.log(parseInt('a1213', 10));


console.log('\n');


// start with 0X, therefore Number will interpret it as a hexadecimal value
console.log(Number('0x11'));

// Cannot be converted to a number, NaN will be returned, notice that
// the number constructor will not cut off a non number part like parseInt does
console.log(Number('123A'));

// scientific notation is allowed
console.log(Number('152e-1'));  // 15.21

Saya selalu menggunakan parseInt, tetapi jangan nol terkemuka yang akan memaksa ke oktal modus.

parseInt() -> Parsing nomor ke redix yang ditentukan.

Number()-> Mengonversi nilai yang ditentukan ke angka yang setara atau NaN jika gagal melakukannya.

Karenanya untuk mengonversi beberapa nilai non-numerik ke angka, kita harus selalu menggunakan fungsi Number ().

misalnya.

Number("")//0
parseInt("")//NaN

Number("123")//123
parseInt("123")//123

Number("123ac") //NaN,as it is a non numeric string
parsInt("123ac") //123,it parse decimal number outof string

Number(true)//1
parseInt(true) //NaN

Ada berbagai kasus sudut parseInt()berfungsi seperti konversi redix, maka kita harus menghindari menggunakan fungsi parseInt () untuk tujuan koersi.

Sekarang, untuk memeriksa cuaca, nilai yang diberikan adalah Numerik atau tidak, kita harus menggunakan isNaN()fungsi asli

parseInt mengonversi ke angka integer, yaitu, mengupas desimal. Nomor tidak dikonversi ke bilangan bulat.

Ide yang bagus untuk menjauh dari parseInt dan gunakan Number dan Math.round kecuali Anda membutuhkan hex atau oktal. Keduanya bisa menggunakan string. Kenapa menjauh dari itu?

parseInt(0.001, 10)
0

parseInt(-0.0000000001, 10)
-1

parseInt(0.0000000001, 10)
1

parseInt(4000000000000000000000, 10)
4

Ini benar-benar tukang daging jumlah yang sangat besar atau sangat kecil. Anehnya itu berfungsi normal jika input ini adalah string.

parseInt("-0.0000000001", 10)
0

parseInt("0.0000000001", 10)
0

parseInt("4000000000000000000000", 10)
4e+21

Alih-alih mengambil risiko sulit untuk menemukan bug dengan ini dan orang-orang lain yang disebutkan, saya hanya akan menghindari parseInt kecuali Anda perlu mengurai sesuatu selain base 10. Number, Math.round, Math.foor, dan .toFixed (0) dapat semuanya melakukan hal yang sama parseInt dapat digunakan tanpa bug jenis ini.

Jika Anda benar-benar ingin atau perlu menggunakan parseInt untuk beberapa kualitas lainnya, jangan pernah menggunakannya untuk mengonversi float ke ints.