Pengenalan PHP #

Tidak ada bahasa pemrograman lain yang perjalanannya sepopuler sekaligus sekontroversial PHP. Dimulai sebagai sekumpulan skrip Personal Home Page yang ditulis Rasmus Lerdorf untuk melacak pengunjung situsnya sendiri pada 1994, PHP berkembang menjadi bahasa yang menjalankan lebih dari 75% server-side web di internet — termasuk WordPress, Wikipedia, dan Facebook di masa awalnya. Sepanjang perjalanannya, PHP beberapa kali dinyatakan “sudah mati” oleh komunitas developer, tapi setiap kali, PHP muncul kembali dengan versi yang lebih modern, lebih cepat, dan lebih aman. PHP 8.x dengan JIT compiler, union types, fibers, dan named arguments adalah bukti bahwa bahasa ini terus berevolusi serius. Artikel ini membahas dari mana PHP berasal, apa yang membuatnya bertahan selama tiga dekade, bagaimana ekosistemnya bekerja, dan kapan PHP masih menjadi pilihan yang masuk akal di 2024.

Filosofi PHP dan Model Eksekusi Server-Side #

Memahami cara PHP bekerja secara fundamental penting sebelum membahas fitur-fiturnya. PHP adalah bahasa yang di-embed langsung ke HTML dan dieksekusi di server — bukan di browser.

Ketika browser meminta halaman PHP, server menjalankan interpreter PHP, mengeksekusi kode, dan mengirimkan HTML hasil render ke browser. Browser tidak pernah melihat kode PHP — hanya outputnya.

sequenceDiagram
    participant Browser
    participant WebServer as Web Server (Nginx/Apache)
    participant PHPFPM as PHP-FPM
    participant DB as Database

    Browser->>WebServer: GET /artikel.php
    WebServer->>PHPFPM: Forward request
    PHPFPM->>DB: SELECT * FROM artikel WHERE id = 1
    DB-->>PHPFPM: Row data
    PHPFPM->>PHPFPM: Eksekusi PHP, render HTML
    PHPFPM-->>WebServer: HTML output
    WebServer-->>Browser: HTTP Response (HTML)
    Note over Browser: PHP tidak terlihat — hanya HTML

Model ini berbeda fundamental dari JavaScript (berjalan di browser) atau Go/Java (process long-running yang mendengarkan koneksi). Secara default, setiap request PHP adalah proses baru yang dimulai dari nol — tidak ada state yang persisten antar request kecuali yang disimpan eksplisit ke database, session, atau cache.

Filosofi ini — share nothing architecture — membuat PHP sangat mudah di-scale secara horizontal: tinggal tambahkan server, tidak perlu koordinasi state antar instance.

flowchart TD
    A[Request 1] --> B[PHP Process 1\nFresh state]
    C[Request 2] --> D[PHP Process 2\nFresh state]
    E[Request 3] --> F[PHP Process 3\nFresh state]
    B --> G[(Database / Redis / Session)]
    D --> G
    F --> G
    G --> B
    G --> D
    G --> F

Sejarah dan Evolusi PHP #

PHP adalah salah satu bahasa dengan evolusi paling dramatis di dunia pemrograman — dari skrip CGI sederhana hingga bahasa modern dengan JIT compiler dan type system yang solid.

Lompatan terbesar dalam sejarah PHP adalah transisi dari PHP 5 ke PHP 7. PHP 7 bukan hanya update inkremental — ini adalah tulis ulang engine dengan peningkatan performa dua kali lipat dan pengurangan penggunaan memori yang drastis. Banyak aplikasi yang pindah dari PHP 5.6 ke PHP 7.0 langsung merasakan penurunan response time yang signifikan tanpa mengubah satu baris kode pun.

PHP 8.0 kemudian membawa JIT (Just-In-Time) compiler — sesuatu yang komunitas PHP impikan selama lebih dari satu dekade. Meskipun manfaat JIT untuk aplikasi web biasa tidak sedramatis yang diharapkan (karena bottleneck biasanya di I/O, bukan CPU), JIT membuka pintu PHP untuk domain yang sebelumnya tidak praktis seperti komputasi numerik dan image processing.

