Belajar Laravel untuk Pemula: MVC, Routing, Eloquent, dan CRUD

Laravel adalah framework PHP paling populer untuk membangun web application, dari blog sederhana sampai sistem enterprise. Dengan filosofi “developer happiness”, Laravel menyediakan tools yang elegan untuk routing, database, authentication, dan hampir semua kebutuhan backend modern — sehingga kamu bisa fokus ke logika aplikasi, bukan ke hal-hal teknis yang berulang. Buat pemula, Laravel adalah salah satu jalan tercepat untuk benar-benar bisa membuat aplikasi web yang jalan, bukan sekadar halaman statis.

Di panduan ini kamu akan belajar Laravel dari nol secara berurutan: apa itu Laravel, konsep MVC, routing, controller, Blade, migration, Eloquent ORM, sampai membangun satu aplikasi CRUD sederhana dari kosong. Semua kode di sini bisa langsung kamu ketik dan jalankan — tidak ada pseudo-code.

Apa Itu Laravel?

Laravel adalah framework open-source berbasis bahasa PHP yang dipakai untuk membangun aplikasi web dengan pola dan konvensi yang rapi. Alih-alih menulis semua dari nol (koneksi database manual, routing manual, validasi manual), Laravel sudah menyediakan struktur dan tools siap pakai, jadi kamu tinggal mengisi logika bisnisnya.

Framework itu ibarat “rangka rumah” yang sudah jadi. Kamu tidak perlu memikirkan pondasi, pipa air, dan instalasi listrik dari awal — kamu tinggal menata ruangan sesuai kebutuhan. Laravel mengurus bagian yang membosankan tapi penting: bagaimana request HTTP diproses, bagaimana data disimpan ke database, bagaimana user login, dan bagaimana halaman dirender. Kalau kamu ingin memahami konsepnya lebih pelan sambil praktik, ada materi pengenalan apa itu Laravel yang bisa kamu kerjakan langsung di browser.

Kenapa Harus Belajar Laravel?

Ada banyak framework backend, tapi Laravel unggul di beberapa hal yang penting buat pemula maupun profesional:

• Eloquent ORM — Interaksi database yang ekspresif dan intuitif, tanpa perlu menulis SQL mentah untuk kebutuhan sehari-hari.
• Artisan CLI — Command-line tool yang powerful; banyak hal (bikin model, controller, migration) tinggal satu perintah.
• Migration — Version control untuk struktur database, jadi tim bisa sinkron tanpa saling kirim file .sql.
• Built-in auth — Sistem login, register, dan reset password nyaris siap pakai.
• Ekosistem lengkap — Queue, cache, email, file storage, broadcasting, semuanya terintegrasi.
• Dokumentasi dan komunitas — Dokumentasi resminya rapi, dan komunitasnya besar sehingga solusi masalah gampang dicari.

Apa yang Perlu Kamu Kuasai Sebelum Laravel?

Laravel bukan titik awal belajar programming — ada prasyarat yang bikin perjalananmu jauh lebih mulus. Kalau kamu memaksa masuk Laravel tanpa dasar ini, banyak kode akan terasa seperti “sihir” yang tidak kamu pahami.

Sebelum mulai, sebaiknya kamu sudah nyaman dengan:

1. Dasar PHP — variabel, array, fungsi, dan struktur kontrol. Ini fondasi yang tidak bisa dilewati.
2. OOP di PHP — hampir semua kode Laravel berbasis class dan object, jadi konsep class, method, dan inheritance wajib kamu pahami lewat materi OOP dasar PHP.
3. HTML dasar — karena tampilan aplikasi tetap dirender jadi HTML. Kalau perlu penyegaran, baca dulu panduan belajar HTML untuk pemula.

Kalau kamu benar-benar baru di dunia web dan belum pernah membuat halaman sendiri, ada baiknya membaca cara membuat website pertama dulu supaya gambaran besarnya jelas sebelum masuk ke framework.

Menyiapkan Environment Laravel

