Object & Method-nya

Object adalah tipe data fundamental JavaScript untuk menyimpan kumpulan pasangan key-value. Artikel ini membahas cara membuat dan mengakses object, method, destructuring, spread, optional chaining, dan konversi JSON.

Pendahuluan

Object adalah struktur data yang menyimpan kumpulan pasangan key-value (properti). Jika array menggunakan index numerik, object menggunakan key (biasanya string) untuk mengakses nilai.

Object adalah tipe data paling fleksibel di JavaScript. Hampir semua hal adalah object: array, fungsi, Date, bahkan DOM element. Object digunakan untuk merepresentasikan entitas dunia nyata — user, produk, pesanan, konfigurasi, dan sebagainya.

Artikel ini membahas cara membuat object, mengakses dan memodifikasi properti, method, method bawaan Object, destructuring, spread, optional chaining, serta konversi ke/dari JSON.

Asumsi: Anda sudah memahami variabel, fungsi, arrow function, dan array dari artikel sebelumnya.


Membuat Object

1. Object Literal (Direkomendasikan)

Cara paling umum — menggunakan kurung kurawal {}.

const user = {
  nama: "Budi",
  umur: 25,
  email: "[email protected]",
  aktif: true
};

const kosong = {};

2. Constructor Object

const user = new Object();
user.nama = "Budi";
user.umur = 25;

console.log(user); // { nama: "Budi", umur: 25 }

Catatan: Cara ini jarang dipakai — object literal lebih ringkas.

3. Object.create() — Dengan Prototype

Membuat object baru dengan prototype tertentu.

const prototipe = {
  sapa() {
    return `Halo, ${this.nama}!`;
  }
};

const user = Object.create(prototipe);
user.nama = "Budi";

console.log(user.sapa()); // "Halo, Budi!"

4. Constructor Function

Pola lama sebelum ada class.

function User(nama, umur) {
  this.nama = nama;
  this.umur = umur;
}

User.prototype.sapa = function() {
  return `Halo, ${this.nama}!`;
};

const budi = new User("Budi", 25);
console.log(budi.sapa()); // "Halo, Budi!"

5. class (ES6)

Sintaks modern untuk membuat object dengan constructor dan method.

class User {
  constructor(nama, umur) {
    this.nama = nama;
    this.umur = umur;
  }

  sapa() {
    return `Halo, ${this.nama}!`;
  }

  get info() {
    return `${this.nama} (${this.umur} tahun)`;
  }
}

const budi = new User("Budi", 25);
console.log(budi.sapa());  // "Halo, Budi!"
console.log(budi.info);    // "Budi (25 tahun)"

Catatan: class adalah syntactic sugar di atas prototype. Detailnya dibahas di artikel terpisah tentang OOP.


Properti Object

Mengakses Properti

Dot notation — untuk key yang valid sebagai identifier:

const user = { nama: "Budi", umur: 25 };

console.log(user.nama); // "Budi"
console.log(user.umur); // 25

Bracket notation — untuk key dengan spasi, karakter khusus, atau key dinamis:

const user = {
  nama: "Budi",
  "nama lengkap": "Budi Santoso",
  "alamat-rumah": "Jakarta"
};

console.log(user["nama lengkap"]);  // "Budi Santoso"
console.log(user["alamat-rumah"]);  // "Jakarta"

// Key dinamis
const key = "nama";
console.log(user[key]); // "Budi"

Mengakses properti yang tidak ada:

console.log(user.pekerjaan); // undefined (tidak error)

Menambah dan Mengubah Properti

const user = { nama: "Budi" };

// Tambah properti baru
user.umur = 25;
user["email"] = "[email protected]";

// Ubah properti
user.nama = "Budi Santoso";

console.log(user);
// { nama: "Budi Santoso", umur: 25, email: "[email protected]" }

Menghapus Properti

const user = { nama: "Budi", umur: 25, email: "[email protected]" };

delete user.umur;
console.log(user); // { nama: "Budi", email: "[email protected]" }

Cek Keberadaan Properti

in operator — mengecek key (termasuk dari prototype):

const user = { nama: "Budi", umur: 25 };

console.log("nama" in user);  // true
console.log("email" in user); // false

hasOwnProperty() — hanya mengecek properti milik object sendiri (bukan prototype):

console.log(user.hasOwnProperty("nama"));  // true
console.log(user.hasOwnProperty("toString")); // false (dari prototype)

Object.hasOwn() (ES2022) — cara modern:

console.log(Object.hasOwn(user, "nama")); // true

Properti Dinamis (Computed Property)

Menggunakan key dari variabel saat membuat object:

const key = "nama";
const nilai = "Budi";

const user = {
  [key]: nilai
};
console.log(user); // { nama: "Budi" }

// Key dari ekspresi
const prefix = "user_";
const data = {
  [`${prefix}id`]: 1,
  [`${prefix}nama`]: "Budi"
};
console.log(data); // { user_id: 1, user_nama: "Budi" }

Shorthand Property

Jika nama variabel sama dengan nama key:

const nama = "Budi";
const umur = 25;

// ❌ Verbose
const user1 = { nama: nama, umur: umur };

// ✅ Shorthand
const user2 = { nama, umur };

console.log(user2); // { nama: "Budi", umur: 25 }

Method Object

Method adalah fungsi yang menjadi properti object.

Mendefinisikan Method

const user = {
  nama: "Budi",
  umur: 25,

  // Method shorthand (ES6)
  sapa() {
    return `Halo, ${this.nama}!`;
  },

  // Function expression
  info: function() {
    return `${this.nama}, ${this.umur} tahun`;
  },

  // Arrow function — HATI-HATI dengan `this`
  sapaArrow: () => {
    // `this` bukan user!
    return "Halo!";
  }
};

console.log(user.sapa());  // "Halo, Budi!"
console.log(user.info());  // "Budi, 25 tahun"

this dalam Object

this merujuk ke object pemanggil method.

const counter = {
  count: 0,
  increment() {
    this.count++;
    return this.count;
  },
  reset() {
    this.count = 0;
  }
};

console.log(counter.increment()); // 1
console.log(counter.increment()); // 2
console.log(counter.increment()); // 3
counter.reset();
console.log(counter.count); // 0

⚠️ Peringatan: Jangan gunakan arrow function sebagai method jika method membutuhkan this yang merujuk ke object. Arrow function mewarisi this dari scope luar (biasanya undefined di module atau window di browser).

Method Chaining

Method bisa mengembalikan this agar bisa dirangkai:

const kalkulator = {
  nilai: 0,

  tambah(n) {
    this.nilai += n;
    return this; // kembalikan this untuk chaining
  },

  kurang(n) {
    this.nilai -= n;
    return this;
  },

  kali(n) {
    this.nilai *= n;
    return this;
  },

  hasil() {
    return this.nilai;
  }
};

const hasil = kalkulator.tambah(10).kali(2).kurang(5).hasil();
console.log(hasil); // 15

Method Bawaan Object

JavaScript menyediakan banyak method statis pada Object untuk manipulasi object.

Object.keys() — Array Key

const user = { nama: "Budi", umur: 25, email: "[email protected]" };

console.log(Object.keys(user));
// ["nama", "umur", "email"]

Object.values() — Array Nilai

console.log(Object.values(user));
// ["Budi", 25, "[email protected]"]

Object.entries() — Array Pasangan [key, value]

console.log(Object.entries(user));
// [["nama", "Budi"], ["umur", 25], ["email", "[email protected]"]]

Iterasi dengan entries():

for (const [key, value] of Object.entries(user)) {
  console.log(`${key}: ${value}`);
}
// nama: Budi
// umur: 25
// email: [email protected]

Object.assign() — Menggabungkan Object

const target = { a: 1 };
const source1 = { b: 2 };
const source2 = { c: 3 };

const hasil = Object.assign(target, source1, source2);
console.log(hasil);  // { a: 1, b: 2, c: 3 }
console.log(target); // { a: 1, b: 2, c: 3 } (target ikut berubah!)

Untuk menyalin tanpa mengubah target:

const salinan = Object.assign({}, source1, source2);
console.log(salinan); // { b: 2, c: 3 }

Tips: Untuk shallow copy, spread operator { ...obj } lebih ringkas dan modern.

Object.freeze() — Membekukan Object

Object yang di-freeze tidak bisa ditambah, diubah, atau dihapus propertinya.

const config = Object.freeze({
  host: "localhost",
  port: 3306
});

config.port = 5432;        // gagal (silent di non-strict, error di strict)
config.hostname = "x";     // gagal
delete config.host;        // gagal

console.log(config);       // { host: "localhost", port: 3306 }
console.log(Object.isFrozen(config)); // true

Catatan: Object.freeze() hanya shallow — object bersarang masih bisa diubah. Untuk deep freeze, perlu fungsi rekursif.

function deepFreeze(obj) {
  Object.getOwnPropertyNames(obj).forEach(name => {
    const value = obj[name];
    if (value && typeof value === "object") {
      deepFreeze(value);
    }
  });
  return Object.freeze(obj);
}

Object.seal() — Menyegel Object

