> For the complete documentation index, see [llms.txt](https://learn.devlabss.my.id/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://learn.devlabss.my.id/laravel/bab-4-controller/4.1-peran-and-fungsi-controller.md).

# 4.1 Peran & Fungsi Controller

## Peran dan fungsi controller

Pada bab sebelumnya, Anda menulis route langsung di `routes/web.php`.

Pola itu masih aman untuk latihan kecil.

Namun, saat aplikasi mulai bertambah besar, file route akan cepat penuh.

Contohnya seperti ini:

```php
Route::get('/beranda', function () {
    return view('beranda');
});
```

Kode itu sederhana.

Masalahnya muncul saat route mulai menangani banyak logika.

Misalnya:

* mengambil data dari database
* memproses input pengguna
* menghitung atau memfilter data
* mengirim data ke view

Di titik itulah controller dibutuhkan.

Controller membantu memisahkan logika aplikasi dari file route.

Dengan begitu, kode jadi lebih rapi, mudah dibaca, dan mudah dikembangkan.

### Target belajar BAB 4

Setelah menyelesaikan BAB 4, Anda diharapkan bisa:

* menjelaskan fungsi controller
* membuat controller dengan Artisan
* menghubungkan route ke method controller
* mengenali pola resource controller
* memindahkan logika sederhana dari route ke controller

### Apa itu controller

Controller adalah class PHP yang menangani request dari route.

Controller biasanya bertugas untuk:

1. Menerima kiriman data atau request dari URL (via Route).
2. Memproses logika aplikasi.
3. Mengirim hasilnya ke view.

Dalam pola MVC:

* **Route** menerima URL
* **Controller** menangani logika
* **View** menampilkan hasil

Kalau disederhanakan:

```
URL -> Route -> Controller -> View -> Browser
```

### Kenapa controller penting

Tanpa controller, file `web.php` bisa cepat berantakan.

Semakin banyak halaman, semakin sulit membaca isi route satu per satu.

Dengan controller, setiap tugas punya tempat yang jelas:

* route tetap singkat
* logika dikumpulkan di satu lokasi
* view fokus pada tampilan

{% hint style="info" %}
Controller belum selalu berisi kode yang rumit. Bahkan saat isinya hanya `return view(...)`, pola ini tetap penting karena membangun struktur yang benar sejak awal.
{% endhint %}

### Membuat controller pertama

Sekarang Anda akan memindahkan route `/beranda` ke controller.

Gunakan urutan ini agar lebih mudah.

{% stepper %}
{% step %}

### Buka terminal proyek

Buka proyek `e-library` di VS Code.

Buka terminal bawaan VS Code.

Pastikan posisi terminal sudah berada di folder proyek Laravel Anda.
{% endstep %}

{% step %}

### Jalankan perintah Artisan

Ketik perintah berikut:

```bash
php artisan make:controller UtamaController
```

Jika berhasil, Laravel akan membuat file controller baru secara otomatis.
{% endstep %}

{% step %}

### Periksa file hasilnya

Buka folder berikut:

```
app/Http/Controllers
```

Di sana Anda akan menemukan file `UtamaController.php`.
{% endstep %}

{% step %}

### Tambahkan method di dalam controller

Buka file `UtamaController.php`.

Lalu ubah isinya menjadi seperti ini:

```php
<?php

namespace App\Http\Controllers;

class UtamaController extends Controller
{
    public function bukaBeranda()
    {
        return view('beranda');
    }
}
```

Method `bukaBeranda()` bertugas menampilkan view `beranda`.
{% endstep %}

{% step %}

### Hubungkan route ke controller

Buka file `routes/web.php`.

Tambahkan import controller di bagian atas:

```php
use App\Http\Controllers\UtamaController;
```

Lalu ubah route `/beranda` menjadi:

```php
Route::get('/beranda', [UtamaController::class, 'bukaBeranda']);
```

Simpan perubahan file tersebut.
{% endstep %}
{% endstepper %}

### Penjelasan kode route baru

Penulisan berikut adalah format dasar route ke controller:

```php
Route::get('/beranda', [UtamaController::class, 'bukaBeranda']);
```

Artinya:

* `UtamaController::class` menunjuk class yang dipakai
* `'bukaBeranda'` menunjuk method yang dijalankan

Saat URL `/beranda` dibuka, alurnya menjadi seperti ini:

```
Browser -> Route /beranda -> UtamaController -> method bukaBeranda() -> view('beranda') -> Browser
```

Ini lebih rapi daripada menaruh semuanya langsung di route.

### Jalankan dan uji hasilnya

Sebelum menguji, pastikan server Laravel sedang berjalan.

Gunakan salah satu cara berikut:

* jalankan **Laragon** lalu klik **Start All**
* atau jalankan `php artisan serve` dari folder proyek

Lalu buka:

* `http://e-library.test/beranda`
* atau `http://127.0.0.1:8000/beranda`

Jika berhasil, halaman beranda tetap tampil seperti sebelumnya.

Bedanya, sekarang route sudah lebih bersih karena logikanya dipindahkan ke controller.

### Troubleshooting yang paling sering

Masalah yang paling sering muncul:

* **`Target class [UtamaController] does not exist.`** — import `use App\Http\Controllers\UtamaController;` belum ditulis atau salah
* **`Class "App\Http\Controllers\Controller" not found`** — struktur file controller berubah atau file dasar controller bermasalah
* **halaman `/beranda` error setelah dipindahkan** — nama method di route tidak sama dengan nama method di controller
* **perubahan tidak terbaca** — file belum disimpan

{% hint style="warning" %}
Jika nama method di route adalah `'bukaBeranda'`, maka di dalam controller juga harus ada `public function bukaBeranda()`. Nama ini harus sama persis.
{% endhint %}

### Output yang harus terlihat

Setelah menyelesaikan BAB 4, hasil minimal yang seharusnya sudah ada:

* file controller baru berhasil dibuat
* route memanggil controller dengan benar
* halaman tetap tampil setelah logika dipindahkan
* Anda bisa membaca struktur method dasar di controller

### Poin evaluasi bab 4.1

Pastikan Anda sudah memahami poin berikut:

* Saya paham controller dipakai untuk memisahkan logika dari file route.
* Saya tahu perintah `php artisan make:controller NamaController`.
* Saya tahu lokasi file controller ada di `app/Http/Controllers`.
* Saya paham format route ke controller adalah `[NamaController::class, 'namaMethod']`.
* Saya tahu pentingnya menulis `use App\Http\Controllers\NamaController;`.
* Saya bisa menguji hasilnya lewat URL `/beranda`.

Jika semuanya sudah jelas, lanjut ke [4.2 Membuat Controller via Artisan](/laravel/bab-4-controller/4.2-membuat-controller-via-artisan.md).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://learn.devlabss.my.id/laravel/bab-4-controller/4.1-peran-and-fungsi-controller.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.