Kelas `Number` di JavaScript

Artikel ini menjelaskan kelas Number di JavaScript.

Kami akan menjelaskan secara rinci karakteristik Number, jebakan umum, API yang berguna, dan contoh praktis langkah demi langkah.

YouTube Video

Kelas Number di JavaScript

Number adalah tipe numerik dasar di JavaScript dan direpresentasikan sebagai floating point presisi ganda IEEE-754 (64-bit).

Dasar-Dasar: Representasi Angka dan Pemeriksaan Tipe

Di JavaScript, semua angka direpresentasikan sebagai tipe 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)

• Kode ini menunjukkan perbedaan antara tipe primitif number dan objek pembungkus Number. Biasanya, tipe primitif digunakan daripada pembungkus.

Nilai Khusus: NaN, Infinity, dan Konstanta

Number menyediakan nilai khusus (NaN, Infinity) dan konstanta.

 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

• Bilangan bulat lebih besar atau sama dengan MAX_SAFE_INTEGER mungkin tidak dapat direpresentasikan secara akurat. Pertimbangkan untuk menggunakan BigInt jika diperlukan akurasi. EPSILON digunakan untuk perbandingan floating-point.

Konversi Angka: Number(), parseInt, parseFloat, dan Operator +

Ada beberapa cara untuk mengonversi string menjadi angka, masing-masing dengan perilaku yang berbeda.

 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() mengembalikan NaN kecuali seluruh string benar-benar dalam format numerik, sedangkan parseInt dan parseFloat akan membaca bagian numerik yang terbaca dari awal string. Lebih aman untuk selalu menyebutkan basis (radix) secara eksplisit saat menggunakan parseInt.

Penanganan dan Pemeriksaan NaN: isNaN dan Number.isNaN

NaN (Not-A-Number) bersifat khusus karena NaN !== NaN. Ada perbedaan dalam cara mereka memeriksa; isNaN global melakukan konversi tipe dan dapat menghasilkan positif palsu, jadi Number.isNaN lebih direkomendasikan.

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 angka dan memvalidasi hasil perhitungan agar terhindar dari konversi tipe yang tidak perlu.

Kesalahan Floating-Point dan Perbandingan Menggunakan Number.EPSILON

Karena IEEE-754, terjadi kesalahan seperti 0.1 + 0.2 !== 0.3. Untuk perbandingan yang ketat, biasanya digunakan selisih 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 memperbolehkan sedikit kesalahan pada perbandingan, implementasi yang lebih robust seperti nearlyEqual yang menghitung skala dan selisih absolut sangat dianjurkan.

Pemeriksaan Bilangan Bulat dan Bilangan Bulat Aman (isInteger, isSafeInteger)

Terdapat API untuk memeriksa apakah sebuah nilai merupakan bilangan bulat dan apakah nilainya dalam rentang bilangan bulat yang aman.

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 akurasi bilangan bulat besar diperlukan, gunakan Number.isSafeInteger untuk memeriksa, dan pertimbangkan BigInt bagi angka yang melebihi rentang tersebut.

Tampilan dan Format: toFixed, toPrecision, toString

Ada beberapa metode yang tersedia untuk mengatur tampilan angka. toFixed mengembalikan string dengan jumlah angka desimal tertentu, namun perlu diperhatikan pembulatan nilainya.

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 string, jadi perlu hati-hati saat mengonversinya kembali ke angka untuk perhitungan.

Perhatian Mengenai Penggabungan String dan Operator +

Operator + digunakan untuk penjumlahan angka dan penggabungan string, sehingga hasil tak terduga bisa terjadi tergantung tipe data yang digunakan.

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)

• Jika string dan angka tercampur, sebaiknya gunakan String(), Number(), atau template literal secara eksplisit untuk menghindari konversi tipe secara implisit.

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

Number.parseInt dan Number.parseFloat adalah alias dari fungsi global. valueOf digunakan untuk mengambil nilai primitif dari objek Number, namun jarang dibutuhkan dalam praktik.

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)

• Saat menggunakan Number.parseInt dan Number.parseFloat, perhatikan radix dan pemangkasan input. Objek pembungkus biasanya dihindari.

Referensi: Contoh Utility Kecil - Fungsi Validasi Angka

Berikut adalah fungsi utilitas kecil yang mengumpulkan pemeriksaan yang sering digunakan. Ini membuat tugas seperti validasi input menjadi lebih mudah.

 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}

• Fungsi-fungsi ini sangat serbaguna dan dapat digunakan berulang kali untuk pemrosesan input dan perbandingan. Implementasi yang melemparkan error berguna untuk tujuan validasi.

Ringkasan Kinerja dan Praktik Terbaik

Berikut adalah poin-poin praktis saat menggunakan Number.

• Pada dasarnya, gunakan tipe primitif number dan hindari new Number().
• Pilih antara Number() (ketat) atau parseInt/parseFloat (ekstraksi parsial) untuk konversi string ke angka sesuai kebutuhan.
• Gunakan Number.isNaN dan Number.isFinite untuk pemeriksaan yang aman.
• Untuk perbandingan floating-point, gunakan Number.EPSILON atau buat fungsi perbandingan khusus.
• Jika diperlukan akurasi bilangan bulat, gunakan Number.isSafeInteger, dan jika melebihi rentang, gunakan BigInt.
• Anda dapat menggunakan toFixed atau toPrecision untuk pembulatan tampilan, namun perhatikan bahwa nilai hasilnya adalah sebuah string.

Ringkasan

Number adalah tipe dasar untuk semua angka di JavaScript, termasuk bilangan bulat, desimal, dan nilai khusus (NaN dan Infinity). Penting untuk memperhatikan konversi tipe dan kesalahan floating-point, serta menggunakan metode seperti Number.isNaN dan Number.EPSILON secara benar. Jika rentang bilangan bulat aman terlampaui, gunakan BigInt, dan gunakan toFixed atau toPrecision untuk pembulatan dan tampilan.

Anda dapat mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Silakan periksa juga saluran YouTube kami.

YouTube Video