Artikel ini membahas tuntas cara membuat form validasi di Laravel 12, mulai dari metode $request->validate() yang paling cepat, daftar aturan validasi yang paling sering dipakai, cara membuat pesan error kustom dalam Bahasa Indonesia, sampai merapikan kode memakai Form Request class. Di akhir ada contoh menampilkan error di Blade dan tips memakai validasi untuk REST API.

Kenapa Validasi Form Itu Wajib

Validasi adalah proses memastikan data yang dikirim pengguna memenuhi syarat sebelum diproses lebih lanjut. Tanpa validasi, aplikasi rentan terhadap tiga masalah besar. Pertama, data tidak konsisten, misalnya kolom email berisi teks biasa atau tanggal lahir berisi angka acak. Kedua, celah keamanan, karena input berbahaya bisa lolos ke database. Ketiga, pengalaman pengguna yang buruk, karena kesalahan baru ketahuan belakangan tanpa penjelasan yang jelas.

Laravel menyelesaikan ketiga masalah ini dengan sistem validasi yang ekspresif. Kamu cukup mendeklarasikan aturan dalam bentuk array, dan Laravel otomatis memeriksa input, mengembalikan pengguna ke form sebelumnya bila ada yang salah, lengkap dengan pesan error dan input lama yang sudah terisi. Semua ini terjadi tanpa kamu menulis logika pengecekan manual yang panjang.

Cara Kerja $request->validate() untuk Form Validasi Laravel 12

Cara tercepat memvalidasi form adalah memanggil metode validate() pada objek $request di dalam controller. Perhatikan contoh berikut untuk form pembuatan artikel.

<?php

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function create()
    {
        return view('posts.create');
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'title'       => 'required|string|min:5|max:100',
            'slug'        => 'required|string|unique:posts,slug',
            'body'        => 'required|string|min:20',
            'category_id' => 'required|exists:categories,id',
            'published_at'=> 'nullable|date',
        ]);

        Post::create($validated);

        return redirect('/posts')->with('success', 'Artikel berhasil disimpan.');
    }
}

Ada tiga hal penting dari kode di atas. Pertama, aturan ditulis sebagai string yang dipisahkan karakter pipe (|), misalnya required|string|min:5. Kedua, metode validate() mengembalikan array $validated yang hanya berisi field yang lolos aturan, sehingga aman langsung dipakai untuk Post::create(). Ketiga, jika validasi gagal, Laravel otomatis mengembalikan (redirect back) pengguna ke halaman form sebelumnya sambil membawa pesan error dan input lama, jadi kamu tidak perlu menulis logika itu sendiri.

Kalau kamu mengikuti seri Laravel di blog ini dari tutorial CRUD Laravel 12, pola di atas akan terasa familiar karena melengkapi proses store dan update yang sudah dibahas di sana.

Aturan Form Validasi Laravel 12 yang Paling Sering Dipakai

Laravel menyediakan puluhan aturan validasi siap pakai. Berikut tabel aturan yang paling sering dipakai dalam form validasi Laravel 12 beserta artinya.

Aturan unique dan exists sangat berguna karena langsung memeriksa ke database tanpa query manual. Contoh unique:users,email memastikan tidak ada dua pengguna dengan email yang sama, sedangkan exists:categories,id memastikan kategori yang dipilih benar-benar ada.

Untuk form edit data, aturan unique perlu pengecualian agar data milik sendiri tidak dianggap duplikat. Caranya dengan menambahkan ID yang dikecualikan, contoh: unique:posts,slug,10 (mengabaikan baris ber-ID 10) atau memakai sintaks lengkap Rule::unique('posts')->ignore($post->id).

Membuat Pesan Error Kustom Bahasa Indonesia

Secara bawaan, pesan error validasi Laravel berbahasa Inggris, misalnya “The title field is required.” Untuk aplikasi berbahasa Indonesia, kamu bisa menggantinya dengan pesan kustom lewat parameter kedua metode validate().

$validated = $request->validate(
    [
        'title'    => 'required|string|min:5|max:100',
        'email'    => 'required|email|unique:users,email',
        'password' => 'required|string|min:8|confirmed',
    ],
    [
        'title.required'      => 'Judul wajib diisi.',
        'title.min'           => 'Judul minimal :min karakter.',
        'title.max'           => 'Judul maksimal :max karakter.',
        'email.required'      => 'Alamat email wajib diisi.',
        'email.email'         => 'Format email tidak valid.',
        'email.unique'        => 'Email ini sudah terdaftar, silakan pakai email lain.',
        'password.required'   => 'Kata sandi wajib diisi.',
        'password.min'        => 'Kata sandi minimal :min karakter.',
        'password.confirmed'  => 'Konfirmasi kata sandi tidak sama.',
    ]
);

Kunci array pesan memakai format {nama_field}.{nama_aturan}, sehingga kamu bisa mengatur pesan berbeda untuk tiap kombinasi field dan aturan. Placeholder seperti :min dan :max otomatis diganti Laravel dengan angka dari aturan yang dipakai, jadi pesan tetap dinamis.

Jika pesan kustom dipakai di banyak form, pendekatan yang lebih rapi adalah menerjemahkan seluruh file bahasa validasi. Salin file lang/en/validation.php menjadi lang/id/validation.php, ubah isinya ke Bahasa Indonesia, lalu set 'locale' => 'id' di config/app.php. Dengan begitu seluruh aplikasi memakai pesan Bahasa Indonesia tanpa mengulang array pesan di setiap controller.

Merapikan Kode dengan Form Request Class

Ketika aturan validasi mulai banyak, menaruhnya di controller membuat metode store() terlihat penuh. Solusi resminya adalah Form Request: class khusus yang menampung aturan validasi, pesan kustom, dan logika otorisasi. Buat dengan Artisan:

php artisan make:request StorePostRequest

Perintah itu menghasilkan file app/Http/Requests/StorePostRequest.php. Isi dengan aturan dan pesanmu:

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class StorePostRequest extends FormRequest
{
    public function authorize(): bool
    {
        return true;
    }

    public function rules(): array
    {
        return [
            'title'       => 'required|string|min:5|max:100',
            'slug'        => 'required|string|unique:posts,slug',
            'body'        => 'required|string|min:20',
            'category_id' => 'required|exists:categories,id',
        ];
    }

    public function messages(): array
    {
        return [
            'title.required'  => 'Judul wajib diisi.',
            'title.min'       => 'Judul minimal :min karakter.',
            'slug.unique'     => 'Slug ini sudah dipakai artikel lain.',
            'body.required'   => 'Isi artikel wajib diisi.',
            'category_id.exists' => 'Kategori yang dipilih tidak valid.',
        ];
    }
}

Metode authorize() menentukan apakah pengguna boleh melakukan request ini; kembalikan true untuk mengizinkan semua, atau tulis logika izin di sana. Lalu pakai class ini sebagai type-hint di controller:

use App\Http\Requests\StorePostRequest;

public function store(StorePostRequest $request)
{
    $validated = $request->validated();

    Post::create($validated);

    return redirect('/posts')->with('success', 'Artikel berhasil disimpan.');
}

Validasi berjalan otomatis sebelum kode di dalam metode dieksekusi. Controller menjadi bersih dan hanya fokus pada logika bisnis. Pola Form Request ini juga dipakai di form autentikasi seperti pada tutorial login dan register dengan Breeze, sehingga layak kamu kuasai sejak awal.

Membuat Aturan Validasi Sendiri

Kadang aturan bawaan tidak cukup, misalnya kamu ingin menolak judul yang mengandung kata terlarang tertentu. Laravel 12 menyediakan perintah Artisan untuk membuat rule kustom.

php artisan make:rule NoSpamWord

Perintah itu membuat class app/Rules/NoSpamWord.php. Implementasikan logika di metode validate():

<?php

namespace App\Rules;

use Closure;
use Illuminate\Contracts\Validation\ValidationRule;

class NoSpamWord implements ValidationRule
{
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        $kataTerlarang = ['gratis', 'promo', 'diskon'];

        foreach ($kataTerlarang as $kata) {
            if (str_contains(strtolower($value), $kata)) {
                $fail('Kolom :attribute mengandung kata yang tidak diizinkan.');
                return;
            }
        }
    }
}

Pakai rule kustom ini seperti aturan biasa dengan membuat instance-nya di array aturan:

use App\Rules\NoSpamWord;

$request->validate([
    'title' => ['required', 'string', 'min:5', new NoSpamWord],
]);

Perhatikan bahwa aturannya ditulis sebagai array (bukan string pipe) ketika dicampur dengan objek rule. Placeholder :attribute otomatis diganti dengan nama field. Rule kustom cocok untuk logika bisnis yang spesifik dan dipakai di banyak form.

Menampilkan Error di Blade

Pesan error yang dihasilkan validasi tersedia di view lewat variabel $errors. Pola yang umum dipakai adalah menampilkan ringkasan di atas form dan pesan per field di bawah inputnya.

@if ($errors->any())
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif

<form method="POST" action="/posts">
    @csrf

    <label for="title">Judul</label>
    <input type="text" name="title" id="title" value="{{ old('title') }}">
    @error('title')
        <small class="text-danger">{{ $message }}</small>
    @enderror

    <label for="body">Isi Artikel</label>
    <textarea name="body" id="body">{{ old('body') }}</textarea>
    @error('body')
        <small class="text-danger">{{ $message }}</small>
    @enderror

    <button type="submit">Simpan</button>
</form>

Directive @error('title') hanya merender isinya jika field title memiliki pesan error, dan variabel $message berisi teks error tersebut. Fungsi old('title') mengisi kembali input dengan nilai yang dikirim pengguna sebelumnya, sehingga mereka tidak perlu mengetik ulang seluruh form hanya karena satu field salah. Kombinasi ketiganya menghasilkan form yang ramah pengguna dengan sedikit kode.

Tips Validasi untuk REST API

Untuk endpoint API, perilaku bawaan validate() yang me-redirect kurang cocok karena klien API mengharapkan respons JSON. Laravel menanganinya otomatis: jika request memiliki header Accept: application/json, kegagalan validasi mengembalikan respons JSON berisi pesan error dengan status 422, tanpa redirect. Jadi aturan yang sama bisa dipakai ulang untuk API.

Untuk struktur API yang lebih terkontrol, validasi juga bisa dilakukan manual dengan Validator::make() agar kamu mengatur sendiri format responsnya. Pembahasan lengkap pola ini ada di artikel cara membuat REST API dengan Laravel yang sudah terbit di blog ini.

Kesimpulan

Form validasi Laravel 12 memberimu tiga lapis kemudahan: $request->validate() untuk kebutuhan cepat, pesan error kustom Bahasa Indonesia agar pengguna paham kesalahannya, dan Form Request class untuk kode yang rapi dan bisa dipakai ulang. Aturan seperti required, unique, exists, dan confirmed mencakup sebagian besar kebutuhan form sehari-hari tanpa query manual.

Mulailah dengan menerapkan validasi pada satu form yang sudah kamu buat, misalnya form tambah artikel dari seri CRUD, lalu pindahkan aturannya ke Form Request saat form mulai kompleks. Kalau kamu ingin mendalami alur autentikasi yang juga mengandalkan validasi berat, baca juga tutorial Laravel 12 membuat fitur login dan register dengan Breeze sebagai latihan berikutnya.

Composer adalah dependency manager untuk PHP, artinya tugasnya mengunduh, memperbarui, dan mengatur library yang dibutuhkan proyekmu beserta seluruh dependensinya. Tanpa Composer, kamu harus mengunduh library satu per satu secara manual dan pusing mengatur versi yang cocok. Dengan Composer, satu perintah cukup untuk menyelesaikan semuanya dengan aman dan konsisten.

Cara Menggunakan Composer Laravel: Pengenalan dan Fungsi

Analogi paling pas untuk Composer adalah manajer paket seperti Play Store, tetapi untuk kode PHP. Saat proyekmu butuh fitur tertentu, misalnya manajemen hak akses pengguna, kamu tidak perlu menulisnya dari nol. Kamu cukup meminta Composer menginstal package yang sudah teruji oleh komunitas, dan Composer mengurus sisanya: mengunduh versi yang cocok, memastikan tidak bentrok dengan package lain, dan mendaftarkannya agar bisa dipakai.

Tiga file adalah jantung cara kerja Composer. File composer.json berisi daftar package yang dibutuhkan proyek beserta versinya, dan file ini wajib masuk version control seperti Git. File composer.lock mencatat versi persis yang terinstal saat ini agar semua anggota tim memakai versi identik. Folder vendor berisi kode package yang diunduh, dan folder ini tidak boleh masuk Git karena bisa dibuat ulang kapan saja dengan satu perintah.

Setiap proyek Laravel yang kamu buat dengan laravel new sebenarnya sudah memakai Composer di balik layar. Jadi kemungkinan besar kamu sudah menjadi pengguna Composer tanpa sadar. Artikel ini membuatmu memahaminya secara sadar dan percaya diri.

Menginstal Composer di Windows

Bila kamu mengikuti Cara Install XAMPP dan Menjalankan Program PHP Pertama, PHP sudah tersedia di komputermu dan Composer bisa langsung dipasang. Unduh installer resmi dari getcomposer.org, tepatnya file Composer-Setup.exe untuk Windows.

Jalankan installer dan pada langkah pemilihan PHP, arahkan ke file php.exe milik XAMPP yang biasanya ada di C:\xampp\php\php.exe. Installer akan mendaftarkan Composer ke PATH Windows sehingga perintah composer bisa dijalankan dari terminal mana pun. Selesaikan wizard sampai akhir, lalu tutup dan buka kembali terminal agar perubahan PATH terbaca.

Untuk pengguna yang memakai PHP terpisah atau Laragon, prinsipnya sama: tunjukkan installer ke php.exe yang aktif dipakai. Bila kamu memakai lebih dari satu versi PHP, pastikan Composer menunjuk ke versi yang sama dengan yang dipakai proyekmu untuk menghindari konflik dependensi.

Verifikasi: Memastikan Composer Terpasang Benar

Buka Command Prompt atau PowerShell baru, lalu jalankan perintah berikut.

composer --version

