Sintaks Utama #

PHP dirancang untuk mudah dipelajari — tapi “mudah dipelajari” bukan berarti tidak ada jebakan. Banyak developer yang baru belajar PHP berhasil menulis kode yang berfungsi, tapi tanpa memahami beberapa aturan dasar yang penting: kapan harus menggunakan perbandingan ketat (===) vs longgar (==), apa perbedaan antara echo dan print, atau mengapa variabel PHP tidak perlu dideklarasikan tipe datanya. Artikel ini membahas semua fondasi sintaks PHP secara menyeluruh — bukan sekadar “ini sintaksnya”, tapi juga “ini alasannya dan ini yang sering salah”. Setelah membaca ini, kamu punya pemahaman yang cukup solid untuk menulis kode PHP yang benar, bukan hanya kode PHP yang kebetulan berjalan.

Tag PHP #

PHP adalah bahasa yang dirancang untuk di-embed di dalam HTML. Cara kerja ini berbeda dari JavaScript (yang punya tag <script>) — PHP menggunakan tag khususnya sendiri yang memberi tahu interpreter mana bagian yang perlu diproses.

Tag standar PHP adalah <?php untuk membuka dan ?> untuk menutup:

<?php
// Semua kode PHP ditulis di sini
echo "Hello, World!";
?>

Penempatan Tag dan Hubungannya dengan HTML #

PHP dan HTML bisa hidup berdampingan di file yang sama. Interpreter PHP hanya memproses bagian di dalam tag <?php ... ?>, sementara bagian di luar tag dikirim langsung ke browser sebagai HTML:

<!DOCTYPE html>
<html>
<body>
    <h1>Selamat Datang</h1>

    <?php
    $nama = "Budi";
    echo "<p>Halo, " . $nama . "!</p>";
    ?>

    <footer>Footer HTML biasa</footer>
</body>
</html>

Omitting Tag Penutup #

Ketika file PHP hanya berisi kode PHP murni (tidak ada HTML sama sekali), ada konvensi penting yang sering diabaikan pemula:

<?php
// ANTI-PATTERN: menutup tag di file PHP murni
class UserRepository
{
    // ... kode kelas
}
?>
<!-- Tag penutup di atas bisa menyebabkan "headers already sent" error
     jika ada whitespace/newline setelah ?> -->

// BENAR: hilangkan tag penutup di file PHP murni
class UserRepository
{
    // ... kode kelas
}
// Tidak ada ?> di akhir file — ini justru yang benar

Tag penutup ?> opsional di akhir file PHP murni, dan lebih baik dihilangkan. Jika ada karakter apapun (termasuk spasi atau newline yang tidak terlihat) setelah ?>, PHP akan mengirimkannya sebagai output sebelum header HTTP, yang menyebabkan error “headers already sent” yang sangat membingungkan.

Short Echo Tag #

PHP juga mengenal short echo tag <?= sebagai shorthand untuk <?php echo:

<!-- Cara panjang -->
<?php echo $judul; ?>

<!-- Short echo tag — lebih ringkas untuk template HTML -->
<?= $judul ?>

<!-- Short echo tag juga mendukung ekspresi -->
<?= strtoupper($nama) ?>
<?= count($items) . " item" ?>

Short echo tag <?= selalu aktif sejak PHP 5.4 dan aman digunakan. Ini idiomatik untuk file template (view layer) karena lebih bersih dibanding <?php echo.

Variabel #

PHP adalah bahasa dengan dynamic typing — tipe variabel ditentukan saat runtime berdasarkan nilai yang diberikan, bukan saat deklarasi. Semua variabel PHP diawali dengan tanda $.

<?php
$nama     = "Budi";        // string
$umur     = 25;            // integer
$tinggi   = 175.5;         // float
$aktif    = true;          // boolean
$alamat   = null;          // null (belum ada nilai)

Aturan Penamaan Variabel #

<?php
// ✓ Nama variabel yang valid
$nama = "Budi";
$namaLengkap = "Budi Santoso";    // camelCase
$nama_lengkap = "Budi Santoso";   // snake_case
$_config = [];                     // boleh diawali underscore
$nilai2 = 100;                     // boleh mengandung angka