Object yang di-seal tidak bisa ditambah/dihapus propertinya, tetapi nilai properti yang ada masih bisa diubah.

const user = { nama: "Budi", umur: 25 };
Object.seal(user);

user.umur = 26;        // OK (ubah nilai)
user.email = "x";      // gagal (tambah properti)
delete user.nama;      // gagal (hapus properti)

console.log(user);     // { nama: "Budi", umur: 26 }
console.log(Object.isSealed(user)); // true

Perbandingan freeze vs seal vs preventExtensions

Aksi freeze seal preventExtensions
Tambah properti ❌ ❌ ❌
Hapus properti ❌ ❌ ✅
Ubah nilai properti ❌ ✅ ✅
Object.preventExtensions(user); // hanya mencegah penambahan

Object.fromEntries() — Object dari Array Pasangan

Kebalikan dari Object.entries().

const entries = [["nama", "Budi"], ["umur", 25]];
const user = Object.fromEntries(entries);
console.log(user); // { nama: "Budi", umur: 25 }

Berguna untuk transformasi:

const harga = { keyboard: 450000, mouse: 150000 };

// Naikkan semua harga 10%
const hargaBaru = Object.fromEntries(
  Object.entries(harga).map(([key, val]) => [key, Math.round(val * 1.1)])
);
console.log(hargaBaru); // { keyboard: 495000, mouse: 165000 }

Object.getOwnPropertyNames()

Mengembalikan semua key milik object sendiri (termasuk non-enumerable).

const user = { nama: "Budi", umur: 25 };
console.log(Object.getOwnPropertyNames(user)); // ["nama", "umur"]

Destructuring Object

Mengekstrak properti object ke variabel.

Dasar

const user = {
  nama: "Budi",
  umur: 25,
  email: "[email protected]"
};

const { nama, umur, email } = user;
console.log(nama);  // "Budi"
console.log(umur);  // 25
console.log(email); // "[email protected]"

Mengganti Nama Variabel

const { nama: namaUser, umur: usia } = user;
console.log(namaUser); // "Budi"
console.log(usia);     // 25

Default Value

const { nama, kota = "Tidak diketahui" } = user;
console.log(kota); // "Tidak diketahui"

Nested Destructuring

const user = {
  nama: "Budi",
  alamat: {
    kota: "Jakarta",
    kodePos: "12345"
  }
};

const { nama, alamat: { kota, kodePos } } = user;
console.log(nama);    // "Budi"
console.log(kota);    // "Jakarta"
console.log(kodePos); // "12345"

Rest pada Destructuring

const user = {
  nama: "Budi",
  umur: 25,
  email: "[email protected]",
  aktif: true
};

const { nama, ...sisanya } = user;
console.log(nama);    // "Budi"
console.log(sisanya); // { umur: 25, email: "[email protected]", aktif: true }

Destructuring dalam Parameter Fungsi

function tampilkanUser({ nama, umur, kota = "Tidak diketahui" }) {
  console.log(`${nama}, ${umur} tahun, ${kota}`);
}

tampilkanUser({ nama: "Budi", umur: 25 }); // "Budi, 25 tahun, Tidak diketahui"

Destructuring dengan Key Dinamis

const key = "nama";
const { [key]: nilai } = user;
console.log(nilai); // "Budi"

Spread Operator pada Object

Menyalin Object (Shallow Copy)

const user = { nama: "Budi", umur: 25 };
const salinan = { ...user };

salinan.umur = 30;
console.log(user.umur);    // 25 (tidak berubah)
console.log(salinan.umur); // 30

Menggabungkan Object

const defaults = { theme: "light", fontSize: 14, language: "id" };
const userPrefs = { theme: "dark", fontSize: 16 };

const config = { ...defaults, ...userPrefs };
console.log(config);
// { theme: "dark", fontSize: 16, language: "id" }

Properti dari object kanan menimpa object kiri.

Menambah/Mengubah Properti Saat Menyalin

const user = { nama: "Budi", umur: 25 };

const userBaru = {
  ...user,
  umur: 26,          // ubah
  email: "[email protected]" // tambah
};

console.log(userBaru);
// { nama: "Budi", umur: 26, email: "[email protected]" }

Catatan: Spread hanya melakukan shallow copy — object bersarang masih berbagi referensi.

const user = {
  nama: "Budi",
  alamat: { kota: "Jakarta" }
};

const salinan = { ...user };
salinan.alamat.kota = "Bandung";

console.log(user.alamat.kota); // "Bandung" (!!) — berbagi referensi

Untuk deep copy, gunakan structuredClone() (modern) atau library seperti Lodash.

