Sintaks Dasar & Variabel

Variabel adalah fondasi setiap program. Artikel ini membahas cara mendeklarasikan variabel dengan var, let, dan const, memahami perbedaannya, serta mengenal operator-operator dasar JavaScript.

Pendahuluan

Setiap program JavaScript terdiri dari statement (pernyataan) yang dieksekusi baris demi baris. Statement paling dasar adalah deklarasi variabel — cara menyimpan nilai agar bisa digunakan kembali.

JavaScript memiliki tiga kata kunci untuk mendeklarasikan variabel: var, let, dan const. Memahami perbedaannya sangat penting karena perilakunya berbeda dalam hal scope, hoisting, dan reassignment.

Artikel ini membahas sintaks dasar, ketiga jenis variabel, aturan penamaan, serta operator-operator dasar JavaScript.

Asumsi: Anda sudah menyiapkan lingkungan JavaScript (browser console atau Node.js) sesuai artikel sebelumnya.


Statement dan Ekspresi

Sebelum masuk ke variabel, pahami dua istilah dasar:

  • Statement — instruksi lengkap yang melakukan sesuatu. Contoh: let x = 5;
  • Ekspresi — potongan kode yang menghasilkan nilai. Contoh: 2 + 3, x * 2, "Hello".

Statement biasanya diakhiri titik koma (;). Meskipun JavaScript memiliki ASI (Automatic Semicolon Insertion) yang otomatis menambahkan titik koma, menuliskannya secara eksplisit adalah praktik yang baik.

let x = 5;          // statement
let y = x + 3;      // statement, dengan ekspresi x + 3
console.log(y);     // statement

Variabel: var, let, dan const

var — Cara Lama (Hindari)

var adalah cara mendeklarasikan variabel di JavaScript versi awal. Masih didukung, tetapi memiliki perilaku yang sering menimbulkan bug.

var nama = "Budi";
console.log(nama); // "Budi"

var nama = "Andi"; // bisa dideklarasikan ulang
console.log(nama); // "Andi"

Masalah var:

  • Function scope, bukan block scope — variabel bocor keluar dari blok {}.
  • Bisa dideklarasikan ulang tanpa error.
  • Hoisting-nya membingungkan (variabel “ada” sebelum dideklarasikan, bernilai undefined).
if (true) {
  var x = 10;
}
console.log(x); // 10 — bocor keluar blok!

Rekomendasi: Jangan gunakan var di kode modern. Gunakan let atau const.

let — Variabel yang Bisa Diubah

let diperkenalkan di ES6 (2015). Memiliki block scope dan bisa di-reassign.

let umur = 25;
console.log(umur); // 25

umur = 26;         // reassignment OK
console.log(umur); // 26

Block scope:

if (true) {
  let x = 10;
  console.log(x); // 10
}
console.log(x);   // ReferenceError: x is not defined

Variabel x hanya hidup di dalam blok if.

Tidak bisa dideklarasikan ulang dalam scope yang sama:

let nama = "Budi";
let nama = "Andi"; // SyntaxError: Identifier 'nama' has already been declared

const — Konstanta (Tidak Bisa Di-reassign)

const juga memiliki block scope, tetapi nilainya tidak bisa di-reassign setelah dideklarasikan.

const PI = 3.14159;
console.log(PI); // 3.14159

PI = 3.14;       // TypeError: Assignment to constant variable

Wajib diinisialisasi saat deklarasi:

const x;         // SyntaxError: Missing initializer in const declaration
const y = 10;    // OK

const bukan berarti “immutable” untuk object/array:

Meskipun binding-nya tidak bisa diubah, isi object atau array yang dideklarasikan dengan const masih bisa dimodifikasi:

const user = { nama: "Budi" };
user.nama = "Andi";        // OK — mengubah properti
console.log(user.nama);    // "Andi"

user = { nama: "Citra" };  // TypeError — reassign binding

const angka = [1, 2, 3];
angka.push(4);             // OK
console.log(angka);        // [1, 2, 3, 4]

Untuk benar-benar membekukan object, gunakan Object.freeze():

const config = Object.freeze({ host: "localhost", port: 3306 });
config.port = 5432;        // gagal diam-diam (atau error di strict mode)
console.log(config.port);  // 3306

Perbandingan var, let, const

Aspek var let const
Scope Function scope Block scope Block scope
Reassign ✅ ✅ ❌
Redeclare ✅ ❌ ❌
Hoisting ✅ (nilai undefined) ✅ (TDZ) ✅ (TDZ)
Wajib inisialisasi ❌ ❌ ✅
Rekomendasi Hindari Untuk nilai berubah Default pilihan

Best practice: Gunakan const sebagai default. Gunakan let hanya jika nilai memang perlu berubah. Jangan gunakan var.

Hoisting dan Temporal Dead Zone (TDZ)

Hoisting adalah perilaku JavaScript yang “mengangkat” deklarasi variabel ke atas scope-nya.

Dengan var:

console.log(x); // undefined (bukan error!)
var x = 5;