// ✗ Nama variabel yang tidak valid
// $2nilai = 100;     // tidak boleh diawali angka
// $nama-ku = "x";   // tanda hubung tidak diperbolehkan
// $nama ku = "x";   // spasi tidak diperbolehkan

PHP tidak memaksa konvensi penamaan, tapi komunitas PHP (termasuk PSR-12) umumnya menggunakan camelCase untuk variabel dan parameter fungsi, serta snake_case untuk nama tabel dan kolom database.

Variabel Variabel #

PHP punya fitur unik bernama variable variables — variabel yang nilainya digunakan sebagai nama variabel lain:

<?php
$kunci = "nama";
$$kunci = "Budi";

echo $nama;   // Output: Budi
echo $$kunci; // Output: Budi (sama)

Fitur ini jarang digunakan dan sebaiknya dihindari karena membuat kode sulit dibaca dan debug. Sebutkan saja di sini agar kamu tidak bingung saat menemukannya di kode orang lain.

Tipe Data #

PHP mendukung delapan tipe data primitif. Memahami perbedaan antar tipe — terutama cara PHP melakukan konversi otomatis — sangat penting untuk menghindari bug yang sulit dilacak.

Tipe Data Skalar #

Tipe	Contoh Nilai	Keterangan
`string`	`"Hello"`, `'World'`	Teks, bisa pakai kutip satu atau dua
`int`	`42`, `-10`, `0`	Bilangan bulat
`float`	`3.14`, `1.5e3`	Bilangan desimal
`bool`	`true`, `false`	Boolean (tidak case-sensitive)

<?php
$string  = "PHP 8.3";
$integer = 42;
$float   = 3.14159;
$boolean = true;

// Cek tipe data dengan gettype() atau var_dump()
var_dump($string);   // string(6) "PHP 8.3"
var_dump($integer);  // int(42)
var_dump($float);    // float(3.14159)
var_dump($boolean);  // bool(true)

String: Kutip Satu vs Kutip Dua #

Ini adalah salah satu perbedaan paling penting yang sering diabaikan:

<?php
$nama = "Budi";

// Kutip dua: variabel di-interpolasi (diganti nilainya)
echo "Halo, $nama!";           // Output: Halo, Budi!
echo "Halo, {$nama}!";        // Output: Halo, Budi! (lebih eksplisit)

// Kutip satu: teks ditampilkan apa adanya, TIDAK ada interpolasi
echo 'Halo, $nama!';          // Output: Halo, $nama!
echo 'Halo, {$nama}!';        // Output: Halo, {$nama}!

// Escape sequence hanya bekerja di kutip dua
echo "Baris pertama\nBaris kedua";   // newline berfungsi
echo 'Baris pertama\nBaris kedua';   // \n ditampilkan literal

Gunakan kutip satu ketika string tidak membutuhkan interpolasi — sedikit lebih cepat karena PHP tidak perlu memeriksa ada variabel atau tidak. Gunakan kutip dua ketika butuh interpolasi atau escape sequence seperti \n dan \t.

Tipe Data Compound #

<?php
// Array — kumpulan nilai
$buah = ["apel", "mangga", "jeruk"];
$profil = ["nama" => "Budi", "umur" => 25];

// Object — instance dari sebuah kelas
class Titik {
    public function __construct(
        public float $x,
        public float $y
    ) {}
}
$titik = new Titik(3.0, 4.0);

// Callable — sesuatu yang bisa dipanggil sebagai fungsi
$kali2 = fn($n) => $n * 2;
echo $kali2(5);  // Output: 10

Null dan Pengecekannya #

<?php
$data = null;

// Tiga cara cek null — masing-masing berbeda perilakunya
var_dump($data === null);     // bool(true) — perbandingan ketat
var_dump(is_null($data));     // bool(true) — fungsi bawaan
var_dump(isset($data));       // bool(false) — cek apakah set DAN bukan null

