Bersedia untuk ECMAScript 6: Kaedah Nombor Baru

Artikel ini merangkumi kaedah nombor baru dan bertambah baik dalam ES6 (ECMAScript 6).

Ini adalah sebahagian daripada siri mengenai ciri -ciri baru ES6, di mana kami juga telah membincangkan kaedah baru yang tersedia untuk jenis data rentetan dan array, tetapi juga jenis data baru seperti MAP dan Weakmap.

Saya akan memperkenalkan anda kepada kaedah dan pemalar baru yang ditambah kepada jenis data nombor. Beberapa kaedah nombor yang diliputi, seperti yang akan kita lihat, tidak baru sama sekali, tetapi mereka telah diperbaiki dan/atau bergerak di bawah objek yang betul (contohnya, isnan ()). Seperti biasa, kami juga akan meletakkan pengetahuan baru yang diperoleh dengan beberapa contoh. Oleh itu, tanpa berlanjutan lagi, mari kita mulakan.

Takeaways Key

ES6 memperkenalkan beberapa kaedah nombor baru, termasuk nombor.isInteger (), number.isnan (), number.isfinite (), number.issafeinteger (), number.parseint (), dan nombor.parsefloat ().

• number.isInteger () memeriksa sama ada nilai lulus adalah ujian integer, nombor.isnan () jika nilai sama dengan nan, dan nombor.isfinite () ujian jika nilai yang diluluskan adalah nombor terhingga.
• number.issafeInteger () menguji sama ada nilai yang diluluskan adalah nombor yang merupakan integer yang selamat, yang ditakrifkan sebagai integer yang boleh diwakili sebagai nombor ketepatan IEEE-754.
• number.parseInt () dan number.parsefloat () tidak baru, tetapi mereka telah dipindahkan di bawah objek nombor untuk tujuan modularization globals. Mereka menghuraikan hujah rentetan dan mengembalikan integer dan nombor titik terapung masing -masing.
• ES6 juga memperkenalkan dua nilai malar yang berkaitan: nombor.max_safe_integer dan nombor.min_safe_integer yang mewakili integer selamat dan minimum minimum dalam JavaScript.
number.isInteger ()

Kaedah pertama yang ingin saya sampaikan ialah nombor.isInteger (). Ia adalah tambahan baru kepada JavaScript, dan ini adalah sesuatu yang anda mungkin telah ditakrifkan dan digunakan oleh diri anda pada masa lalu. Ia menentukan sama ada nilai yang diluluskan kepada fungsi adalah integer atau tidak. Kaedah ini kembali benar jika nilai lulus adalah integer, dan sebaliknya. Pelaksanaan kaedah ini agak mudah, tetapi ia masih baik untuk memilikinya secara asli. Salah satu penyelesaian yang mungkin untuk mencipta semula fungsi ini ialah:

hanya untuk bersenang -senang, saya cuba mencipta semula fungsi ini dan saya berakhir dengan pendekatan yang berbeza:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && number % 1 === 0;
</span><span>};
</span>

Kedua -dua fungsi ini baik dan berguna tetapi mereka tidak menghormati spesifikasi ECMAScript 6. Oleh itu, jika anda ingin polyfill kaedah ini, anda memerlukan sesuatu yang lebih kompleks, seperti yang akan kita lihat tidak lama lagi. Buat masa ini, mari kita mulakan dengan menemui sintaks nombor.isInteger ():

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && Math.floor(number) === number;
</span><span>};
</span>

hujah nombor mewakili nilai yang anda mahu uji.

<span>Number.isInteger(number)
</span>

Beberapa contoh penggunaan kaedah ini ditunjukkan di bawah:

demo langsung kod sebelumnya ditunjukkan di bawah dan juga boleh didapati di JSBin.

<span>// prints 'true'
</span><span>console.log(Number.isInteger(19));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger(3.5));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger([1, 2, 3]));
</span>

Kaedah ini disokong dalam nod dan semua pelayar moden, kecuali Internet Explorer. Jika anda perlu menyokong pelayar yang lebih tua, anda boleh menggunakan polyfill, seperti yang terdapat di Rangkaian Pemaju Mozilla pada halaman Kaedah. Ini juga diterbitkan semula di bawah untuk kemudahan anda:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && number % 1 === 0;
</span><span>};
</span>

number.isnan ()

Jika anda telah menulis sebarang kod JavaScript pada masa lalu, kaedah ini tidak sepatutnya menjadi baru kepada anda. Buat sementara waktu sekarang, JavaScript mempunyai kaedah yang dipanggil Isnan () yang terdedah melalui objek tetingkap. Kaedah ini menguji jika nilai adalah sama dengan NAN, di mana ia kembali benar, atau sebaliknya palsu. Masalah dengan window.isnan () adalah bahawa ia mempunyai masalah kerana ia juga kembali benar untuk nilai -nilai yang ditukar ke nombor akan menjadi nan. Untuk memberi anda idea konkrit mengenai isu ini, semua pernyataan berikut kembali benar:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && Math.floor(number) === number;
</span><span>};
</span>