Untuk mulai, kamu butuh tiga hal: PHP versi 8.2 atau lebih baru, Composer (package manager PHP), dan sebuah database seperti MySQL atau SQLite. Setelah itu, membuat project baru cuma satu perintah.

Cek dulu apakah PHP dan Composer sudah terpasang:

php --version        # harus 8.2 ke atas
composer --version   # memastikan Composer terpasang

Kalau keduanya sudah ada, buat project Laravel baru:

composer create-project laravel/laravel aplikasi-catatan
cd aplikasi-catatan

Composer akan mengunduh Laravel beserta semua dependensinya ke folder aplikasi-catatan. Setelah selesai, jalankan development server bawaan:

php artisan serve

Buka http://localhost:8000 di browser — kalau muncul halaman selamat datang Laravel, berarti setup kamu berhasil. Struktur folder yang paling sering kamu sentuh sebagai pemula:

aplikasi-catatan/
├── app/
│   ├── Http/Controllers/   ← Controller (logika request)
│   └── Models/             ← Model (representasi tabel database)
├── database/
│   └── migrations/         ← Migration (struktur tabel)
├── resources/
│   └── views/              ← Blade template (tampilan)
├── routes/
│   └── web.php             ← Definisi route/URL
└── .env                    ← Konfigurasi (database, dll)

Sebelum lanjut, buka file .env dan atur koneksi database. Cara paling mudah untuk belajar adalah pakai SQLite karena tidak perlu install server database:

# .env
DB_CONNECTION=sqlite
# hapus atau kosongkan DB_DATABASE, DB_HOST, DB_USERNAME, DB_PASSWORD

Lalu buat file database kosongnya:

touch database/database.sqlite

Dengan begini, environment kamu siap untuk membuat aplikasi pertama.

Apa Itu MVC?

MVC (Model-View-Controller) adalah pola arsitektur yang memisahkan aplikasi menjadi tiga bagian dengan tugas berbeda, dan Laravel dibangun sepenuhnya di atas pola ini. Tujuannya sederhana: memisahkan data, tampilan, dan logika supaya kode gampang dirawat dan dikembangkan.

Tiga komponen MVC:

• Model — Representasi data dan logika bisnis; bagian yang berinteraksi dengan database.
• View — Tampilan yang dilihat user; berupa HTML dan Blade template.
• Controller — Penghubung antara Model dan View; menerima request, mengambil data, lalu mengembalikan response.

Bayangkan alurnya seperti pelayan di restoran. Kamu (user) memesan ke pelayan (controller). Pelayan menyampaikan pesanan ke dapur (model) yang menyiapkan makanan (data). Setelah jadi, pelayan menyajikan makanan di piring (view) ke meja kamu. Kamu tidak perlu tahu isi dapur, dan dapur tidak perlu tahu siapa kamu — masing-masing punya tugas jelas.

User → Request → Controller → Model → Database
                     ↓
                    View → Response → User

Alur sederhananya: user mengakses URL, lalu route mengarahkannya ke controller, controller mengambil data dari model, dan hasilnya ditampilkan lewat view. Pemisahan ini yang bikin aplikasi Laravel tetap rapi meski fiturnya makin banyak.

Lihat Alur MVC Secara Interaktif

Teori memang lebih gampang menempel kalau kamu lihat sendiri alurnya bergerak. Klik Play di bawah untuk melihat bagaimana sebuah request mengalir dari user, masuk ke controller, mampir ke model, sampai kembali jadi response:

Laravel MVC Flow

▶ Play

👤User

→

🛤️Route

→

🎮Controller

→

📦Model

→

🗄️Database

→

🎨View

→

📄Response

Step 1User

User mengakses /posts/1

Setelah paham gambaran besarnya, kita bahas satu per satu komponen yang membentuk alur ini, dimulai dari pintu masuk aplikasi: routing.

Routing

Route adalah pemetaan antara URL dan kode yang dijalankan ketika URL itu diakses. Ketika user membuka /about, Laravel melihat daftar route untuk mencari yang cocok, lalu menjalankan kode yang terkait. Semua route web didefinisikan di file routes/web.php.

Bentuk paling sederhana mengembalikan langsung sebuah view atau teks:

// routes/web.php
Route::get('/', function () {
    return view('welcome');
});

Route::get('/about', function () {
    return 'Halaman About';
});

// Route yang mengarah ke method di controller
Route::get('/catatan', [CatatanController::class, 'index']);
Route::get('/catatan/{catatan}', [CatatanController::class, 'show']);
Route::post('/catatan', [CatatanController::class, 'store']);

Perhatikan Route::get dan Route::post — ini adalah HTTP verb. get untuk menampilkan halaman, post untuk mengirim data (misalnya submit form). Laravel juga punya put, patch, dan delete untuk operasi update dan hapus. Kamu bisa mencoba semua konsep ini langsung lewat materi routing Laravel interaktif.

Route Parameters

Sering kali URL punya bagian yang dinamis, misalnya ID atau slug. Kamu bisa menangkapnya dengan kurung kurawal:

Route::get('/catatan/{id}', function (string $id) {
    return "Menampilkan catatan dengan ID: {$id}";
});

// Parameter opsional dengan tanda tanya dan nilai default
Route::get('/user/{nama?}', function (?string $nama = 'Tamu') {
    return "Halo, {$nama}";
});

Ketika user membuka /catatan/5, nilai 5 otomatis masuk ke variabel $id. Ini fondasi dari halaman detail yang menampilkan satu item spesifik.

Named Routes

Menuliskan URL secara hardcode di banyak tempat itu rapuh — kalau URL berubah, kamu harus mengubahnya di mana-mana. Named route menyelesaikan ini dengan memberi nama pada route:

Route::get('/catatan/{catatan}', [CatatanController::class, 'show'])->name('catatan.show');

Sekarang di kode lain kamu cukup memanggil namanya, dan Laravel yang menyusun URL-nya:

$url = route('catatan.show', ['catatan' => 5]);  // menghasilkan /catatan/5

Resource Routes

Untuk aplikasi CRUD, menulis tujuh route satu per satu itu melelahkan. Laravel menyediakan satu baris ajaib:

Route::resource('catatan', CatatanController::class);

Satu baris ini otomatis membuat tujuh route sekaligus: index (daftar), create (form tambah), store (simpan data baru), show (detail), edit (form edit), update (simpan perubahan), dan destroy (hapus). Inilah pola yang akan kita pakai di mini-project nanti.

Controller

Controller adalah tempat kamu meletakkan logika untuk menangani request. Alih-alih menaruh banyak kode di dalam file route, kamu memindahkannya ke method-method di dalam class controller supaya lebih terorganisir. Setiap method biasanya menangani satu aksi.

Buat controller dengan Artisan:

php artisan make:controller CatatanController --resource

Flag --resource membuat controller dengan tujuh method kosong yang cocok dengan resource route. Isinya kira-kira begini:

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

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

class CatatanController extends Controller
{
    public function index()
    {
        $catatan = Catatan::latest()->paginate(10);
        return view('catatan.index', compact('catatan'));
    }

    public function show(Catatan $catatan)
    {
        return view('catatan.show', compact('catatan'));
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'judul' => 'required|max:255',
            'isi' => 'required',
        ]);

        Catatan::create($validated);

        return redirect('/catatan')->with('success', 'Catatan berhasil dibuat!');
    }
}

Ada satu fitur keren di sini: perhatikan show(Catatan $catatan). Ini disebut Route Model Binding. Karena kamu men-type-hint parameter dengan class Catatan, Laravel otomatis mencari data catatan berdasarkan ID di URL dan menyuntikkannya ke method. Kamu tidak perlu menulis Catatan::find($id) secara manual. Untuk memperdalam bagaimana controller bekerja, ada materi controller Laravel yang membahasnya langkah demi langkah.

Blade Templates

Blade adalah templating engine bawaan Laravel yang dipakai untuk menulis view. Blade memungkinkan kamu menyisipkan data PHP ke dalam HTML dengan sintaks yang bersih, plus punya directive khusus untuk perulangan, kondisi, dan pewarisan layout. File Blade selalu berakhiran .blade.php dan berada di resources/views.