Type Juggling — Konversi Otomatis #

PHP secara otomatis mengkonversi tipe data saat dibutuhkan. Ini fitur yang memudahkan, tapi juga sumber bug yang sering muncul:

<?php
// PHP mengkonversi string ke integer saat operasi aritmatika
$hasil = "10" + 5;
var_dump($hasil);  // int(15) — string "10" dikonversi ke int

// String yang tidak dimulai angka dikonversi ke 0
$hasil2 = "abc" + 5;
var_dump($hasil2); // int(5)

// Boolean dalam konteks aritmatika
$hasil3 = true + true;
var_dump($hasil3); // int(2)

Perilaku ini adalah alasan mengapa perbandingan ketat (===) hampir selalu lebih aman dari perbandingan longgar (==) — dibahas lebih detail di bagian Operator.

Operator #

PHP memiliki set operator yang kaya. Yang paling penting untuk dipahami betul adalah operator perbandingan, karena behavior-nya yang tidak intuitif sering menjadi sumber bug.

Operator Aritmatika #

<?php
$a = 17;
$b = 5;

echo $a + $b;   // 22  — penjumlahan
echo $a - $b;   // 12  — pengurangan
echo $a * $b;   // 85  — perkalian
echo $a / $b;   // 3.4 — pembagian (selalu float jika tidak habis)
echo $a % $b;   // 2   — modulo (sisa bagi)
echo $a ** $b;  // 1419857 — pangkat (PHP 5.6+)

// Increment / Decrement
$c = 10;
echo $c++;  // 10 — tampilkan dulu, baru increment
echo $c;    // 11
echo ++$c;  // 12 — increment dulu, baru tampilkan

Operator Perbandingan: Ketat vs Longgar #

Ini adalah bagian yang paling krusial untuk dipahami dengan benar:

<?php
// Operator longgar (==) — membandingkan nilai setelah konversi tipe
var_dump(0 == "foo");    // bool(true)  di PHP 7, bool(false) di PHP 8!
var_dump(0 == "");       // bool(false) di PHP 8
var_dump(1 == "1");      // bool(true)  — "1" dikonversi ke int 1
var_dump(null == false); // bool(true)
var_dump("" == false);   // bool(true)
var_dump("0" == false);  // bool(true)
var_dump(100 == "1e2");  // bool(true)  — notasi ilmiah!

// Operator ketat (===) — membandingkan nilai DAN tipe
var_dump(1 === "1");     // bool(false) — tipe berbeda
var_dump(1 === 1);       // bool(true)
var_dump(null === false);// bool(false) — tipe berbeda

Perilaku == berubah antara PHP 7 dan PHP 8. Di PHP 7, 0 == "foo" menghasilkan true (string non-numerik dikonversi ke 0). Di PHP 8, hasilnya false. Ini adalah breaking change yang menyebabkan bug saat migrasi versi. Gunakan === untuk menghindari ambiguitas ini sepenuhnya.

<?php
// ANTI-PATTERN: gunakan == untuk cek kondisi yang melibatkan tipe campuran
function cariUser($id) {
    // Anggap fungsi ini return false jika tidak ditemukan, atau array jika ada
    // ...
}

if (cariUser(0) == false) {
    // BUG: jika cariUser() return array kosong [],
    // [] == false adalah true, tapi cariUser() berhasil!
}

// BENAR: gunakan === untuk perbandingan yang eksplisit
if (cariUser(0) === false) {
    echo "User tidak ditemukan";
}

Tabel Perbandingan Operator #

Operator	Nama	Contoh	Hasil
`==`	Sama (longgar)	`1 == "1"`	`true`
`===`	Identik (ketat)	`1 === "1"`	`false`
`!=`	Tidak sama (longgar)	`1 != "2"`	`true`
`!==`	Tidak identik (ketat)	`1 !== "1"`	`true`
`<`	Kurang dari	`1 < 2`	`true`
`>`	Lebih dari	`2 > 1`	`true`
`<=`	Kurang dari atau sama	`1 <= 1`	`true`
`>=`	Lebih dari atau sama	`2 >= 1`	`true`
`<=>`	Spaceship	`1 <=> 2`	`-1`