Apa yang anda perlukan adalah kaedah yang mengembalikan benar hanya jika nilai nan diluluskan. Itulah sebabnya ECMAScript 6 telah memperkenalkan kaedah nombor.isnan (). Sintaksinya cukup banyak yang anda harapkan:

<span>Number.isInteger(number)
</span>

di sini, nilai adalah nilai yang anda mahu uji. Beberapa contoh penggunaan kaedah ini ditunjukkan di bawah:

<span>// prints 'true'
</span><span>console.log(Number.isInteger(19));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger(3.5));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger([1, 2, 3]));
</span>

seperti yang anda dapat lihat, menguji nilai yang sama, kami memperoleh hasil yang berbeza.

Demo langsung coretan sebelumnya ditunjukkan di bawah dan juga boleh didapati di JSBin.

Kaedah ini disokong dalam nod dan semua pelayar moden, kecuali Internet Explorer. Jika anda ingin menyokong penyemak imbas lain, polyfill yang sangat mudah untuk kaedah ini adalah seperti berikut:

<span>if (!Number.isInteger) {
</span>  <span>Number.isInteger = function isInteger (nVal) {
</span>    <span>return typeof nVal === 'number' &&
</span>      <span>isFinite(nVal) &&
</span>      nVal <span>> -9007199254740992 &&
</span>      nVal <span>< 9007199254740992 &&
</span>      <span>Math.floor(nVal) === nVal;
</span>  <span>};
</span><span>}
</span>

Alasan ini berfungsi adalah kerana NAN adalah satu-satunya nilai yang tidak refleksif dalam JavaScript, yang bermaksud bahawa ia adalah satu-satunya nilai yang tidak sama dengan dirinya sendiri.

number.isfinite ()

Kaedah ini berkongsi cerita yang sama seperti yang sebelumnya. Dalam JavaScript terdapat kaedah yang dipanggil window.isfinite () yang menguji jika nilai yang diluluskan adalah nombor terhingga atau tidak. Malangnya, ia juga kembali benar untuk nilai -nilai yang ditukar

ke nombor akan menjadi nombor terhingga. Contoh isu ini ditunjukkan di bawah:

Atas sebab ini, dalam ECMAScript 6 terdapat kaedah yang dipanggil Isfinite () yang dimiliki oleh nombor. Sintaksinya adalah seperti berikut:

<span>// prints 'true'
</span><span>console.log(window.isNaN(0/0));
</span>
<span>// prints 'true'
</span><span>console.log(window.isNaN('test'));
</span>
<span>// prints 'true'
</span><span>console.log(window.isNaN(undefined));
</span>
<span>// prints 'true'
</span><span>console.log(window.isNaN({prop: 'value'}));
</span>

di sini, nilai adalah nilai yang anda mahu uji. Jika anda menguji nilai yang sama dari coretan sebelumnya, anda dapat melihat bahawa hasilnya berbeza:

<span>Number.isNaN(value)
</span>

Demo langsung coretan sebelumnya ditunjukkan di bawah dan juga boleh didapati di JSBin.

<span>// prints 'true'
</span><span>console.log(Number.isNaN(0/0));
</span>
<span>// prints 'true'
</span><span>console.log(Number.isNaN(NaN));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isNaN(undefined));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isNaN({prop: 'value'}));
</span>

Kaedah ini disokong dalam nod dan semua pelayar moden, kecuali Internet Explorer. Anda boleh mencari polyfill untuknya pada halaman kaedah di MDN.

number.issafeInteger ()

Kaedah Number.IsafeInteger () adalah tambahan baru kepada ES6. Ia menguji sama ada nilai yang diluluskan adalah nombor yang merupakan integer yang selamat, di mana ia kembali benar. Integer yang selamat ditakrifkan sebagai integer yang memenuhi kedua -dua syarat berikut:

• Nombor ini boleh diwakili sebagai nombor ketepatan IEEE-754
• Perwakilan IEEE-754 nombor itu tidak boleh menjadi hasil dari mana-mana integer lain agar sesuai dengan perwakilan IEEE-754.

Berdasarkan definisi ini, bilangan bulat selamat adalah semua bilangan bulat dari -(2 ⁵³ -1) termasuk 2 ⁵³ -1 termasuk. Nilai -nilai ini penting dan kami akan membincangkannya sedikit lagi pada akhir bahagian ini.

Sintaks kaedah ini ialah:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && number % 1 === 0;
</span><span>};
</span>

