BAB 5: ARRAY

5-6: Array Destructuring

Objectives

Menggunakan list() dan short list syntax
Destructuring associative arrays
Destructuring bersarang (nested)
Rest operator dalam array
Destructuring di dalam foreach

Apa itu Destructuring?

Destructuring adalah cara membongkar array menjadi beberapa variabel sekaligus dalam satu baris. Alih-alih menulis tiga baris assignment, kamu tulis satu baris yang langsung "menangkap" elemen-elemen array ke variabel terpisah.

php
<?php

$colors = ["red", "green", "blue"];

// Tanpa destructuring: tiga baris
$first = $colors[0];
$second = $colors[1];
$third = $colors[2];

// Dengan destructuring: satu baris
[$first, $second, $third] = $colors;

echo "$first, $second, $third";  // Output: red, green, blue

?>

php
$colors = ["red", "green", "blue"];

[$first, $second, $third] = $colors;

Variabel	Nilai
`$first`	`"red"`
`$second`	`"green"`
`$third`	`"blue"`

Bayangkan seperti membongkar kardus berisi tiga botol: kamu tidak mengambil botol satu per satu — kamu langsung mengeluarkan ketiganya sekaligus dan menaruhnya di tiga rak berbeda.

💡Tip

Destructuring tidak mengubah array aslinya. $colors tetap utuh setelah di-destructure — ini operasi "salin", bukan "pindah".

Basic Destructuring

Ada dua sintaks: list() (sejak PHP 4) dan short list [] (sejak PHP 7.1). Keduanya identik, tapi [] lebih pendek dan lebih umum di kode modern.

php
<?php

// Traditional list()
$colors = ["red", "green", "blue"];
list($first, $second, $third) = $colors;
echo "$first, $second, $third";  // Output: red, green, blue

// Short list (PHP 7.1+)
[$first, $second, $third] = $colors;
echo "$first, $second, $third";  // Output: red, green, blue

// Skip elements — pakai koma kosong
[$a, , $c] = [1, 2, 3];
echo "$a, $c";  // Output: 1, 3

// Assign last element — variabel ketiga menangkap index 2
[$a, $b, $c] = [1, 2, 3, 4, 5];
echo "$c";  // Output: 3
// Elemen 4 dan 5 diabaikan

?>

⚠️Perhatian

Saat jumlah variabel lebih sedikit dari elemen array, elemen sisanya diabaikan — tidak error. Tapi saat variabel lebih banyak dari elemen (misal [$a, $b, $c] = [1, 2]), PHP melempar warning "Undefined array key 2" dan $c bernilai null.

Jumlah Variabel Tidak Harus Sama

php
<?php

$point = [10, 20];

// Ambil keduanya
[$x, $y] = $point;
echo "($x, $y)";  // Output: (10, 20)

// Ambil hanya satu
[$x] = $point;
echo $x;  // Output: 10

// Ambil dua dari array yang lebih panjang
$data = [100, 200, 300, 400];
[$first, $second] = $data;
echo "$first, $second";  // Output: 100, 200

?>

Destructuring Associative Arrays

Untuk associative array, destructuring memakai key-nya. Ini sangat berguna untuk "mengekstrak" field tertentu dari data user, config, atau response API.

php
<?php

$user = [
    "name" => "Andi",
    "email" => "andi@example.com",
    "age" => 25
];

// With keys
["name" => $name, "email" => $email] = $user;
echo "$name, $email";  // Output: Andi, andi@example.com

// Using list() — sama saja
list("name" => $name, "age" => $age) = $user;
echo "$name, $age";  // Output: Andi, 25

// Tidak semua key harus diambil
["email" => $email] = $user;
echo $email;  // Output: andi@example.com

?>

Keunggulan destructuring associative: urutan tidak penting. Kamu bisa menulis ["email" => $e, "name" => $n] — PHP mencocokkan berdasarkan key, bukan posisi. Ini berbeda dari destructuring indexed yang bergantung pada urutan.

php
<?php

$response = [
    "status" => "success",
    "data" => ["id" => 7, "title" => "Belajar PHP"],
    "meta" => ["total" => 1]
];

// Ekstrak status dan data sekaligus
["status" => $status, "data" => $data] = $response;
echo $status;   // Output: success
echo $data["title"];  // Output: Belajar PHP