Bila muncul tulisan seperti Composer version 2.x.x, instalasi berhasil. Angka 2 di depan menandakan Composer versi 2 yang jauh lebih cepat dan hemat memori dibanding versi 1. Bila perintah tidak dikenali, berarti PATH belum terbaca: tutup semua jendela terminal, buka yang baru, dan coba lagi. Bila masih gagal, ulangi instalasi dan pastikan opsi penambahan ke PATH tidak dilewatkan.

Perintah berguna kedua untuk verifikasi adalah composer diagnose, yang memeriksa koneksi ke repositori package dan memberi tahu bila ada masalah jaringan atau konfigurasi. Jalankan sesekali bila instalasi package gagal tanpa pesan yang jelas.

Memahami composer.json dan composer.lock

Buka file composer.json di proyek Laravel-mu dan perhatikan strukturnya. Bagian require berisi package wajib beserta batasan versinya, sedangkan require-dev berisi package khusus pengembangan seperti testing yang tidak ikut ke production.

{
    "require": {
        "php": "^8.2",
        "laravel/framework": "^12.0",
        "spatie/laravel-permission": "^6.0"
    },
    "require-dev": {
        "phpunit/phpunit": "^11.0"
    }
}

Tanda ^ (caret) artinya boleh memakai versi minor dan patch terbaru selama versi major-nya sama. Jadi ^12.0 mengizinkan 12.1 atau 12.9, tetapi tidak 13.0. Aturan ini menjaga kompatibilitas sambil tetap mendapat perbaikan bug otomatis.

File composer.lock dibuat otomatis saat pertama kali dependensi diinstal. Ia mengunci versi persis setiap package termasuk dependensi transitifnya. Saat rekan tim menjalankan composer install, Composer membaca file lock ini sehingga semua orang mendapat versi yang identik. Inilah kenapa composer.lock wajib di-commit ke Git, sedangkan folder vendor tidak.

Empat Perintah Composer yang Wajib Dikuasai

Hampir semua pekerjaan Composer sehari-hari hanya memakai empat perintah berikut. Pahami perbedaannya baik-baik karena tertukar memakainya adalah sumber bug klasik.

composer require dipakai untuk menambah package baru ke proyek. Perintah ini mengunduh package, menambahkannya ke composer.json, dan memperbarui composer.lock sekaligus.

composer require spatie/laravel-permission

composer update dipakai untuk menaikkan versi package yang sudah ada ke versi terbaru sesuai batasan di composer.json. Hati-hati: perintah tanpa argumen ini memperbarui SEMUA package sekaligus, yang berisiko bila ada perubahan breaking. Untuk aman, sebutkan nama package-nya secara spesifik.

composer update spatie/laravel-permission

composer remove adalah kebalikan dari require: menghapus package dari proyek, composer.json, dan composer.lock sekaligus.

composer remove spatie/laravel-permission

composer install dipakai saat kamu baru meng-clone proyek dari Git. Perintah ini membaca composer.lock dan mengunduh versi persis yang terkunci, sehingga lingkunganmu identik dengan tim. Inilah perintah pertama yang harus dijalankan setiap menerima proyek Laravel dari orang lain, sebelum php artisan migrate atau perintah lainnya.

Selain empat perintah utama, ada dua perintah bantu yang berguna untuk audit. Perintah composer show menampilkan daftar package yang terinstal beserta versinya, sedangkan composer outdated menunjukkan package mana yang sudah punya versi lebih baru tersedia. Keduanya bersifat read-only sehingga aman dijalankan kapan saja tanpa mengubah apa pun di proyekmu.

Autoload PSR-4: Cara Composer Menemukan Class-mu

Salah satu keajaiban Composer yang jarang disadari pemula adalah autoloading. Dulu developer PHP harus menulis require manual untuk setiap file class. Composer menghilangkan kebutuhan itu lewat standar PSR-4 yang memetakan namespace ke struktur folder.

Lihat bagian autoload di composer.json proyek Laravel.

"autoload": {
    "psr-4": {
        "App\\": "app/",
        "Database\\Factories\\": "database/factories/"
    }
}

Artinya class App\Models\Post otomatis dipetakan ke file app/Models/Post.php. Selama kamu mengikuti konvensi penamaan ini, kamu tidak pernah perlu menulis require manual. Setiap kali menambah namespace baru, jalankan composer dump-autoload agar peta autoload dibuat ulang.

Pemahaman ini menjelaskan kenapa perintah Artisan seperti make:model selalu menaruh file di lokasi yang tepat. Framework dan Composer sudah sepakat soal konvensi, dan tugasmu hanyalah mengikutinya.

Cara Menggunakan Composer Laravel: Studi Kasus Install Package Nyata

Mari praktikkan alur lengkap dengan package nyata yang populer: spatie/laravel-permission untuk manajemen role dan permission. Package ini dipakai ribuan proyek production dan menjadi contoh sempurna.

Langkah pertama, instal package-nya di proyek Laravel-mu.

composer require spatie/laravel-permission

Composer akan mengunduh package beserta dependensinya, lalu memperbarui composer.json dan composer.lock. Perhatikan outputnya: Composer memberitahu versi persis yang dipasang dan apakah ada dependensi tambahan yang ikut diunduh.

Langkah kedua, publikasikan file konfigurasi dan migrasinya memakai Artisan.

php artisan vendor:publish --provider="Spatie\Permission\PermissionServiceProvider"
php artisan migrate

Perintah pertama menyalin file konfigurasi package ke proyekmu sehingga bisa disesuaikan, sedangkan yang kedua membuat tabel roles, permissions, dan tabel pivotnya di database. Pola dua langkah ini, install lalu publish, berlaku untuk hampir semua package Laravel.

Langkah ketiga, pasang trait-nya ke model User agar bisa memakai fitur role.

// app/Models/User.php
namespace App\Models;

use Spatie\Permission\Traits\HasRoles;
use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable
{
    use HasRoles;

    // ... kode model lainnya
}

Sekarang kamu bisa menulis kode seperti $user->assignRole('admin') atau memeriksa dengan $user->hasRole('admin') di mana saja. Satu perintah Composer tadi telah memberimu sistem manajemen hak akses yang butuh berminggu-minggu bila ditulis dari nol. Inilah alasan kenapa ekosistem package PHP begitu powerful.

Kesalahan Umum Saat Memakai Composer

Pertama, menjalankan composer update tanpa argumen di proyek production lalu kaget ada package yang berubah perilaku. Di production, selalu pakai composer install yang membaca file lock, bukan update. Kedua, meng-commit folder vendor ke Git sehingga repository membengkak dan konflik tidak perlu terjadi. Pastikan vendor/ ada di file .gitignore, yang untungnya sudah bawaan di proyek Laravel baru.

Ketiga, lupa menjalankan composer install setelah clone proyek lalu bingung kenapa php artisan error Class not found. Keempat, konflik versi saat require package lama ke Laravel baru. Baca pesan error Composer baik-baik karena ia biasanya menjelaskan package mana yang meminta versi PHP atau Laravel yang berbeda, lalu cari versi package yang mendukung versimu.

Kelima, memakai perintah Composer dengan user root di Linux tanpa flag yang tepat sehingga file vendor terkunci permission-nya. Di Windows masalah ini jarang terjadi, tetapi di VPS atau WSL, jalankan Composer sebagai user biasa, bukan root.

Keenam, menjalankan perintah Composer di folder yang salah sehingga muncul error bahwa file composer.json tidak ditemukan. Selalu pastikan terminalmu berada di root proyek Laravel, yaitu folder yang berisi file composer.json dan artisan, sebelum menjalankan perintah apa pun.

Langkah Selanjutnya

Kamu sekarang bisa menginstal Composer, memakai empat perintah intinya dengan tepat, memahami peran composer.json dan composer.lock, serta memasang package nyata sampai bisa dipakai di kode. Ini adalah fondasi workflow PHP modern yang dipakai di setiap proyek profesional.

Satu kebiasaan yang layak dibangun mulai sekarang adalah mengeksplorasi Packagist, direktori resmi tempat semua package PHP terdaftar. Sebelum menulis kode sendiri untuk kebutuhan umum seperti manipulasi tanggal, ekspor Excel, atau kirim email, cari dulu di Packagist, siapa tahu sudah ada package matang yang terawat. Untuk menjaga proyek tetap sehat, jalankan composer outdated sesekali guna melihat package mana yang punya versi baru, lalu perbarui satu per satu sambil membaca changelog-nya. Kebiasaan kecil ini menghindarkanmu dari package kedaluwarsa yang diam-diam menyimpan celah keamanan.

Package yang baru saja dipasang paling terasa manfaatnya saat dipadukan dengan sistem autentikasi. Lanjutkan ke Tutorial Laravel 12: Membuat Fitur Login dan Register dengan Breeze untuk melengkapi proyekmu dengan login yang aman. Dan bila kamu ingin mengulang dasar membangun aplikasi dari nol sebelum menambah package, Tutorial Laravel 12: Membuat CRUD Sederhana dari Nol untuk Pemula adalah tempat latihan yang tepat.

Studi kasus kita sederhana dan dekat dengan dunia nyata: satu Post bisa memiliki banyak Comment, sedangkan setiap Comment hanya milik satu Post. Pola inilah yang disebut one to many, relasi paling umum yang akan kamu temui di hampir setiap aplikasi. Setelah menguasainya, relasi lain seperti many to many akan terasa jauh lebih mudah dipahami.

Relasi Eloquent Laravel One to Many: Konsep Dasarnya

Sebelum menyentuh kode, pahami dulu anatomi relasi one to many. Di sisi database, tabel comments menyimpan kolom post_id yang menunjuk ke kolom id di tabel posts. Kolom post_id inilah yang disebut foreign key, yaitu kunci tamu yang menjadi jembatan antar tabel.

Di sisi Eloquent, relasi ini didefinisikan dari dua arah yang saling melengkapi. Dari sisi Post, relasinya dibaca sebagai “satu post memiliki banyak comment” dan ditulis dengan method hasMany. Dari sisi Comment, relasinya dibaca sebagai “satu comment milik satu post” dan ditulis dengan method belongsTo. Kedua method ini ditaruh di dalam class model masing-masing.

Konvensi penamaan Laravel sangat membantumu di sini. Bila kamu mengikuti konvensi (model Post untuk tabel posts, foreign key post_id), Eloquent bisa menebak semuanya secara otomatis tanpa konfigurasi tambahan. Kamu hanya perlu menulis method relasinya, dan sisanya ditangani framework.

Persiapan: Model dan Migrasi Post serta Comment

Kita mulai dari migrasi. Buat model beserta migrasinya dengan perintah Artisan berikut. Flag -m membuat file migrasi sekalian.

php artisan make:model Post -m
php artisan make:model Comment -m

Buka file migrasi posts dan isi dengan kolom yang dibutuhkan. Karena ini studi kasus blog sederhana, kolomnya cukup judul, isi, dan timestamps bawaan.

// database/migrations/xxxx_create_posts_table.php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration {
    public function up(): void
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->string('judul');
            $table->text('isi');
            $table->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('posts');
    }
};

Selanjutnya migrasi comments. Inilah bagian pentingnya: tambahkan foreignId('post_id') yang dirantai dengan constrained() agar Laravel otomatis membuat foreign key ke tabel posts, plus onDelete('cascade') supaya komentar ikut terhapus saat post induknya dihapus.