stateDiagram-v2
    [*] --> ScriptingEra: 1994-1999
    ScriptingEra --> OOPEra: PHP 5.0 (2004)
    OOPEra --> ModernEra: PHP 7.0 (2015)
    ModernEra --> TypedEra: PHP 8.0 (2020)
    TypedEra --> [*]

    ScriptingEra: CGI scripts, HTML embedding, form handling
    OOPEra: OOP matang, namespace, closure, PDO
    ModernEra: 2x lebih cepat, scalar types, return types
    TypedEra: JIT, union types, enums, fibers, readonly

Fitur Modern PHP 8.x #

PHP 8.x membawa fitur-fitur yang mendekatkan PHP ke bahasa modern seperti Kotlin atau Swift dalam hal ekspresivitas dan keamanan tipe.

Named Arguments #

Named arguments memungkinkan kamu meneruskan argumen berdasarkan nama parameter, bukan posisinya — membuat pemanggilan fungsi dengan banyak parameter opsional jauh lebih readable.

<?php

// ANTI-PATTERN: argumen positional — susah dibaca, rawan salah urutan
$result = array_slice($array, 0, null, true);

// BENAR: named arguments — jelas tanpa harus buka dokumentasi
$result = array_slice(array: $array, offset: 0, preserve_keys: true);

// Named arguments sangat berguna untuk fungsi dengan banyak boolean flags
// ANTI-PATTERN:
setcookie('user', 'Unis', 0, '', '', true, true);

// BENAR:
setcookie(
    name: 'user',
    value: 'Unis',
    secure: true,
    httponly: true
);

Match Expression #

match adalah pengganti switch yang lebih aman: strict comparison, tidak ada fall-through, dan harus exhaustive (atau ada default).

<?php

$status = 404;

// ANTI-PATTERN: switch dengan loose comparison dan fall-through yang mudah lupa
switch ($status) {
    case 200:
        $label = 'OK';
        break;
    case 404:
        $label = 'Not Found';
        break;
    default:
        $label = 'Unknown';
}

// BENAR: match — strict, tidak ada fall-through, return value langsung
$label = match($status) {
    200, 201 => 'Success',
    301, 302 => 'Redirect',
    404      => 'Not Found',
    500      => 'Server Error',
    default  => 'Unknown',
};

echo $label; // Not Found

Union Types dan Intersection Types #

<?php

// Union types — parameter bisa menerima lebih dari satu tipe
function prosesInput(int|string $input): string {
    return is_int($input) ? "Angka: $input" : "String: $input";
}

echo prosesInput(42);      // Angka: 42
echo prosesInput("halo");  // String: halo

// Nullable shorthand
function cariPengguna(int $id): ?array {  // ?array = array|null
    // return array atau null jika tidak ditemukan
    return $id > 0 ? ['id' => $id, 'nama' => 'Unis'] : null;
}

// Intersection types (PHP 8.1) — objek harus mengimplementasikan SEMUA interface
interface Serializable {}
interface Loggable {}

function simpanDanLog(Serializable&Loggable $objek): void {
    // $objek dijamin punya semua method dari kedua interface
}

Enums (PHP 8.1) #

PHP akhirnya punya enum native — bukan class konstanta yang disimulasikan, tapi tipe tersendiri yang bisa memiliki method dan mengimplementasikan interface.

<?php

// ANTI-PATTERN: konstanta kelas — tidak type-safe, tidak ada validasi
class StatusLama {
    const AKTIF = 'aktif';
    const NONAKTIF = 'nonaktif';
    const PENDING = 'pending';
}
// Masalah: fungsi menerima string apapun, tidak bisa validasi
function ubahStatus(string $status): void { /* ... */ }
ubahStatus('salah_ketik'); // diterima tanpa error!

// BENAR: Backed enum — type-safe, terintegrasi dengan database
enum Status: string {
    case Aktif    = 'aktif';
    case Nonaktif = 'nonaktif';
    case Pending  = 'pending';

    public function label(): string {
        return match($this) {
            Status::Aktif    => 'Aktif',
            Status::Nonaktif => 'Tidak Aktif',
            Status::Pending  => 'Menunggu Konfirmasi',
        };
    }

    public function isActive(): bool {
        return $this === Status::Aktif;
    }
}

function ubahStatus(Status $status): void { /* ... */ }
ubahStatus(Status::Aktif);   // benar
// ubahStatus('aktif');       // TypeError — tidak bisa lagi kirim string sembarangan