Operator Spaceship #

Operator <=> (spaceship) sangat berguna untuk sorting. Hasilnya -1, 0, atau 1:

<?php
// Sangat berguna sebagai callback usort()
$angka = [3, 1, 4, 1, 5, 9, 2, 6];
usort($angka, fn($a, $b) => $a <=> $b);  // ascending
// Output: [1, 1, 2, 3, 4, 5, 6, 9]

$produk = [
    ["nama" => "Laptop", "harga" => 15000000],
    ["nama" => "Mouse",  "harga" => 250000],
    ["nama" => "Monitor","harga" => 5000000],
];
usort($produk, fn($a, $b) => $a["harga"] <=> $b["harga"]);
// Produk terurut dari harga terendah ke tertinggi

Operator Logika #

<?php
$a = true;
$b = false;

var_dump($a && $b);   // bool(false) — AND
var_dump($a || $b);   // bool(true)  — OR
var_dump(!$a);        // bool(false) — NOT
var_dump($a xor $b);  // bool(true)  — XOR (salah satu tapi tidak keduanya)

// and / or punya precedence lebih rendah dari && / ||
// Ini bisa menyebabkan bug yang halus:
$x = true and false;  // $x = true! karena: ($x = true) and false
$y = true && false;   // $y = false — ini yang dimaksud

Operator Null Coalescing #

Operator ?? (null coalescing) sangat berguna untuk menangani nilai yang mungkin null:

<?php
// ANTI-PATTERN: verbose dan repetitif
$nama = isset($_GET['nama']) ? $_GET['nama'] : 'Tamu';

// BENAR: null coalescing operator (??)
$nama = $_GET['nama'] ?? 'Tamu';

// Bisa di-chain
$kota = $_GET['kota'] ?? $profil['kota'] ?? 'Jakarta';

// Null coalescing assignment (??=) — PHP 7.4+
$config['timeout'] ??= 30;  // set ke 30 hanya jika null atau tidak ada

Struktur Kendali #

PHP mendukung semua struktur kendali yang familiar dari bahasa lain, dengan beberapa fitur tambahan yang berguna.

If / Elseif / Else #

<?php
$nilai = 75;

if ($nilai >= 90) {
    echo "A";
} elseif ($nilai >= 80) {
    echo "B";
} elseif ($nilai >= 70) {
    echo "C";
} elseif ($nilai >= 60) {
    echo "D";
} else {
    echo "E";
}

Untuk kondisi sederhana, gunakan ternary operator atau match expression (PHP 8.0+):

<?php
$umur = 20;

// Ternary — untuk kondisi dua cabang
$status = $umur >= 18 ? "dewasa" : "anak-anak";

// Match expression — lebih aman dari switch (strict comparison, return value)
$hari = 3;
$namaHari = match($hari) {
    1 => "Senin",
    2 => "Selasa",
    3 => "Rabu",
    4 => "Kamis",
    5 => "Jumat",
    6, 7 => "Akhir Pekan",
    default => "Tidak valid",
};
echo $namaHari;  // Output: Rabu

Switch vs Match #

<?php
$warna = "merah";

// Switch: menggunakan == (longgar), bisa ada fall-through jika lupa break
switch ($warna) {
    case "merah":
        echo "Stop";
        break;       // jangan lupa break!
    case "kuning":
        echo "Hati-hati";
        break;
    default:
        echo "Tidak dikenal";
}

// Match: menggunakan === (ketat), tidak ada fall-through, harus exhaustive
// Jika tidak ada arm yang cocok dan tidak ada default, throw UnhandledMatchError
$pesan = match($warna) {
    "merah"  => "Stop",
    "kuning" => "Hati-hati",
    "hijau"  => "Jalan",
    default  => "Tidak dikenal",
};
echo $pesan;

Gunakan match di PHP 8+ kecuali kamu membutuhkan fall-through behavior yang memang disengaja.

Perulangan #