// database/migrations/xxxx_create_comments_table.php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration {
    public function up(): void
    {
        Schema::create('comments', function (Blueprint $table) {
            $table->id();
            $table->foreignId('post_id')
                  ->constrained()
                  ->onDelete('cascade');
            $table->string('nama_komentator');
            $table->text('isi_komentar');
            $table->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('comments');
    }
};

Method constrained() akan menebak tabel tujuan dari nama kolom: post_id berarti tabel posts kolom id. Bila penamaanmu tidak mengikuti konvensi, kamu bisa menyebutkannya eksplisit seperti constrained('posts', 'id'). Setelah kedua migrasi siap, jalankan php artisan migrate untuk membuat tabelnya di database. Pastikan konfigurasi database di file .env sudah benar, seperti yang dibahas di Belajar MySQL untuk Pemula.

Relasi Eloquent Laravel One to Many: hasMany dan belongsTo di Model

Sekarang buka model Post dan tambahkan method relasi comments. Nama method memakai bentuk jamak karena satu post punya banyak comment, dan return type-nya adalah HasMany.

// app/Models/Post.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;

class Post extends Model
{
    protected $fillable = ['judul', 'isi'];

    public function comments(): HasMany
    {
        return $this->hasMany(Comment::class);
    }
}

Lalu buka model Comment dan tambahkan method post dengan return type BelongsTo. Nama method memakai bentuk tunggal karena satu comment hanya milik satu post.

// app/Models/Comment.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Comment extends Model
{
    protected $fillable = ['post_id', 'nama_komentator', 'isi_komentar'];

    public function post(): BelongsTo
    {
        return $this->belongsTo(Post::class);
    }
}

Perhatikan bahwa $fillable pada Comment menyertakan post_id agar bisa diisi massal saat membuat komentar baru. Dengan dua method ini, Eloquent sekarang paham hubungan kedua tabel. Kamu bisa mengakses $post->comments untuk mendapat koleksi komentar, atau $comment->post untuk mendapat post induknya, tanpa menulis satu pun query SQL manual.

Praktik: Menyimpan dan Membaca Data Berelasi

Relasi yang sudah didefinisikan membuat kode penyimpanan data menjadi sangat ekspresif. Untuk membuat comment yang otomatis terhubung ke post tertentu, cukup panggil relasinya lalu method create.

use App\Models\Post;

$post = Post::find(1);

// Membuat comment yang otomatis terisi post_id = 1
$post->comments()->create([
    'nama_komentator' => 'Ani',
    'isi_komentar' => 'Artikelnya sangat membantu, terima kasih!',
]);

Bentuk $post->comments() dengan tanda kurung mengembalikan query builder relasi sehingga kamu bisa merantainya dengan create, where, atau count. Sedangkan $post->comments tanpa tanda kurung langsung mengeksekusi dan mengembalikan koleksi hasil. Perbedaan kecil ini penting dan sering membingungkan pemula, jadi hafalkan polanya.

Untuk membaca, kamu bisa mengakses relasi dari kedua arah dengan natural.

// Dari post ke comments-nya
$post = Post::find(1);
foreach ($post->comments as $comment) {
    echo $comment->nama_komentator . ': ' . $comment->isi_komentar . "\n";
}

// Dari comment ke post induknya
$comment = Comment::find(5);
echo $comment->post->judul;

Tampilkan di Blade juga semudah itu. Contoh menampilkan daftar post beserta komentarnya:

@foreach ($posts as $post)
  <h2>{{ $post->judul }}</h2>
  <p>{{ $post->isi }}</p>

  <h4>Komentar ({{ $post->comments->count() }})</h4>
  <ul>
    @foreach ($post->comments as $comment)
      <li><strong>{{ $comment->nama_komentator }}:</strong> {{ $comment->isi_komentar }}</li>
    @endforeach
  </ul>
@endforeach

Waspadai Masalah N+1 dan Atasi dengan Eager Loading

Ada satu jebakan performa yang wajib kamu pahami sejak awal: masalah N+1 query. Perhatikan kode controller berikut yang terlihat wajar tetapi bermasalah.

// CARA LAMBAT: memicu N+1 query
$posts = Post::all(); // 1 query untuk mengambil semua post

foreach ($posts as $post) {
    echo $post->comments->count(); // +1 query untuk SETIAP post!
}

Bila ada 50 post, kode ini menjalankan 1 query untuk posts ditambah 50 query untuk comments, total 51 query. Inilah N+1: satu query awal plus N query tambahan. Pada data kecil tidak terasa, tetapi di production dengan ribuan baris, halamanmu bisa menjadi sangat lambat.

Solusinya adalah eager loading dengan method with(), yang memuat relasi sekaligus dalam query tambahan yang efisien.

// CARA CEPAT: hanya 2 query untuk semua data
$posts = Post::with('comments')->get(); // 1 query posts + 1 query comments

foreach ($posts as $post) {
    echo $post->comments->count(); // tidak ada query baru, data sudah dimuat
}

Eloquent akan menjalankan satu query untuk semua comments yang post_id-nya cocok, lalu mencocokkannya di memori. Hasilnya selalu hanya 2 query berapa pun jumlah post-nya. Aturan praktisnya: setiap kali kamu mengakses relasi di dalam loop, pastikan relasi itu dimuat dengan with() di awal. Kamu juga bisa memuat relasi bertingkat seperti with('comments.user') bila comment berelasi lagi ke tabel users.

Relasi di Route dan Controller: Contoh Lengkap

Mari rangkai semuanya dalam contoh controller nyata yang menampilkan satu post beserta komentarnya, plus form tambah komentar. Pertama daftarkan route-nya.

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

Route::get('/posts/{post}', [PostController::class, 'show'])->name('posts.show');
Route::post('/posts/{post}/comments', [PostController::class, 'storeComment'])
    ->name('posts.comments.store');

Lalu buat controllernya. Perhatikan penggunaan with('comments') untuk eager loading dan validasi input sebelum menyimpan.

// app/Http/Controllers/PostController.php
namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function show(Post $post)
    {
        // Muat ulang post beserta comments-nya secara eager
        $post->load('comments');

        return view('posts.show', compact('post'));
    }

    public function storeComment(Request $request, Post $post)
    {
        $validated = $request->validate([
            'nama_komentator' => 'required|max:100',
            'isi_komentar' => 'required|max:1000',
        ]);

        $post->comments()->create($validated);

        return redirect()->route('posts.show', $post)
            ->with('sukses', 'Komentar berhasil ditambahkan.');
    }
}

Teknik Route::get('/posts/{post}') yang dipasangkan dengan parameter Post $post disebut route model binding: Laravel otomatis mengambilkan model Post berdasarkan ID di URL. Ini menghemat kode pencarian manual dan sudah mengikuti praktik terbaik Laravel 12.

Kesalahan Umum Saat Membuat Relasi Eloquent

Beberapa error klasik yang sering ditemui pemula beserta penyebabnya. Pertama, error Class not found pada relasi biasanya karena lupa mengimpor class model terkait dengan use App\Models\Comment; di atas file. Kedua, foreign key tidak terbentuk karena urutan migrasi salah: migrasi posts harus berjalan sebelum comments, jadi perhatikan timestamp pada nama file migrasi.

Ketiga, mass assignment error saat create biasanya karena post_id belum masuk ke $fillable pada model Comment. Keempat, relasi mengembalikan null atau koleksi kosong padahal data ada di database. Cek apakah nama method relasi, nama foreign key, dan konvensi tabel semuanya konsisten. Bila memakai nama tabel atau kolom yang tidak standar, sebutkan eksplisit di parameter hasMany dan belongsTo, misalnya $this->hasMany(Comment::class, 'tulisan_id').

Langkah Selanjutnya

Kamu sekarang bisa memodelkan relasi one to many dengan benar: migrasi foreign key lewat foreignId dan constrained(), method hasMany dan belongsTo di model, sampai teknik eager loading untuk menghindari N+1 query. Ini adalah skill database yang dipakai di hampir setiap proyek Laravel profesional.

Relasi ini juga menjadi fondasi untuk topik lanjutan seperti many to many dengan tabel pivot, polymorphic relations, dan API Resources yang menyajikan data berelasi sebagai JSON. Untuk melihat bagaimana data berelasi disajikan ke aplikasi lain, lanjutkan ke Cara Membuat REST API dengan Laravel: Panduan Lengkap untuk Pemula. Dan bila kamu ingin mengulang dasar pengelolaan data tunggal sebelum melangkah lebih jauh, Tutorial Laravel 12: Membuat CRUD Sederhana dari Nol untuk Pemula selalu siap menjadi tempatmu berlatih lagi.

XAMPP adalah paket gratis berisi Apache (web server), MySQL atau MariaDB (database), PHP, dan Perl dalam satu instalasi. Tanpa XAMPP, file PHP yang kamu tulis tidak bisa dijalankan karena browser hanya memahami HTML, CSS, dan JavaScript. Dengan XAMPP, komputermu berubah menjadi server web mini tempat kamu bereksperimen sebebasnya tanpa biaya hosting.

Cara Install XAMPP: Persiapan Sebelum Mulai

Sebelum mengunduh, pastikan komputermu memenuhi syarat yang ringan ini. XAMPP berjalan baik di Windows 10 atau 11 dengan RAM minimal 4 GB dan ruang disk kosong sekitar 2 GB. Kamu juga butuh hak akses administrator saat instalasi karena XAMPP perlu mendaftarkan service dan membuka port jaringan lokal.

Satu catatan penting untuk pengguna Windows: nonaktifkan dulu antivirus yang terlalu agresif atau tambahkan folder instalasi ke daftar pengecualian bila instalasi gagal di tengah jalan. Beberapa antivirus salah mendeteksi komponen XAMPP sebagai ancaman. Selain itu, pastikan tidak ada aplikasi lain yang sedang memakai port 80, seperti Skype versi lama atau IIS, karena ini penyebab paling umum Apache gagal start. Kita bahas solusinya di bagian troubleshooting.

Langkah 1: Download XAMPP dari Situs Resmi

Selalu unduh XAMPP dari situs resminya di apachefriends.org. Jangan mengunduh dari situs pihak ketiga karena berisiko disisipi malware. Di halaman utama situs tersebut, pilih versi untuk Windows, lalu unduh installer versi PHP terbaru yang tersedia. Ukuran file installer biasanya sekitar 150 sampai 160 MB, jadi pastikan koneksi internetmu stabil.

Pilih versi PHP terbaru yang ditawarkan karena tutorial ini memakai sintaks PHP 8 yang modern. Versi lama seperti PHP 7 masih bisa dipakai, tetapi beberapa fitur baru tidak akan tersedia. Setelah file installer selesai diunduh, jangan buru-buru menjalankannya bila kamu memakai Windows dengan User Account Control yang ketat. Klik kanan file installer lalu pilih Run as administrator agar proses instalasi berjalan lancar.

Cara Install XAMPP di Windows: Menjalankan Installer

Jalankan installer dan ikuti wizard yang muncul. Pada layar pemilihan komponen, biarkan semua komponen tercentang bila ruang diskmu cukup, atau minimal pastikan Apache, MySQL, PHP, dan phpMyAdmin terpilih. Keempat komponen inilah yang akan paling sering kamu pakai.

Selanjutnya installer menanyakan folder tujuan. Lokasi defaultnya adalah C:\xampp dan sangat disarankan untuk tidak mengubahnya. Banyak tutorial dan konfigurasi mengasumsikan XAMPP ada di lokasi ini, sehingga mengubahnya hanya menambah potensi masalah. Hindari juga menginstal di dalam C:\Program Files karena izin foldernya lebih ketat dan sering menimbulkan error permission.

Klik Next sampai instalasi selesai. Prosesnya memakan waktu beberapa menit tergantung kecepatan disk. Bila Windows Firewall menampilkan peringatan dan meminta izin akses jaringan untuk Apache atau MySQL, pilih Allow access agar keduanya bisa berjalan normal.

Langkah 3: Menyalakan Apache dan MySQL Lewat Control Panel

Setelah instalasi selesai, buka XAMPP Control Panel dari Start Menu. Jendela ini adalah pusat kendalimu: setiap service punya tombol Start dan Stop masing-masing. Untuk mulai ngoding PHP, kamu cukup menyalakan dua service: Apache dan MySQL.

Klik tombol Start pada baris Apache. Bila berhasil, latar barisnya berubah hijau dan tertulis Running beserta nomor PID dan port (biasanya 80 dan 443). Lakukan hal yang sama untuk MySQL yang biasanya berjalan di port 3306. Bila salah satunya gagal start dan barisnya berwarna merah, jangan panik dulu dan langsung lompat ke bagian troubleshooting di akhir artikel.

Untuk memastikan Apache benar-benar hidup, buka browser dan ketik http://localhost di address bar. Bila muncul halaman selamat datang XAMPP, berarti web server lokalmu sudah berjalan sempurna. Alamat localhost ini setara dengan 127.0.0.1, yaitu alamat yang menunjuk ke komputermu sendiri.

Selagi MySQL berjalan, kamu juga bisa membuka http://localhost/phpmyadmin di browser untuk melihat phpMyAdmin, yaitu aplikasi web bawaan XAMPP untuk mengelola database lewat tampilan grafis. Kamu belum perlu memakainya sekarang, tetapi ketahui saja bahwa ia ada dan siap dipakai saat kamu mulai belajar database di artikel berikutnya.

Mengenal Folder htdocs: Tempat Menyimpan Proyekmu

Semua file web yang ingin dijalankan lewat XAMPP harus disimpan di dalam folder htdocs, yang berlokasi di C:\xampp\htdocs. Anggap folder ini sebagai root atau halaman depan dari server lokalmu. Setiap subfolder di dalamnya otomatis menjadi alamat web tersendiri.

Contohnya, bila kamu membuat folder C:\xampp\htdocs\belajar, maka isinya bisa diakses lewat http://localhost/belajar di browser. File bernama index.php di dalam folder itu akan terbuka otomatis saat kamu mengunjungi alamat foldernya, sama seperti perilaku hosting sungguhan. Pola inilah yang dipakai semua developer PHP di seluruh dunia untuk pengembangan lokal.

Satu aturan emas: jangan pernah menyimpan file PHP di folder lain seperti Documents lalu membukanya langsung dengan double click. File yang dibuka langsung tanpa lewat http://localhost tidak diproses oleh PHP, sehingga kode PHP-mu hanya tampil sebagai teks mentah atau tidak berjalan sama sekali.

Program PHP Pertama: Menampilkan phpinfo dan Halo Dunia

Sekarang saatnya menulis kode PHP pertama. Buka Notepad atau VS Code, lalu buat file bernama info.php di dalam C:\xampp\htdocs dengan isi berikut.

<?php
phpinfo();
?>

Simpan, lalu buka http://localhost/info.php di browser. Bila muncul halaman panjang berisi informasi konfigurasi PHP, selamat, PHP-mu bekerja. Fungsi phpinfo() ini sangat berguna untuk memeriksa versi PHP dan ekstensi yang aktif. Setelah yakin berhasil, hapus file info.php karena membiarkannya di server production bisa membocorkan informasi sistem.

Selanjutnya buat program legendaris setiap pemula: halo dunia. Buat file halo.php di folder htdocs dengan isi berikut.

<?php
$nama = "Budi";
$umur = 20;
?>
<!DOCTYPE html>
<html lang="id">
<head>
  <meta charset="UTF-8">
  <title>Halo Dunia</title>
</head>
<body>
  <h1>Halo dunia!</h1>
  <p>Nama saya <?php echo $nama; ?>, umur saya <?php echo $umur; ?> tahun.</p>
  <p>Hari ini: <?php echo date("l, d F Y"); ?></p>
</body>
</html>

Buka http://localhost/halo.php dan perhatikan hasilnya. Kode di antara <?php dan ?> dieksekusi di server, sedangkan sisanya dikirim apa adanya sebagai HTML. Fungsi date() menampilkan tanggal server sesuai format yang diminta. Pola mencampur PHP dan HTML seperti inilah dasar dari semua aplikasi PHP, termasuk yang dibangun dengan framework modern.

Membuat Form GET Sederhana dan Memproses Datanya

Program statis memang menyenangkan di awal, tetapi kekuatan PHP sesungguhnya adalah memproses data dari pengguna. Contoh paling sederhana adalah form yang mengirim data lewat method GET. Buat file sapa.php di folder htdocs dengan isi berikut.

<!DOCTYPE html>
<html lang="id">
<head>
  <meta charset="UTF-8">
  <title>Form Sapa</title>
</head>
<body>
  <h1>Form Sapaan</h1>
  <form method="GET" action="sapa.php">
    <label>Nama kamu: <input type="text" name="nama" required></label>
    <button type="submit">Kirim</button>
  </form>

  <?php if (isset($_GET["nama"])): ?>
    <p>
      Halo, <?php echo htmlspecialchars($_GET["nama"]); ?>!
      Senang bertemu denganmu.
    </p>
  <?php endif; ?>
