JavaScript : Angka JavaScript

Bekerja Dengan Angka

JavaScript mendukung angka integer dan floating-point yang dapat direpresentasikan dalam notasi desimal, heksadesimal, atau oktal. Tidak seperti bahasa lain, JavaScript tidak memperlakukan angka integer dan floating-point secara berbeda. Semua angka dalam JavaScript direpresentasikan sebagai angka floating-point. Berikut ini contoh yang menunjukkan angka-angka dalam berbagai format:

var x = 2;  // integer number
var y = 3.14;  // floating-point number
var z = 0xff;  // hexadecimal number

Angka ekstra besar dapat direpresentasikan dalam notasi eksponensial, mis. 6.02e+23 (sama dengan 6.02×1023).

var x = 1.57e4;  // same as 15700
var y = 4.25e+6;  // same as 4.25e6 or 4250000
var z = 4.25e-6;  // same as 0.00000425

Bilangan juga dapat direpresentasikan dalam notasi heksadesimal (base 16). Angka heksadesimal diawali dengan 0x. Mereka biasanya digunakan untuk mewakili warna. Berikut contohnya:

var x = 0xff;  // same as 255
var y = 0xb4;  // same as 180
var z = 0x00;  // same as 0
Mengoperasikan Angka dan String

Seperti yang kalian ketahui dari bab-bab sebelumnya, operator + digunakan untuk penambahan dan penggabungan. Jadi, melakukan operasi matematika pada angka dan string dapat menghasilkan hasil yang menarik. Contoh berikut akan menunjukkan kepada kalian apa yang terjadi ketika kalian menambahkan angka dan string:

var x = 10;
var y = 20;
var z = "30";

// Adding a number with a number, the result will be sum of numbers
console.log(x + y); // 30

// Adding a string with a string, the result will be string concatenation
console.log(z + z); // '3030'

// Adding a number with a string, the result will be string concatenation
console.log(x + z); // '1030'

// Adding a string with a number, the result will be string concatenation
console.log(z + x); // '3010'

// Adding strings and numbers, the result will be string concatenation
console.log("The result is: " + x + y); // 'The result is: 1020'

// Adding numbers and strings, calculation performed from left to right
console.log(x + y + z); // 'The result is: 3030'

Jika kalian memperhatikan contoh di atas dengan cermat, kalian akan menemukan bahwa hasil operasi terakhir bukan hanya penggabungan string sederhana, karena operator dengan prioritas yang sama dievaluasi dari kiri ke kanan. Itu sebabnya, karena variabel x dan y keduanya adalah angka-angka yang ditambahkan pertama maka hasilnya disatukan dengan variabel z yang merupakan string, maka hasil akhirnya adalah 30 + “30” = “3030”.

Tetapi, jika kalian melakukan operasi matematika lainnya seperti perkalian, pembagian, atau pengurangan hasilnya akan berbeda. JavaScript akan secara otomatis mengonversi string numerik (mis. String yang berisi nilai numerik) ke angka di semua operasi numerik, seperti yang ditunjukkan dalam contoh berikut:

var x = 10;
var y = 20;
var z = "30";

// Subtracting a number from a number
console.log(y - x); // 10

// Subtracting a number from a numeric string
console.log(z - x); // 20

// Multiplying a number with a numeric string
console.log(x * z); // 300

// Dividing a number with a numeric string
console.log(z / x); // 3

Selain itu, jika kalian mencoba mengalikan atau membagi angka dengan string yang bukan numerik, itu akan kembali menjadi NaN (Not a Number). Juga, jika kalian menggunakan NaN dalam operasi matematika, hasilnya juga akan menjadi NaN.

var x = 10;
var y = "foo";
var z = NaN;

// Subtracting a number from a non-numeric string
console.log(y - x); // NaN

// Multiplying a number with a non-numeric string
console.log(x * y); // NaN

// Dividing a number with a non-numeric string
console.log(x / y); // NaN

// Adding NaN to a number 
console.log(x + z); // NaN
						
// Adding NaN to a string 
console.log(y + z); // fooNaN
Mewakili Infinity

Infinity mewakili angka yang terlalu besar untuk ditangani oleh JavaScript. JavaScript memiliki kata kunci khusus Infinity dan -Infinity untuk merepresentasikan infinity positif dan negatif. Misalnya, membaginya dengan 0 mengembalikan Infinity, seperti yang ditunjukkan di bawah ini:

var x = 5 / 0;
console.log(x); // Infinity

var y = -5 / 0;
console.log(y); // -Infinity
Menghindari Masalah Presisi

Kadang-kadang, operasi pada angka floating-point menghasilkan hasil yang tidak terduga, seperti yang ditunjukkan di bawah ini:

var x = 0.1 + 0.2;
console.log(x) // 0.30000000000000004

Seperti yang kalian lihat hasilnya 0,30000000000000000004 daripada yang diharapkan yaitu 0,3. Perbedaan ini disebut representation error atau roundoff error. Itu terjadi karena JavaScript dan banyak bahasa lain menggunakan bentuk biner (base 2) untuk mewakili angka desimal (base 10) secara internal. Sayangnya, sebagian besar pecahan desimal tidak dapat direpresentasikan secara tepat dalam bentuk biner, sehingga terjadi sedikit perbedaan.

Untuk menghindari masalah ini, kalian dapat menggunakan solusi seperti ini:

var x = (0.1 * 10 + 0.2 * 10) / 10;
console.log(x) // 0.3