Menampilkan data pakai kurung kurawal ganda, yang otomatis aman dari serangan XSS:

{{-- resources/views/catatan/index.blade.php --}}
@extends('layouts.app')

@section('content')
  <h1>Daftar Catatan</h1>

  @forelse($catatan as $item)
    <article>
      <h2>{{ $item->judul }}</h2>
      <p>{{ Str::limit($item->isi, 150) }}</p>
      <small>{{ $item->created_at->diffForHumans() }}</small>
    </article>
  @empty
    <p>Belum ada catatan.</p>
  @endforelse

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

Beberapa directive yang paling sering dipakai:

• @extends dan @section — untuk mewarisi layout induk sehingga header/footer tidak ditulis berulang.
• @if, @else, @endif — untuk logika kondisi.
• @foreach dan @forelse — untuk perulangan; @forelse punya bonus blok @empty ketika data kosong.
• @csrf — token keamanan yang wajib ada di setiap form.
• @auth dan @guest — untuk menampilkan konten berdasarkan status login.

Karena Blade pada akhirnya menghasilkan HTML, pemahaman HTML kamu tetap terpakai penuh di sini. Kalau ingin latihan menulis directive ini secara langsung, coba materi Blade template interaktif.

Migration

Migration adalah “version control untuk struktur database”. Alih-alih membuat tabel lewat aplikasi database secara manual, kamu mendeskripsikan struktur tabel dalam file PHP, lalu Laravel yang mengeksekusinya. Keuntungannya besar: siapa pun di tim bisa membuat ulang struktur database yang persis sama hanya dengan satu perintah.

Buat migration dengan Artisan (atau ikut terbuat saat membuat model, seperti nanti kita lakukan):

// database/migrations/xxxx_create_catatan_table.php
public function up(): void
{
    Schema::create('catatan', function (Blueprint $table) {
        $table->id();
        $table->string('judul');
        $table->text('isi');
        $table->enum('status', ['draft', 'terbit'])->default('draft');
        $table->timestamps();
    });
}

Setiap baris mendeskripsikan satu kolom: id() membuat primary key auto-increment, string() untuk teks pendek, text() untuk teks panjang, dan timestamps() otomatis membuat kolom created_at dan updated_at. Setelah file siap, jalankan:

php artisan migrate           # jalankan semua migration yang belum dijalankan
php artisan migrate:rollback  # batalkan batch migration terakhir
php artisan migrate:fresh     # hapus semua tabel lalu jalankan ulang dari awal

Konsep migrasi ini dibahas lebih dalam di materi migrasi Laravel, termasuk cara menambah kolom dan mengubah tabel yang sudah ada.

Eloquent ORM

Eloquent adalah cara Laravel berinteraksi dengan database menggunakan object, bukan query SQL mentah. Setiap tabel di database diwakili oleh satu class Model, dan setiap baris data menjadi satu object. Dengan Eloquent, mengambil dan menyimpan data terasa seperti menulis kalimat biasa.

Sebuah model minimal cukup meng-extend Model:

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

use Illuminate\Database\Eloquent\Model;

class Catatan extends Model
{
    protected $table = 'catatan';

    protected $fillable = ['judul', 'isi', 'status'];
}

Properti $fillable menentukan kolom mana yang boleh diisi secara massal lewat create() atau update() — ini pengaman penting supaya user tidak bisa mengisi kolom sembarangan.

Relasi Antar Model

Kekuatan Eloquent paling terasa saat menghubungkan tabel. Misal sebuah catatan dimiliki oleh seorang user dan punya banyak komentar:

class Catatan extends Model
{
    protected $fillable = ['judul', 'isi', 'status', 'user_id'];

    public function user()
    {
        return $this->belongsTo(User::class);
    }

    public function komentar()
    {
        return $this->hasMany(Komentar::class);
    }
}

Dengan relasi ini, kamu bisa menulis $catatan->user->name atau me-loop $catatan->komentar tanpa menulis JOIN sama sekali.

Query yang Ekspresif

Ini contoh operasi yang paling sering kamu pakai sehari-hari:

// Ambil semua data
$semua = Catatan::all();

// Filter dengan kondisi
$terbit = Catatan::where('status', 'terbit')->get();

// Sorting dan batasi jumlah
$terbaru = Catatan::latest()->take(5)->get();

// Eager loading relasi (mencegah query berlebihan)
$dengan = Catatan::with('komentar')->find(1);

// Aggregasi
$jumlah = Catatan::where('status', 'terbit')->count();

// Membuat data baru
Catatan::create([
    'judul' => 'Catatan Pertama',
    'isi' => 'Isi catatan...',
    'status' => 'terbit',
]);

// Update
$catatan = Catatan::find(1);
$catatan->update(['judul' => 'Judul Baru']);

// Hapus
$catatan->delete();

Eloquent membuat query database terasa seperti bahasa sehari-hari. Untuk memperdalamnya, mulai dari materi dasar Eloquent, lalu uji pemahamanmu lewat game Pembisik Eloquent yang menantang kamu menebak query yang tepat untuk sebuah hasil.

Membuat CRUD Sederhana: Aplikasi Catatan

Sekarang kita rangkai semua konsep di atas menjadi satu aplikasi CRUD (Create, Read, Update, Delete) yang benar-benar jalan: aplikasi catatan sederhana. CRUD adalah “hello world”-nya web development karena mencakup semua operasi dasar terhadap data. Ikuti langkah demi langkah, dan di akhir kamu akan punya aplikasi yang bisa menambah, menampilkan, mengubah, dan menghapus catatan.

Langkah 1: Buat Model, Migration, dan Controller Sekaligus

Artisan bisa membuat ketiganya dalam satu perintah:

php artisan make:model Catatan -mcr

Flag -mcr artinya: -m membuat migration, -c membuat controller, dan -r menjadikannya resource controller. Sangat efisien.

Langkah 2: Definisikan Struktur Tabel

Buka file migration yang baru terbuat di database/migrations dan isi method up:

public function up(): void
{
    Schema::create('catatans', function (Blueprint $table) {
        $table->id();
        $table->string('judul');
        $table->text('isi');
        $table->timestamps();
    });
}

Catatan: secara default Laravel memberi nama tabel bentuk jamak dari nama model, jadi model Catatan memetakan ke tabel catatans. Jalankan migration:

php artisan migrate

Langkah 3: Atur Model

Tambahkan $fillable di model supaya kolom bisa diisi massal:

// app/Models/Catatan.php
class Catatan extends Model
{
    protected $fillable = ['judul', 'isi'];
}

Langkah 4: Daftarkan Route

Buka routes/web.php dan tambahkan satu baris resource route:

use App\Http\Controllers\CatatanController;

Route::resource('catatan', CatatanController::class);

Cek hasilnya dengan php artisan route:list — kamu akan lihat tujuh route sudah otomatis terdaftar.

Langkah 5: Isi Controller

Sekarang isi logika di CatatanController. Ini inti dari operasi CRUD:

namespace App\Http\Controllers;

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

class CatatanController extends Controller
{
    // READ — tampilkan semua catatan
    public function index()
    {
        $catatan = Catatan::latest()->get();
        return view('catatan.index', compact('catatan'));
    }

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

    // CREATE — simpan catatan baru
    public function store(Request $request)
    {
        $validated = $request->validate([
            'judul' => 'required|max:255',
            'isi' => 'required',
        ]);

        Catatan::create($validated);

        return redirect()->route('catatan.index')
            ->with('success', 'Catatan berhasil ditambahkan!');
    }

    // READ — tampilkan satu catatan
    public function show(Catatan $catatan)
    {
        return view('catatan.show', compact('catatan'));
    }

    // UPDATE — tampilkan form edit
    public function edit(Catatan $catatan)
    {
        return view('catatan.edit', compact('catatan'));
    }

    // UPDATE — simpan perubahan
    public function update(Request $request, Catatan $catatan)
    {
        $validated = $request->validate([
            'judul' => 'required|max:255',
            'isi' => 'required',
        ]);

        $catatan->update($validated);

        return redirect()->route('catatan.index')
            ->with('success', 'Catatan berhasil diperbarui!');
    }

