Setelah ngebahas tentang value dan expression di cerita sebelumnya, kali ini kita akan bahas tentang tipe-tipe data di dalam dunia Javascript. Untuk sebagian orang mungkin enggak merasa perlu tau tentang tipe data di Javascript, pokok bisa ngoding langsung pake ya cuss lah enggak perlu tipe data tipe data-an. Well, it’s your preference…
Untuk teman-teman yang sebelumnya kuliah di bidang terkait komputer (SI, TI, IT, dll), mungkin enggak asing dengan “mempelajari tipe data” suatu bahasa pemrograman, karena sebenernya mengenal tipe data di suatu bahasa pemrograman bisa cukup mempengaruhi program kita nantinya dan kita tahu batasan-batasan serta kemungkinan error apabila kita memasukkan value dengan tipe data tertentu.
Mengecek tipe data dengan typeof
Di Javascript, untuk mengecek tipe data dari suatu value kita cukup menggunakan typeof(value) atau typeof value . Maka kemudian Javascript akan mengembalikan tipe data dari value tersebut dalam bentuk string.
let a = "Tahu petis";
typeof a; // "string"
let b = 123;
typeof b; // "number"
Primitive Values
String
Tipe data string adalah tipe data yang digunakan untuk menyimpan suatu teks. Berbeda dengan beberapa bahasa pemrograman yang terbilang sudah berumur dimana ada tipe data char untuk menyimpan karakter dan ada tipe data string yang berupa array of characters untuk menyimpan teks, Javascript (dan mungkin kebanyakan bahasa pemrograman yang ada sekarang) hanya menggunakan string untuk menyimpan teks (maupun karakter).
let s = "Tahu walik";
typeof s; // "string"
Booleans
Tipe data boolean terdiri dari 2 value antara true atau false . Tipe data boolean biasanya dipakai untuk logical operations, seperti if else atau switch .
let bool = true;
typeof bool; // "boolean"
Meskipun hanya terdiri dari true dan false , value dari boolean bisa digenerate dari value yang lain seperti string, number, undefined, ataupun null.
let data = [];
if (data.length) { // data.length = 0; 0 dianggap sebagai false
do something;
} else {
do other;
}
Misalnya 0 akan dianggap sebagai false , != 0 dianggap sebagai true; string kosong "" akan dianggap sebagai false , null ataupun undefined juga dikembalikan sebagai false .
Numbers
Seperti namanya, number merupakan tipe data untuk menyimpan segala bentuk angka dalam Javascript. Baik itu berupa integer, float, double, dan Infinity, semua dianggap sebagai number. Tipe data number digunakan untuk penghitungan matematis seperti tambah kurang kali bagi.
let number = 123;
typeof number; // "number"
Ada beberapa hal yang cukup tricky dengan tipe data number di Javascript, misalnya seperti ini.
console.log(1 + 2 === 3) // true
console.log(0.1 + 0.2 === 0.3) // falseconsole.log(0.1 + 0.2 === 0.30000000000000004); // true
Kok bisa?
Jawabannya karena angka di Javascript enggak berlaku seperti angka matematis, ingat Javascript adalah bahasa pemrograman yang universe nya ada di dalam komputer, maka penghitungan yang dilakukan adalah matematika komputer. Bukan berarti “Javascriptnya ccd nih!”, tapi memang cara penghitungan komputer apalagi terkait dengan floating number cukup berbeda dengan gimana kita (manusia) menghitung floating number.
Meminjam istilah dari Dan Abramov, bayangkan sebuah scanner (untuk scan foto, bukan Scanner di bahasa pemrograman lain). Fungsi scanner adalah mengubah dokumen fisik menjadi dokumen digital, ketika kita melakukan scanning pada suatu gambar/dokumen biasanya scanner akan mengambil warna terdekat dari warna asli dari dokumen kita, itulah kenapa hasil warna scanner enggak selalu presisi warnanya tepat. Apalagi ketika melakukan scan dari dua warna yang hampir-hampir sama, scanner bisa aja ketipu dan memilih warna yang sama.
Jadi bisa kita katakan baik scanner dan Javascript punya batasan presisi tertentu.
Karena sebenernya dalam matematika itu terdapat susunan angka yang enggak terbatas, tapi floating point hanya ada 18 quantilion. Jadi ketika kita menulis suatu angka dalam bentuk float (desimal) atau melakukan penghitungan dengan angka desimal, maka yang dilakukan Javascript adalah memilih angka dengan presisi terdekat dari value yang kita tulis.
Misalnya seperti ini, 1.2000000000006 tentu lebih presisi dibandingkan 1.20006 . Semakin jauh angka di belakang koma (semakin mendekati 0), maka bisa dikatakan angka yang dihasilkan semakin presisi. Itulah kenapa hal ini
console.log(0.1 + 0.2 === 0.3) // falseconsole.log(0.1 + 0.2 === 0.30000000000000004); // true
bisa terjadi.
Tapi pemilihan Javascript dengan value terdekat hanya berlaku pada floating number dan tidak berlaku pada integer. Makanya console.log(1 + 2 === 3) mengembalikan value true .
Another tricky special numbers
Selain tentang batasan ketepatan/presisi di Javascript, ada beberapa angka yang spesial. Mungkin ketika ngoding kita pernah menjumpai NaN, Infinity, -Infinity, -0 . Semua value barusan termasuk dalam tipe data angka (iya NaN juga angka), biasanya value ini muncul ketika kita melakukan operasi matematika yang tidak valid, sedangkan bagaimanapun Javascript tetap perlu mengembalikan sebuah value, voila muncul lah angka-angka spesial ini.
let penyebut = 0;
let a = 1 / penyebut; // Infinity
let b = 0 / penyebut; // NaN
let c = -a; // -Infinity
let d = 1 / c; // -0
Mungkin kamu bertanya-tanya kenapa NaN (not a number) itu sebuah tipe data number, padahal jelas-jelas tulisannya “bukan sebuah angka”. NaN enggak literally diartikan sebagai “bukan sebuah angka” tapi lebih tepat diartikan sebagai “bukan sebuah angka yang valid”. Dan NaN bukan sebuah null , undefined , string, atau tipe data yang lain.
Ohiya NaN === NaN akan mengembalikan false loh.
BigInt
Masih terkait dengan dunia angka, ada tipe data yang terbilang baru dan jarang dipake di Javascript (at least aku jarang pakenya), yaitu BigInt. Sesuai namanya tipe data ini untuk menyimpan angka yang sangat besar (merepresentasikan semua angka yang lebih dari 2^53–1), kalo ada yang pernah belajar Java sebelumnya, BigInt ini sama kaya BigInteger di Java.
let int = BigInt(123);
typeof int; // "bigint";
typeof 1n; // "bigint";
Sebenernya belum banyak yang bisa aku bahas terkait BigInt ini karena memang jarang dipake di project-project ku selama ini, tapi let’s do my best sambil baca dokumentasinya.
BigInt ini hampir-hampir sama kaya number, tapi ya ada bedanya, misalnya enggak bisa dioperasikan dengan Math dan enggak bisa dioperasikan dengan number.
let int = 123n;
Math.round(int);
// Uncaught TypeError: Cannot convert a BigInt value to a number
let a = int - 2;
// Uncaught TypeError: Cannot mix BigInt and other types, use explicit conversions
Operasi matematika yang bisa dilakukan di BigInt juga terbatas + , - , * , ** , dan % .
console.log(2n + 3n); // 5n
console.log(2n - 1n); // 1n
console.log(2n * 3n); // 6n
console.log(2n ** 5n); // 32n
console.log(23n % 3n); // 2n;
Sebenernya bisa juga BigInt dioperasikan dengan / tapi hasilnya enggak tepat, karena hasil pembagiannya akan dibulatkan menjadi sebuah nilai integer (bilangan bulat).
console.log(9n / 3n); // 6n
console.log(5n / 2n); // 2n, bukan 2.5n
Selengkapnya tentang BigInt bisa dicek di sini.
Nah itu dia part 1 dari tipe data di Javascript, kita akan bahas beberapa tipe data lainnya di part selanjutnya. So stay tune and happy coding!