Include dan Require

Saat proyek tumbuh, kode harus dipecah menjadi file-file terpisah agar mudah dikelola. Artikel ini membahas include, require, perbedaannya, struktur proyek, partials, dan autoloading dasar.

Pendahuluan

Saat proyek PHP tumbuh, menulis semua kode dalam satu file menjadi tidak praktis. Kode menjadi sulit dibaca, sulit diuji, dan sulit dipelihara. Solusinya adalah memecah kode menjadi file-file terpisah — header, footer, fungsi, konfigurasi, dan sebagainya.

PHP menyediakan empat konstruksi untuk menyisipkan file:

  • include
  • require
  • include_once
  • require_once

Artikel ini membahas perbedaannya, cara menggunakannya, struktur proyek yang baik, dan autoloading dasar.

Asumsi: Anda sudah memahami fungsi, array, dan session dari artikel sebelumnya.


Include vs Require

include

Menyisipkan dan mengeksekusi file. Jika file tidak ditemukan, PHP menghasilkan warning tetapi melanjutkan eksekusi.

<?php
include "header.php";
echo "Konten halaman";
include "footer.php";

require

Menyisipkan dan mengeksekusi file. Jika file tidak ditemukan, PHP menghasilkan fatal error dan menghentikan eksekusi.

<?php
require "config.php";
// Jika config.php tidak ada, eksekusi berhenti di sini

include_once dan require_once

Sama seperti include dan require, tetapi hanya menyisipkan file sekali. Jika file sudah pernah disisipkan, permintaan berikutnya diabaikan.

<?php
require_once "functions.php";
require_once "functions.php"; // diabaikan — tidak error

Perbandingan

Konstruksi File Tidak Ditemukan Duplikat
include Warning, lanjut Disisipkan ulang
require Fatal error, berhenti Disisipkan ulang
include_once Warning, lanjut Diabaikan
require_once Fatal error, berhenti Diabaikan

Kapan Menggunakan yang Mana?

Situasi Gunakan
File wajib (config, fungsi inti) require atau require_once
File opsional (template, widget) include atau include_once
File yang mungkin disisipkan berulang *_once
File yang aman disisipkan berulang include / require

Rekomendasi: Gunakan require_once untuk file yang wajib dan tidak boleh duplikat (config, fungsi, class). Gunakan include untuk template yang mungkin disisipkan berulang (misalnya partials).


Cara Menggunakan Include

Path Relatif

<?php
include "header.php";              // relatif terhadap working directory
include "./header.php";            // relatif terhadap file saat ini
include "../header.php";           // naik satu folder

⚠️ Peringatan: Path relatif bergantung pada working directory, bukan lokasi file. Ini bisa menyebabkan bug jika file di-include dari folder berbeda.

Path Absolut

<?php
include __DIR__ . "/header.php";           // relatif terhadap file ini
require __DIR__ . "/../config/database.php";

__DIR__ adalah konstanta magic yang berisi direktori file saat ini. Ini adalah cara paling aman untuk include file.

Tips: Selalu gunakan __DIR__ untuk include file — menghindari masalah path relatif.

Include dengan Variabel

File yang di-include mewarisi scope tempat ia di-include.

header.php:

<header>
    <h1><?= htmlspecialchars($judul) ?></h1>
    <p>Selamat datang, <?= htmlspecialchars($nama) ?></p>
</header>

index.php:

<?php
$judul = "Halaman Utama";
$nama = "Budi";
include __DIR__ . "/header.php";
?>

Variabel $judul dan $nama tersedia di header.php.

Include di Dalam Fungsi

Jika include dilakukan di dalam fungsi, variabel di file yang di-include hanya tersedia di scope fungsi tersebut.

<?php
function tampilkanHeader() {
    $judul = "Halaman";
    include __DIR__ . "/header.php";
}

tampilkanHeader();

Return Value

include dan require mengembalikan nilai jika file yang di-include memiliki return.

config.php:

<?php
return [
    "host" => "localhost",
    "db" => "toko_online",
];

index.php:

<?php
$config = include __DIR__ . "/config.php";
echo $config["host"]; // "localhost"

Tips: Pola ini sering digunakan untuk file konfigurasi — mengembalikan array daripada mendefinisikan variabel global.


Struktur Proyek

Saat proyek tumbuh, struktur folder yang baik sangat penting. Berikut struktur yang direkomendasikan:

proyek/
├── public/                  # Document root (yang diakses browser)
│   ├── index.php
│   ├── login.php
│   ├── logout.php
│   ├── assets/
│   │   ├── css/
│   │   ├── js/
│   │   └── img/
│   └── uploads/
├── src/                     # Kode aplikasi
│   ├── functions.php
│   ├── auth.php
│   ├── database.php
│   └── helpers/
│       ├── string.php
│       └── array.php
├── templates/               # Template HTML
│   ├── header.php
│   ├── footer.php
│   └── sidebar.php
├── config/                  # Konfigurasi
│   ├── database.php
│   └── app.php
├── vendor/                  # Composer dependencies
├── .env                     # Environment variables (jangan commit!)
├── .gitignore
└── composer.json