</body>
</html>

Cara kerjanya begini. Saat form disubmit, browser mengirim data ke URL yang sama dengan parameter di address bar, misalnya sapa.php?nama=Ani. PHP menangkapnya lewat array superglobal $_GET. Fungsi isset() memeriksa apakah parameternya ada sebelum dipakai, supaya tidak muncul warning saat halaman pertama kali dibuka. Fungsi htmlspecialchars() wajib dipakai setiap menampilkan input pengguna untuk mencegah serangan XSS, yaitu kode jahat yang disisipkan lewat form.

Coba isi form dengan namamu lalu perhatikan address bar berubah. Itulah karakteristik method GET: datanya terlihat di URL. Untuk data sensitif seperti password, method POST lebih tepat karena datanya tidak tampil di URL. Prinsip memproses input form inilah yang nantinya berkembang menjadi fitur login, pendaftaran, dan CRUD lengkap.

Masalah Umum Saat Install XAMPP dan Cara Mengatasinya

Hampir setiap pemula menabrak minimal satu masalah berikut. Tenang, semuanya ada solusinya.

Apache tidak bisa start, port 80 sudah dipakai. Ini masalah nomor satu. Penyebab umum adalah Skype, IIS, atau aplikasi lain yang menduduki port 80. Solusi termudah: tutup aplikasi penyebabnya. Alternatifnya, ubah port Apache menjadi 8080 lewat tombol Config lalu Apache (httpd.conf), cari baris Listen 80 dan ubah menjadi Listen 8080, kemudian akses situsmu lewat http://localhost:8080.

MySQL tidak bisa start. Biasanya karena sudah ada instalasi MySQL lain yang berjalan sebagai service Windows. Buka Services, cari service MySQL yang bukan milik XAMPP, lalu hentikan atau ubah menjadi manual. Setelah itu start ulang MySQL dari XAMPP Control Panel.

Akses ditolak atau error permission. Terjadi bila XAMPP diinstal tanpa Run as administrator atau ditaruh di folder dengan izin ketat. Solusinya: jalankan XAMPP Control Panel sebagai administrator dengan klik kanan lalu Run as administrator.

Halaman localhost tidak tampil. Pastikan Apache berstatus Running berwarna hijau di Control Panel, lalu coba http://127.0.0.1 sebagai alternatif http://localhost. Bila tetap gagal, restart Apache dari Control Panel.

Langkah Selanjutnya Setelah XAMPP Berjalan

Kamu sekarang punya lingkungan pengembangan PHP yang lengkap: Apache melayani halaman, MySQL siap menyimpan data, dan kamu sudah bisa menulis serta memproses program PHP. Ini fondasi yang sama dipakai developer profesional sebelum mengerjakan proyek sungguhan.

Langkah berikutnya yang paling masuk akal adalah berkenalan dengan database MySQL karena hampir semua aplikasi web menyimpannya di sana. Baca panduan Belajar MySQL untuk Pemula: Membuat Database, Tabel, dan Query Dasar untuk melanjutkan dari titik ini. Setelah nyaman dengan database, saatnya naik kelas ke framework: Tutorial Laravel 12: Membuat CRUD Sederhana dari Nol untuk Pemula memakai XAMPP sebagai server lokalnya dan akan terasa jauh lebih mudah karena kamu sudah paham cara kerja di balik layarnya.

Kabar baiknya, kamu tidak perlu menginstal apa pun untuk mulai belajar. Cukup buka browser Chrome atau Edge, tekan F12 untuk membuka DevTools, lalu pilih tab Console. Di sanalah kamu bisa mengetik dan menjalankan kode JavaScript secara langsung. Untuk latihan yang lebih serius, kamu bisa memakai VS Code sebagai editor kode. Kalau belum memasangnya, baca dulu panduan 7 Ekstensi VS Code Wajib untuk Mahasiswa dan Programmer Pemula agar pengalaman ngodingmu lebih nyaman sejak awal.

Tutorial JavaScript Pemula: Persiapan dan Cara Menjalankan Kode

Sebelum menulis baris pertama, pahami dulu di mana kode JavaScript dijalankan. Ada dua tempat utama. Pertama, di browser melalui tab Console DevTools seperti yang sudah disebutkan. Cara ini paling cepat untuk bereksperimen dengan potongan kode kecil. Kedua, di dalam file HTML memakai tag script, yang akan kita pakai pada studi kasus di bagian akhir artikel ini.

Aturan mainnya sederhana. Setiap contoh kode pada artikel ini memakai sintaks modern JavaScript (ES6 ke atas) yang didukung semua browser terbaru. Kamu disarankan mengetik ulang setiap contoh, bukan sekadar menyalinnya, karena otot jarimu perlu terbiasa dengan sintaksnya. Kalau muncul error berwarna merah di Console, jangan panik. Baca pesannya baik-baik karena pesan error JavaScript biasanya cukup jelas menunjukkan baris yang bermasalah.

Satu kebiasaan penting sejak awal: biasakan memberi nama variabel dan fungsi yang deskriptif dalam bahasa Inggris, misalnya namaMahasiswa atau hitungTotal, bukan x atau data1. Kode yang kamu tulis hari ini akan kamu baca lagi minggu depan, dan nama yang jelas menghemat banyak waktu.

Mengenal Variabel: let, const, dan var

Variabel adalah wadah untuk menyimpan data. Di JavaScript modern ada dua kata kunci utama untuk membuat variabel, yaitu let dan const. Kamu mungkin juga menemukan var di kode-kode lama, tetapi untuk proyek baru sebaiknya hindari var karena perilakunya yang membingungkan terkait cakupan variabel.

Gunakan const untuk nilai yang tidak akan berubah setelah dibuat, dan let untuk nilai yang memang perlu diubah. Aturan praktisnya: selalu mulai dengan const, ganti ke let hanya bila kamu benar-benar perlu mengubah nilainya.

const namaKampus = "STT Payakumbuh";
let semester = 3;

console.log(namaKampus); // STT Payakumbuh
console.log(semester);   // 3

semester = 4; // boleh, karena memakai let
console.log(semester); // 4

// namaKampus = "Kampus Lain"; // ERROR: tidak boleh mengubah const

Perhatikan bahwa mengubah isi dari const yang berupa object atau array masih diperbolehkan, yang dilarang adalah mengganti seluruh referensinya. Ini konsep yang akan terasa manfaatnya saat kamu bekerja dengan data yang kompleks.

const mahasiswa = { nama: "Budi", ipk: 3.5 };
mahasiswa.ipk = 3.7; // boleh: mengubah isi properti
console.log(mahasiswa.ipk); // 3.7

Tipe Data Dasar yang Wajib Dikuasai

JavaScript punya beberapa tipe data dasar. Lima yang paling sering dipakai pemula adalah string (teks), number (angka), boolean (benar atau salah), null (kosong yang disengaja), dan undefined (belum diberi nilai). Kamu bisa memeriksa tipe sebuah nilai dengan operator typeof.

const nama = "Ani";          // string
const umur = 20;             // number
const lulus = true;          // boolean
let nilai = null;            // null
let alamat;                  // undefined

console.log(typeof nama);  // "string"
console.log(typeof umur);  // "number"
console.log(typeof lulus); // "boolean"

Satu hal unik JavaScript adalah ia tidak membedakan integer dan desimal, semuanya bertipe number. Operasi aritmetika dasar memakai simbol yang sudah familier: tambah (+), kurang (-), kali (*), bagi (/), dan sisa bagi (%).

const a = 10;
const b = 3;
console.log(a + b); // 13
console.log(a % b); // 1 (sisa pembagian 10 oleh 3)

Hati-hati dengan operator + pada string karena ia berfungsi sebagai penggabung teks, bukan penjumlahan. Untuk menggabungkan variabel ke dalam kalimat, cara modernnya memakai template literal dengan backtick dan ${}.

const namaDepan = "Dewi";
const kota = "Padang";
console.log(`Halo, saya ${namaDepan} dari ${kota}.`);
// Halo, saya Dewi dari Padang.

Fungsi: Blok Kode yang Bisa Dipakai Ulang

Fungsi adalah blok kode yang diberi nama dan bisa dipanggil berkali-kali. Tanpa fungsi, kamu akan menulis kode yang sama berulang-ulang. Ada dua cara penulisan yang umum: deklarasi fungsi biasa dan arrow function yang lebih ringkas.

// Deklarasi fungsi biasa
function sapa(nama) {
  return `Halo, ${nama}! Selamat belajar JavaScript.`;
}

console.log(sapa("Rina")); // Halo, Rina! Selamat belajar JavaScript.

// Arrow function (sintaks ES6)
const kuadrat = (angka) => {
  return angka * angka;
};

console.log(kuadrat(5)); // 25

// Arrow function satu baris bisa lebih ringkas lagi
const tambah = (x, y) => x + y;
console.log(tambah(4, 7)); // 11

Fungsi bisa menerima parameter (masukan) dan mengembalikan nilai lewat return. Parameter membuat fungsi menjadi fleksibel karena perilakunya bisa berubah tergantung argumen yang diberikan saat dipanggil. Biasakan memberi nilai default pada parameter bila masuk akal, supaya fungsi tetap berjalan walau pemanggil lupa memberi argumen.

function hitungDiskon(harga, persenDiskon = 10) {
  const potongan = harga * (persenDiskon / 100);
  return harga - potongan;
}

console.log(hitungDiskon(100000));     // 90000 (pakai default 10%)
console.log(hitungDiskon(100000, 25)); // 75000

Array dan Object: Menyimpan Banyak Data Sekaligus

Variabel biasa hanya menyimpan satu nilai. Untuk menyimpan banyak nilai, JavaScript menyediakan array (daftar berurutan) dan object (kumpulan pasangan kunci dan nilai).

Array memakai kurung siku dan indeksnya dimulai dari nol. Beberapa method array yang wajib hafal adalah push untuk menambah data, length untuk menghitung isi, dan forEach atau map untuk memproses setiap elemen.

const daftarBuah = ["apel", "mangga", "pisang"];

console.log(daftarBuah[0]);      // "apel" (indeks mulai dari 0)
console.log(daftarBuah.length);  // 3

daftarBuah.push("anggur");       // tambah di akhir
console.log(daftarBuah.length);  // 4

// forEach: menjalankan fungsi untuk tiap elemen
daftarBuah.forEach((buah) => {
  console.log(`Saya suka ${buah}`);
});

Object memakai kurung kurawal dan menyimpan data sebagai pasangan kunci: nilai. Ini struktur yang paling sering kamu temui saat berurusan dengan data dari API atau database.

const mahasiswa = {
  nama: "Fajar",
  nim: "2024001",
  jurusan: "Informatika",
  aktif: true
};

console.log(mahasiswa.nama);    // "Fajar" (dot notation)
console.log(mahasiswa["nim"]);  // "2024001" (bracket notation)

mahasiswa.semester = 5; // menambah properti baru
console.log(mahasiswa.semester); // 5

Kombinasi array berisi object adalah pola paling umum di dunia nyata, misalnya daftar mahasiswa yang masing-masing punya nama dan NIM. Kuasai pola ini baik-baik karena ia muncul di hampir setiap aplikasi.

const daftarMahasiswa = [
  { nama: "Fajar", ipk: 3.5 },
  { nama: "Sinta", ipk: 3.8 },
  { nama: "Bimo", ipk: 3.2 }
];

daftarMahasiswa.forEach((mhs) => {
  console.log(`${mhs.nama} memiliki IPK ${mhs.ipk}`);
});

Manipulasi DOM: Menghubungkan JavaScript dengan Halaman Web

DOM (Document Object Model) adalah representasi halaman HTML sebagai struktur pohon yang bisa dibaca dan diubah oleh JavaScript. Inilah jembatan yang membuat halaman web menjadi interaktif. Tiga kemampuan DOM yang paling sering dipakai adalah mengambil elemen, mengubah isinya, dan merespons kejadian dari pengguna.

Untuk mengambil elemen, gunakan document.getElementById bila elemen punya atribut id, atau document.querySelector yang lebih fleksibel karena memakai sintaks selector CSS.

// <p id="sapaan">Halo dunia</p>
const paragraf = document.getElementById("sapaan");
paragraf.textContent = "Halo, JavaScript!"; // ubah isi teks

// querySelector memakai selector CSS
const tombol = document.querySelector(".btn-kirim");
tombol.style.backgroundColor = "orange"; // ubah gaya langsung

Interaksi sesungguhnya terjadi lewat event listener, yaitu fungsi yang dijalankan saat pengguna melakukan sesuatu seperti mengklik tombol. Polanya selalu sama: ambil elemen, pasang addEventListener, tulis fungsi yang dijalankan.

// <button id="tombolKlik">Klik saya</button>
// <p id="hasil"></p>

const tombolKlik = document.getElementById("tombolKlik");
const hasil = document.getElementById("hasil");

let jumlahKlik = 0;

tombolKlik.addEventListener("click", () => {
  jumlahKlik++;
  hasil.textContent = `Tombol diklik ${jumlahKlik} kali.`;
});

Selain click, ada banyak event lain seperti input (saat mengetik di form), submit (saat form dikirim), dan mouseover. Untuk mengubah tampilan, cara paling rapi adalah menambah atau menghapus class CSS lewat classList, bukan mengubah style satu per satu.

// <div id="kotak" class="kotak-biru"></div>
const kotak = document.getElementById("kotak");

kotak.classList.add("kotak-merah");    // tambah class
kotak.classList.remove("kotak-biru");  // hapus class
kotak.classList.toggle("aktif");       // alihkan: ada jadi hilang, hilang jadi ada

Method toggle pada contoh terakhir inilah yang akan menjadi bintang utama studi kasus kita berikutnya.

Studi Kasus Tutorial JavaScript Pemula: Membuat Toggle Dark Mode

Sekarang gabungkan semua yang sudah dipelajari menjadi satu program utuh: tombol yang mengalihkan halaman antara mode terang dan mode gelap. Buat satu file bernama dark-mode.html, lalu isi dengan kode berikut.