Deklarasi var x diangkat ke atas, tetapi nilainya belum diinisialisasi — hasilnya undefined.

Dengan let dan const:

console.log(y); // ReferenceError: Cannot access 'y' before initialization
let y = 5;

Variabel let/const juga diangkat, tetapi berada di Temporal Dead Zone (TDZ) — periode antara awal scope dan baris deklarasi. Mengaksesnya sebelum deklarasi menghasilkan ReferenceError.

Tips: Selalu deklarasikan variabel sebelum digunakan. TDZ mencegah bug yang tidak terlihat.


Aturan Penamaan Variabel

Aturan Wajib

  1. Diawali huruf, _, atau $ — tidak boleh angka.

    let nama = "Budi";    // ✅
    let _private = 1;     // ✅
    let $harga = 100;     // ✅
    let 1nama = "Budi";   // ❌ SyntaxError
    
  2. Hanya berisi huruf, angka, _, dan $ — tanpa spasi atau karakter khusus.

    let nama_saya = "Budi";   // ✅
    let nama-saya = "Budi";   // ❌ (dianggap pengurangan)
    
  3. Case-sensitive — nama dan Nama adalah variabel berbeda.

  4. Tidak boleh menggunakan reserved words — seperti let, const, if, for, return, dll.

Convention (Kesepakatan)

Gaya Contoh Digunakan Untuk
camelCase namaLengkap, totalHarga Variabel & fungsi (standar JS)
PascalCase UserService, ProductCard Class & constructor
UPPER_SNAKE_CASE MAX_SIZE, API_URL Konstanta global
_prefix _private Properti “internal” (konvensi)
const MAX_LOGIN_ATTEMPTS = 5;      // konstanta
let jumlahPercobaan = 0;           // variabel
function hitungTotal() {}          // fungsi
class KeranjangBelanja {}          // class

Nama yang Deskriptif

// ❌ Buruk
let x = 5;
let d = new Date();

// ✅ Baik
let jumlahProduk = 5;
let tanggalSekarang = new Date();

Operator Dasar

1. Operator Aritmatika

Operator Arti Contoh Hasil
+ Penjumlahan 5 + 3 8
- Pengurangan 5 - 3 2
* Perkalian 5 * 3 15
/ Pembagian 10 / 4 2.5
% Modulus (sisa bagi) 10 % 3 1
** Pangkat 2 ** 3 8
let a = 10;
let b = 3;

console.log(a + b);   // 13
console.log(a - b);   // 7
console.log(a * b);   // 30
console.log(a / b);   // 3.3333...
console.log(a % b);   // 1
console.log(a ** b);  // 1000

Operator + pada string (concatenation):

console.log("Hello" + " " + "World"); // "Hello World"
console.log("Angka: " + 5);           // "Angka: 5" (number jadi string)
console.log(5 + 3 + "!");             // "8!" (5+3 dulu, lalu + "!")
console.log("!" + 5 + 3);             // "!53" (string + 5 = "!5", + 3 = "!53")

Perhatian: Urutan operasi memengaruhi hasil saat mencampur string dan number.

2. Operator Penugasan (Assignment)

Operator Contoh Setara Dengan
= x = 5 —
+= x += 3 x = x + 3
-= x -= 3 x = x - 3
*= x *= 3 x = x * 3
/= x /= 3 x = x / 3
%= x %= 3 x = x % 3
**= x **= 3 x = x ** 3
let total = 100;
total += 50;   // 150
total -= 20;   // 130
total *= 2;    // 260
total /= 4;    // 65

3. Operator Increment & Decrement

let counter = 0;

counter++;    // 1 (post-increment: kembalikan nilai lama, lalu tambah)
counter--;    // 0 (post-decrement)

++counter;    // 1 (pre-increment: tambah dulu, lalu kembalikan)
--counter;    // 0 (pre-decrement)

Perbedaan pre dan post:

let x = 5;
console.log(x++); // 5 (kembalikan 5, lalu x jadi 6)
console.log(x);   // 6

let y = 5;
console.log(++y); // 6 (y jadi 6 dulu, lalu kembalikan 6)
console.log(y);   // 6

4. Operator Perbandingan

Operator Arti Contoh Hasil
== Sama (longgar, dengan konversi tipe) 5 == "5" true
=== Sama (ketat, tanpa konversi) 5 === "5" false
!= Tidak sama (longgar) 5 != "5" false
!== Tidak sama (ketat) 5 !== "5" true
> Lebih besar 5 > 3 true
< Lebih kecil 5 < 3 false
>= Lebih besar atau sama 5 >= 5 true
<= Lebih kecil atau sama 5 <= 3 false

Selalu gunakan === dan !== — hindari == dan != karena melakukan konversi tipe yang tidak terduga:

console.log(0 == "");        // true  (!!)
console.log(0 == "0");       // true
console.log("" == "0");      // false
console.log(null == undefined); // true
console.log(null === undefined); // false

Best practice: Gunakan === dan !== secara konsisten. Ini mencegah bug halus akibat konversi tipe otomatis.

5. Operator Logika

