Tipe Data & Konversi
JavaScript memiliki tipe data dinamis — variabel bisa berisi tipe apa pun. Artikel ini membahas tipe data primitif, object, cara mengecek tipe, serta konversi implisit dan eksplisit antar tipe.
Pendahuluan
JavaScript adalah bahasa dynamically typed — Anda tidak perlu mendeklarasikan tipe variabel saat membuatnya. Tipe ditentukan otomatis berdasarkan nilai yang diberikan, dan bisa berubah saat runtime.
let x = 42; // x bertipe number
x = "Hello"; // sekarang x bertipe string (tidak error!)
Fleksibilitas ini memudahkan penulisan kode, tetapi juga sumber bug jika tidak dipahami. Artikel ini membahas tipe data JavaScript secara lengkap, cara mengecek tipe, serta konversi implisit dan eksplisit.
Dua Kategori Besar: Primitif vs Object
Tipe data JavaScript terbagi menjadi dua kategori:
Primitif (Immutable)
Tujuh tipe primitif:
string— teks.number— angka (integer & desimal).boolean—true/false.null— ketiadaan nilai yang disengaja.undefined— nilai yang belum diinisialisasi.symbol— identifier unik (ES6).bigint— integer besar (ES2020).
Primitif bersifat immutable — nilainya tidak bisa diubah. Operasi pada primitif selalu menghasilkan nilai baru.
Object (Mutable)
Selain tujuh primitif, semuanya adalah object:
Object,Array,Function,Date,RegExp,Map,Set, dll.
Object bersifat mutable — isinya bisa diubah.
Tipe Primitif Secara Detail
1. string — Teks
String adalah urutan karakter. Bisa dibuat dengan single quote, double quote, atau backtick (template literal).
const nama1 = 'Budi';
const nama2 = "Andi";
const nama3 = `Citra`;
console.log(nama1); // "Budi"
console.log(typeof nama1); // "string"
Template literal (backtick) — mendukung interpolasi & multi-baris:
const nama = "Budi";
const umur = 25;
const sapaan = `Halo, ${nama}! Umur Anda ${umur} tahun.`;
console.log(sapaan); // "Halo, Budi! Umur Anda 25 tahun."
const multiBaris = `Baris pertama
Baris kedua
Baris ketiga`;
console.log(multiBaris);
Escape character:
| Escape | Arti |
|---|---|
\n |
Baris baru |
\t |
Tab |
\\ |
Backslash |
\' |
Single quote |
\" |
Double quote |
\` |
Backtick |
console.log("Baris 1\nBaris 2");
console.log("Dia berkata: \"Halo!\"");
console.log('It\'s okay');
String adalah immutable:
let s = "Hello";
s[0] = "J"; // gagal diam-diam (tidak error di non-strict)
console.log(s); // "Hello" (tidak berubah)
// Untuk "mengubah", buat string baru
s = "J" + s.slice(1);
console.log(s); // "Jello"
Properti & method string yang sering dipakai:
const teks = " Hello World ";
console.log(teks.length); // 15 (termasuk spasi)
console.log(teks.trim()); // "Hello World"
console.log(teks.toUpperCase()); // " HELLO WORLD "
console.log(teks.toLowerCase()); // " hello world "
console.log(teks.includes("World")); // true
console.log(teks.indexOf("World")); // 8
console.log(teks.slice(2, 7)); // "Hello"
console.log(teks.replace("World", "JS")); // " Hello JS "
console.log(teks.split(" ")); // ["", "", "Hello", "World", "", ""]
2. number — Angka
JavaScript hanya memiliki satu tipe number untuk integer dan desimal (floating point 64-bit, standar IEEE 754).
const bulat = 42;
const desimal = 3.14;
const negatif = -10;
const eksponensial = 1.5e3; // 1500
console.log(typeof bulat); // "number"
Nilai khusus:
console.log(0 / 0); // NaN (Not a Number)
console.log(1 / 0); // Infinity
console.log(-1 / 0); // -Infinity
console.log(NaN === NaN); // false (NaN tidak sama dengan dirinya sendiri!)
console.log(Number.isNaN(NaN)); // true — cara yang benar mengecek NaN
Masalah presisi floating point:
console.log(0.1 + 0.2); // 0.30000000000000004 (!!)
console.log(0.1 + 0.2 === 0.3); // false
Penyebab: Bilangan desimal disimpan dalam biner, dan sebagian nilai tidak bisa direpresentasikan secara exact.
Solusi:
// Bandingkan dengan toleransi
console.log(Math.abs((0.1 + 0.2) - 0.3) < Number.EPSILON); // true
// Untuk uang, gunakan integer (dalam sen) atau library seperti decimal.js
const harga = 1999; // Rp19,99 dalam sen
Batas number:
console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991
console.log(Number.MIN_SAFE_INTEGER); // -9007199254740991
console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
console.log(Number.MIN_VALUE); // 5e-324
Melebihi MAX_SAFE_INTEGER? Gunakan BigInt.
Method number yang sering dipakai:
const n = 3.14159;
console.log(n.toFixed(2)); // "3.14" (string!)
console.log(Math.round(n)); // 3
console.log(Math.floor(n)); // 3
console.log(Math.ceil(n)); // 4
console.log(Math.abs(-5)); // 5
console.log(Math.max(1, 5, 3)); // 5
console.log(Math.min(1, 5, 3)); // 1
console.log(Math.random()); // angka acak 0–1
console.log(Number.isInteger(5)); // true
console.log(Number.isInteger(5.0)); // true
3. boolean — Benar/Salah
Hanya dua nilai: true dan false.
const aktif = true;
const selesai = false;
console.log(typeof aktif); // "boolean"
Boolean dari perbandingan:
console.log(5 > 3); // true
console.log(5 === "5"); // false
console.log(!true); // false
Truthy dan Falsy:
Semua nilai bisa dikonversi ke boolean. Nilai-nilai falsy (dianggap false):
| Falsy | Keterangan |
|---|---|
false |
boolean false |
0 |
angka nol |
-0 |
negatif nol |
0n |
BigInt nol |
"" |
string kosong |
null |
null |
undefined |
undefined |
NaN |
Not a Number |
Semua nilai lain adalah truthy — termasuk "0", "false", [], {}, dan function(){}.
console.log(Boolean("")); // false
console.log(Boolean("0")); // true (string non-kosong!)
console.log(Boolean([])); // true (array kosong truthy!)
console.log(Boolean({})); // true (object kosong truthy!)
console.log(Boolean(0)); // false
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
console.log(Boolean(NaN)); // false
Peringatan: Array kosong
[]dan object kosong{}adalah truthy. Untuk mengecek array kosong, gunakanarr.length === 0.
4. null — Ketiadaan Nilai yang Disengaja
null berarti “tidak ada nilai” — biasanya di-set secara eksplisit oleh programmer.
let user = null; // sengaja kosong (belum login)
console.log(user); // null
console.log(typeof null); // "object" (quirk historis!)
console.log(user === null); // true
Kapan menggunakan null?
- Ketika sebuah variabel sengaja tidak memiliki nilai.
- Sebagai nilai awal yang akan diisi nanti.
- Untuk menandakan “tidak ada hasil” (misalnya
find()tidak menemukan apa pun).
5. undefined — Belum Diinisialisasi
undefined berarti “belum didefinisikan” — biasanya muncul otomatis.
let x;
console.log(x); // undefined
function sapa(nama) {
console.log(nama); // undefined jika dipanggil tanpa argumen
}
sapa();
const obj = {};
console.log(obj.properti); // undefined (properti tidak ada)
console.log(typeof undefined); // "undefined"
null vs undefined:
| Aspek | null |
undefined |
|---|---|---|
| Arti | Tidak ada nilai (disengaja) | Belum diinisialisasi (otomatis) |
typeof |
"object" |
"undefined" |
| Di-set oleh | Programmer | JavaScript |
== |
null == undefined → true |
— |
=== |
null === undefined → false |
— |
Best practice: Gunakan
nulluntuk menandakan “tidak ada nilai” secara eksplisit. Biarkanundefinedmuncul secara alami.
6. symbol — Identifier Unik
Diperkenalkan di ES6. Setiap Symbol dijamin unik.
const id1 = Symbol("id");
const id2 = Symbol("id");
console.log(id1 === id2); // false (selalu unik)
console.log(typeof id1); // "symbol"
// Berguna sebagai key properti object yang "tersembunyi"
const user = {
nama: "Budi",
[Symbol("id")]: 12345
};
console.log(Object.keys(user)); // ["nama"] — Symbol tidak muncul
Symbol jarang dipakai di kode sehari-hari, tetapi penting untuk library dan framework (misalnya React menggunakan Symbol untuk menandai elemen).
7. bigint — Integer Besar
Diperkenalkan di ES2020. Untuk integer yang melebihi Number.MAX_SAFE_INTEGER.
const besar = 9007199254740993n; // perhatikan suffix 'n'
const besarLain = BigInt("9007199254740993");
console.log(besar); // 9007199254740993n
console.log(typeof besar); // "bigint"
console.log(besar + 1n); // 9007199254740994n
// Tidak bisa dicampur dengan number biasa
console.log(besar + 1); // TypeError: Cannot mix BigInt and other types
console.log(besar + 1n); // OK
BigInt berguna untuk kriptografi, ID unik besar, atau perhitungan yang butuh presisi integer penuh.
Object: Tipe Non-Primitif
Object Biasa
const user = {
nama: "Budi",
umur: 25,
alamat: {
kota: "Jakarta",
kodePos: "12345"
}
};
console.log(typeof user); // "object"
console.log(user.nama); // "Budi"
console.log(user["umur"]); // 25
console.log(user.alamat.kota); // "Jakarta"
Array
Array adalah object khusus untuk menyimpan urutan nilai.
const angka = [1, 2, 3, 4, 5];
console.log(typeof angka); // "object" (bukan "array"!)
console.log(Array.isArray(angka)); // true — cara yang benar
console.log(angka.length); // 5
console.log(angka[0]); // 1
Peringatan:
typeof []mengembalikan"object". Untuk mengecek array, gunakanArray.isArray().
Function
Function juga object (dengan properti dan method).
function sapa(nama) {
return `Halo, ${nama}!`;
}
console.log(typeof sapa); // "function"
console.log(sapa("Budi")); // "Halo, Budi!"
Mengecek Tipe Data
typeof — Untuk Primitif (dan Function)
console.log(typeof "Hello"); // "string"
console.log(typeof 42); // "number"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" ← quirk!
console.log(typeof Symbol()); // "symbol"
console.log(typeof 10n); // "bigint"
console.log(typeof {}); // "object"
console.log(typeof []); // "object" ← quirk!
console.log(typeof function(){}); // "function"
Array.isArray() — Untuk Array
console.log(Array.isArray([])); // true
console.log(Array.isArray({})); // false
console.log(Array.isArray("Hello")); // false
instanceof — Untuk Cek Instance Class
console.log([] instanceof Array); // true
console.log({} instanceof Object); // true
console.log(new Date() instanceof Date); // true
Object.prototype.toString.call() — Cara Paling Akurat
const cekTipe = (nilai) => Object.prototype.toString.call(nilai).slice(8, -1);
console.log(cekTipe("Hello")); // "String"
console.log(cekTipe(42)); // "Number"
console.log(cekTipe(null)); // "Null"
console.log(cekTipe(undefined)); // "Undefined"
console.log(cekTipe([])); // "Array"
console.log(cekTipe({})); // "Object"
console.log(cekTipe(function(){})); // "Function"
console.log(cekTipe(new Date())); // "Date"
Number.isNaN() vs isNaN()
// isNaN() — melakukan konversi tipe dulu (bisa menyesatkan)
console.log(isNaN("Hello")); // true (karena "Hello" -> NaN)
console.log(isNaN("123")); // false (karena "123" -> 123)
// Number.isNaN() — hanya true jika benar-benar NaN (tanpa konversi)
console.log(Number.isNaN("Hello")); // false (bukan NaN, tapi string)
console.log(Number.isNaN(NaN)); // true
Best practice: Gunakan
Number.isNaN()— lebih akurat.
Konversi Tipe (Type Conversion)
Konversi Implisit (Coercion)
JavaScript otomatis mengonversi tipe dalam konteks tertentu. Ini sering menjadi sumber bug.
Ke string:
console.log("Angka: " + 42); // "Angka: 42"
console.log(42 + ""); // "42"
console.log([1, 2, 3] + ""); // "1,2,3"
console.log({} + ""); // "[object Object]"
console.log(null + ""); // "null"
console.log(undefined + ""); // "undefined"
Ke number:
console.log("5" * 2); // 10 (string -> number)
console.log("5" - 2); // 3
console.log("5" / 2); // 2.5
console.log("5" + 2); // "52" (!!) — plus adalah concatenation untuk string
console.log(true + 1); // 2
console.log(false + 1); // 1
console.log(null + 1); // 1
console.log(undefined + 1); // NaN
console.log("abc" * 2); // NaN
Ke boolean (truthy/falsy):
if ("") { ... } // tidak jalan (falsy)
if ("0") { ... } // jalan (truthy!)
if ([]) { ... } // jalan (truthy!)
if (0) { ... } // tidak jalan (falsy)
Peringatan: Konversi implisit bisa membingungkan. Selalu konversi secara eksplisit agar kode mudah dipahami.
Konversi Eksplisit
Ke string:
String(42); // "42"
String(true); // "true"
String(null); // "null"
String(undefined); // "undefined"
String([1, 2, 3]); // "1,2,3"
(42).toString(); // "42"
(255).toString(16); // "ff" (hexadecimal)
(8).toString(2); // "1000" (binary)
Ke number:
Number("42"); // 42
Number("3.14"); // 3.14
Number(""); // 0 (!!)
Number(" "); // 0
Number("abc"); // NaN
Number("42abc"); // NaN
Number(true); // 1
Number(false); // 0
Number(null); // 0
Number(undefined); // NaN
parseInt("42"); // 42
parseInt("42px"); // 42 (berhenti di non-digit)
parseInt("3.14"); // 3 (hanya integer)
parseInt("ff", 16); // 255 (basis 16)
parseInt("abc"); // NaN
parseFloat("3.14"); // 3.14
parseFloat("3.14abc"); // 3.14
parseFloat("abc"); // NaN
+"42"; // 42 (unary plus)
+"3.14"; // 3.14
+""; // 0
+"abc"; // NaN
Perbedaan Number() vs parseInt() / parseFloat():
| Input | Number() |
parseInt() |
parseFloat() |
|---|---|---|---|
"42" |
42 |
42 |
42 |
"42px" |
NaN |
42 |
42 |
"3.14" |
3.14 |
3 |
3.14 |
"" |
0 |
NaN |
NaN |
" 42 " |
42 |
42 |
42 |
true |
1 |
NaN |
NaN |
null |
0 |
NaN |
NaN |
Tips: Gunakan
Number()untuk konversi ketat (harus angka valid). GunakanparseInt()/parseFloat()jika string mungkin mengandung karakter non-angka setelah angka (misalnya"42px").
Ke boolean:
Boolean("Hello"); // true
Boolean(""); // false
Boolean(0); // false
Boolean(42); // true
Boolean(null); // false
Boolean(undefined); // false
Boolean(NaN); // false
Boolean([]); // true
Boolean({}); // true
// Cara ringkas dengan double negation
!!"Hello"; // true
!!""; // false
!!0; // false
!!42; // true
Contoh Praktis: Validasi Input Form
Mari gabungkan konsep tipe data dan konversi untuk validasi input:
function validasiForm(input) {
// Pastikan input adalah string
const nama = String(input.nama ?? "").trim();
const umurStr = String(input.umur ?? "").trim();
const email = String(input.email ?? "").trim();
const error = [];
// Validasi nama
if (nama.length === 0) {
error.push("Nama wajib diisi");
} else if (nama.length < 3) {
error.push("Nama minimal 3 karakter");
}
// Validasi umur
const umur = Number(umurStr);
if (umurStr === "") {
error.push("Umur wajib diisi");
} else if (Number.isNaN(umur)) {
error.push("Umur harus berupa angka");
} else if (!Number.isInteger(umur)) {
error.push("Umur harus bilangan bulat");
} else if (umur < 17 || umur > 100) {
error.push("Umur harus antara 17 dan 100");
}
// Validasi email (sederhana)
if (!email.includes("@")) {
error.push("Email tidak valid");
}
return {
valid: error.length === 0,
error,
data: error.length === 0 ? { nama, umur, email } : null
};
}
// Uji
console.log(validasiForm({ nama: "Budi", umur: "25", email: "[email protected]" }));
// { valid: true, error: [], data: { nama: 'Budi', umur: 25, email: '[email protected]' } }
console.log(validasiForm({ nama: "B", umur: "abc", email: "budi" }));
// {
// valid: false,
// error: ['Nama minimal 3 karakter', 'Umur harus berupa angka', 'Email tidak valid'],
// data: null
// }
Ringkasan
| Tipe | typeof |
Contoh | Catatan |
|---|---|---|---|
string |
"string" |
"Hello" |
Immutable |
number |
"number" |
42, 3.14 |
Floating point 64-bit |
boolean |
"boolean" |
true, false |
— |
null |
"object" |
null |
Quirk historis |
undefined |
"undefined" |
undefined |
Belum diinisialisasi |
symbol |
"symbol" |
Symbol("id") |
Selalu unik |
bigint |
"bigint" |
42n |
Integer besar |
object |
"object" |
{}, [], new Date() |
Mutable |
function |
"function" |
function(){} |
Object khusus |
Falsy values: false, 0, -0, 0n, "", null, undefined, NaN.
Poin penting:
- JavaScript dynamically typed — tipe ditentukan saat runtime.
typeof null→"object"dantypeof []→"object"— gunakanArray.isArray()untuk array.- Gunakan
Number.isNaN()bukanisNaN(). - Konversi eksplisit lebih aman daripada implisit.
Number("")→0, tetapiparseInt("")→NaN— pahami perbedaannya.- Hati-hati dengan presisi floating point (
0.1 + 0.2 !== 0.3). []dan{}adalah truthy — jangan gunakan sebagai kondisi “kosong”.
Pada artikel berikutnya, kita akan membahas Struktur Kontrol & Perulangan — if, switch, for, while, dan lainnya.