<!DOCTYPE html>
<html lang="id">
<head>
  <meta charset="UTF-8">
  <title>Toggle Dark Mode</title>
  <style>
    body {
      font-family: sans-serif;
      text-align: center;
      padding: 50px;
      transition: background-color 0.3s, color 0.3s;
    }
    body.dark {
      background-color: #1a1a2e;
      color: #f0f0f0;
    }
    button {
      padding: 12px 24px;
      font-size: 16px;
      cursor: pointer;
      border: none;
      border-radius: 8px;
      background-color: orange;
      color: white;
    }
  </style>
</head>
<body>
  <h1 id="judul">Belajar JavaScript Itu Seru</h1>
  <p>Klik tombol di bawah untuk mengganti tema halaman.</p>
  <button id="tombolTema">Aktifkan Dark Mode</button>

  <script>
    const tombolTema = document.getElementById("tombolTema");
    const judul = document.getElementById("judul");

    tombolTema.addEventListener("click", () => {
      document.body.classList.toggle("dark");

      const modeGelapAktif = document.body.classList.contains("dark");

      if (modeGelapAktif) {
        tombolTema.textContent = "Aktifkan Light Mode";
        judul.textContent = "Mode Gelap Aktif";
      } else {
        tombolTema.textContent = "Aktifkan Dark Mode";
        judul.textContent = "Belajar JavaScript Itu Seru";
      }
    });
  </script>
</body>
</html>

Mari bedah cara kerjanya baris per baris. Pertama, const dipakai untuk menyimpan referensi ke tombol dan judul karena referensi ini tidak pernah berubah. Kedua, addEventListener("click", ...) memasang fungsi yang berjalan setiap tombol diklik. Ketiga, classList.toggle("dark") menambah class dark ke body bila belum ada, atau menghapusnya bila sudah ada, sehingga CSS yang sudah disiapkan otomatis mengubah warna latar dan teks. Keempat, classList.contains("dark") memeriksa status saat ini supaya teks tombol dan judul ikut diperbarui dengan benar.

Coba simpan file itu lalu buka di browser dan klik tombolnya beberapa kali. Perhatikan bahwa seluruh logika hanya belasan baris. Inilah kekuatan manipulasi DOM: sedikit kode, dampak langsung terlihat. Sebagai tantangan mandiri, coba simpan pilihan tema pengguna memakai localStorage supaya mode gelap tetap aktif walau halaman di-refresh.

Kesalahan Umum yang Sering Dilakukan Pemula

Setiap pemula JavaScript hampir pasti menabrak beberapa jebakan klasik. Mengetahui jebakan ini sejak awal menghemat waktu debugging yang lumayan.

Pertama, memakai = (assignment) padahal maksudnya === (perbandingan ketat) di dalam if. JavaScript juga punya == yang melakukan konversi tipe otomatis dan sering menimbulkan hasil mengejutkan, jadi biasakan selalu memakai ===.

const umur = "20"; // string, bukan number!

if (umur == 20) {
  console.log("lolos dengan =="); // tercetak, karena konversi tipe
}

if (umur === 20) {
  console.log("tidak akan tercetak"); // string "20" tidak identik dengan number 20
}

Kedua, menjalankan kode DOM sebelum elemennya ada. Kalau tag script ditaruh di dalam head tanpa atribut khusus, kode berjalan sebelum body selesai dimuat sehingga getElementById mengembalikan null. Solusi paling mudah adalah menaruh script tepat sebelum penutup </body>, seperti pada studi kasus di atas.

Ketiga, lupa bahwa indeks array dimulai dari nol. Mengakses daftarBuah[3] pada array berisi tiga elemen menghasilkan undefined, bukan error, sehingga bug-nya bisa lolos tanpa disadari.

Keempat, mengubah const secara langsung. Ingat, const melarang assignment ulang terhadap variabelnya, walau isi object-nya masih boleh diubah. Pesan errornya berbunyi “Assignment to constant variable” yang cukup jelas.

Langkah Selanjutnya Setelah Tutorial Ini

Selamat, kamu sekarang memegang fondasi JavaScript yang solid: variabel dengan let dan const, tipe data, fungsi termasuk arrow function, array dan object, sampai manipulasi DOM dengan event listener. Fondasi ini cukup untuk membuat halaman web interaktif sederhana dan menjadi modal wajib sebelum melangkah ke topik yang lebih besar.

Langkah logis berikutnya adalah mempelajari cara JavaScript berkomunikasi dengan server lewat HTTP request. Untuk itu, baca dulu penjelasan konsepnya di artikel Apa Itu API? Penjelasan Sederhana Lengkap dengan Contoh untuk Pemula, lalu praktikkan dengan fetch untuk mengambil data nyata. Setelah nyaman di sisi frontend, saatnya melirik sisi backend: panduan Tutorial Laravel 12: Membuat CRUD Sederhana dari Nol untuk Pemula akan menunjukkan bagaimana data yang kamu olah di browser sebenarnya disimpan dan dikelola di server. Kombinasi JavaScript di frontend dan Laravel di backend adalah paket skill yang sangat dicari di dunia kerja pengembangan web saat ini.

Panduan ini adalah lanjutan alami dari seri Laravel di blog ini. Kita memakai Laravel 12 dengan PHP 8.2, dan di akhir kamu akan memahami cara kerja autentikasi bawaan Laravel, cara mengubah tampilannya, serta cara melindungi halaman agar hanya bisa diakses pengguna yang sudah login.

Apa Itu Laravel Breeze?

Laravel Breeze adalah starter kit autentikasi resmi dari tim Laravel yang menyediakan semua hal dasar: halaman login, register, lupa password, reset password, verifikasi email, halaman profil, dan route dashboard. Breeze tersedia dalam beberapa varian tampilan (Blade, Livewire, React, Vue, dan API), dan dalam tutorial ini kita memakai varian Blade karena paling cocok untuk pemula yang sudah familiar dengan HTML.

Penting untuk dipahami: Breeze bukan package ajaib yang menyembunyikan kode. Semua controller, view, dan route-nya dipublikasikan ke projectmu sehingga kamu bisa membaca, mempelajari, dan mengubahnya sesuka hati. Inilah yang membuatnya ideal untuk belajar, berbeda dengan solusi autentikasi yang kodenya tertutup.

Prasyarat sebelum mulai: PHP 8.2 atau lebih baru, Composer, Node.js dengan npm, dan MySQL yang sudah berjalan. Kalau MySQL-mu belum siap, ikuti dulu panduan Belajar MySQL untuk Pemula yang sudah terjadwal di blog ini.

Tutorial Laravel Breeze Login Register: Instalasi

Langkah pertama adalah membuat project Laravel 12 baru, lalu menambahkan Breeze sebagai dependensi development:

composer create-project laravel/laravel:^12.0 auth-breeze
cd auth-breeze
composer require laravel/breeze --dev

Perintah pertama mengunduh kerangka Laravel 12 ke folder auth-breeze. Perintah kedua menambahkan package Breeze khusus untuk lingkungan development. Selanjutnya, jalankan installer Breeze dan pilih varian Blade saat ditanya:

php artisan breeze:install

Installer akan menanyakan stack yang diinginkan. Pilih blade untuk tutorial ini. Breeze kemudian mempublikasikan controller autentikasi ke app/Http/Controllers/Auth, view ke resources/views/auth, dan route ke routes/auth.php. Ia juga menambahkan route dashboard contoh ke routes/web.php.

Setelah instalasi, jalankan migrasi database untuk membuat tabel users dan tabel pendukungnya:

php artisan migrate

Pastikan konfigurasi database di file .env sudah benar (nama database, username, dan password MySQL). Jika migrasi gagal, 90 persen penyebabnya adalah kredensial database yang salah di .env.

Terakhir, install dependensi frontend dan jalankan server development:

npm install
npm run dev

Jalankan juga php artisan serve di terminal terpisah, lalu buka http://localhost:8000. Kamu akan melihat halaman welcome Laravel dengan tautan Login dan Register di pojok kanan atas. Klik Register, isi formulir, dan akun pertamamu langsung jadi.

Memahami File-File Penting Breeze

Agar tidak sekadar “bisa pakai”, mari pahami struktur yang dibuat Breeze. Route autentikasi didaftarkan di routes/auth.php yang di-include dari routes/web.php:

require __DIR__.'/auth.php';

Controller seperti RegisteredUserController dan AuthenticatedSessionController di folder app/Http/Controllers/Auth menangani logika register dan login. View-nya ada di resources/views/auth/, misalnya login.blade.php dan register.blade.php, memakai class Tailwind CSS untuk tampilannya.

Model App\Models\User sudah disiapkan dengan trait HasFactory dan Notifiable, serta kolom name, email, dan password yang otomatis di-hash dengan bcrypt saat register. Kamu tidak perlu menulis logika hashing password sendiri.

Tutorial Laravel Breeze Login Register: Kustomisasi Tampilan

Tampilan bawaan Breeze memang fungsional, tetapi kamu pasti ingin menyesuaikannya dengan identitas aplikasimu. Karena semua view dipublikasikan ke project, kustomisasi semudah mengedit file Blade biasa.

Misalnya, untuk mengubah judul dan teks di halaman login, buka resources/views/auth/login.blade.php dan ubah bagian headingnya. Kamu juga bisa mengganti logo bawaan dengan logomu sendiri di file layout resources/views/layouts/guest.blade.php yang dipakai semua halaman autentikasi.

Untuk mengubah nama aplikasi yang tampil di email verifikasi dan notifikasi, cukup ubah di file .env:

APP_NAME="Aplikasi Kampusku"

Setelah mengubah view atau asset, pastikan Vite dev server (npm run dev) sedang berjalan agar perubahan Tailwind langsung terlihat. Untuk production, jalankan npm run build agar asset dikompilasi menjadi file statis yang optimal.

Proteksi Route dengan Middleware Auth

Fitur login tidak ada gunanya jika halaman penting tetap bisa dibuka tanpa login. Di Laravel, proteksi dilakukan dengan middleware auth. Breeze sudah mencontohkannya pada route dashboard di routes/web.php:

use App\Http\Controllers\ProfileController;
use Illuminate\Support\Facades\Route;

Route::get('/', function () {
    return view('welcome');
});

Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware(['auth', 'verified'])->name('dashboard');

Route::middleware('auth')->group(function () {
    Route::get('/profile', [ProfileController::class, 'edit'])->name('profile.edit');
    Route::patch('/profile', [ProfileController::class, 'update'])->name('profile.update');
    Route::delete('/profile', [ProfileController::class, 'destroy'])->name('profile.destroy');
});

require __DIR__.'/auth.php';

Pola yang perlu kamu tiru adalah Route::middleware('auth')->group(...): semua route di dalam grup ini otomatis menolak pengunjung yang belum login dan mengarahkannya ke halaman login. Middleware verified menambahkan syarat bahwa email pengguna harus sudah diverifikasi.

Untuk halaman admin atau dosen nantinya, kamu bisa membuat middleware sendiri, misalnya is_admin, dan menerapkannya dengan pola yang sama. Prinsipnya selalu sama: daftarkan middleware, lalu tempelkan ke route atau grup route yang perlu dilindungi.

Menguji Alur Login dan Register

Setelah semua terpasang, uji alur lengkapnya seperti pengguna sungguhan. Daftarkan akun baru lewat halaman register, verifikasi bahwa kamu langsung diarahkan ke dashboard, lalu logout dan login kembali dengan akun yang sama. Coba juga fitur “lupa password” untuk memastikan email reset terkirim (untuk development, atur MAIL_MAILER=log di .env agar isi email tercatat di file log, bukan benar-benar terkirim).

Uji juga sisi keamanannya: buka URL /dashboard di jendela incognito tanpa login. Kamu harus diarahkan ke halaman login. Jika halaman dashboard tetap terbuka, berarti middleware belum terpasang dengan benar.

Menambah Field Kustom pada Form Register

Form register bawaan Breeze hanya meminta nama, email, dan password. Untuk aplikasi nyata, kamu sering butuh field tambahan, misalnya nomor HP atau NIM. Caranya terdiri dari tiga langkah: tambah kolom di database, tampilkan di form, dan simpan lewat controller.

Pertama, buat migrasi untuk menambah kolom:

php artisan make:migration add_no_hp_to_users_table

Lalu edit file migrasi yang dihasilkan:

public function up(): void
{
    Schema::table('users', function (Blueprint $table) {
        $table->string('no_hp', 15)->nullable()->after('email');
    });
}

Jalankan php artisan migrate untuk menerapkan perubahan. Kedua, tambahkan input di resources/views/auth/register.blade.php mengikuti pola input yang sudah ada. Ketiga, buka app/Http/Controllers/Auth/RegisteredUserController.php dan tambahkan validasi serta penyimpanan field barunya:

$request->validate([
    'name' => ['required', 'string', 'max:255'],
    'email' => ['required', 'string', 'email', 'max:255', 'unique:'.User::class],
    'no_hp' => ['nullable', 'string', 'max:15'],
    'password' => ['required', 'confirmed', Rules\Password::defaults()],
]);

$user = User::create([
    'name' => $request->name,
    'email' => $request->email,
    'no_hp' => $request->no_hp,
    'password' => Hash::make($request->password),
]);

Pola ini berlaku untuk field tambahan apa pun. Kuncinya selalu tiga langkah yang sama: migrasi, view, dan controller. Setelah memahami polanya, kamu bisa menambahkan field sebanyak yang dibutuhkan aplikasimu.

Membuat Halaman Terproteksi Sendiri

Sekarang praktikkan middleware auth pada halaman buatanmu sendiri, misalnya halaman “Nilai Saya” untuk mahasiswa. Buat controller dan view-nya:

php artisan make:controller NilaiController

Isi controller dengan method sederhana:

namespace App\Http\Controllers;

class NilaiController extends Controller
{
    public function index()
    {
        $nilai = [
            ['mk' => 'Pemrograman Dasar', 'nilai' => 'A'],
            ['mk' => 'Basis Data', 'nilai' => 'AB'],
        ];
        return view('nilai.index', compact('nilai'));
    }
}

Lalu daftarkan route-nya di dalam grup middleware auth di routes/web.php:

Route::middleware('auth')->group(function () {
    Route::get('/nilai-saya', [NilaiController::class, 'index'])->name('nilai.index');
    // ... route profile bawaan Breeze tetap di sini
});

Buat file view resources/views/nilai/index.blade.php yang extends layout Breeze, dan halaman itu kini hanya bisa diakses setelah login. Coba akses /nilai-saya tanpa login untuk membuktikan proteksinya bekerja. Pola inilah fondasi dari semua fitur berbasis peran: halaman admin, dashboard dosen, dan area member semuanya memakai teknik yang sama.

Troubleshooting Instalasi Breeze

Tiga masalah paling sering dialami pemula saat mengikuti tutorial ini. Pertama, composer require laravel/breeze --dev gagal karena versi PHP di bawah 8.2. Laravel 12 mensyaratkan PHP 8.2 atau lebih baru, jadi periksa dengan php -v dan upgrade dulu jika perlu.

Kedua, php artisan migrate error dengan pesan access denied. Ini hampir selalu berarti kredensial database di file .env salah, atau database-nya belum dibuat. Buat dulu database kosongnya (misalnya via phpMyAdmin), lalu sesuaikan DB_DATABASE, DB_USERNAME, dan DB_PASSWORD.

Ketiga, halaman tampil tanpa styling Tailwind (terlihat polos). Penyebabnya adalah Vite dev server belum berjalan. Pastikan npm run dev aktif di terminal terpisah saat development, atau jalankan npm run build agar asset dikompilasi menjadi file statis yang optimal. Jika port 5173 bentrok, tutup proses yang memakai port tersebut lalu jalankan ulang.

Satu tips tambahan: jika kamu mengerjakan tutorial ini di komputer laboratorium kampus yang tidak mengizinkan instalasi Node.js sama sekali, kamu tetap bisa mengikuti bagian backend (instalasi Breeze, migrasi, middleware) karena hanya membutuhkan PHP dan Composer. Bagian tampilan memang butuh npm, tetapi logika autentikasinya tetap bisa dipelajari dan diuji tanpa itu.

Kesimpulan

Kamu sudah menyelesaikan tutorial Laravel Breeze login register ini: menginstal Breeze via Composer, menjalankan migrasi database, memahami struktur controller dan view yang dihasilkan, mengkustomisasi tampilan Blade, dan memproteksi route dengan middleware auth. Dengan fondasi ini, aplikasi apapun yang kamu bangun sudah punya sistem autentikasi yang aman mengikuti standar Laravel.

Seri Laravel di blog ini kini mencakup CRUD, REST API, dan autentikasi. Langkah berikutnya yang alami adalah menggabungkan ketiganya dalam satu project utuh. Mulai dari Tutorial Laravel 12: Membuat CRUD Sederhana dari Nol untuk Pemula jika kamu belum mengikutinya, lalu lanjutkan ke Cara Membuat REST API dengan Laravel untuk mengekspos datamu sebagai API. Dengan Git untuk version control, MySQL untuk database, dan Breeze untuk autentikasi, kamu sudah punya bekal lengkap membangun aplikasi web modern.

Tutorial ini melanjutkan seri Laravel di blog ini. Kita akan memakai contoh yang sama dengan tutorial sebelumnya, yaitu data produk dengan kolom name, description, price, dan stock. Bedanya, kali ini datanya tidak ditampilkan lewat Blade, melainkan disajikan sebagai data JSON yang bisa dikonsumsi aplikasi apa pun. Kalau kamu belum mengikuti tutorial CRUD sebelumnya, sangat disarankan menyelesaikannya dulu agar model dan tabel produknya sudah siap.

Apa Itu REST API dan Kenapa Laravel Cocok untuk Itu

REST API adalah cara standar dua aplikasi berkomunikasi lewat HTTP. Client mengirim request ke sebuah alamat (endpoint), lalu server membalas dengan data, biasanya dalam format JSON. Setiap operasi memakai method HTTP yang berbeda, dan pola ini berlaku konsisten di hampir semua API modern.

Laravel cocok untuk membuat REST API karena tiga alasan. Pertama, routing dan resource controller-nya memang dirancang mengikuti pola REST. Kedua, Eloquent membuat urusan database menjadi singkat. Ketiga, ekosistemnya lengkap: ada Sanctum untuk autentikasi token, API Resource untuk mengatur format JSON, dan validasi bawaan yang rapi. Kamu tidak perlu memasang banyak paket tambahan hanya untuk membuat API yang layak pakai.

Prasyarat Sebelum Mulai

Pastikan hal berikut sudah siap di komputermu:

1. Proyek Laravel 12 dari tutorial CRUD sebelumnya, dengan model Product dan tabel products yang sudah termigrasi.
2. Server lokal berjalan lewat perintah php artisan serve.
3. Aplikasi untuk menguji API, misalnya Postman, Insomnia, atau cukup terminal untuk perintah curl.

Kalau proyek CRUD belum ada, kamu tetap bisa mengikuti tutorial ini dari proyek Laravel baru. Cukup buat model dan migration produk seperti pada tutorial sebelumnya, lalu lanjutkan dari langkah pertama di bawah.

Langkah 1: Memasang Sanctum dengan Perintah install:api

Di Laravel versi modern, dukungan API tidak aktif secara bawaan agar proyek web biasa tetap ringan. Untuk mengaktifkannya, jalankan satu perintah berikut di terminal proyekmu:

php artisan install:api

Perintah ini melakukan beberapa hal sekaligus: memasang paket Laravel Sanctum, membuat file routes/api.php, dan menyiapkan migration untuk tabel personal_access_tokens yang nanti menyimpan token login pengguna. Setelah perintah selesai, jalankan migration:

php artisan migrate

Semua route yang kamu tulis di routes/api.php otomatis memakai awalan /api. Jadi route products di file itu akan diakses sebagai /api/products. Inilah yang membedakannya dari route web di routes/web.php.

Langkah 2: Membuat Controller Khusus API

Jangan mencampur controller web dan controller API dalam satu file. Controller web mengembalikan tampilan Blade, sedangkan controller API mengembalikan JSON. Buat controller baru di dalam folder Api:

php artisan make:controller Api/ProductController

Buka file app/Http/Controllers/Api/ProductController.php, lalu isi dengan kode berikut:

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Http\Resources\ProductResource;
use App\Models\Product;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    public function index()
    {
        return ProductResource::collection(Product::latest()->paginate(10));
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'description' => 'nullable|string',
            'price' => 'required|numeric|min:0',
            'stock' => 'required|integer|min:0',
        ]);

        $product = Product::create($validated);

        return (new ProductResource($product))
            ->response()
            ->setStatusCode(201);
    }

    public function show(Product $product)
    {
        return new ProductResource($product);
    }

    public function update(Request $request, Product $product)
    {
        $validated = $request->validate([
            'name' => 'sometimes|string|max:255',
            'description' => 'nullable|string',
            'price' => 'sometimes|numeric|min:0',
            'stock' => 'sometimes|integer|min:0',
        ]);

        $product->update($validated);

        return new ProductResource($product);
    }

    public function destroy(Product $product)
    {
        $product->delete();

        return response()->json(['message' => 'Produk berhasil dihapus.']);
    }
}

Ada tiga hal yang perlu diperhatikan dari kode di atas. Pertama, validasi tetap dilakukan di setiap operasi tulis, sama seperti CRUD versi web. Kedua, pada method update kita memakai aturan sometimes agar client boleh mengubah sebagian kolom saja, sesuai sifat method PATCH. Ketiga, method show dan update memakai route model binding: Laravel otomatis mencari produk berdasarkan ID di URL, dan otomatis membalas 404 bila ID tidak ditemukan. Kamu tidak perlu menulis pencarian manual.

Sebagai pengembangan lanjutan, validasi di controller ini nantinya bisa dipisah ke Form Request agar controller lebih ramping. Untuk tahap dasar, validasi langsung seperti ini sudah cukup dan lebih mudah diikuti.

Langkah 3: Mengatur Format JSON dengan API Resource

Kalau model langsung dikembalikan sebagai JSON, semua kolom di tabel akan ikut tampil, termasuk yang seharusnya tidak perlu diketahui client. API Resource memberi kamu kendali penuh atas kolom apa saja yang dikirim. Buat resource-nya:

php artisan make:resource ProductResource

Lalu buka app/Http/Resources/ProductResource.php dan ubah method toArray menjadi:

public function toArray(Request $request): array
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'description' => $this->description,
        'price' => (int) $this->price,
        'stock' => (int) $this->stock,
        'created_at' => $this->created_at?->toDateTimeString(),
        'updated_at' => $this->updated_at?->toDateTimeString(),
    ];
}

Jangan lupa menambahkan use Illuminate\Http\Request; di bagian atas file bila belum ada. Dengan resource ini, format balasan akan konsisten di semua endpoint: data produk dibungkus dalam kunci data, dan untuk daftar produk Laravel otomatis menambahkan informasi pagination seperti total halaman. Konsistensi format seperti ini yang membuat API nyaman dipakai tim frontend.

Langkah 4: Mendaftarkan Route API

Sekarang daftarkan endpoint-nya di routes/api.php:

<?php

use App\Http\Controllers\Api\ProductController;
use Illuminate\Support\Facades\Route;

Route::apiResource('products', ProductController::class);

Satu baris apiResource itu menghasilkan lima endpoint sekaligus sesuai tabel di awal artikel. Untuk memastikan semuanya terdaftar dengan benar, jalankan:

php artisan route:list --path=api

Kamu akan melihat daftar route beserta method HTTP dan controller tujuannya. Bila daftar ini sudah muncul, API dasarmu sebenarnya sudah jadi dan siap diuji.

Langkah 5: Menguji API dengan curl

Pastikan server berjalan, lalu buka terminal baru dan coba beberapa perintah berikut.

Mengambil semua produk:

curl http://127.0.0.1:8000/api/products

Menambah produk baru:

curl -X POST http://127.0.0.1:8000/api/products -H "Content-Type: application/json" -H "Accept: application/json" -d '{"name":"Keyboard Mechanical","description":"Keyboard RGB hot swap","price":350000,"stock":12}'

Balasan yang benar untuk penambahan data adalah status 201 Created beserta data produk yang baru dibuat, lengkap dengan ID-nya. Kalau kamu mendapat status 422, berarti validasi gagal dan pesan errornya ada di dalam JSON balasan. Baca pesan itu baik baik, karena di situlah petunjuk kolom mana yang bermasalah.

Di Postman, langkahnya setara: pilih method POST, masukkan URL yang sama, buka tab Body, pilih raw dan JSON, lalu tempel isi data produknya. Jangan lupa selalu mengirim header Accept: application/json agar Laravel membalas error dalam format JSON, bukan halaman HTML.

Langkah 6: Menambahkan Autentikasi Token dengan Sanctum

API yang terbuka untuk siapa pun cocok untuk data publik, tetapi operasi tambah, ubah, dan hapus data sebaiknya hanya boleh dilakukan pengguna yang sudah login. Sanctum menyelesaikan ini dengan token: pengguna login sekali, menerima token, lalu mengirim token itu di setiap request berikutnya.

Pertama, aktifkan trait HasApiTokens pada model User. Buka app/Models/User.php dan sesuaikan bagian atas class:

use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;
    // ...
}

Kedua, buat controller autentikasi:

php artisan make:controller Api/AuthController

Isi file app/Http/Controllers/Api/AuthController.php dengan kode berikut:

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\ValidationException;

class AuthController extends Controller
{
    public function register(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|string|email|unique:users',
            'password' => 'required|string|min:8|confirmed',
        ]);

        $user = User::create([
            'name' => $validated['name'],
            'email' => $validated['email'],
            'password' => Hash::make($validated['password']),
        ]);

        return response()->json([
            'user' => $user,
            'token' => $user->createToken('api-token')->plainTextToken,
        ], 201);
    }

    public function login(Request $request)
    {
        $request->validate([
            'email' => 'required|string|email',
            'password' => 'required|string',
        ]);

        $user = User::where('email', $request->email)->first();

        if (! $user || ! Hash::check($request->password, $user->password)) {
            throw ValidationException::withMessages([
                'email' => ['Email atau password salah.'],
            ]);
        }

        return response()->json([
            'user' => $user,
            'token' => $user->createToken('api-token')->plainTextToken,
        ]);
    }

    public function logout(Request $request)
    {
        $request->user()->currentAccessToken()->delete();

        return response()->json(['message' => 'Berhasil logout.']);
    }
}

Ketiga, perbarui routes/api.php agar endpoint produk terlindungi, sedangkan register dan login tetap terbuka:

<?php

use App\Http\Controllers\Api\AuthController;
use App\Http\Controllers\Api\ProductController;
use Illuminate\Support\Facades\Route;

Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);

Route::middleware('auth:sanctum')->group(function () {
    Route::apiResource('products', ProductController::class);
    Route::post('/logout', [AuthController::class, 'logout']);
});

Pola ini umum dipakai: membaca data pun bisa kamu longgarkan bila memang datanya publik, misalnya memindahkan method index dan show ke luar grup middleware. Untuk latihan ini, semua endpoint produk kita lindungi agar perilaku tokennya terlihat jelas.

Langkah 7: Menguji Endpoint yang Terlindungi

Coba akses /api/products tanpa token. Laravel akan membalas status 401 Unauthorized. Itu tanda perlindungannya bekerja.

Selanjutnya login untuk mendapatkan token:

curl -X POST http://127.0.0.1:8000/api/login -H "Content-Type: application/json" -H "Accept: application/json" -d '{"email":"contoh@mail.com","password":"password123"}'

Salin nilai token dari balasan, lalu pakai pada request berikutnya lewat header Authorization:

curl http://127.0.0.1:8000/api/products -H "Accept: application/json" -H "Authorization: Bearer TOKEN_KAMU"

Kali ini data produk akan tampil. Di Postman, token yang sama bisa diisi pada tab Authorization dengan tipe Bearer Token. Simpan token ini baik baik dan jangan pernah menaruhnya di kode frontend yang dipublikasikan, karena siapa pun yang memiliki token itu bisa bertindak atas nama pengguna pemiliknya.

Troubleshooting yang Sering Terjadi

