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
vardi kode modern. Gunakanletatauconst.
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
constsebagai default. Gunakanlethanya jika nilai memang perlu berubah. Jangan gunakanvar.
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
-
Diawali huruf,
_, atau$— tidak boleh angka.let nama = "Budi"; // ✅ let _private = 1; // ✅ let $harga = 100; // ✅ let 1nama = "Budi"; // ❌ SyntaxError -
Hanya berisi huruf, angka,
_, dan$— tanpa spasi atau karakter khusus.let nama_saya = "Budi"; // ✅ let nama-saya = "Budi"; // ❌ (dianggap pengurangan) -
Case-sensitive —
namadanNamaadalah variabel berbeda. -
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 nullmengembalikan"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
??ketika0atau""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
constsebagai default,lethanya jika perlu berubah. - Jangan gunakan
vardi kode modern. - Selalu gunakan
===dan!==untuk perbandingan. - Pahami TDZ — akses variabel sebelum deklarasi menghasilkan error.
consttidak membuat object/array immutable — gunakanObject.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.