    // DELETE — hapus catatan
    public function destroy(Catatan $catatan)
    {
        $catatan->delete();

        return redirect()->route('catatan.index')
            ->with('success', 'Catatan berhasil dihapus!');
    }
}

Perhatikan pola berulang di sini: method create, edit hanya menampilkan form, sedangkan store, update memvalidasi lalu menyimpan, dan semuanya diakhiri redirect dengan pesan sukses. Route Model Binding (Catatan $catatan) mengambil alih pekerjaan mencari data dari ID.

Langkah 6: Buat View

Buat folder resources/views/catatan, lalu buat file-file view. Pertama, daftar catatan (index.blade.php):

{{-- resources/views/catatan/index.blade.php --}}
<!DOCTYPE html>
<html lang="id">
<head><meta charset="utf-8"><title>Catatan</title></head>
<body>
  <h1>Daftar Catatan</h1>

  @if(session('success'))
    <p style="color: green">{{ session('success') }}</p>
  @endif

  <a href="{{ route('catatan.create') }}">+ Tambah Catatan</a>

  @forelse($catatan as $item)
    <article>
      <h2><a href="{{ route('catatan.show', $item) }}">{{ $item->judul }}</a></h2>
      <a href="{{ route('catatan.edit', $item) }}">Edit</a>

      <form action="{{ route('catatan.destroy', $item) }}" method="POST" style="display:inline">
        @csrf
        @method('DELETE')
        <button type="submit">Hapus</button>
      </form>
    </article>
  @empty
    <p>Belum ada catatan. Yuk buat yang pertama!</p>
  @endforelse
</body>
</html>

Ada dua hal penting di form hapus. @csrf menyisipkan token keamanan yang wajib ada di setiap form POST. @method('DELETE') adalah trik Laravel: karena browser HTML hanya mendukung GET dan POST, directive ini memberi tahu Laravel untuk memperlakukan request seolah-olah bermetode DELETE.

Berikutnya, form tambah (create.blade.php):

{{-- resources/views/catatan/create.blade.php --}}
<!DOCTYPE html>
<html lang="id">
<head><meta charset="utf-8"><title>Tambah Catatan</title></head>
<body>
  <h1>Tambah Catatan</h1>

  @if($errors->any())
    <ul style="color: red">
      @foreach($errors->all() as $error)
        <li>{{ $error }}</li>
      @endforeach
    </ul>
  @endif

  <form action="{{ route('catatan.store') }}" method="POST">
    @csrf
    <p><input type="text" name="judul" placeholder="Judul" value="{{ old('judul') }}"></p>
    <p><textarea name="isi" placeholder="Isi catatan">{{ old('isi') }}</textarea></p>
    <button type="submit">Simpan</button>
  </form>
</body>
</html>

Fungsi old('judul') mengembalikan nilai yang tadi diisi user kalau validasi gagal, jadi form tidak kosong setelah error. Form edit (edit.blade.php) mirip, hanya perlu menambah @method('PUT') dan mengisi value dari data yang ada:

{{-- resources/views/catatan/edit.blade.php --}}
<form action="{{ route('catatan.update', $catatan) }}" method="POST">
  @csrf
  @method('PUT')
  <p><input type="text" name="judul" value="{{ old('judul', $catatan->judul) }}"></p>
  <p><textarea name="isi">{{ old('isi', $catatan->isi) }}</textarea></p>
  <button type="submit">Perbarui</button>
</form>

Dengan enam langkah ini, aplikasi CRUD kamu sudah lengkap: buka http://localhost:8000/catatan, dan kamu bisa menambah, melihat, mengedit, serta menghapus catatan. Selamat — kamu baru saja membangun aplikasi Laravel pertamamu dari nol.

Middleware

Middleware adalah lapisan yang menyaring HTTP request sebelum sampai ke controller. Bayangkan seperti satpam di pintu masuk: request harus lolos pemeriksaan dulu sebelum boleh masuk. Kegunaan paling umum adalah membatasi halaman hanya untuk user yang sudah login.