Route /api tidak ditemukan (404). Biasanya karena install:api belum dijalankan atau file routes/api.php belum terdaftar. Jalankan php artisan route:list –path=api untuk memastikan, dan bersihkan cache route dengan php artisan route:clear bila perlu.

Balasan error berupa halaman HTML, bukan JSON. Client tidak mengirim header Accept: application/json. Tambahkan header itu di curl atau Postman, terutama saat menguji validasi dan autentikasi.

Status 401 padahal sudah login. Periksa tiga hal: token disalin utuh tanpa spasi tambahan, header diawali kata Bearer diikuti satu spasi, dan route memang berada di dalam grup auth:sanctum. Kesalahan paling sering adalah token tertukar dengan token dari sesi login lama yang sudah dihapus.

Class HasApiTokens tidak ditemukan. Artinya Sanctum belum terpasang. Jalankan kembali php artisan install:api, atau pasang manual dengan composer require laravel/sanctum lalu php artisan vendor:publish untuk konfigurasinya.

Error kolom tidak boleh diisi (mass assignment). Sama seperti tutorial CRUD: pastikan semua kolom produk sudah terdaftar di properti fillable pada model Product.

FAQ REST API Laravel

1. Apa bedanya Route::apiResource dan Route::resource?
apiResource hanya membuat lima route untuk operasi data (index, store, show, update, destroy), sedangkan resource menambahkan route create dan edit yang dipakai untuk menampilkan form HTML. Karena API tidak punya form, apiResource adalah pilihan yang tepat.

2. Apakah REST API Laravel harus selalu memakai Sanctum?
Tidak selalu. API publik yang hanya menampilkan data terbuka bisa dibuat tanpa autentikasi. Sanctum dipakai bila ada data milik pengguna atau operasi tulis yang perlu dibatasi. Untuk komunikasi antar server yang lebih kompleks, ada juga Laravel Passport berbasis OAuth2, tetapi untuk kebanyakan aplikasi pemula Sanctum jauh lebih sederhana.

3. Bagaimana cara membatasi jumlah data per halaman?
Pada contoh ini kita memakai paginate(10), dan client bisa berpindah halaman dengan menambahkan ?page=2 pada URL. Jumlah per halaman boleh diubah sesuai kebutuhan, dan lazimnya disertakan juga pilihan per_page dari query string bila API dipakai banyak client.

4. Bisakah API ini dipakai aplikasi Flutter atau React Native?
Bisa, dan memang untuk itulah API ini dibuat. Aplikasi mobile cukup mengirim request HTTP ke endpoint yang sama dan membaca balasan JSON-nya. Yang perlu diperhatikan, alamat 127.0.0.1 hanya berlaku di komputer pengembang. Untuk pengujian dari HP, gunakan alamat IP lokal komputer atau layanan tunnel selama pengembangan.

5. Bagaimana cara membuat versi API, misalnya v1 dan v2?
Kelompokkan route ke dalam awalan versi, contohnya Route::prefix(‘v1’) pada grup route, sehingga URL menjadi /api/v1/products. Dengan cara ini, perubahan besar di masa depan bisa diterbitkan sebagai v2 tanpa merusak aplikasi lama yang masih memakai v1.

Kesimpulan

Kamu baru saja mengubah aplikasi CRUD Laravel menjadi REST API yang utuh: endpoint produk dengan format JSON yang konsisten lewat API Resource, validasi di setiap operasi tulis, pagination, dan autentikasi token memakai Sanctum. Pola ini adalah fondasi hampir semua backend modern, baik untuk aplikasi mobile, frontend JavaScript, maupun integrasi antar layanan.

Langkah alami berikutnya adalah menerapkan pola yang sama ke data lain di aplikasimu, lalu mempelajari cara men-deploy API ini ke server agar bisa diakses dari mana saja. Sebagai penguat dasar, baca kembali seri awalnya di Tutorial Laravel 12: Membuat CRUD Sederhana dari Nol untuk Pemula dan padukan dengan bantuan AI secara etis lewat panduan 5 Tools AI Gratis untuk Mahasiswa yang juga sudah terbit di blog ini.

Sudah berhasil membuat endpoint pertamamu? Ceritakan di kolom komentar method mana yang paling membingungkan, nanti kita bahas bersama.

Dalam tutorial Laravel 12 ini, kamu akan membangun aplikasi pendataan produk sederhana dari nol: tambah data, tampilkan daftar, ubah data, dan hapus data. Semua langkah dijelaskan berurutan lengkap dengan contoh kode yang bisa langsung kamu praktikkan. Di akhir tutorial, kamu akan memahami alur kerja utama Laravel yaitu route, controller, model, migration, dan Blade. Kalau kamu benar-benar baru di dunia Laravel, baca juga panduan membuat project sederhana menggunakan Laravel untuk pengenalan awal yang lebih santai.

Apa Itu CRUD dan Kenapa Laravel Cocok untuk Mempelajarinya?

CRUD adalah fondasi hampir semua aplikasi web. Aplikasi kasir, sistem akademik, toko online, semuanya dibangun di atas empat operasi ini. Laravel sangat cocok untuk belajar CRUD karena menyediakan semua peralatannya secara bawaan: Eloquent ORM untuk database, Blade untuk tampilan, dan resource controller yang memetakan operasi CRUD ke method secara rapi.

Yang akan kita bangun adalah aplikasi Data Produk sederhana dengan field nama, deskripsi, harga, dan stok.

Prasyarat: Yang Perlu Disiapkan

Sebelum mulai, pastikan komputermu sudah memiliki:

1. PHP 8.2 atau lebih baru (Laravel 12 membutuhkan minimal PHP 8.2). Cek dengan perintah php -v.
2. Composer, package manager PHP. Cek dengan composer --version.
3. MySQL atau MariaDB yang sudah berjalan. Kamu juga bisa memakai SQLite untuk latihan cepat.
4. Teks editor seperti VS Code.

Jika semua sudah siap, mari mulai langkah pertama.

Langkah 1: Instalasi Laravel 12

Buka terminal, lalu jalankan perintah berikut untuk membuat proyek baru bernama toko-sederhana:

composer create-project laravel/laravel:^12.0 toko-sederhana
cd toko-sederhana

Tunggu proses instalasi selesai. Setelah itu, jalankan server development bawaan Laravel:

php artisan serve

Buka browser dan akses http://127.0.0.1:8000. Jika halaman selamat datang Laravel muncul, instalasi berhasil.

Langkah 2: Konfigurasi Database

Buka file .env di folder proyek, lalu sesuaikan pengaturan database dengan milikmu:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=toko_sederhana
DB_USERNAME=root
DB_PASSWORD=

Buat database kosong bernama toko_sederhana di MySQL terlebih dahulu, misalnya lewat phpMyAdmin atau perintah SQL CREATE DATABASE toko_sederhana;.

Langkah 3: Membuat Model, Migration, dan Controller Sekaligus

Salah satu keunggulan Laravel adalah perintah artisan yang bisa menghasilkan beberapa file sekaligus. Untuk fitur produk, kita butuh model Product, file migration untuk tabelnya, dan controller. Cukup satu perintah:

php artisan make:model Product -mcr

Arti flag-nya: -m membuat migration, -c membuat controller, -r membuat controller bertipe resource (sudah berisi method CRUD standar). Perintah ini menghasilkan tiga file:

• app/Models/Product.php
• database/migrations/xxxx_xx_xx_xxxxxx_create_products_table.php
• app/Http/Controllers/ProductController.php

Langkah 4: Menulis Migration untuk Tabel Products

Buka file migration yang baru dibuat, lalu definisikan struktur tabel di dalam method up:

public function up(): void
{
    Schema::create('products', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->text('description')->nullable();
        $table->decimal('price', 12, 2);
        $table->integer('stock')->default(0);
        $table->timestamps();
    });
}

Setelah itu jalankan migration untuk membuat tabelnya di database:

php artisan migrate

Jika berhasil, tabel products beserta kolomnya sudah tersedia.

Langkah 5: Mengatur Model Product

Buka app/Models/Product.php dan tambahkan properti $fillable. Properti ini menentukan kolom mana saja yang boleh diisi secara massal, sekaligus melindungi dari celah mass assignment:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    protected $fillable = ['name', 'description', 'price', 'stock'];
}

Langkah 6: Menulis Logika CRUD di Controller

Inilah bagian inti tutorial. Buka app/Http/Controllers/ProductController.php dan isi ketujuh method resource sebagai berikut:

<?php

namespace App\Http\Controllers;

use App\Models\Product;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    // READ: tampilkan semua produk
    public function index()
    {
        $products = Product::latest()->paginate(10);
        return view('products.index', compact('products'));
    }

    // CREATE: tampilkan form tambah
    public function create()
    {
        return view('products.create');
    }

    // CREATE: simpan data baru
    public function store(Request $request)
    {
        $validated = $request->validate([
            'name'        => 'required|string|max:255',
            'description' => 'nullable|string',
            'price'       => 'required|numeric|min:0',
            'stock'       => 'required|integer|min:0',
        ]);

        Product::create($validated);

        return redirect()->route('products.index')
            ->with('success', 'Produk berhasil ditambahkan.');
    }

    // READ: tampilkan satu produk
    public function show(Product $product)
    {
        return view('products.show', compact('product'));
    }

    // UPDATE: tampilkan form edit
    public function edit(Product $product)
    {
        return view('products.edit', compact('product'));
    }

    // UPDATE: simpan perubahan
    public function update(Request $request, Product $product)
    {
        $validated = $request->validate([
            'name'        => 'required|string|max:255',
            'description' => 'nullable|string',
            'price'       => 'required|numeric|min:0',
            'stock'       => 'required|integer|min:0',
        ]);

        $product->update($validated);

        return redirect()->route('products.index')
            ->with('success', 'Produk berhasil diperbarui.');
    }

    // DELETE: hapus produk
    public function destroy(Product $product)
    {
        $product->delete();

        return redirect()->route('products.index')
            ->with('success', 'Produk berhasil dihapus.');
    }
}

Perhatikan dua hal penting di kode ini. Pertama, $request->validate() memastikan data yang masuk sudah benar sebelum disimpan. Kedua, Laravel otomatis mengubah parameter Product $product menjadi data produk yang sesuai berdasarkan ID di URL. Fitur ini namanya route model binding.

Langkah 7: Mendaftarkan Route

Buka routes/web.php dan daftarkan satu baris route resource. Satu baris ini otomatis membuat semua URL dan nama route untuk ketujuh method di atas:

use App\Http\Controllers\ProductController;

Route::resource('products', ProductController::class);

Dengan ini kamu mendapatkan URL seperti /products (daftar), /products/create (form tambah), /products/{id}/edit (form ubah), dan seterusnya.

Langkah 8: Membuat Tampilan dengan Blade

Buat folder resources/views/products, lalu buat file-file berikut.

Layout dasar (resources/views/layouts/app.blade.php):