PHP menyediakan empat jenis loop. Masing-masing punya use case yang tepat:

<?php
// while — ketika kondisi diperiksa sebelum iterasi
$i = 1;
while ($i <= 5) {
    echo $i . " ";
    $i++;
}
// Output: 1 2 3 4 5

// do-while — body dijalankan minimal satu kali
$input = "";
do {
    // Simulasi: minta input sampai tidak kosong
    $input = "data valid";  // anggap ini dari user input
} while ($input === "");

// for — ketika jumlah iterasi sudah diketahui
for ($i = 0; $i < 5; $i++) {
    echo $i . " ";
}
// Output: 0 1 2 3 4

// foreach — untuk iterasi array atau iterable
$buah = ["apel", "mangga", "jeruk"];
foreach ($buah as $index => $nama) {
    echo "$index: $nama\n";
}
// Output:
// 0: apel
// 1: mangga
// 2: jeruk

Break dan Continue #

<?php
// break — keluar dari loop
for ($i = 0; $i < 10; $i++) {
    if ($i === 5) break;
    echo $i . " ";
}
// Output: 0 1 2 3 4

// continue — lewati iterasi ini, lanjut ke berikutnya
for ($i = 0; $i < 10; $i++) {
    if ($i % 2 === 0) continue;  // lewati bilangan genap
    echo $i . " ";
}
// Output: 1 3 5 7 9

// break dengan argumen — keluar dari N level loop bersarang
for ($i = 0; $i < 3; $i++) {
    for ($j = 0; $j < 3; $j++) {
        if ($j === 1) break 2;  // keluar dari kedua loop sekaligus
        echo "$i,$j ";
    }
}
// Output: 0,0

Fungsi #

Fungsi di PHP adalah first-class citizen sejak PHP 5.3 dengan diperkenalkannya closure. Ada beberapa cara mendefinisikan fungsi yang masing-masing punya konteks penggunaan berbeda.

Fungsi Biasa #

<?php
// Definisi dasar
function sapa(string $nama, string $sapaan = "Halo"): string {
    return "$sapaan, $nama!";
}

echo sapa("Budi");           // Halo, Budi!
echo sapa("Siti", "Selamat pagi");  // Selamat pagi, Siti!

Perhatikan penggunaan type hint (string) untuk parameter dan return type. PHP 7+ mendukung type hint untuk semua tipe skalar, dan ini sangat direkomendasikan karena membuat kode lebih mudah dipahami dan bug lebih cepat terdeteksi.

Variadic Function #

<?php
// Fungsi yang menerima jumlah argumen tak terbatas
function jumlahkan(int ...$angka): int {
    return array_sum($angka);
}

echo jumlahkan(1, 2, 3);         // 6
echo jumlahkan(10, 20, 30, 40);  // 100

// Spread operator — kebalikan dari variadic
$data = [1, 2, 3, 4, 5];
echo jumlahkan(...$data);  // 15

Closure dan Arrow Function #

<?php
// Closure — fungsi anonim
$kali = function(int $a, int $b): int {
    return $a * $b;
};
echo $kali(3, 4);  // 12

// Closure perlu 'use' untuk mengakses variabel luar
$faktor = 3;
$kaliTiga = function(int $n) use ($faktor): int {
    return $n * $faktor;
};
echo $kaliTiga(5);  // 15

// Arrow function (PHP 7.4+) — otomatis capture variabel luar
$kaliTigaArrow = fn(int $n): int => $n * $faktor;
echo $kaliTigaArrow(5);  // 15 (sama, tapi lebih ringkas)

// Arrow function sangat berguna sebagai callback
$angka = [1, 2, 3, 4, 5, 6];
$genap  = array_filter($angka, fn($n) => $n % 2 === 0);
$kali2  = array_map(fn($n) => $n * 2, $angka);

Array #

Array di PHP adalah struktur data yang sangat fleksibel — bisa berfungsi sebagai list, dictionary, stack, queue, atau kombinasinya.

Array Terindeks dan Asosiatif #