?>

💡Tip

Pola ini sangat umum di kode produksi: function API mengembalikan array besar, lalu pemanggilnya langsung mengekstrak field yang dibutuhkan dengan destructuring. Kode jadi satu baris, tanpa menulis $result["status"] berulang-ulang.

Nested Destructuring

Destructuring juga bisa menembus array bersarang — tinggal tulis struktur kurung siku yang meniru bentuk array aslinya.

php
<?php

$matrix = [
    [1, 2],
    [3, 4]
];

// Destructure baris pertama
[$firstRow] = $matrix;
print_r($firstRow);
// Output:
// Array
// (
//     [0] => 1
//     [1] => 2
// )

// Destructure sampai level sel
[[$a, $b], [$c, $d]] = $matrix;
echo "$a, $b, $c, $d";  // Output: 1, 2, 3, 4

// Nested associative
$user = [
    "name" => "Andi",
    "address" => ["city" => "Jakarta", "zip" => "10230"]
];

["name" => $name, "address" => ["city" => $city]] = $user;
echo "$name tinggal di $city";  // Output: Andi tinggal di Jakarta

?>

Baca [["city" => $city]] sebagai "di dalam key address (yang berupa array), ambil nilai dari key city". Struktur kurung siku di kiri persis meniru struktur array di kanan.

Swap Variables

Salah satu kegunaan destructuring yang paling disukai: menukar dua variabel tanpa variabel sementara.

php
<?php

$a = 1;
$b = 2;

[$a, $b] = [$b, $a];

echo "$a, $b";  // Output: 2, 1

?>

Tanpa destructuring, pertukaran butuh tiga baris dan variabel $temp:

php
<?php

$a = 1;
$b = 2;

// Cara lama: butuh variabel penampung
$temp = $a;
$a = $b;
$b = $temp;

echo "$a, $b";  // Output: 2, 1

?>

💡Tip

Di sisi kanan [$a, $b] = [$b, $a], PHP membuat array baru [$b, $a] sebelum assignment dimulai. Jadi nilai lama $a dan $b sudah tersimpan aman saat ditukar. Trik ini juga bekerja untuk tiga variabel: [$a, $b, $c] = [$b, $c, $a].

Menangkap Sisa Elemen (Rest)

⚠️Perhatian

Penting: Berbeda dengan JavaScript, PHP tidak mendukung spread/rest operator (...) di dalam destructuring assignment. [$first, ...$rest] = $arr; akan menghasilkan fatal error: "Spread operator is not supported in assignments". Untuk menangkap sisa elemen, gunakan array_slice() atau array_splice().

php
<?php

$numbers = [1, 2, 3, 4, 5];

// Destructure dua elemen pertama
[$first, $second] = $numbers;

echo $first;   // Output: 1
echo $second;  // Output: 2

// Sisa elemen: ambil mulai dari index 2
$rest = array_slice($numbers, 2);

print_r($rest);
// Output:
// Array
// (
//     [0] => 3
//     [1] => 4
//     [2] => 5
// )

// Kombinasi: destructuring + slice untuk "head dan tail"
[$head, $second] = $numbers;
$tail = array_slice($numbers, 2);
echo $head;   // Output: 1
print_r($tail);
// Output:
// Array
// (
//     [0] => 3
//     [1] => 4
//     [2] => 5
// )

?>

Alternatif: array_shift untuk pop dari depan

php
<?php

$numbers = [1, 2, 3, 4, 5];

// Ambil elemen pertama (mengeluarkannya dari array)
$first = array_shift($numbers);
echo $first;   // Output: 1

// Sekarang $numbers berisi [2, 3, 4, 5] — sisanya!
print_r($numbers);

?>

Menangkap Sisa Key-Value dari Associative Array

php
<?php

$config = [
    "host" => "localhost",
    "port" => 3306,
    "user" => "root",
    "pass" => "secret"
];

// Ambil dua key utama
$host = $config["host"];
$port = $config["port"];

// Hapus dari array, sisanya otomatis jadi "rest"
unset($config["host"], $config["port"]);

echo "$host:$port";  // Output: localhost:3306
print_r($config);
// Output:
// Array
// (
//     [user] => root
//     [pass] => secret
// )

// Atau lebih ringkas dengan array_diff_key:
$picked = ["host" => $config["host"], "port" => $config["port"]];
$rest = array_diff_key($config, $picked);