<!DOCTYPE html>
<html lang="id">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Data Produk</title>
    <style>
        body { font-family: sans-serif; max-width: 900px; margin: 2rem auto; padding: 0 1rem; }
        table { width: 100%; border-collapse: collapse; margin-top: 1rem; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background: #f4f4f4; }
        .alert { background: #d4edda; padding: 10px; border-radius: 4px; margin-bottom: 1rem; }
        .btn { display: inline-block; padding: 6px 12px; border-radius: 4px; text-decoration: none; }
        .btn-primary { background: #0d6efd; color: #fff; }
        .btn-warning { background: #ffc107; color: #000; }
        .btn-danger { background: #dc3545; color: #fff; border: none; cursor: pointer; }
        form div { margin-bottom: 12px; }
        label { display: block; margin-bottom: 4px; font-weight: bold; }
        input, textarea { width: 100%; padding: 8px; border: 1px solid #ccc; border-radius: 4px; }
        .error { color: #dc3545; font-size: 0.9em; }
    </style>
</head>
<body>
    <h1>Aplikasi Data Produk</h1>

    @if (session('success'))
        <div class="alert">{{ session('success') }}</div>
    @endif

    @yield('content')
</body>
</html>

Daftar produk (resources/views/products/index.blade.php):

@extends('layouts.app')

@section('content')
    <a href="{{ route('products.create') }}" class="btn btn-primary">Tambah Produk</a>

    <table>
        <thead>
            <tr>
                <th>Nama</th>
                <th>Harga</th>
                <th>Stok</th>
                <th>Aksi</th>
            </tr>
        </thead>
        <tbody>
            @forelse ($products as $product)
                <tr>
                    <td>{{ $product->name }}</td>
                    <td>Rp {{ number_format($product->price, 0, ',', '.') }}</td>
                    <td>{{ $product->stock }}</td>
                    <td>
                        <a href="{{ route('products.edit', $product) }}" class="btn btn-warning">Ubah</a>
                        <form action="{{ route('products.destroy', $product) }}" method="POST" style="display:inline">
                            @csrf
                            @method('DELETE')
                            <button type="submit" class="btn btn-danger"
                                onclick="return confirm('Hapus produk ini?')">Hapus</button>
                        </form>
                    </td>
                </tr>
            @empty
                <tr><td colspan="4">Belum ada data produk.</td></tr>
            @endforelse
        </tbody>
    </table>

    {{ $products->links() }}
@endsection

Form tambah (resources/views/products/create.blade.php):

@extends('layouts.app')

@section('content')
    <h2>Tambah Produk Baru</h2>

    <form action="{{ route('products.store') }}" method="POST">
        @csrf
        <div>
            <label>Nama Produk</label>
            <input type="text" name="name" value="{{ old('name') }}">
            @error('name') <div class="error">{{ $message }}</div> @enderror
        </div>
        <div>
            <label>Deskripsi</label>
            <textarea name="description">{{ old('description') }}</textarea>
        </div>
        <div>
            <label>Harga</label>
            <input type="number" name="price" value="{{ old('price') }}">
            @error('price') <div class="error">{{ $message }}</div> @enderror
        </div>
        <div>
            <label>Stok</label>
            <input type="number" name="stock" value="{{ old('stock', 0) }}">
            @error('stock') <div class="error">{{ $message }}</div> @enderror
        </div>
        <button type="submit" class="btn btn-primary">Simpan</button>
    </form>
@endsection

Form ubah (resources/views/products/edit.blade.php): salin file create.blade.php, lalu ubah dua hal: action form menjadi route('products.update', $product) dan tambahkan @method('PUT') tepat di bawah @csrf. Isi value setiap input dengan data lama, contohnya value="{{ old('name', $product->name) }}".

Tiga hal penting pada form Blade: @csrf wajib ada untuk keamanan, @method('PUT') dan @method('DELETE') diperlukan karena browser hanya mendukung GET dan POST, dan @error menampilkan pesan validasi dari controller.

Langkah 9: Uji Aplikasi

Pastikan server masih berjalan (php artisan serve), lalu buka http://127.0.0.1:8000/products. Coba alurnya satu per satu: tambah produk baru, lihat daftarnya, ubah datanya, lalu hapus. Jika pesan sukses muncul dan data berubah sesuai harapan, selamat, CRUD Laravel 12 pertamamu sudah jadi.

Memahami Alur Kerja: Dari URL Sampai ke Browser

Agar tidak sekadar menyalin kode, pahami alur yang terjadi setiap kali kamu membuka halaman. Misalnya saat mengakses /products:

1. Route menerima permintaan dan meneruskannya ke method index di ProductController.
2. Controller meminta data ke model Product, yang mengambilnya dari tabel products lewat Eloquent.
3. Controller mengirim data tersebut ke view products.index.
4. Blade menggabungkan view dengan layout, lalu hasilnya dikirim kembali ke browser sebagai HTML.

Alur yang sama berlaku untuk semua operasi. Form tambah mengirim POST ke method store, form ubah mengirim PUT ke method update, dan tombol hapus mengirim DELETE ke method destroy. Kalau kamu hafal alur empat tahap ini, debugging aplikasi Laravel akan jauh lebih mudah karena kamu selalu tahu di lapisan mana masalah terjadi.

Kesalahan Umum Pemula dan Cara Mengatasinya

SQLSTATE Access denied. Periksa kembali DB_USERNAME, DB_PASSWORD, dan nama database di file .env. Setelah mengubah .env, tidak perlu restart apapun kecuali config di-cache.

MassAssignmentException. Kamu lupa menambahkan kolom ke $fillable di model. Tambahkan nama kolom yang error ke array tersebut.

Halaman 404 saat buka /products. Pastikan route resource sudah didaftarkan di routes/web.php dan tidak ada typo pada nama controller.

Perubahan tidak tersimpan. Cek validasi di controller. Jika validasi gagal, Laravel mengembalikan ke form sebelumnya beserta pesan error, jadi perhatikan bagian @error di Blade.

FAQ: Pertanyaan Seputar CRUD Laravel

Apa itu CRUD dalam Laravel?
CRUD adalah empat operasi dasar pengelolaan data yaitu Create (membuat), Read (membaca), Update (mengubah), dan Delete (menghapus). Di Laravel, keempatnya dipetakan rapi ke dalam resource controller dengan tujuh method standar.

Apakah tutorial ini bisa dipakai untuk Laravel 11?
Bisa, dengan sedikit penyesuaian. Struktur dasar resource controller, migration, dan Blade hampir sama. Namun beberapa detail seperti persyaratan versi PHP bisa berbeda, jadi sesuaikan dengan dokumentasi versi yang kamu pakai.

Apakah harus bisa PHP dulu sebelum belajar Laravel?
Sangat disarankan memahami dasar PHP seperti variabel, fungsi, array, dan konsep OOP (class dan object). Tanpa dasar itu, kode Laravel akan terasa seperti sulap.

Bagaimana cara menampilkan pesan error validasi?
Gunakan directive @error('nama_field') di file Blade tepat di bawah input yang bersangkutan. Laravel otomatis mengirim pesan error kembali ke form jika validasi di controller gagal.

Apa langkah selanjutnya setelah menguasai CRUD?
Pelajari autentikasi (login dan register), relasi antar tabel di Eloquent, upload file, dan pembuatan REST API. REST API adalah kelanjutan alami karena pola controller-nya mirip dengan yang baru saja kamu pelajari.

Penutup

Kamu baru saja membangun aplikasi CRUD lengkap di Laravel 12: instalasi, migration, model, resource controller, route, dan tampilan Blade. Pola ini akan terus kamu temui di hampir semua proyek Laravel, jadi pastikan kamu benar-benar memahaminya sebelum lanjut.

Langkah alami berikutnya adalah mengubah CRUD ini menjadi REST API, karena pola controller-nya sangat mirip. Baca juga panduan kami tentang cara membuat REST API dengan Laravel untuk melanjutkan perjalanan belajarmu.

Mengapa Memilih Tiket.com untuk Membeli Tiket BLACKPINK?

Tikets.com selalu menjadi platform pilihan utama bagi para penggemar yang ingin membeli tiket konser. Ada beberapa alasan mengapa Tiket.com menjadi mitra resmi penjualan tiket konser BLACKPINK, antara lain:

1. Proses Pembelian yang Mudah dan Cepat
   Dengan antarmuka yang mudah digunakan, Tiket.com memungkinkan Anda untuk membeli tiket dengan beberapa langkah sederhana. Bahkan pada saat penjualan tiket besar seperti konser BLACKPINK, sistem di Tiket.com sudah disiapkan untuk menangani lonjakan trafik pengguna dengan efisien.

2. Keamanan dan Kepercayaan
   Tiket.com dikenal dengan sistem pembayaran yang aman dan terpercaya. Anda dapat melakukan pembayaran menggunakan berbagai metode, seperti kartu kredit, transfer bank, hingga e-wallet, yang mempermudah transaksi.

3. Akses Langsung ke General Sale
   Tiket konser BLACKPINK dapat dibeli melalui general sale di Tiket.com, yang terbuka untuk publik tanpa keanggotaan khusus. Ini memberikan kesempatan bagi semua penggemar untuk membeli tiket.

Harga Tiket Konser BLACKPINK 2025 Jakarta

Tiket untuk konser BLACKPINK WORLD TOUR IN JAKARTA dijual dengan berbagai kategori, dengan harga yang bervariasi sesuai dengan lokasi tempat duduk dan paket yang dipilih. Berikut adalah daftar harga tiket konser yang dapat Anda pilih:

• Blink PIT Package (standing): Rp 3.800.000

• Blink Package (seating): Rp 3.800.000

• Platinum (seating): Rp 3.400.000

• Cat 1 (seating): Rp 3.100.000

• Cat 2 (seating): Rp 2.600.000

• Cat 3 (seating): Rp 2.300.000

• Cat 4 (seating): Rp 2.000.000

• Restricted View (seating): Rp 1.450.000

Harap dicatat bahwa harga yang tercantum belum termasuk pajak dan biaya administrasi. Pastikan untuk memeriksa harga final saat melakukan pembayaran di platform Tiket.com.

Cara Membeli Tiket BLACKPINK di Tiket.com

Berikut adalah langkah-langkah mudah untuk membeli tiket BLACKPINK WORLD TOUR IN JAKARTA melalui Tiket.com:

1. Unduh dan Masuk ke Aplikasi Tiket.com
   Jika Anda belum memiliki aplikasi Tiket.com, unduh terlebih dahulu melalui Google Play Store atau Apple App Store. Jika sudah, masuk ke akun Tiket.com Anda. Jika belum memiliki akun, Anda dapat membuatnya terlebih dahulu.

2. Cari Konser BLACKPINK
   Setelah berhasil login, buka aplikasi dan klik ikon “Event” di halaman utama. Di bagian ini, Anda akan menemukan berbagai acara, termasuk konser BLACKPINK WORLD TOUR IN JAKARTA. Pilih banner konser tersebut untuk melanjutkan.

3. Masuk ke Sistem Antrean Otomatis
   Pada pukul 10.00 WIB tanggal 12 Juni 2025, saat penjualan tiket dibuka, Anda akan diarahkan ke sistem antrean otomatis atau waiting room. Pastikan Anda sudah siap di waktu yang tepat untuk menghindari kehilangan kesempatan.

4. Pilih Tiket dan Tentukan Jumlahnya
   Setelah masuk ke antrean, pilih kategori tiket yang Anda inginkan, serta jumlah tiket yang ingin Anda beli (maksimal enam tiket per akun per hari). Pastikan Anda memilih tiket yang sesuai dengan preferensi Anda.

5. Lengkapi Data Pemesanan
   Setelah memilih tiket, Anda akan diminta untuk melengkapi data pribadi seperti nama dan alamat email. Pastikan data yang dimasukkan benar agar proses transaksi berjalan lancar.

6. Pilih Metode Pembayaran dan Selesaikan Transaksi
   Pilih metode pembayaran yang tersedia, seperti kartu kredit, transfer bank, atau e-wallet. Setelah memilih metode pembayaran, lanjutkan dengan transaksi dan tunggu konfirmasi pembayaran.

7. Tiket Anda Akan Tersedia
   Setelah pembayaran berhasil, tiket elektronik (e-ticket) akan tersedia di halaman “Your Orders” pada aplikasi atau situs web Tiket.com Anda. Pastikan untuk menyimpan e-ticket ini sebagai bukti masuk ke konser.

Tips Menghadapi War Tiket BLACKPINK

Saat membeli tiket konser BLACKPINK, Anda mungkin akan mengalami “war tiket” atau persaingan ketat karena tingginya permintaan. Berikut beberapa tips yang dapat membantu Anda:

• Siapkan Akun dan Data Diri
  Pastikan akun Tiket.com Anda sudah terdaftar dan data diri lengkap sebelum penjualan tiket dimulai. Ini akan menghemat waktu Anda pada saat antrean dimulai.

• Buka Aplikasi Sebelum Waktu Penjualan
  Pastikan Anda sudah membuka aplikasi Tiket.com dan siap di sistem antrean sebelum penjualan dimulai pada pukul 10.00 WIB. Jangan menunggu menit terakhir!

• Siapkan Metode Pembayaran
  Untuk menghindari keterlambatan, pastikan metode pembayaran Anda sudah terdaftar dan siap digunakan. Pilih metode yang paling cepat untuk menyelesaikan transaksi.

Kehadiran BLACKPINK di Jakarta: Momen yang Dinantikan

Konser BLACKPINK di Jakarta 2025 diperkirakan akan menjadi salah satu acara terbesar tahun ini. BLACKPINK—yang terdiri dari Jisoo, Jennie, Rosé, dan Lisa—dikenal dengan aksi panggung yang spektakuler, visual yang memukau, dan energi yang luar biasa. Kehadiran mereka di Jakarta pastinya akan membawa pengalaman konser yang tak terlupakan bagi para penggemar di Indonesia.

Dengan basis penggemar yang besar di seluruh dunia, konser ini akan menjadi momen bersejarah bagi para BLINK di Indonesia. Bagi yang sudah membeli tiket, pastikan Anda menyiapkan diri untuk menikmati penampilan luar biasa dari grup ini.

Kesimpulan

Penjualan tiket BLACKPINK WORLD TOUR IN JAKARTA 2025 sudah dimulai, dan Tiket.com adalah platform resmi tempat Anda bisa mendapatkan tiket konser mereka. Dengan mengikuti langkah-langkah yang sudah dijelaskan di atas, Anda bisa mendapatkan tiket dengan mudah dan cepat. Ingat, persiapkan diri Anda sebelum waktu penjualan dimulai pada pukul 10.00 WIB agar tidak ketinggalan tiket.

Jangan lewatkan kesempatan langka ini untuk menyaksikan aksi panggung BLACKPINK secara langsung! Buka aplikasi Tiket.com Anda sekarang, dan pastikan Anda mendapatkan tiket untuk pengalaman konser yang tak terlupakan.

Adapun yang harus kita persiapkan dalam pembelajaran sample dataset pada scikit-learn adalah :

• Memiliki akun Gmail, kemudian login ke dalam akun Gmail.
• Buka google colab untuk menjalankan script dari scikit-learn.
• Buat project baru

• Untuk kasus kali ini kita memakai iris dataset, ketikan kedalam script kode script berikut

from sklearn.datasets import load_iris
iris = load_iris()
iris

Penjelasan dari script di atas adalah pertama kita harus install dulu sklearn.datasets kemudian kita import function load_iris. untuk memanggil iris dataset dengan load_iris() kemudian kita tampung dalam satu variabel dengan nama iris, kemudian untuk menampilkan kita ketik variabel iris.

Untuk menjalankan program tersebut cukup dengan mengklik tombol play pada menu di samping program. hasilnya seperti gambar di bawah ini :

Kita akan mendata keys apa saja yang dimiliki oleh iris dataset, dengan mengetikan kode pada baris baru:

iris.keys()

kemudian jalankan, maka hasilnya seperti gambar di bawah ini :

Adapun Keys() yang tersedia dari iris dataset adalah : ‘data’, ‘target’, ‘frame’, ‘target_names’, ‘DESCR’, ‘feature_names’, ‘filename’, ‘data_module’.

Untuk data keys akan berkaitan dengan data features, sedangkan target berkaitan nanti dengan data – data target. Frame untuk menanandakan apakah data format yang ada pada iris dataset data frame atau bukan data frame. Target_names dan Features names akan berkolerasi dengan nama atau label untuk setiap target dan featuresnya. DESCR merupakan kependekan dari deskripsi . filename akan berkolerasi dengan lokasi filename projek ini dan yang terakhir data_module adalah modul yang diakses pada sklearn yaitu sklearn.datasets.data.

Deskripsi Dari Sample Dataset

Sample dataset yang kita gunakan dapat teman – teman gali infromasinya melalui link wikipedia. untuk mengakses metadata dari iris dataset adalah dengan cara mengetikan script di bawah ini :

print(iris.DESCR)

hasilnya dapat kita lihat di bawah ini

Dari gambar di atas dapat kita ambil informasi tentang judul dataset, dengan judul Iris plants dataset, number of instances jumlah baris 150 baris terdapat 3 class ( Iris-Setosa, Iris-Versicolour, Iris-Virginica ) di dalam1 class terdapat 50 baris. Number of attributes ada 4 atributes : sepal lenght, sepal width, petal length dan petal widht dengan format ukuran centimeter ( cm ).