<?php
// Array terindeks (numerik)
$buah = ["apel", "mangga", "jeruk"];
echo $buah[0];  // apel

// Array asosiatif (key-value)
$profil = [
    "nama"  => "Budi Santoso",
    "umur"  => 25,
    "kota"  => "Jakarta",
];
echo $profil["nama"];  // Budi Santoso

// Array bisa di-nested
$data = [
    "users" => [
        ["id" => 1, "nama" => "Budi"],
        ["id" => 2, "nama" => "Siti"],
    ],
    "total" => 2,
];
echo $data["users"][0]["nama"];  // Budi

Fungsi Array yang Paling Sering Dipakai #

<?php
$angka = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3];

// Ukuran array
echo count($angka);  // 10

// Sorting
sort($angka);          // sort ascending, ubah array asli
$sorted = sorted($angka); // tidak ada, gunakan:
$copy = $angka;
sort($copy);           // ✓ sort copy, bukan original

// Cari elemen
echo in_array(9, $angka);         // true
echo array_search(9, $angka);     // index-nya

// Transformasi
$kali2  = array_map(fn($n) => $n * 2, $angka);
$besar  = array_filter($angka, fn($n) => $n > 4);
$jumlah = array_reduce($angka, fn($carry, $n) => $carry + $n, 0);

// Slicing dan splicing
$potongan = array_slice($angka, 0, 3);  // ambil 3 elemen pertama
array_push($angka, 99);                  // tambah di akhir
$pertama = array_shift($angka);          // ambil dan hapus elemen pertama

// Unik dan merge
$unik   = array_unique($angka);
$gabung = array_merge([1, 2], [3, 4]);

Superglobals #

Superglobals adalah variabel built-in PHP yang tersedia di semua scope — di dalam fungsi, kelas, maupun file yang di-include sekalipun. Ini adalah pintu masuk data dari luar ke dalam aplikasi PHP.

flowchart LR
    A[Browser / Client] -- "Query String ?id=1" --> B["$_GET"]
    A -- "Form POST" --> C["$_POST"]
    A -- "Cookie" --> D["$_COOKIE"]
    A -- "Upload file" --> E["$_FILES"]
    F[Server] -- "Info server" --> G["$_SERVER"]
    H[Session] -- "Data sesi" --> I["$_SESSION"]
    B & C & D & E & G & I --> J[Aplikasi PHP]

Daftar Superglobals dan Fungsinya #

Superglobal	Isi	Kapan Digunakan
`$_GET`	Data dari query string URL	Menerima parameter pencarian, filter, pagination
`$_POST`	Data dari form method POST	Login, submit form, upload data
`$_REQUEST`	Gabungan GET + POST + COOKIE	Hindari — ambigu dan tidak aman
`$_FILES`	Data file yang diupload	Form dengan `enctype="multipart/form-data"`
`$_SESSION`	Data sesi user	Login state, shopping cart
`$_COOKIE`	Cookie dari browser	Remember me, preferensi user
`$_SERVER`	Info server dan request	IP address, URL, method, header
`$_ENV`	Environment variables	Konfigurasi dari `.env` file
`$GLOBALS`	Semua variabel global	Hindari — membuat kode sulit debug

Menggunakan Superglobals dengan Aman #

Data dari superglobals $_GET, $_POST, $_COOKIE, dan $_FILES berasal langsung dari user — tidak bisa dipercaya. Selalu validasi dan sanitasi sebelum digunakan, terutama sebelum dimasukkan ke database atau ditampilkan ke halaman.

<?php
// ANTI-PATTERN: langsung pakai data dari user tanpa validasi
$nama = $_GET['nama'];
echo "Halo, " . $nama;  // Rentan XSS!

$id = $_GET['id'];
$query = "SELECT * FROM users WHERE id = $id";  // Rentan SQL Injection!

// BENAR: validasi dan sanitasi terlebih dahulu
$nama = filter_input(INPUT_GET, 'nama', FILTER_SANITIZE_SPECIAL_CHARS);
if ($nama === null || $nama === false) {
    $nama = "Tamu";
}
echo "Halo, " . htmlspecialchars($nama, ENT_QUOTES, 'UTF-8');