const deepCopy = structuredClone(user);
deepCopy.alamat.kota = "Surabaya";
console.log(user.alamat.kota); // "Jakarta" (tidak berubah)

Optional Chaining dan Nullish Coalescing

Optional Chaining (?.)

Mengakses properti dengan aman — jika object null atau undefined, hasilnya undefined alih-alih error.

const user = {
  nama: "Budi",
  alamat: {
    kota: "Jakarta"
  }
};

console.log(user.alamat?.kota);       // "Jakarta"
console.log(user.pekerjaan?.kantor);  // undefined (tidak error)
console.log(user.alamat?.kodePos);    // undefined

Tanpa ?.:

console.log(user.pekerjaan.kantor); // TypeError!

Dengan method:

const user = {
  nama: "Budi",
  sapa() {
    return `Halo, ${this.nama}!`;
  }
};

console.log(user.sapa?.());       // "Halo, Budi!"
console.log(user.kerja?.());      // undefined (tidak error)

Dengan array:

const users = [{ nama: "Budi" }];
console.log(users[0]?.nama);  // "Budi"
console.log(users[1]?.nama);  // undefined

Nullish Coalescing (??)

Memberikan nilai default hanya jika nilai null atau undefined (bukan falsy).

const user = {
  nama: "Budi",
  umur: 0,           // 0 adalah nilai valid
  email: null
};

console.log(user.umur ?? 18);    // 0   (karena 0 bukan null/undefined)
console.log(user.email ?? "Tidak ada"); // "Tidak ada"
console.log(user.telepon ?? "-"); // "-"

Perbandingan dengan ||:

const umur = 0;

console.log(umur || 18);  // 18 (karena 0 falsy)
console.log(umur ?? 18);  // 0  (karena 0 bukan null/undefined)

Kombinasi ?. dan ??

const config = {
  database: {
    host: "localhost"
  }
};

const port = config.database?.port ?? 3306;
console.log(port); // 3306

const host = config.database?.host ?? "127.0.0.1";
console.log(host); // "localhost"

JSON: Konversi Object

JSON (JavaScript Object Notation) adalah format pertukaran data yang sangat umum — digunakan di API, file konfigurasi, dan penyimpanan.

JSON.stringify() — Object ke String JSON

const user = {
  nama: "Budi",
  umur: 25,
  aktif: true,
  hobi: ["coding", "membaca"]
};

const json = JSON.stringify(user);
console.log(json);
// '{"nama":"Budi","umur":25,"aktif":true,"hobi":["coding","membaca"]}'

Pretty print (dengan indentasi):

console.log(JSON.stringify(user, null, 2));
// {
//   "nama": "Budi",
//   "umur": 25,
//   "aktif": true,
//   "hobi": [
//     "coding",
//     "membaca"
//   ]
// }

Memilih properti tertentu (replacer):

const json = JSON.stringify(user, ["nama", "umur"]);
console.log(json); // '{"nama":"Budi","umur":25}'

Replacer function:

const json = JSON.stringify(user, (key, value) => {
  if (key === "umur") return undefined; // sembunyikan umur
  return value;
});

JSON.parse() — String JSON ke Object

const json = '{"nama":"Budi","umur":25,"aktif":true}';
const user = JSON.parse(json);

console.log(user.nama);  // "Budi"
console.log(user.umur);  // 25

Error handling:

try {
  const user = JSON.parse('{"nama": invalid}');
} catch (error) {
  console.error("JSON tidak valid:", error.message);
}

Reviver function:

const json = '{"nama":"Budi","tanggalLahir":"1997-05-15"}';
const user = JSON.parse(json, (key, value) => {
  if (key === "tanggalLahir") return new Date(value);
  return value;
});

console.log(user.tanggalLahir instanceof Date); // true

Batasan JSON

JSON tidak mendukung:

  • undefined (dihilangkan)
  • function (dihilangkan)
  • Symbol (dihilangkan)
  • BigInt (error)
  • Date (dikonversi ke string ISO)
  • Map / Set (dikonversi ke {})
const data = {
  nama: "Budi",
  fn: () => {},
  undef: undefined,
  tanggal: new Date("2022-12-26")
};

console.log(JSON.stringify(data));
// '{"nama":"Budi","tanggal":"2022-12-26T00:00:00.000Z"}'

Contoh Praktis

1. Data User dan Transformasi

const user = {
  id: 1,
  nama: "Budi Santoso",
  email: "[email protected]",
  alamat: {
    jalan: "Jl. Merdeka No. 10",
    kota: "Jakarta",
    kodePos: "12345"
  },
  hobi: ["coding", "membaca", "bersepeda"]
};

