Bagaimana cara saya mengatasi perilaku oktars parseInt JavaScript?

Coba jalankan yang berikut dalam JavaScript:

parseInt('01'); //equals 1
parseInt('02'); //equals 2
parseInt('03'); //equals 3
parseInt('04'); //equals 4
parseInt('05'); //equals 5
parseInt('06'); //equals 6
parseInt('07'); //equals 7
parseInt('08'); //equals 0 !!
parseInt('09'); //equals 0 !!

Saya baru belajar dengan susah payah bahwa JavaScript menganggap nol di depan menunjukkan integer oktal , dan karena tidak ada "8"atau "9"di basis-8, fungsi mengembalikan nol. Suka atau tidak, ini sesuai desain .

Apa solusinya?

Catatan: Demi kelengkapan, saya akan memposting solusi, tapi ini solusi yang saya benci, jadi tolong posting jawaban lain / lebih baik.

Memperbarui:

Edisi 5 dari standar JavaScript ( ECMA-262 ) memperkenalkan perubahan besar yang menghilangkan perilaku ini. Mozilla memiliki yang baik write-up .

Ini adalah gotcha Javascript yang umum dengan solusi sederhana:

Cukup tentukan basisnya , atau 'radix', seperti:

parseInt('08',10); // 8

Anda juga bisa menggunakan Nomor :

Number('08'); // 8

Jika Anda tahu nilai Anda akan berada dalam rentang integer 32 bit yang ditandatangani, maka ~~xakan melakukan hal yang benar di semua skenario.

~~"08" === 8
~~"foobar" === 0
~~(1.99) === 1
~~(-1.99)  === -1

Jika Anda mencari biner bukan ( ~), spesifikasi memerlukan konversi "ToInt32" untuk argumen yang melakukan konversi yang jelas ke Int32 dan ditentukan untuk memaksaNaN nilai menjadi nol.

Ya, ini sangat hackish tetapi sangat nyaman ...

Dari dokumentasi parseInt , gunakan argumen radix opsional untuk menentukan basis-10:

parseInt('08', 10); //equals 8
parseInt('09', 10); //equals 9

Ini menurut saya pedantic, membingungkan, dan bertele-tele (sungguh, argumen tambahan di setiap parseInt?) Jadi saya berharap ada Cara yang Lebih Baik.

function parseDecimal(s) { return parseInt(s, 10); }

sunting: membuat fungsi Anda sendiri, untuk melakukan apa yang benar-benar Anda inginkan, hanyalah sebuah opsi jika Anda tidak suka menambahkan panggilan ", 10" sepanjang waktu ke panggilan parseInt (). Ini memiliki kelemahan menjadi fungsi yang tidak standar: lebih nyaman bagi Anda jika Anda sering menggunakannya, tetapi mungkin lebih membingungkan bagi orang lain.

Tentukan basisnya:

var number = parseInt(s, 10);

Apakah akan sangat nakal untuk mengganti parseInt dengan versi yang mengasumsikan desimal jika tidak memiliki parameter kedua? (catatan - tidak diuji)

parseIntImpl = parseInt
parseInt = function(str, base){return parseIntImpl(str, base ? base : 10)}

Anda juga dapat, alih-alih menggunakan parseFloat atau parseInt, gunakan operator unary ( + ).

+"01"
// => 1

+"02"
// => 2

+"03"
// => 3

+"04"
// => 4

+"05"
// => 5

+"06"
// => 6

+"07"
// => 7

+"08"
// => 8

+"09"
// => 9

dan untuk ukuran yang baik

+"09.09"
// => 9.09

MDN Link

Operator plus unary mendahului operan dan mengevaluasi operan tetapi mencoba mengubahnya menjadi angka, jika belum. Meskipun negasi unary (-) juga dapat mengkonversi non-angka, unary plus adalah cara tercepat dan lebih disukai untuk mengubah sesuatu menjadi angka , karena ia tidak melakukan operasi lain pada nomor tersebut.

Bagaimana dengan ini untuk desimal:

('09'-0) === 9  // true

('009'-0) === 9 // true

Jika Anda sudah melakukan banyak pengkodean dengan parseInt dan tidak ingin menambahkan ", 10" ke semuanya, Anda bisa mengganti fungsi untuk menjadikan basis 10 sebagai default:

window._oldParseInt = window.parseInt;
window.parseInt = function(str, rad) {
    if (! rad) {
        return _oldParseInt(str, 10);
    }
    return _oldParseInt(str, rad);
};

Itu mungkin membingungkan pembaca kemudian, jadi membuat fungsi parseInt10 () mungkin lebih jelas. Secara pribadi saya lebih suka menggunakan fungsi sederhana daripada harus menambahkan ", 10" sepanjang waktu - hanya menciptakan lebih banyak peluang untuk kesalahan.

Masalah ini tidak dapat direplikasi di Chrome terbaru atau Firefox (2019).