Mengapa Folder public/?

  • Keamanan — file konfigurasi, kode aplikasi, dan .env tidak bisa diakses langsung via URL.
  • Kebersihan — hanya file yang perlu diakses browser yang ada di public/.
  • Standar — banyak framework (Laravel, Symfony) menggunakan struktur ini.

Konfigurasi Web Server

Apache — arahkan DocumentRoot ke folder public/:

<VirtualHost *:80>
    DocumentRoot "/var/www/proyek/public"
    <Directory "/var/www/proyek/public">
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

Nginx:

server {
    root /var/www/proyek/public;
    index index.php;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        fastcgi_pass unix:/run/php/php8.2-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

PHP built-in server:

php -S localhost:8000 -t public/

Partial adalah file template yang disisipkan ke banyak halaman — header, footer, sidebar, navigasi.

templates/header.php

<!DOCTYPE html>
<html lang="id">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title><?= htmlspecialchars($judul ?? "Aplikasi") ?></title>
    <link rel="stylesheet" href="/assets/css/style.css">
</head>
<body>
    <header>
        <nav>
            <a href="/">Beranda</a>
            <a href="/produk.php">Produk</a>
            <a href="/keranjang.php">Keranjang</a>
            <?php if (isset($_SESSION["user_id"])): ?>
                <span>Halo, <?= htmlspecialchars($_SESSION["user_nama"]) ?></span>
                <a href="/logout.php">Logout</a>
            <?php else: ?>
                <a href="/login.php">Login</a>
            <?php endif; ?>
        </nav>
    </header>
    <main>

templates/footer.php

    </main>
    <footer>
        <p>&copy; <?= date("Y") ?> Toko Online. All rights reserved.</p>
    </footer>
    <script src="/assets/js/app.js"></script>
</body>
</html>

public/index.php

<?php
session_start();

$judul = "Halaman Utama";
require __DIR__ . "/../templates/header.php";
?>

<h1>Selamat datang!</h1>
<p>Ini adalah halaman utama aplikasi.</p>

<?php require __DIR__ . "/../templates/footer.php"; ?>

Tips: Gunakan require untuk partials yang wajib (header, footer) dan include untuk partials opsional (sidebar, widget).


Autoloading

Saat proyek memiliki banyak class, menulis require untuk setiap class menjadi tidak praktis. Autoloading memungkinkan PHP memuat class secara otomatis saat dibutuhkan.

spl_autoload_register()

<?php
spl_autoload_register(function ($className) {
    $file = __DIR__ . "/src/" . str_replace("\\", "/", $className) . ".php";
    if (file_exists($file)) {
        require $file;
    }
});

// Sekarang class dimuat otomatis
$user = new User();        // memuat src/User.php
$produk = new Produk();    // memuat src/Produk.php

Autoloading dengan Namespace (PSR-4)

PSR-4 adalah standar autoloading yang memetakan namespace ke folder.

Struktur:

src/
├── Models/
│   ├── User.php          (namespace App\Models)
│   └── Produk.php        (namespace App\Models)
├── Controllers/
│   └── UserController.php (namespace App\Controllers)
└── Helpers/
    └── Str.php            (namespace App\Helpers)

src/Models/User.php:

<?php
namespace App\Models;

class User {
    public function __construct(
        public string $nama,
        public string $email,
    ) {}
}

Autoloader:

<?php
spl_autoload_register(function ($className) {
    $prefix = "App\\";
    $baseDir = __DIR__ . "/src/";

    $len = strlen($prefix);
    if (strncmp($prefix, $className, $len) !== 0) {
        return;
    }

    $relativeClass = substr($className, $len);
    $file = $baseDir . str_replace("\\", "/", $relativeClass) . ".php";

    if (file_exists($file)) {
        require $file;
    }
});

// Penggunaan
use App\Models\User;

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

Tips: Untuk proyek nyata, gunakan Composer — autoloading PSR-4 sudah ditangani otomatis (dibahas di artikel Composer).


Contoh Praktis

1. Struktur Aplikasi Sederhana

config/app.php:

<?php
return [
    "nama" => "Toko Online",
    "versi" => "1.0.0",
    "timezone" => "Asia/Jakarta",
    "debug" => true,
];

config/database.php:

<?php
return [
    "host" => "localhost",
    "port" => 3306,
    "database" => "toko_online",
    "username" => "root",
    "password" => "",
];

src/database.php:

<?php
function getKoneksi(): PDO {
    static $pdo = null;

    if ($pdo === null) {
        $config = require __DIR__ . "/../config/database.php";
        $dsn = "mysql:host={$config['host']};port={$config['port']};dbname={$config['database']};charset=utf8mb4";

        $pdo = new PDO($dsn, $config["username"], $config["password"], [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES => false,
        ]);
    }

    return $pdo;
}

src/helpers.php:

<?php
function formatRupiah(float $angka): string {
    return "Rp" . number_format($angka, 0, ",", ".");
}

function e(string $teks): string {
    return htmlspecialchars($teks, ENT_QUOTES, "UTF-8");
}

function redirect(string $url): never {
    header("Location: $url");
    exit;
}

public/index.php:

<?php
session_start();

// Load konfigurasi dan helper
$config = require __DIR__ . "/../config/app.php";
require_once __DIR__ . "/../src/helpers.php";
require_once __DIR__ . "/../src/database.php";

// Set timezone
date_default_timezone_set($config["timezone"]);

// Ambil data
$pdo = getKoneksi();
$stmt = $pdo->query("SELECT id, nama, harga FROM produk ORDER BY nama");
$produk = $stmt->fetchAll();

// Render
$judul = "Daftar Produk";
require __DIR__ . "/../templates/header.php";
?>

<h1>Daftar Produk</h1>
<ul>
    <?php foreach ($produk as $p): ?>
        <li>
            <?= e($p["nama"]) ?> - <?= formatRupiah($p["harga"]) ?>
        </li>
    <?php endforeach; ?>
</ul>

<?php require __DIR__ . "/../templates/footer.php"; ?>

2. Autoloading dengan Composer

Jika menggunakan Composer, autoloading PSR-4 cukup didefinisikan di composer.json:

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        },
        "files": [
            "src/helpers.php"
        ]
    }
}