echo Status::Aktif->label();         // Aktif
echo Status::from('pending')->label(); // Menunggu Konfirmasi

Fibers (PHP 8.1) #

Fibers adalah primitif untuk concurrency kooperatif — mirip coroutine — yang memungkinkan eksekusi fungsi di-pause dan dilanjutkan tanpa memblokir seluruh proses. Ini adalah fondasi dari async PHP di level bahasa.

<?php

$fiber = new Fiber(function(): string {
    $nilai = Fiber::suspend('fiber dimulai');  // pause, kirim nilai ke luar
    echo "Fiber dilanjutkan dengan nilai: $nilai\n";
    return 'selesai';
});

$nilaiPertama = $fiber->start();       // mulai fiber, dapat nilai suspend
echo "Fiber suspend: $nilaiPertama\n"; // fiber dimulai

$hasilAkhir = $fiber->resume('halo');  // lanjutkan fiber dengan nilai
echo "Fiber return: $hasilAkhir\n";    // selesai

Fibers di PHP bukan async/await seperti di JavaScript atau Dart. PHP tidak memiliki event loop bawaan — Fibers hanya primitif yang memungkinkan library async seperti ReactPHP atau Amp membangun abstraksi yang lebih tinggi di atasnya. Untuk aplikasi web biasa dengan PHP-FPM, Fibers tidak relevan secara langsung — yang relevan adalah library yang menggunakannya di balik layar.

Ekosistem: Composer dan Packagist #

Composer adalah package manager PHP yang merevolusi cara developer PHP mengelola dependensi. Sebelum Composer (2012), PHP tidak punya standar distribusi library yang universal — developer menggunakan PEAR, meng-copy file manual, atau bergantung pada framework bundled libraries.

# Instalasi dependensi
composer require laravel/framework
composer require guzzlehttp/guzzle        # HTTP client
composer require symfony/console          # CLI framework

# Dev dependencies
composer require --dev phpunit/phpunit
composer require --dev laravel/pint       # code formatter

# Manajemen
composer install    # install dari composer.lock (production)
composer update     # update ke versi terbaru yang kompatibel
composer dump-autoload  # regenerasi autoloader

# Informasi
composer show                  # daftar semua package terinstall
composer outdated              # cek package yang perlu diupdate

Contoh composer.json untuk aplikasi Laravel:

{
    "name": "aplikasi/saya",
    "description": "Aplikasi web Laravel",
    "require": {
        "php": "^8.2",
        "laravel/framework": "^11.0",
        "guzzlehttp/guzzle": "^7.2",
        "predis/predis": "^2.0"
    },
    "require-dev": {
        "phpunit/phpunit": "^11.0",
        "laravel/pint": "^1.0",
        "mockery/mockery": "^1.4",
        "fakerphp/faker": "^1.9"
    },
    "autoload": {
        "psr-4": {
            "App\\": "app/"
        }
    }
}

Package Populer per Kategori #

Framework PHP #

PHP memiliki ekosistem framework yang paling beragam di dunia web development. Setiap framework punya filosofi dan trade-off yang berbeda.

Laravel #

Laravel adalah framework PHP paling populer saat ini. Sintaksnya ekspresif, ekosistemnya kaya, dan dokumentasinya sangat baik. Laravel cocok untuk hampir semua ukuran proyek web.

<?php

// routes/web.php
use App\Http\Controllers\ArtikelController;

Route::middleware(['auth'])->group(function () {
    Route::get('/artikel', [ArtikelController::class, 'index']);
    Route::post('/artikel', [ArtikelController::class, 'store']);
    Route::put('/artikel/{artikel}', [ArtikelController::class, 'update']);
    Route::delete('/artikel/{artikel}', [ArtikelController::class, 'destroy']);
});

// app/Http/Controllers/ArtikelController.php
class ArtikelController extends Controller
{
    public function index(): View
    {
        $artikel = Artikel::with('penulis')
            ->where('published', true)
            ->orderByDesc('created_at')
            ->paginate(15);

        return view('artikel.index', compact('artikel'));
    }

    public function store(StoreArtikelRequest $request): RedirectResponse
    {
        $artikel = auth()->user()->artikel()->create(
            $request->validated()
        );

        return redirect()->route('artikel.show', $artikel)
            ->with('success', 'Artikel berhasil dipublikasikan.');
    }
}

