Number - JavaScript
Published: 2024-02-09 03:47:32

Angka (Number) dalam JavaScript diwakili dengan bilangan biner, oleh sebab itu sangat sulit menulis bilangan pecahan dalam JavaScript sehingga secara umum JavaScript tidak cocok untuk perhitungan keuangan dan scientific.
JavaScript memiliki 5 tipe data yang bisa menampung nilai :
1. string
2. number
3. boolean
4. object
5. function

JavaScript memiliki 6 tipe data object :
1. Object
2. Date
3. Array
4. String
5. Number
6. Boolean


JavaScript memiliki 2 tipe data yang tidak bisa menampung nilai :
1. null : tidak ada nilai atau untuk membersihkan nilai dari sebuah variabel
2. undefined : variabel yang dideklarasikan tapi belum diisi nilai, atau argumen fungsi yang tidak memiliki nilai

Sekarang akan kita bahas Number serta beberapa metode manipulasinya.

```javascript
console.log(23 === 23.0); // Output: true
console.log(0.1 + 0.2); // Output: 0.30000000000000004
console.log(0.1 + 0.2 === 0.3); // Output: false

// Konversi string menjadi angka (number)
const str = '23';
console.log(typeof str); // Output: string
const str2 = Number(str);
console.log(typeof str2); // Output: number
console.log(+str); // Output: 23 (number)

// Parsing: mengubah bilangan ke bilangan lain
console.log(Number.parseInt('30px', 10)); // Output: 30, mengubah ke bilangan bulat (integer) base 10
console.log(Number.parseInt('e23', 10)); // Output: nan, karakter pertama bukan angka
console.log(Number.parseFloat('2.5rem')); // Output: 2.5, mengubah ke bilangan pecahan (float)
console.log(Number.parseInt('2.5rem')); // Output: 2, dibulatkan kebawah

// isNan: mengevaluasi apakah nilai BUKAN berupa angka
console.log(Number.isNaN(20)); // Output: false
console.log(Number.isNaN('20')); // Output: false
console.log(Number.isNaN(+'20x')); // Output: true, bukan angka. Konversi string ke angka tidak bisa dilakukan jika terdapat karakter bukan angka
console.log(Number.isNaN(23 / 0)); // Output: false

// isFinite: mengevaluasi apakah nilai berupa angka
console.log(Number.isFinite(20)); // Output: true
console.log(Number.isFinite('20')); // Output: false
console.log(Number.isFinite(+'20x')); // Output: false
console.log(Number.isFinite(23 / 0)); // Output: false

// isInteger: mengevaluasi apakah nilai berupa bilangan bulat
console.log(Number.isInteger(23)); // Output: true
console.log(Number.isInteger(23.0)); // Output: true
console.log(Number.isInteger(23.004)); // Output: false
console.log(Number.isInteger(23 / 0)); // Output: false
```
**MATH OBJECT**

