Articles
Pengenalan kepada JavaScript
Kelas `Number` dalam JavaScript

Kelas `Number` dalam JavaScript

Artikel ini menerangkan kelas Number dalam JavaScript.

Kami akan menerangkan secara terperinci ciri-ciri Number, kesilapan yang sering berlaku, API yang berguna, dan contoh-contoh praktikal secara berperingkat.

YouTube Video

Kelas Number dalam JavaScript

Number ialah jenis asas nombor dalam JavaScript dan diwakili sebagai titik terapung dwi-presisi IEEE-754 (64-bit).

Asas: Perwakilan Nombor dan Pemeriksaan Jenis

Dalam JavaScript, semua nombor diwakili sebagai jenis primitif number.

 1// Primitive numbers and Number object
 2const a = 42;                 // primitive number
 3const b = 3.14;               // primitive float
 4const c = Number(10);         // primitive via constructor call (function form)
 5const d = new Number(10);     // Number object (wrapper)
 6
 7console.log(typeof a);        // "number"
 8console.log(typeof d);        // "object"
 9console.log(c == d);          // true  (value coerces)
10console.log(c === d);         // false (different types)
  • Kod ini menunjukkan perbezaan antara number primitif dan objek pembungkus Number. Kebiasaannya, jenis primitif digunakan berbanding pembungkus.

Nilai Khas: NaN, Infinity, dan Pemalar

Number menyediakan nilai khas (NaN, Infinity) dan pemalar.

 1// Special numeric values and constants
 2console.log(Number.NaN);                 // NaN
 3console.log(Number.POSITIVE_INFINITY);   // Infinity
 4console.log(Number.NEGATIVE_INFINITY);   // -Infinity
 5
 6console.log(Number.MAX_VALUE);           // largest positive representable
 7console.log(Number.MIN_VALUE);           // smallest positive representable (closest to 0)
 8console.log(Number.MAX_SAFE_INTEGER);    // 9007199254740991
 9console.log(Number.MIN_SAFE_INTEGER);    // -9007199254740991
10console.log(Number.EPSILON);             // smallest difference ~2.220446049250313e-16
  • Integer yang lebih besar atau sama dengan MAX_SAFE_INTEGER mungkin tidak diwakili dengan tepat. Pertimbangkan untuk menggunakan BigInt jika ketepatan diperlukan. EPSILON digunakan untuk perbandingan nombor titik terapung.

Penukaran Nombor: Number(), parseInt, parseFloat, dan Operator +

Terdapat beberapa cara untuk menukar rentetan kepada nombor, setiap satu mempunyai tingkah laku yang berbeza.

 1// Converting strings to numbers
 2console.log(Number("42"));        // 42
 3console.log(Number("  3.14 "));   // 3.14
 4console.log(+ "7");               // 7 (unary +)
 5
 6console.log(parseInt("42px"));    // 42
 7console.log(parseFloat("3.14abc"));// 3.14
 8
 9// Careful with parseInt and radix
10console.log(parseInt("08"));      // 8
11console.log(parseInt("08", 10));  // 8 (explicit radix is safer)
  • Number() akan mengembalikan NaN kecuali keseluruhan rentetan adalah format nombor, manakala parseInt dan parseFloat menukarkan bahagian nombor yang boleh dibaca dari awal rentetan. Adalah lebih selamat untuk sentiasa menyatakan radix secara jelas semasa menggunakan parseInt.

Kendalian dan Pemeriksaan NaN: isNaN dan Number.isNaN

NaN (Bukan-Nombor) adalah istimewa kerana NaN !== NaN. Terdapat perbezaan cara mereka memeriksa; fungsi global isNaN melakukan penukaran jenis dan mungkin memberikan keputusan positif palsu, jadi disarankan menggunakan Number.isNaN.

1// NaN detection differences
2console.log(NaN === NaN);             // false
3
4console.log(isNaN("foo"));            // true  -> because "foo" coerces to NaN
5console.log(Number.isNaN("foo"));     // false -> "foo" is not the numeric NaN
6
7console.log(Number.isNaN(NaN));       // true
  • Gunakan Number.isNaN untuk memeriksa nombor dan mengesahkan hasil pengiraan bagi mengelakkan penukaran jenis yang tidak perlu.

Ralat Titik Terapung dan Perbandingan Menggunakan Number.EPSILON

Disebabkan oleh IEEE-754, ralat seperti 0.1 + 0.2 !== 0.3 boleh berlaku. Untuk perbandingan yang teliti, adalah biasa menggunakan perbezaan dan Number.EPSILON.

1// Floating point precision example and EPSILON comparison
2const sum = 0.1 + 0.2;
3console.log(sum === 0.3);             // false
4
5function nearlyEqual(a, b, epsilon = Number.EPSILON) {
6  return Math.abs(a - b) <= epsilon * Math.max(1, Math.abs(a), Math.abs(b));
7}
8
9console.log(nearlyEqual(sum, 0.3));   // true
  • Jika membenarkan ralat dalam perbandingan, disarankan menggunakan pelaksanaan yang kukuh seperti nearlyEqual yang juga melakukan penskalaan serta menggunakan perbezaan mutlak.

Pemeriksaan Integer dan Integer Selamat (isInteger, isSafeInteger)