Symfony #

Symfony adalah framework yang didesain untuk proyek enterprise besar. Lebih verbose dari Laravel, tapi lebih fleksibel dan modular — banyak komponen Symfony dipakai oleh framework lain termasuk Laravel.

<?php

// src/Controller/ArtikelController.php
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class ArtikelController extends AbstractController
{
    public function __construct(
        private readonly ArtikelRepository $repository,
        private readonly LoggerInterface $logger,
    ) {}

    #[Route('/artikel', name: 'artikel_list', methods: ['GET'])]
    public function index(): Response
    {
        $artikel = $this->repository->findPublished();

        return $this->render('artikel/index.html.twig', [
            'artikel' => $artikel,
        ]);
    }
}

Penanganan Error dan Type Safety #

PHP modern jauh lebih strict dalam hal tipe dibanding PHP 5 — tapi perlu dikonfigurasi dengan benar.

<?php

declare(strict_types=1); // WAJIB di setiap file untuk strict type checking

// ANTI-PATTERN: tanpa type declaration — PHP melakukan type coercion diam-diam
function tambah($a, $b) {
    return $a + $b;
}
tambah("5", 3); // PHP diam-diam convert "5" ke 5 — berjalan tapi berisiko

// BENAR: dengan type declaration dan strict_types
function tambahAngka(int $a, int $b): int {
    return $a + $b;
}
// tambahAngka("5", 3); // TypeError dengan strict_types=1

// Error handling modern — Exception hierarchy
function ambilPengguna(int $id): array
{
    if ($id <= 0) {
        throw new InvalidArgumentException("ID harus positif, diberikan: $id");
    }

    $pengguna = $this->db->find($id);

    if ($pengguna === null) {
        throw new RuntimeException("Pengguna dengan ID $id tidak ditemukan");
    }

    return $pengguna;
}

// try-catch-finally
try {
    $pengguna = ambilPengguna($idDariRequest);
    prosesPengguna($pengguna);
} catch (InvalidArgumentException $e) {
    // Error input — log dan return 400
    $this->logger->warning($e->getMessage());
    return response()->json(['error' => $e->getMessage()], 400);
} catch (RuntimeException $e) {
    // Error data — log dan return 404
    $this->logger->info("Pengguna tidak ditemukan", ['id' => $idDariRequest]);
    return response()->json(['error' => 'Tidak ditemukan'], 404);
} finally {
    // Selalu dieksekusi — cleanup, logging, dll
    $this->db->releaseConnection();
}

Kapan Memilih PHP #

PHP bukan pilihan untuk semua skenario, tapi ada domain di mana PHP masih sangat kompetitif.

Pilih PHP jika:
  ✓ Kamu membangun CMS atau platform konten (WordPress ecosystem)
  ✓ Tim sudah memiliki expertise PHP yang dalam
  ✓ Kamu butuh hosting murah dan mudah — PHP tersedia di hampir semua shared hosting
  ✓ Proyek e-commerce dengan Laravel atau Magento
  ✓ Web application dengan requirement umum — CRUD, auth, dashboard
  ✓ Kamu butuh ekosistem package yang sangat mature untuk web

Pertimbangkan alternatif jika:
  ✗ Kamu membangun real-time application dengan banyak concurrent connection → Node.js, Go
  ✗ Kamu butuh performa tinggi untuk CPU-intensive computation → Go, Rust
  ✗ Microservices yang butuh startup time sangat cepat → Go, Rust
  ✗ Tim lebih familiar dengan bahasa lain dan tidak ada kebutuhan PHP-specific → ikuti keahlian tim
  ✗ Mobile backend yang butuh response time <1ms secara konsisten → Go
  ✗ ML/AI pipeline → Python

flowchart TD
    A{Apa kebutuhan utama?} --> B{Web app / CMS?}
    A --> C{Real-time / WebSocket berat?}
    A --> D{CPU-intensive?}
    A --> E{Ekosistem WordPress?}

    B -- Ya, team PHP --> F[PHP + Laravel ✓]
    B -- Ya, team baru --> G[Pertimbangkan Go atau Python]
    C -- Ya --> H[Node.js / Go lebih cocok]
    D -- Ya --> I[Go / Rust lebih cocok]
    E -- Ya --> J[PHP tidak tergantikan ✓]
    E -- Tidak --> K[Evaluasi bahasa lain]