print_r($rest);
// Output:
// Array
// (
//     [user] => root
//     [pass] => secret
// )

?>

💡Tip

Ingat pola ini: destructuring untuk mengambil elemen tertentu + array_slice()/unset() untuk sisanya. Ini adalah cara idiomatic PHP menggantikan rest operator yang tidak didukung.

Destructuring dalam foreach

Ini mungkin penggunaan destructuring yang paling sering di dunia nyata: di dalam foreach, setiap iterasi langsung membongkar elemen array-nya.

php
<?php

// Data dari database: array of associative arrays
$users = [
    ["name" => "Andi", "email" => "andi@mail.com"],
    ["name" => "Budi", "email" => "budi@mail.com"],
    ["name" => "Citra", "email" => "citra@mail.com"]
];

// Tanpa destructuring
foreach ($users as $user) {
    echo "{$user['name']} <{$user['email']}>\n";
}

// Dengan destructuring — lebih jelas dan pendek
foreach ($users as ["name" => $name, "email" => $email]) {
    echo "$name <$email>\n";
}
// Output:
// Andi <andi@mail.com>
// Budi <budi@mail.com>
// Citra <citra@mail.com>

// Destructuring indexed array di dalam foreach
$points = [[3, 4], [10, 12], [7, 24]];
foreach ($points as [$x, $y]) {
    echo "($x, $y)\n";
}
// Output:
// (3, 4)
// (10, 12)
// (7, 24)

?>

💡Tip

foreach ($rows as [$a, $b]) atau foreach ($rows as ["key" => $value]) membuat loop data terlihat sangat bersih — variabel langsung tersedia tanpa menulis $row[...] berkali-kali. Ini gaya yang sangat disukai di kode PHP modern.

Common Mistakes

Mistake	Contoh Salah	Kenapa Salah	Solusi
Variabel lebih banyak dari elemen	`[$a, $b, $c] = [1, 2]`	Warning "Undefined array key 2"	Pastikan jumlah variabel <= elemen, atau beri default
Lupa urutan pada indexed array	`[$b, $a] = $arr` padahal mau `$a` dulu	Destructuring indexed berbasis posisi	Tulis variabel sesuai urutan elemen
Rest operator bukan di akhir	`[...$rest, $last] = $arr`	Syntax error	Taruh `...$rest` di posisi terakhir
Mengira destructuring menghapus array	`[$a, $b] = $arr` lalu `$arr` kosong	Array asli tidak berubah	Pahami bahwa ini operasi salin
Cek `array_search` hasil destructuring dengan `==`	`if ($idx == false)`	Index 0 dianggap false	Gunakan `!== false`

Exercise

Destructuring untuk get first dan last element dari array [10, 20, 30, 40]
Swap dua variable tanpa temporary variable
Parse HTTP request dengan array destructuring: ["method" => $method, "path" => $path, "query" => $query]
Gunakan destructuring nested untuk mengambil city dari array user yang punya key address
Tulis foreach dengan destructuring untuk menampilkan daftar [nama, harga] dari array products
Gunakan rest operator untuk memisahkan elemen pertama dari sisa array, lalu tampilkan keduanya

Summary

Konsep	Penjelasan
Destructuring	Membongkar array menjadi variabel sekaligus dalam satu baris
`list($a, $b) = $arr`	Sintaks lama (PHP 4+)
`[$a, $b] = $arr`	Short list syntax (PHP 7.1+), lebih disukai
Skip elemen	Pakai koma kosong: `[$a, , $c] = $arr`
Destructuring associative	Pakai key: `["name" => $name] = $arr`; urutan tidak penting
Nested destructuring	Kurung siku bersarang meniru bentuk array
Swap	`[$a, $b] = [$b, $a]` tanpa variabel sementara
Rest operator	`[...$rest]` menangkap sisa elemen; wajib di posisi terakhir
Destructuring di foreach	`foreach ($rows as [$a, $b])` — pola paling umum di kode produksi
Perilaku	Tidak mengubah array asli; kelebihan elemen diabaikan; kekurangan elemen = warning

Klik tombol ini setelah menyelesaikan materi

📝

Quiz Bab 5

Uji pemahamanmu tentang Array

▶️ Mulai Quiz