// Untuk query database, gunakan prepared statement
$id = filter_input(INPUT_GET, 'id', FILTER_VALIDATE_INT);
if ($id === false || $id === null) {
    // id tidak valid
    http_response_code(400);
    exit("ID tidak valid");
}
// Lanjut dengan PDO prepared statement
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([$id]);

OOP — Dasar-Dasar #

PHP adalah bahasa yang mendukung OOP secara penuh sejak versi 5. Pemahaman dasar OOP sangat penting karena hampir semua framework PHP modern (Laravel, Symfony, CodeIgniter) dibangun di atasnya.

Class, Property, dan Method #

<?php
class Produk
{
    // Properties — data yang dimiliki object
    public string $nama;
    public float $harga;
    private int $stok;

    // Constructor — dijalankan saat object dibuat
    public function __construct(string $nama, float $harga, int $stok = 0)
    {
        $this->nama  = $nama;
        $this->harga = $harga;
        $this->stok  = $stok;
    }

    // Method — aksi yang bisa dilakukan object
    public function tampilkanInfo(): string
    {
        return "{$this->nama} — Rp " . number_format($this->harga, 0, ',', '.');
    }

    // Getter untuk property private
    public function getStok(): int
    {
        return $this->stok;
    }

    // Method yang memodifikasi state
    public function tambahStok(int $jumlah): void
    {
        if ($jumlah <= 0) {
            throw new \InvalidArgumentException("Jumlah harus positif");
        }
        $this->stok += $jumlah;
    }
}

// Membuat instance (object)
$laptop = new Produk("Laptop ProBook", 15_000_000, 10);
echo $laptop->tampilkanInfo();  // Laptop ProBook — Rp 15.000.000
echo $laptop->getStok();        // 10
$laptop->tambahStok(5);
echo $laptop->getStok();        // 15

Constructor Promotion (PHP 8.0+) #

PHP 8 memperkenalkan constructor promotion yang mempersingkat deklarasi property:

<?php
// ANTI-PATTERN: cara lama — property dideklarasikan dua kali
class UserLama
{
    public string $nama;
    public string $email;
    private int $umur;

    public function __construct(string $nama, string $email, int $umur)
    {
        $this->nama  = $nama;
        $this->email = $email;
        $this->umur  = $umur;
    }
}

// BENAR: constructor promotion — lebih ringkas, hasil identik
class User
{
    public function __construct(
        public string $nama,
        public string $email,
        private int $umur,
    ) {}

    public function getUmur(): int
    {
        return $this->umur;
    }
}

$user = new User("Budi", "[email protected]", 25);
echo $user->nama;      // Budi
echo $user->getUmur(); // 25

Ringkasan #

Hilangkan tag penutup ?> di file PHP murni — karakter apapun setelahnya bisa menyebabkan “headers already sent” error yang membingungkan.
Gunakan === bukan == untuk perbandingan — == melakukan konversi tipe otomatis yang hasilnya sering tidak terduga, terutama antara PHP 7 dan PHP 8.
Kutip satu vs kutip dua — kutip satu untuk string literal, kutip dua ketika butuh interpolasi variabel atau escape sequence.
Null coalescing ?? adalah cara idiomatik menangani nilai yang mungkin null atau undefined — jauh lebih bersih dari isset() + ternary.
match lebih aman dari switch — menggunakan perbandingan ketat, tidak ada fall-through, dan melempar error jika tidak ada arm yang cocok.
Arrow function fn() otomatis meng-capture variabel dari scope luar tanpa use — ideal untuk callback pendek.
Superglobals tidak bisa dipercaya — selalu validasi dan sanitasi data dari $_GET, $_POST, dan $_COOKIE sebelum digunakan.
Constructor promotion (PHP 8+) menghilangkan boilerplate deklarasi property — manfaatkan fitur ini untuk kelas yang lebih bersih.

← Sebelumnya: Instalasi Berikutnya: Komentar →