FAQ #

Apakah PHP sudah mati?

Tidak. PHP masih menjalankan lebih dari 75% dari semua website di internet, termasuk WordPress yang sendiri dipakai oleh lebih dari 40% website dunia. PHP 8.x aktif dikembangkan dengan rilis minor setiap tahun dan rilis major setiap 3–4 tahun. Komunitas tetap besar, dan ekosistem Laravel terus tumbuh.

Apa perbedaan PHP-FPM dan Apache mod_php?

mod_php menjalankan PHP sebagai modul di dalam proses Apache — setiap worker Apache membawa interpreter PHP. PHP-FPM (FastCGI Process Manager) adalah proses terpisah yang berkomunikasi dengan web server via FastCGI. PHP-FPM lebih efisien untuk traffic tinggi karena bisa dikelola secara independen dari web server, mendukung konfigurasi pool yang fleksibel, dan bisa dipakai dengan Nginx.

Kapan harus pakai declare(strict_types=1)?

Selalu — untuk semua file PHP yang kamu tulis. Tanpa strict_types=1, PHP melakukan type coercion secara diam-diam yang bisa menyembunyikan bug. Dengan strict types, fungsi yang dideklarasikan menerima int akan melempar TypeError jika dikirim string — bahkan string yang berisi angka seperti "42". Ini jauh lebih predictable.

Apakah PHP mendukung async programming?

PHP mendukung async melalui library pihak ketiga seperti ReactPHP, Amp, dan Swoole. PHP 8.1 menambahkan Fibers sebagai primitif level bahasa yang memungkinkan library-library ini bekerja lebih efisien. Namun untuk sebagian besar aplikasi web biasa yang menggunakan PHP-FPM, async tidak relevan — setiap request sudah terisolasi dan PHP-FPM menangani concurrency di level process pool.

Apa itu PSR dan mengapa penting?

PSR (PHP Standards Recommendations) adalah standar yang dikeluarkan oleh PHP-FIG (Framework Interop Group). PSR paling penting adalah PSR-4 (autoloading), PSR-7 (HTTP message interface), dan PSR-12 (coding style). Mengikuti PSR memastikan kode kamu kompatibel dengan ekosistem package yang luas dan mudah dipahami oleh developer PHP lain.

Ringkasan #

• PHP adalah bahasa server-side dengan share-nothing architecture — setiap request dieksekusi sebagai proses fresh tanpa state persisten. Model ini membuat PHP mudah di-scale horizontal tapi berbeda paradigma dari bahasa dengan process long-running seperti Go atau Node.js.
• PHP 7.0 adalah game changer performa — dua kali lebih cepat dari PHP 5.6 dengan pengurangan memori yang signifikan. Jika masih ada proyek di PHP 5.x, migrasi ke PHP 8.x adalah prioritas.
• PHP 8.x membawa fitur bahasa modern — JIT compiler, named arguments, match expression, union types, enums, readonly properties, dan fibers menjadikan PHP 8.x bahasa yang jauh lebih ekspresif dan aman dibanding PHP 5.
• declare(strict_types=1) wajib di setiap file — tanpa ini, PHP melakukan type coercion diam-diam yang menyembunyikan bug. Aktifkan strict types untuk semua kode baru.
• Composer adalah fondasi ekosistem modern PHP — tidak ada alasan menulis aplikasi PHP tanpa Composer di 2024. Packagist menyediakan ribuan package yang siap pakai.
• Laravel untuk produktivitas, Symfony untuk fleksibilitas enterprise — keduanya adalah pilihan excellent dengan trade-off berbeda. Untuk proyek baru dengan tim kecil-menengah, Laravel adalah titik awal yang sangat solid.
• PHP tetap tidak tergantikan di ekosistem WordPress — lebih dari 40% internet berjalan di WordPress. Jika pekerjaanmu bersinggungan dengan WordPress, WooCommerce, atau plugin development, PHP tidak ada penggantinya.
• Enum native (PHP 8.1) menggantikan class konstanta — pakai enum untuk semua nilai yang terbatas dan terdefinisi. Lebih type-safe, bisa punya method, dan terintegrasi dengan pattern matching.