Terdapat API untuk memeriksa sama ada nilai adalah integer dan sama ada ia berada dalam julat integer selamat.

1// Integer and safe integer checks
2console.log(Number.isInteger(3));                 // true
3console.log(Number.isInteger(3.0));               // true
4console.log(Number.isInteger(3.1));               // false
5
6console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER)); // true
7console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1)); // false
  • Jika ketepatan integer besar diperlukan, gunakan Number.isSafeInteger untuk memeriksa, dan pertimbangkan menggunakan BigInt bagi nombor melebihi julat tersebut.

Paparan dan Format: toFixed, toPrecision, toString

Terdapat kaedah untuk mengawal paparan nombor. toFixed mengembalikan rentetan dengan bilangan tempat perpuluhan tertentu, tetapi perlu berhati-hati dengan pembundaran.

1// Formatting numbers for display
2const x = 1.23456;
3console.log(x.toFixed(2));         // "1.23"   (string)
4console.log(x.toPrecision(3));     // "1.23"   (string with total significant digits)
5console.log((255).toString(16));   // "ff"     (hexadecimal string)
  • toFixed mengembalikan rentetan, jadi pastikan untuk memeriksa nilai selepas menukarnya kepada nombor untuk pengiraan.

Perhatian Berkaitan Penggabungan Rentetan dan Operator +

Operator + digunakan untuk penambahan nombor dan penggabungan rentetan, jadi hasil yang tidak dijangka mungkin berlaku bergantung pada jenis data.

1// Pitfall with + operator and type coercion
2console.log(1 + 2 + "px");    // "3px"
3console.log("px" + 1 + 2);    // "px12"
4console.log(1 + "2" - 0);     // 3  (string coerced to number for subtraction)
  • Apabila rentetan dan nombor dicampurkan, adalah lebih selamat menggunakan String(), Number(), atau literal templat secara jelas untuk mengelakkan penukaran jenis secara tersirat.

Kes Penggunaan Lanjutan: Number.parseInt / Number.parseFloat, valueOf

Number.parseInt dan Number.parseFloat adalah alias kepada fungsi global. valueOf digunakan untuk mendapatkan nilai primitif daripada objek Number, tetapi jarang diperlukan dalam amalan.

1// Number.parseInt/parseFloat aliases and valueOf example
2console.log(Number.parseInt("100", 10));   // 100
3console.log(Number.parseFloat("3.14"));    // 3.14
4
5const nObj = new Number(5);
6console.log(nObj.valueOf());               // 5
7console.log(nObj + 1);                     // 6  (object coerced to primitive)
  • Semasa menggunakan Number.parseInt dan Number.parseFloat, berhati-hati dengan radix dan pemangkasan input. Objek pembungkus biasanya dielakkan.

Rujukan: Contoh Utiliti Kecil - Fungsi Pengesahan Nombor

Berikut adalah fungsi utiliti kecil yang mengumpulkan pemeriksaan yang biasa digunakan. Ini memudahkan tugasan seperti pengesahan input.

 1// Small number utility functions
 2function toNumberStrict(value) {
 3  // Return a Number or throw for invalid numeric strings
 4  const n = Number(value);
 5  if (typeof value === "string" && value.trim() === "") {
 6    throw new Error("Empty string is not a valid number");
 7  }
 8  if (Number.isNaN(n)) {
 9    throw new Error(`Invalid number: ${value}`);
10  }
11  return n;
12}
13
14function almostEqual(a, b, eps = Number.EPSILON) {
15  // Robust relative comparison
16  return Math.abs(a - b) <= eps * Math.max(1, Math.abs(a), Math.abs(b));
17}
  • Ini adalah fungsi yang sangat serba boleh yang boleh digunakan berulang kali untuk pemprosesan input dan perbandingan. Pelaksanaan yang membaling ralat berguna untuk tujuan pengesahan.

Ringkasan Prestasi dan Amalan Terbaik

Berikut adalah perkara praktikal semasa menggunakan Number.

  • Secara asasnya, gunakan jenis primitif number dan elakkan new Number().
  • Pilih antara Number() (ketat) atau parseInt/parseFloat (pengekstrakan separa) untuk penukaran rentetan ke nombor bergantung pada kes penggunaan anda.
  • Gunakan Number.isNaN dan Number.isFinite untuk pemeriksaan selamat.
  • Untuk perbandingan titik terapung, gunakan Number.EPSILON atau cipta fungsi perbandingan khas.
  • Apabila ketepatan integer diperlukan, gunakan Number.isSafeInteger, dan jika melebihi julat, gunakan BigInt.
  • Anda boleh menggunakan toFixed atau toPrecision untuk pembundaran paparan, tetapi ambil perhatian bahawa nilai yang dikembalikan adalah rentetan.

Ringkasan

Number ialah jenis asas untuk semua nombor dalam JavaScript, termasuk integer, perpuluhan, dan nilai khas (NaN dan Infinity). Penting untuk mengetahui tentang penukaran jenis dan ralat titik terapung, serta menggunakan kaedah seperti Number.isNaN dan Number.EPSILON dengan betul. Jika julat integer selamat dilebihi, gunakan BigInt, dan gunakan toFixed atau toPrecision untuk pembundaran dan paparan.

Anda boleh mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Sila lihat juga saluran YouTube kami.

YouTube Video

Kelas `JSON` dalam JavaScript