Setelah menjalankan composer dump-autoload, cukup:

<?php
require __DIR__ . "/../vendor/autoload.php";

use App\Models\User;

$user = new User("Budi", "[email protected]");

Tips: Composer menangani autoloading PSR-4 dan file yang perlu selalu dimuat (via files). Ini adalah standar industri.


Tips dan Best Practice

  1. Gunakan __DIR__ untuk include file — menghindari masalah path relatif.

  2. Gunakan require_once untuk file wajib dan tidak boleh duplikat (config, fungsi, class).

  3. Gunakan include untuk template yang mungkin disisipkan berulang.

  4. Struktur folder dengan public/ sebagai document root — meningkatkan keamanan.

  5. Pisahkan konfigurasi ke folder config/ — jangan hardcode di kode.

  6. Gunakan Composer untuk autoloading PSR-4 di proyek nyata.

  7. Hindari include file dari input user — bisa menyebabkan Local File Inclusion (LFI).

<?php
// ❌ SANGAT BERBAHAYA — LFI
include $_GET["page"] . ".php";

// ✅ AMAN — whitelist
$halamanValid = ["home", "produk", "kontak"];
$halaman = $_GET["page"] ?? "home";
if (!in_array($halaman, $halamanValid, true)) {
    $halaman = "home";
}
include __DIR__ . "/pages/$halaman.php";
  1. Gunakan require untuk file yang wajib — jangan biarkan aplikasi berjalan tanpa config.

  2. Hindari include file dari URL — allow_url_include harus Off.

  3. Dokumentasikan struktur proyek di README — memudahkan kolaborasi.

  4. Gunakan return di file config — mengembalikan array daripada variabel global.

  5. Untuk class, gunakan autoloading — jangan require manual satu per satu.


Ringkasan

Konstruksi File Tidak Ada Duplikat Kapan Digunakan
include Warning, lanjut Disisipkan Template opsional
require Fatal error Disisipkan File wajib
include_once Warning, lanjut Diabaikan Template yang mungkin duplikat
require_once Fatal error Diabaikan File wajib yang tidak boleh duplikat

Poin penting:

  • include menghasilkan warning jika file tidak ada; require menghasilkan fatal error.
  • *_once mencegah file disisipkan lebih dari sekali.
  • __DIR__ adalah cara aman untuk path file — menghindari masalah path relatif.
  • Struktur folder dengan public/ meningkatkan keamanan — file konfigurasi tidak bisa diakses langsung.
  • Partials (header, footer, sidebar) memecah template menjadi bagian yang dapat digunakan ulang.
  • Autoloading memuat class secara otomatis — gunakan spl_autoload_register() atau Composer.
  • Jangan include file dari input user — risiko Local File Inclusion (LFI).
  • Gunakan return di file config — mengembalikan array daripada variabel global.
  • Composer adalah standar industri untuk autoloading PSR-4.

Pada artikel berikutnya, kita akan membahas Koneksi PHP ke MySQL — menghubungkan aplikasi ke database.

Top