// Destructuring nested
const {
  nama,
  alamat: { kota },
  hobi: [hobiUtama]
} = user;

console.log(`${nama} tinggal di ${kota}, hobi utama: ${hobiUtama}`);
// "Budi Santoso tinggal di Jakarta, hobi utama: coding"

// Transformasi
const ringkasan = {
  ...user,
  namaLengkap: user.nama,
  jumlahHobi: user.hobi.length
};

console.log(Object.keys(ringkasan));
// ["id", "nama", "email", "alamat", "hobi", "namaLengkap", "jumlahHobi"]

2. Konfigurasi dengan Default

function buatKoneksi(options = {}) {
  const config = {
    host: "localhost",
    port: 3306,
    user: "root",
    database: "test",
    ...options
  };

  return `mysql://${config.user}@${config.host}:${config.port}/${config.database}`;
}

console.log(buatKoneksi());
// "mysql://root@localhost:3306/test"

console.log(buatKoneksi({ database: "toko_online", port: 3307 }));
// "mysql://root@localhost:3307/toko_online"

3. Menghitung Total Belanja (Object sebagai Map)

const keranjang = {
  keyboard: { harga: 450000, jumlah: 2 },
  mouse: { harga: 150000, jumlah: 1 },
  monitor: { harga: 1500000, jumlah: 1 }
};

// Total dengan Object.entries + reduce
const total = Object.entries(keranjang)
  .map(([nama, item]) => item.harga * item.jumlah)
  .reduce((sum, val) => sum + val, 0);

console.log(total); // 2550000

// Daftar item
const daftarItem = Object.entries(keranjang)
  .map(([nama, item]) => `${nama} x${item.jumlah}`)
  .join(", ");

console.log(daftarItem); // "keyboard x2, mouse x1, monitor x1"

4. Grouping dengan reduce

const transaksi = [
  { id: 1, kategori: "makanan", total: 50000 },
  { id: 2, kategori: "transport", total: 25000 },
  { id: 3, kategori: "makanan", total: 75000 },
  { id: 4, kategori: "hiburan", total: 100000 }
];

const totalPerKategori = transaksi.reduce((acc, t) => {
  acc[t.kategori] = (acc[t.kategori] || 0) + t.total;
  return acc;
}, {});

console.log(totalPerKategori);
// { makanan: 125000, transport: 25000, hiburan: 100000 }

5. Deep Clone dengan structuredClone

const original = {
  nama: "Budi",
  alamat: { kota: "Jakarta" },
  hobi: ["coding", "membaca"]
};

const clone = structuredClone(original);
clone.alamat.kota = "Bandung";
clone.hobi.push("bersepeda");

console.log(original);
// { nama: "Budi", alamat: { kota: "Jakarta" }, hobi: ["coding", "membaca"] }
console.log(clone);
// { nama: "Budi", alamat: { kota: "Bandung" }, hobi: ["coding", "membaca", "bersepeda"] }

6. Mengubah Object menjadi Query String

function toQueryString(params) {
  return Object.entries(params)
    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
    .join("&");
}

const params = {
  q: "laptop gaming",
  kategori: "elektronik",
  page: 2,
  limit: 10
};

console.log(toQueryString(params));
// "q=laptop%20gaming&kategori=elektronik&page=2&limit=10"

Ringkasan

Kategori Method / Sintaks
Membuat {}, new Object(), Object.create(), class
Akses obj.key, obj["key"], obj?.key
Modifikasi obj.key = value, delete obj.key
Cek "key" in obj, Object.hasOwn(obj, "key")
Iterasi Object.keys(), Object.values(), Object.entries(), for...in
Copy/Merge { ...obj }, Object.assign()
Freeze/Seal Object.freeze(), Object.seal()
Destructuring const { a, b } = obj
JSON JSON.stringify(), JSON.parse()
Deep clone structuredClone(obj)

Poin penting:

  • Gunakan object literal {} untuk membuat object.
  • Dot notation untuk key valid; bracket notation untuk key dinamis atau karakter khusus.
  • in mengecek termasuk prototype; Object.hasOwn() hanya milik sendiri.
  • Arrow function tidak cocok sebagai method yang membutuhkan this.
  • Object.freeze() hanya shallow — gunakan structuredClone() untuk deep copy.
  • ?. mengakses properti dengan aman; ?? fallback hanya untuk null/undefined.
  • JSON.stringify() menghilangkan undefined, function, dan Symbol.
  • Spread { ...obj } melakukan shallow copy — object bersarang berbagi referensi.

Pada artikel berikutnya, kita akan membahas DOM Manipulation — mengubah halaman web dengan JavaScript.

Top