> 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-6-fitur-read/6.4-penjelasan-aliran-variabel-ke-view.md).

# 6.4 Penjelasan Aliran Variabel ke View

## Penjelasan aliran variabel ke view

Anak RPL, di subbab ini kita tidak menambah fitur baru.

Fokus kita adalah memahami **jalur data**.

Bagian ini penting sekali.

Karena banyak siswa bisa menyalin kode, tetapi belum benar-benar paham data bergerak ke mana.

Kalau alur ini sudah dipahami, bab create, update, delete, dan relasi nanti akan terasa jauh lebih ringan.

### Teori awal dan analogi

Bayangkan Anda memesan buku lewat petugas perpustakaan.

Alurnya bukan:

* siswa langsung masuk ke gudang
* lalu mengambil buku sendiri

Alurnya lebih rapi:

1. siswa meminta buku
2. petugas menerima permintaan
3. petugas mengecek rak
4. petugas membawa data buku
5. petugas menyerahkan ke meja informasi
6. siswa melihat hasilnya

Di Laravel:

* browser = siswa yang meminta
* route = pintu masuk permintaan
* controller = petugas yang menerima permintaan
* model = penghubung ke rak data
* view = meja informasi
* browser = tempat hasil akhirnya terlihat

### Alur dasarnya

Saat halaman daftar buku dibuka, kira-kira inilah yang terjadi:

1. browser membuka URL `/buku`
2. route memanggil `BukuController@index`
3. controller menjalankan query lewat model `Buku`
4. hasil query disimpan ke `$bukus`
5. controller mengirim `$bukus` ke view
6. Blade membaca `$bukus` lalu menampilkannya

Kalau dibuat lebih visual:

```
Browser
   ↓
Route
   ↓
Controller
   ↓
Model
   ↓
Database
   ↑
Model
   ↑
Controller
   ↓
View Blade
   ↓
Browser
```

### Langkah praktik step-by-step

Walau ini bab penjelasan, Anda tetap perlu melihat file yang sudah dibuat.

{% stepper %}
{% step %}

### Buka controller

Buka file:

`app/Http/Controllers/BukuController.php`

Fokus pada method `index()`.
{% endstep %}

{% step %}

### Buka view

Buka file:

`resources/views/buku/index.blade.php`

Perhatikan bagian `@forelse ($bukus as $buku)`.
{% endstep %}

{% step %}

### Cocokkan nama variabel

Pastikan nama variabel yang dikirim dari controller adalah `$bukus`.

Pastikan view juga membaca `$bukus`.
{% endstep %}

{% step %}

### Uji lagi di browser

Sebelum membuka browser, pastikan server masih hidup.

* jika memakai **Laragon**, cek **Start All**
* jika memakai terminal, cek `php artisan serve` masih berjalan

Lalu buka kembali halaman `/buku`.
{% endstep %}
{% endstepper %}

### Contoh controller yang lengkap

```php
public function index()
{
    $bukus = Buku::all();

    return view('buku.index', compact('bukus'));
}
```

### Apa fungsi `compact('bukus')`

`compact('bukus')` adalah cara singkat untuk mengirim variabel ke view.

Hasilnya setara dengan:

```php
return view('buku.index', [
    'bukus' => $bukus
]);
```

Artinya, view `buku.index` akan menerima variabel bernama `$bukus`.

### Penjelasan pasca-praktik

Sekarang kita bedah alur ini satu per satu.

#### 1. Request masuk dari browser

Saat siswa membuka `/buku`, browser mengirim request ke Laravel.

Laravel lalu mencocokkan URL itu dengan route.

#### 2. Route memanggil controller

Kalau route cocok, Laravel menjalankan method `index()` pada `BukuController`.

Di titik ini, controller mulai bekerja.

#### 3. Controller memanggil model

Di dalam method `index()`, ada baris:

```php
$bukus = Buku::all();
```

Baris ini meminta model `Buku` untuk mengambil semua data.

#### 4. Model membaca database

Model `Buku` tahu bahwa ia terhubung ke tabel `buku`.

Karena itu, query diarahkan ke tabel tersebut.

Hasilnya bukan satu data.

Hasilnya kumpulan data buku.

#### 5. Controller mengirim data ke view

Setelah data didapat, controller tidak menampilkan data itu sendiri.

Controller mengirim data itu ke Blade:

```php
return view('buku.index', compact('bukus'));
```

Di sinilah perpindahan data terjadi dari controller ke view.

#### 6. Blade membaca data

Di file Blade, `$bukus` diulang satu per satu:

```blade
@forelse ($bukus as $buku)
```

Maka setiap item bisa dipanggil seperti:

```blade
{{ $buku->judul }}
```

### Kenapa nama variabel harus konsisten

Bagian ini sering sekali menjadi sumber error kecil.

Jika controller mengirim `bukus`, maka view harus membaca `$bukus`.

Kalau view menulis `$dataBuku`, maka Blade tidak akan menemukannya.

Jika tidak cocok, error bisa muncul.

Contoh yang salah:

```php
return view('buku.index', compact('bukus'));
```

tetapi di Blade Anda menulis:

```blade
@foreach ($dataBuku as $buku)
```

Itu akan gagal karena `$dataBuku` tidak pernah dikirim.

### Bentuk data yang diterima Blade

Hasil `Buku::all()` adalah kumpulan object.

Karena itu, tiap item biasanya diakses seperti ini:

```blade
{{ $buku->judul }}
{{ $buku->penulis }}
```

Bukan seperti array biasa:

```blade
{{ $buku['judul'] }}
```

Untuk modul ini, bentuk object lebih mudah diikuti.

### Cara berpikir yang paling aman saat debugging

Kalau suatu saat data tidak tampil, pakai urutan pikir seperti ini:

1. apakah route memanggil controller yang benar
2. apakah controller mengambil data yang benar
3. apakah controller mengirim variabel ke view
4. apakah Blade memakai nama variabel yang sama
5. apakah nama field sesuai dengan kolom database

Jika urutan ini dipakai, sumber error lebih cepat ditemukan.

### Troubleshooting yang paling sering

Masalah yang paling sering muncul:

* **`Undefined variable`** — nama variabel di Blade tidak cocok
* **halaman tampil tetapi tabel kosong** — query berhasil, tetapi data memang belum ada
* **`Attempt to read property on null`** — object yang diakses tidak berisi data yang diharapkan

{% hint style="info" %}
Saat bingung, cek dulu nama variabelnya. Masalah paling sering ada di sana.
{% endhint %}

{% hint style="warning" %}
Jangan menulis nama variabel sembarangan. Variabel yang dikirim controller dan yang dibaca view harus sama persis.
{% endhint %}

### Poin evaluasi bab 6.4

Pastikan Anda sudah memahami poin berikut:

* Saya paham alur data dari route sampai browser.
* Saya paham controller mengambil data lalu mengirimnya ke view.
* Saya paham fungsi `compact('bukus')`.
* Saya tahu nama variabel di controller dan Blade harus sama.
* Saya tahu field seperti `judul` diakses lewat `$buku->judul`.
* Saya punya urutan pengecekan saat data tidak tampil.

Jika semuanya sudah jelas, lanjut ke [6.5 Membuat Nomor Otomatis dengan Blade](/laravel/bab-6-fitur-read/6.5-membuat-nomor-otomatis-dengan-blade.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-6-fitur-read/6.4-penjelasan-aliran-variabel-ke-view.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.