Operator Arti Contoh
&& AND (dan) true && false → false
|| OR (atau) true || false → true
! NOT (negasi) !true → false

Short-circuit evaluation:

// && mengembalikan operand pertama yang falsy, atau operand terakhir
console.log(true && "Hello");   // "Hello"
console.log(false && "Hello");  // false

// || mengembalikan operand pertama yang truthy, atau operand terakhir
console.log(false || "Default"); // "Default"
console.log("Hello" || "Default"); // "Hello"

Pola umum:

// Nilai default
const nama = inputNama || "Anonim";

// Eksekusi kondisional
isLoggedIn && tampilkanDashboard();

6. Operator Ternary (Kondisional)

Sintaks: kondisi ? nilai_jika_true : nilai_jika_false

const umur = 20;
const status = umur >= 18 ? "Dewasa" : "Anak-anak";
console.log(status); // "Dewasa"

Setara dengan:

let status;
if (umur >= 18) {
  status = "Dewasa";
} else {
  status = "Anak-anak";
}

Ternary cocok untuk kondisi sederhana. Untuk logika kompleks, gunakan if...else agar lebih mudah dibaca.

7. Operator typeof

Mengecek tipe data:

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 historis!)
console.log(typeof {});         // "object"
console.log(typeof []);         // "object"
console.log(typeof function(){}); // "function"

Catatan: typeof null mengembalikan "object" — ini adalah bug historis JavaScript yang tidak bisa diperbaiki tanpa merusak kode lama.

8. Operator Nullish Coalescing (??)

Diperkenalkan di ES2020. Mirip ||, tetapi hanya fallback jika nilai null atau undefined (bukan falsy seperti 0 atau "").

const nilai = 0;

console.log(nilai || 100);  // 100 (karena 0 falsy)
console.log(nilai ?? 100);  // 0   (karena 0 bukan null/undefined)

const nama = null;
console.log(nama ?? "Anonim"); // "Anonim"

Tips: Gunakan ?? ketika 0 atau "" adalah nilai valid yang tidak boleh diganti default.

9. Operator Optional Chaining (?.)

Diperkenalkan di ES2020. Mengakses properti dengan aman — jika objek 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)

Tanpa ?.:

console.log(user.pekerjaan.kantor); // TypeError: Cannot read property 'kantor' of undefined

Komentar

Komentar diabaikan oleh JavaScript — berguna untuk dokumentasi.

// Komentar satu baris

/*
  Komentar
  multi-baris
*/

/**
 * Komentar JSDoc — untuk dokumentasi fungsi
 * @param {string} nama - nama pengguna
 * @returns {string} sapaan
 */
function sapa(nama) {
  return `Halo, ${nama}!`;
}

Tips: Tulis komentar untuk menjelaskan mengapa, bukan apa. Kode yang baik sudah menjelaskan “apa” melalui nama variabel yang jelas.


Contoh Praktis: Menghitung Total Belanja

Mari gabungkan semua yang telah dipelajari:

// Konstanta
const HARGA_PRODUK = 150000;
const DISKON_PERSEN = 10;

// Variabel
let jumlahBeli = 3;
let totalSebelumDiskon = HARGA_PRODUK * jumlahBeli;
let nilaiDiskon = totalSebelumDiskon * (DISKON_PERSEN / 100);
let totalAkhir = totalSebelumDiskon - nilaiDiskon;

// Cek apakah dapat gratis ongkir (minimal 300rb)
const gratisOngkir = totalAkhir >= 300000;

// Output
console.log(`Jumlah beli: ${jumlahBeli}`);
console.log(`Total sebelum diskon: Rp${totalSebelumDiskon}`);
console.log(`Diskon (${DISKON_PERSEN}%): Rp${nilaiDiskon}`);
console.log(`Total akhir: Rp${totalAkhir}`);
console.log(`Gratis ongkir: ${gratisOngkir ? "Ya" : "Tidak"}`);

Output:

Jumlah beli: 3
Total sebelum diskon: Rp450000
Diskon (10%): Rp45000
Total akhir: Rp405000
Gratis ongkir: Ya

Ringkasan

Konsep Poin Penting
var Function scope, bisa redeclare — hindari
let Block scope, bisa reassign
const Block scope, tidak bisa reassign — default pilihan
Hoisting var → undefined; let/const → TDZ
Penamaan camelCase untuk variabel, UPPER_SNAKE_CASE untuk konstanta
=== vs == Selalu gunakan === (strict equality)
?? vs || ?? hanya fallback untuk null/undefined
?. Akses properti aman tanpa error

Poin penting:

  • Gunakan const sebagai default, let hanya jika perlu berubah.
  • Jangan gunakan var di kode modern.
  • Selalu gunakan === dan !== untuk perbandingan.
  • Pahami TDZ — akses variabel sebelum deklarasi menghasilkan error.
  • const tidak membuat object/array immutable — gunakan Object.freeze() jika perlu.
  • Gunakan nama variabel yang deskriptif.

Pada artikel berikutnya, kita akan membahas Tipe Data & Konversi — string, number, boolean, dan cara mengonversi antar tipe.

Top