// hanya user login yang bisa akses route ini
Route::middleware('auth')->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index']);
    Route::resource('catatan', CatatanController::class);
});

Middleware auth bawaan Laravel akan mengecek apakah user sudah login. Kalau belum, Laravel otomatis mengalihkannya ke halaman login. Kamu juga bisa membuat middleware sendiri, misalnya untuk mengecek peran (role) atau membatasi akses berdasarkan waktu.

Validation

Validation memastikan data yang masuk sesuai aturan sebelum disimpan ke database. Laravel punya sistem validasi bawaan yang ringkas: cukup mendeskripsikan aturan, dan kalau gagal, Laravel otomatis mengembalikan user ke halaman sebelumnya lengkap dengan pesan error.

$validated = $request->validate([
    'judul' => 'required|string|max:255',
    'email' => 'required|email|unique:users',
    'isi' => 'required|min:10',
    'gambar' => 'nullable|image|max:2048',
]);

Beberapa aturan yang sering dipakai: required (wajib diisi), max dan min (panjang), email (format email valid), unique:users (belum ada di tabel users), dan image (harus file gambar). Kamu bisa menggabung beberapa aturan dengan tanda |. Kalau semua lolos, $validated berisi data yang sudah bersih dan siap disimpan. Materi lengkapnya ada di pelajaran validasi Laravel.

Artisan CLI

Artisan adalah command-line tool bawaan Laravel yang mempercepat hampir semua pekerjaan repetitif. Daripada membuat file secara manual, kamu tinggal mengetik satu perintah. Ini beberapa yang paling berguna sehari-hari:

php artisan make:model Catatan -mcr    # model + migration + controller resource
php artisan make:middleware CekPeran   # buat middleware baru
php artisan migrate                    # jalankan migration
php artisan route:list                 # lihat semua route yang terdaftar
php artisan tinker                     # REPL interaktif dengan konteks Laravel
php artisan db:seed                    # jalankan seeder untuk isi data awal

Perintah php artisan tinker sangat berguna untuk pemula: ia membuka shell interaktif di mana kamu bisa mencoba query Eloquent langsung, misalnya mengetik Catatan::count() dan langsung lihat hasilnya tanpa membuat route.

Kesalahan Umum Pemula Laravel

Banyak pemula tersandung di masalah yang sama. Mengenalinya lebih awal akan menghemat berjam-jam frustrasi. Berikut kesalahan yang paling sering terjadi beserta solusinya.

1. Lupa @csrf di form. Kalau kamu submit form POST tanpa @csrf, Laravel menolaknya dengan error 419 Page Expired. Solusinya selalu tambahkan @csrf di dalam setiap tag form.

2. Mass assignment error. Ketika kamu memanggil Catatan::create() tapi lupa mengisi $fillable di model, Laravel akan menolak dengan error MassAssignmentException. Selalu daftarkan kolom yang boleh diisi di properti $fillable.

3. Lupa menjalankan migration. Error no such table atau Base table not found hampir selalu berarti kamu belum menjalankan php artisan migrate. Jalankan dulu sebelum mengakses data.

4. Salah paham GET vs POST. Menampilkan halaman pakai GET, mengirim data pakai POST. Untuk update dan hapus, gunakan @method('PUT') atau @method('DELETE') di dalam form karena browser tidak mendukungnya secara native.

5. Menaruh semua logika di route. Godaan menulis semua kode di web.php itu besar, tapi cepat berantakan. Pindahkan logika ke controller sejak awal supaya kode tetap terstruktur.

6. N+1 query problem. Kalau kamu me-loop data lalu mengakses relasinya (misalnya $item->user->name) tanpa eager loading, Laravel menembak database berkali-kali. Gunakan with() seperti Catatan::with('user')->get() untuk memuat relasi sekaligus.

7. Mengabaikan pesan error. Laravel punya halaman error yang sangat informatif. Baca baris pertamanya — sering kali jawaban sudah ada di sana, lengkap dengan file dan nomor baris yang bermasalah.

FAQ Belajar Laravel