Jumlah poin floating-point JavaScript hingga 17 digit, yang cukup presisi atau akurat dalam kebanyakan kasus. Juga, dalam bilangan bulat JavaScript (angka tanpa bagian fraksional atau notasi eksponensial) akurat hingga 15 digit, seperti yang ditunjukkan dalam contoh berikut:

var x = 999999999999999;
console.log(x); // 999999999999999

var y = 9999999999999999;
console.log(y); // 10000000000000000
Melakukan Operasi pada Angka

JavaScript menyediakan beberapa properti dan metode untuk melakukan operasi pada nilai angka. Seperti yang sudah kalian ketahui dari bab sebelumnya, dalam JavaScript tipe data primitif dapat bertindak seperti objek ketika kalian merujuknya dengan notasi akses properti (mis. Notasi titik).

Parsing Integers dari Strings

Metode parseInt() dapat digunakan untuk mengurai integer dari sebuah string. Metode ini sangat berguna dalam situasi ketika kalian berurusan dengan nilai-nilai seperti unit CSS mis. 50px, 12pt, dll. Dan kalian ingin mengekstrak nilai numerik darinya.

Jika metode parseInt() menjumpai karakter yang bukan numerik di base yang telah ditentukan, maka hal tersebut akan berhenti menguraikan dan mengembalikan nilai integer yang diuraikan hingga saat itu. Jika karakter pertama tidak dapat dikonversi menjadi angka, metode ini akan mengembalikan NaN (bukan angka). Berikut contohnya:

console.log(parseInt("3.14"));  // 3
console.log(parseInt("50px"));  // 50
console.log(parseInt("12pt"));  // 12
console.log(parseInt("0xFF", 16));  // 255
console.log(parseInt("20 years"));  // 20
console.log(parseInt("Year 2048"));  // NaN
console.log(parseInt("10 12 2018"));  // 10

Demikian pula, kalian bisa menggunakan metode parseFloat() untuk mem-parsing angka floating-point dari sebuah string. Metode parseFloat() bekerja dengan cara yang sama dengan metode parseInt(), kecuali bahwa ia mengambil bilangan bulat dan angka dengan desimal.

console.log(parseFloat("3.14"));  // 3.14
console.log(parseFloat("50px"));  // 50
console.log(parseFloat("1.6em"));  // 1.6
console.log(parseFloat("124.5 lbs"));  // 124.5
console.log(parseFloat("weight 124.5 lbs"));  // NaN
console.log(parseFloat("6.5 acres"));  // 6.5
Mengubah Angka menjadi String

Metode toString() dapat digunakan untuk mengonversi angka ke string yang setara. Metode ini secara opsional menerima parameter integer dalam rentang 2 hingga 36 yang menentukan basis yang digunakan untuk mewakili nilai numerik. Berikut contohnya:

var x = 10;
var y = x.toString();
console.log(y);  // '10'
console.log(typeof y);  // string
console.log(typeof x);  // number

console.log((12).toString());  // '12'
console.log((15.6).toString());  // '15.6'
console.log((6).toString(2));  // '110'
console.log((255).toString(16));  // 'ff'
Memformat Angka dalam Notasi Eksponensial

Kalian dapat menggunakan metode toExponential() untuk memformat atau mewakili angka dalam notasi eksponensial. Metode ini secara opsional menerima parameter bilangan bulat yang menentukan jumlah digit setelah titik desimal. Juga, nilai yang dikembalikan adalah string, bukan angka. Berikut contohnya:

var x = 67.1234;

console.log(x.toExponential());  // 6.71234e+1
console.log(x.toExponential(6));  // 6.712340e+1
console.log(x.toExponential(4));  // 6.7123e+1
console.log(x.toExponential(2));  // 6.71e+1
Memformat Angka ke Fixed Desimal

Kalian dapat menggunakan metode toFixed() ketika Kalian ingin memformat angka dengan jumlah digit tetap di sebelah kanan titik desimal. Nilai yang dikembalikan oleh metode ini adalah string dan memiliki jumlah digit yang ditentukan dengan tepat setelah titik desimal. Jika parameter digit tidak ditentukan atau dihilangkan, maka akan ditulis sebagai 0. Berikut ini contohnya:

var x = 72.635;

console.log(x.toFixed());  // '73' (note rounding, no fractional part)
console.log(x.toPrecision(2));  // '72.64' (note rounding)
console.log(x.toPrecision(1));  // '72.6'

var y = 6.25e+5;
console.log(y.toFixed(2)); // '625000.00'

var z = 1.58e-4;
console.log(z.toFixed(2));  // '0.00' (since 1.58e-4 is equal to 0.000158)
Memformat Angka dengan Presisi

Jika kalian menginginkan bentuk angka yang paling tepat, kalian dapat menggunakan metode toPrecision() sebagai gantinya. Metode ini mengembalikan string yang mewakili angka ke presisi yang ditentukan.

Jika presisi cukup besar untuk memasukkan semua digit dari bagian bilangan bulat, maka angka tersebut diformat menggunakan notasi titik tetap. Jika tidak, nomor tersebut diformat menggunakan notasi eksponensial. Parameter presisi bersifat opsional. Berikut contohnya:

var x = 6.235;

console.log(x.toPrecision());  // '6.235'
console.log(x.toPrecision(3));  // '6.24' (note rounding)
console.log(x.toPrecision(2));  // '6.2'
console.log(x.toPrecision(1));  // '6'

var y = 47.63;
console.log(y.toPrecision(2)); // '48' (note rounding, no fractional part)

var z = 1234.5;
console.log(z.toPrecision(2));  // '1.2e+3'