di sini, nilai adalah nilai yang anda mahu uji. Beberapa contoh penggunaan kaedah ini ditunjukkan di bawah:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && Math.floor(number) === number;
</span><span>};
</span>

demo langsung kod ini ditunjukkan di bawah dan juga boleh didapati di JSBin.

Number.IsafeInteger () disokong dalam nod dan semua pelayar moden, kecuali Internet Explorer. Polyfill untuk kaedah ini, yang diekstrak dari ES6-shim oleh Paul Miller, adalah:

<span>Number.isInteger(number)
</span>

Perhatikan bahawa polyfill ini bergantung pada number.isInteger () kaedah yang dibincangkan sebelum ini, jadi anda perlu polyfill yang terakhir juga untuk menggunakan yang satu ini.

ECMAScript 6 juga memperkenalkan dua nilai malar yang berkaitan: nombor.max_safe_integer dan nombor.min_safe_integer. Bekas mewakili integer selamat maksimum dalam JavaScript -iaitu, 2 ⁵³ -1 -manakala yang terakhir adalah integer selamat minimum, iaitu -(2 ⁵³ -1). Seperti yang anda perhatikan, ini adalah nilai yang sama yang saya sebutkan tadi.

number.parseInt () dan number.parsefloat ()

number.parseInt () dan number.parsefloat () kaedah diliputi dalam bahagian yang sama kerana, tidak seperti kaedah lain yang serupa yang disebutkan dalam artikel ini, mereka sudah wujud dalam versi sebelumnya Ecmascript, tetapi tidak berbeza dari mereka versi global lama. Jadi, anda boleh menggunakannya dengan cara yang sama yang telah anda lakukan setakat ini dan anda boleh mengharapkan hasil yang sama. Tujuan menambahkan kaedah ini kepada bilangan adalah modularization globals.

Demi kesempurnaan, saya melaporkan sintaks mereka:

<span>// prints 'true'
</span><span>console.log(Number.isInteger(19));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger(3.5));
</span>
<span>// prints 'false'
</span><span>console.log(Number.isInteger([1, 2, 3]));
</span>

di sini, rentetan mewakili nilai yang anda mahu menghuraikan dan radix adalah radix yang anda mahu gunakan untuk menukar rentetan.

coretan berikut menunjukkan beberapa contoh penggunaan:

<span>if (!Number.isInteger) {
</span>  <span>Number.isInteger = function isInteger (nVal) {
</span>    <span>return typeof nVal === 'number' &&
</span>      <span>isFinite(nVal) &&
</span>      nVal <span>> -9007199254740992 &&
</span>      nVal <span>< 9007199254740992 &&
</span>      <span>Math.floor(nVal) === nVal;
</span>  <span>};
</span><span>}
</span>

demo langsung kod ini dipaparkan di bawah dan juga boleh didapati di JSBin.

Kaedah ini disokong dalam nod dan semua pelayar moden, kecuali Explorer Internet. Sekiranya anda ingin polyfill mereka, anda hanya boleh memanggil kaedah global yang berkaitan seperti yang disenaraikan di bawah:

<span>Number.isInteger = Number.isInteger || function (number) {
</span>  <span>return typeof number === 'number' && number % 1 === 0;
</span><span>};
</span>

Sokongan penyemak imbas

Grafik berikut menggambarkan sokongan penyemak imbas untuk sambungan ke objek nombor terbina dalam dalam ES6. Tetikus di atas kotak untuk melihat peratusan penggunaan versi penyemak imbas masing -masing.

Bolehkah saya menggunakan nombor ES6? Data mengenai sokongan untuk ciri nombor ES6 di seluruh pelayar utama dari Caniuse.com.

Kaedah Nombor ES6: Membungkus

Dalam tutorial ini, kami telah meliputi kaedah dan pemalar baru yang ditambah dalam ECMAScript 6 yang berfungsi dengan jenis data nombor. Perlu diingat bahawa ES6 juga telah menambah satu lagi pemalar yang saya belum disebutkan setakat ini. Ini adalah nombor.epsilon dan mewakili perbezaan antara satu dan nilai terkecil yang lebih besar daripada satu yang boleh diwakili sebagai nombor. 🎜> Soalan Lazim (Soalan Lazim) Mengenai Kaedah Nombor ES6

Apakah kaedah nombor ES6 yang baru dan bagaimana mereka berfungsi? Ini termasuk nombor.isfinite (), number.isInteger (), number.isnan (), number.parsefloat (), dan number.parseInt (). Setiap kaedah ini melaksanakan fungsi tertentu. Sebagai contoh, nombor.isfinite () memeriksa jika nilai adalah nombor terhingga, manakala nombor.isInteger () memeriksa jika nilai adalah integer. Nombor.Isnan () memeriksa jika nilai adalah nan (bukan nombor), dan nombor.parsefloat () dan nombor.parseInt () menghuraikan argumen rentetan dan mengembalikan nombor titik terapung dan masing -masing integer. Bagaimanakah kaedah number.epsilon berfungsi dalam ES6?