Apakah harus jago PHP dulu sebelum belajar Laravel?

Tidak harus jago, tapi kamu wajib paham dasarnya, terutama OOP (class, object, inheritance) karena seluruh Laravel dibangun di atas konsep ini. Kalau kamu memaksa belajar Laravel tanpa dasar PHP, banyak kode akan terasa seperti sihir yang tidak kamu mengerti. Luangkan waktu memantapkan PHP dasar dan OOP dulu, baru masuk Laravel.

Berapa lama waktu untuk bisa Laravel?

Kalau kamu sudah menguasai PHP dan OOP, konsep inti Laravel (routing, controller, Blade, Eloquent, migration) bisa kamu pahami dalam beberapa minggu belajar konsisten. Untuk benar-benar nyaman membangun aplikasi CRUD sendiri tanpa banyak menyontek, umumnya butuh satu sampai tiga bulan latihan rutin, tergantung intensitas dan seberapa banyak kamu praktik langsung.

Laravel untuk backend atau frontend?

Laravel adalah framework backend — ia mengurus logika server, database, dan routing. Namun dengan Blade, Laravel juga bisa merender tampilan HTML, jadi ia bisa membangun aplikasi web utuh sendirian. Untuk interaktivitas di sisi browser, kamu biasanya tetap butuh JavaScript; kalau ingin memahami peran JS di web, baca apa itu JavaScript. Banyak proyek modern juga memasangkan Laravel sebagai API dengan frontend terpisah seperti React.

Pakai database apa untuk belajar Laravel?

Untuk belajar, SQLite adalah pilihan paling praktis karena tidak perlu menginstal server database — cukup satu file. Untuk proyek yang lebih serius atau produksi, MySQL dan PostgreSQL adalah pilihan umum. Yang bagus dari Laravel, kamu bisa berpindah antar database hanya dengan mengubah konfigurasi di file .env tanpa menulis ulang kode Eloquent.

Apa bedanya Laravel dengan PHP biasa?

PHP biasa (native) berarti kamu menulis semuanya dari nol: koneksi database, routing, validasi, keamanan. Laravel menyediakan semua itu secara terstruktur sehingga kamu jauh lebih cepat dan kode lebih aman secara default. Analoginya, PHP native seperti memasak dari bahan mentah, sedangkan Laravel seperti dapur lengkap dengan peralatan siap pakai — hasil akhirnya sama-sama masakan, tapi prosesnya jauh lebih efisien dengan Laravel.

Apakah Laravel masih relevan dan banyak dicari?

Ya. Laravel tetap menjadi framework PHP paling banyak dipakai dan permintaan developer Laravel masih tinggi, terutama untuk aplikasi bisnis, sistem internal, dan startup. Karena PHP menjalankan sebagian besar web di dunia, keahlian Laravel adalah aset yang solid untuk karier web development.

Langkah Selanjutnya

Setelah menguasai dasar Laravel dan berhasil membuat CRUD pertama, ini arah pengembangan yang masuk akal:

1. Authentication — pasang Laravel Breeze untuk sistem login/register instan.
2. Relasi lanjutan — pelajari relasi one-to-many dan many-to-many untuk data yang saling terkait.
3. API Development — bangun API dengan API Resources dan autentikasi token Sanctum.
4. Queue & Jobs — jalankan tugas berat (kirim email, proses gambar) di background.
5. Testing — tulis test otomatis supaya kamu berani mengubah kode tanpa takut merusak fitur lama.
6. Deployment — belajar men-deploy ke VPS atau layanan seperti Laravel Forge.

Kunci belajar Laravel bukan menghafal semua fitur, tapi membangun sesuatu. Mulai dari yang sederhana — ulangi membuat CRUD dengan tema berbeda (todo list, katalog produk, blog), pahami alurnya sampai lancar, lalu perlahan tambah fitur yang lebih kompleks. Semua konsep di panduan ini bisa kamu latih secara interaktif lewat materi-materi Laravel di Hyper Sheets, dan setiap kali kamu berhasil menyelesaikan satu fitur, kamu akan makin percaya diri. Selamat ngoding!