```javascript
// sqrt
console.log(Math.sqrt(25)); // Output: 5
console.log(25 ** (1 / 2)); // Output: 5
console.log(8 ** (1 / 3)); // Output: 2

// min - max
console.log(Math.max(5, 34, 56, 12, 34, 67)); // Output: 67
console.log(Math.max(5, 34, 56, 12, 34, '67')); // Output: 67, otomatis mengkonversi string menjadi angka
console.log(Math.max(5, '34px', 56, 12, 34, 67)); // Output: nan, terdapat karakter bukan angka dalam kumpulan nilai

console.log(Math.min(5, 34, 56, 12, 34, 67)); // Output: 5
console.log(Math.min('5', 34, 56, 12, 34, 67)); // Output: 5, otomatis mengkonversi string menjadi angka
console.log(Math.min(5, '34px', 56, 12, 34, 67)); // Output: nan, terdapat karakter bukan angka dalam kumpulan nilai

// bilangan konstan PI
console.log(Math.PI * Number.parseFloat('10px') ** 2); // Output: 314.1592653589793

// pembulatan
console.log(Math.trunc(50.7)); // Output: 50, pembulatan kebawah
console.log(Math.round(23.7)); // Output: 24, pembulatan keatas untuk desimal lebih dari 0.5
console.log(Math.round(23.2)); // Output: 23, pembulatan kebawah untuk desimal kurang dari 0.5
console.log(Math.ceil(23.7)); // Output: 24, pembulatan keatas berapapun nilai desimal
console.log(Math.ceil('23.2')); // Output: 24, pembulatan keatas berapapun nilai desimal
console.log(Math.floor(23.7)); // Output: 23, pembulatan kebawah berapapun nilai desimal
console.log(Math.floor('23.2')); // Output: 23, pembulatan kebawah berapapun nilai desimal

// trunc dan floor menghasilkan nilai sama untuk bilangan positif, tapi berbeda untuk bilangan negatif
console.log(Math.trunc(-50.7)); // Output: -50
console.log(Math.floor(-50.7)); // Output: -51

// random: nilai random antara 0 dan 1 (tidak pernah bernilai 0 ataupun 1)
console.log(Math.trunc(Math.random() * 6) + 1); // Output: bilangan acak 1 sampai dengan 6 (termasuk 1 dan 6)

const random = (min, max) => Math.trunc(Math.random() * (max - min) + 1) + min;
console.log(random(10, 20)); // Output: bilangan acak antara 10 dan 20 (termasuk 10 dan 20)

// toFixed(): mengembalikan nilai berupa string
console.log((2.7).toFixed(0)); // bulat desimal, Output: 3
console.log(typeof (2.7).toFixed(0)); // Output: string
console.log((2.7).toFixed(3)); // 3 angka di belakang koma, Output: 2.700
console.log((2.7342342).toFixed(3)); // 3 angka di belakang koma, Output: 2.734
console.log(+(2.7342342).toFixed(3)); // konversi menjadi number, Output: 2.734
console.log(typeof +(2.7).toFixed(0)); // Output: number

// remainder operator (%): sisa hasil bagi
console.log(5 % 2);
const isEven = (n) => n % 2 === 0;
console.log(isEven(9)); // Output: false
console.log(isEven(4)); // Output: true

// numeric separator
const diameter = 233_000_000_000;
console.log(diameter); // Output: 233000000000
const priceCent = 345_565;
console.log(priceCent); // Output: 345565

const PI = 3.14_15;
console.log(PI); // Output: 3.1415

console.log(Number('23_000')); // Output: nan, karena terdapat karakter string
console.log(parseInt('23_000')); // Output: 23
```
**BIGINT**
BigInt diperkenalkan pada ECMASCRIPT 2020, digunakan untuk menyimpan angka yang bernilai besar yang tidak bisa diwakili oleh Number. Dalam JavaScript angka diwakili oleh bilangan biner 64 bit, hanya 53 bit yang digunakan sisanya digunakan untuk penanda desimal dan bilangan negatif.
BigInt dibuat dengan cara memanggil fungsi BigInt() atau menambahkan huruf n di akhir angka. BigInt tidak bisa dimanipulasi dengan metode Object Math dan juga tidak bisa dicampur operasinya dengan Number.

```javascript
// angka maksimum yang bisa ditangani oleh Number
console.log(2 ** 53 - 1); // Output: 9007199254740991
console.log(Number.MAX_SAFE_INTEGER); // Output: 9007199254740991
```
Apa yang terjadi jika kita menambahkan angka melebihi MAX_SAFE_INTEGER ?

```javascript
console.log(9007199254740991); // Output: 9007199254740991
console.log(90071992547409912); // Output: 90071992547409920
console.log(900719925474099123); // Output: 900719925474099100
```
Bisa dilihat nilainya sudah tidak valid lagi, pada bagian inilah BigInt mengambil peran. Jika kita menggunakan BigInt maka hasilnya sebagai berikut.

```javascript
console.log(9007199254740991); // Output: 9007199254740991
console.log(90071992547409912n); // Output: 90071992547409912n
console.log(900719925474099123n); // Output: 900719925474099123n
```

```javascript
console.log(543463209829074892734826427864725476); // number, Output: 5.434632098290749e+35
console.log(543463209829074892734826427864725476n); // BigInt, Output: 543463209829074892734826427864725476n
console.log(BigInt(543463209829074892734826427864725476)); // BigInt konversi dari Number, Output: 543463209829074906066561013957787648n
```

![result](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/98phptb8hi8yhvvhw300.png)
Perhatikan pada contoh diatas bahwa ada ada perbedaan hasil ketika membuat BigInt langsung dan ketika menggunakan konversi dari Number. Maka disarankan untuk membuat BigInt dengan memberi akhiran n pada Number daripada dengan fungsi BigInt.

```javascript
const huge = 13412323432432432423543543n;
const num = 23;
console.log(huge * num); // Output: error, BigInt tidak bisa dicampur operasinya dengan Number
console.log(huge * BigInt(num)); // Output: 308483438945945945741501489n

console.log(20n > 15); // Output: true
console.log(20n === 20); // Output: false
console.log(20n == 20); // Output: true
console.log(20n == '20'); // Output: true
console.log(huge + ' is REALLY BIG NUMBER'); // Output: 13412323432432432423543543 is REALLY BIG NUMBER

```