Number.Epsilon dalam ES6 adalah pemalar baru yang mewakili selang terkecil antara dua nombor yang boleh diwakili. Ia amat berguna apabila membandingkan nombor titik terapung untuk kesamaan. Oleh kerana nombor titik terapung diwakili dalam komputer, mereka mungkin tidak sama sama walaupun mereka kelihatan. Number.Epsilon boleh digunakan untuk memeriksa sama ada perbezaan antara dua nombor adalah kurang daripada selang terkecil ini, menunjukkan bahawa ia sama dengan berkesan. 🎜> Kaedah Number.IsafeInteger () dalam ES6 digunakan untuk menentukan sama ada nilai adalah integer yang selamat. Integer yang selamat adalah nombor yang boleh diwakili sebagai nombor ketepatan dua kali ganda IEEE -754, yang bermaksud ia berada dalam julat -(2^53 -1) dan 2^53 -1. Kaedah ini berguna apabila anda mahu Pastikan nombor boleh diwakili dengan tepat dalam JavaScript, yang boleh menjadi penting dalam operasi matematik tertentu.

bagaimana kaedah number.parseInt () berbeza dari fungsi parseInt () global? sebahagian daripada objek nombor. Ini bermakna anda boleh memanggilnya sebagai kaedah pada objek nombor, dan bukannya sebagai fungsi mandiri. Fungsi adalah sama - ia menukarkan rentetan ke integer pada radix atau asas yang ditentukan. Nombor.max_safe_integer dan nombor.min_safe_integer pemalar dalam ES6 mewakili nilai integer maksimum dan minimum dalam javascript. Integer yang selamat adalah salah satu yang boleh diwakili sebagai nombor ketepatan dua kali IEEE-754. Pemalar ini berguna apabila anda perlu menyemak sama ada nombor berada dalam julat integer yang selamat, yang boleh menjadi penting dalam operasi matematik tertentu. >

Kaedah Number.Isnan () dalam ES6 digunakan untuk menentukan sama ada nilai adalah nan (bukan nombor). Ini berbeza dengan fungsi Isnan () global, yang menukarkan hujahnya kepada nombor sebelum mengujinya. Nombor.isnan () tidak melakukan penukaran ini, jadi ia hanya mengembalikan benar jika argumen adalah nilai nan sebenar, dan bukan jika argumen adalah nilai yang tidak dapat ditukar kepada nombor.

Apa Adakah penggunaan number.isfinite () kaedah dalam ES6?

Kaedah Number.Isfinite () dalam ES6 digunakan untuk menentukan sama ada nilai adalah nombor terhingga. Ini berbeza dengan fungsi Isfinite Global (), yang menukarkan hujahnya kepada nombor sebelum mengujinya. Nombor.isfinite () tidak melakukan penukaran ini, jadi ia hanya mengembalikan benar jika hujah adalah nombor terhingga, dan bukan jika argumen adalah nilai yang tidak dapat ditukar kepada nombor. Kaedah nombor.parSefloat () berfungsi dalam ES6?

Kaedah Number.ParSefloat () dalam ES6 pada dasarnya sama dengan fungsi Global ParseFloat (), tetapi ia adalah sebahagian daripada objek nombor. Ini bermakna anda boleh memanggilnya sebagai kaedah pada objek nombor, dan bukannya sebagai fungsi mandiri. Fungsian adalah sama - ia menghancurkan argumen rentetan dan mengembalikan nombor titik terapung.

Bagaimana saya boleh menggunakan kaedah number.isInteger () dalam ES6? Kaedah dalam ES6 digunakan untuk menentukan sama ada nilai adalah integer. Kaedah ini kembali benar jika nilai adalah nombor yang tidak tak terhingga, bukan nan, dan boleh dinyatakan tanpa komponen pecahan. Ia berguna apabila anda perlu menyemak sama ada nombor adalah integer, yang boleh menjadi penting dalam operasi matematik tertentu.

Apakah aplikasi praktikal kaedah nombor ES6 yang baru? Mereka boleh digunakan untuk memeriksa sama ada nombor adalah terhingga, integer, nan, atau integer yang selamat, dan untuk menghuraikan rentetan ke dalam nombor. Kaedah ini amat berguna dalam operasi matematik, pengesahan data, dan di mana sahaja di mana kawalan tepat ke atas nombor diperlukan.

Atas ialah kandungan terperinci Bersedia untuk ECMAScript 6: Kaedah Nombor Baru. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!