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:

  1. string — teks.
  2. number — angka (integer & desimal).
  3. boolean — true / false.
  4. null — ketiadaan nilai yang disengaja.
  5. undefined — nilai yang belum diinisialisasi.
  6. symbol — identifier unik (ES6).
  7. 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, gunakan arr.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 null untuk menandakan “tidak ada nilai” secara eksplisit. Biarkan undefined muncul 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, gunakan Array.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). Gunakan parseInt()/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" dan typeof [] → "object" — gunakan Array.isArray() untuk array.
  • Gunakan Number.isNaN() bukan isNaN().
  • Konversi eksplisit lebih aman daripada implisit.
  • Number("") → 0, tetapi parseInt("") → 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.

Top