BAB 5: ARRAY

5-2: Array Indexing

Objectives

Menambah dan mengubah element array
Menghapus element dengan unset()
Memahami re-indexing dan kenapa array tidak re-index otomatis
Mengenal array_pop(), array_shift(), dan array_splice()
Menghindari common mistakes saat memanipulasi index

Konsep Index

Index adalah posisi elemen di dalam array. Yang membedakan PHP dari banyak bahasa lain: PHP menyimpan index sebagai bagian dari array, jadi index tidak harus berurutan — bisa ada lubang (gap) di tengahnya.

Contoh: $colors = ["Red", "Green", "Blue"] secara visual:

Index	Value
Index [0]	"Red"
Index [1]	"Green"
Index [2]	"Blue"
Index [3]	(setelah `$colors[] = "Pink"`)

Saat kamu menambahkan elemen tanpa menyebut index ($colors[] = ...), PHP otomatis memakai index terbesar yang ada + 1. Jadi kalau array punya index 0, 1, 2, elemen baru akan masuk ke index 3.

💡Tip

Bayangkan PHP punya "penanda posisi" yang selalu menunjuk ke angka terbesar yang pernah dipakai. Saat kamu memakai $arr[], PHP menaruh elemen baru tepat setelah penanda itu — meskipun ada lubang di tengah array.

Add Element

Ada beberapa cara menambah elemen, masing-masing dengan efek berbeda terhadap index.

php
<?php

$colors = ["Red", "Green"];

// Append dengan [] — PHP otomatis memilih index terbesar + 1
$colors[] = "Blue";
$colors[] = "Yellow";
// Sekarang: [0]=>Red, [1]=>Green, [2]=>Blue, [3]=>Yellow

// Append beberapa sekaligus dengan array_push
array_push($colors, "Purple", "Orange");
// Sekarang: [0]=>Red, [1]=>Green, [2]=>Blue, [3]=>Yellow,
//           [4]=>Purple, [5]=>Orange

// Prepend — semua index digeser ke kanan, elemen baru di index 0
array_unshift($colors, "White");
// Sekarang: [0]=>White, [1]=>Red, [2]=>Green, [3]=>Blue, ...

// Add dengan specific index
$colors[10] = "Pink";
// Index 7-9 tidak ada (gap), index 10 berisi "Pink"

print_r($colors);
// Output:
// Array
// (
//     [0] => White
//     [1] => Red
//     [2] => Green
//     [3] => Blue
//     [4] => Yellow
//     [5] => Purple
//     [6] => Orange
//     [10] => Pink
// )

// Setelah ada gap, append tetap memakai index terbesar + 1
$colors[] = "Black";
// "Black" masuk ke index 11, bukan 7!

?>

⚠️Perhatian

Memakai index acak seperti $colors[10] = "Pink" membuat gap di array. Kalau array itu nanti di-loop dengan for dan count(), elemen di index 7, 8, 9 akan terlewati diam-diam. Kalau memang butuh index berurutan, pakai $colors[] atau re-index dengan array_values().

Modify Element

Mengubah elemen semudah mengaksesnya — tinggal assign nilai baru ke index atau key yang sama.

php
<?php

$items = ["Apple", "Banana", "Cherry"];

// Modify by index
$items[1] = "Blueberry";
print_r($items);
// Output:
// Array
// (
//     [0] => Apple
//     [1] => Blueberry
//     [2] => Cherry
// )

// Modify last element — tanpa tahu panjang array
$items[count($items) - 1] = "Cranberry";
echo $items[2];  // Output: Cranberry

// end() mengambil nilai elemen terakhir (tanpa mengubah array)
echo end($items);  // Output: Cranberry

// Modify by key (associative)
$user = ["name" => "Andi", "age" => 25];
$user["name"] = "Budi";
echo $user["name"];  // Output: Budi

?>

Pola $items[count($items) - 1] dipakai saat kamu ingin mengubah elemen terakhir tanpa tahu panjang array. Ada cara yang lebih singkat dengan function array_key_last() (PHP 7.3+):

php
<?php

$items = ["Apple", "Banana", "Cherry"];

// array_key_last() — key dari elemen terakhir
$lastKey = array_key_last($items);
$items[$lastKey] = "Durian";
echo $items[2];  // Output: Durian

// Versi super singkat
$items[array_key_last($items)] = "Elderberry";
echo $items[2];  // Output: Elderberry

?>

Delete Element

unset() menghapus elemen berdasarkan index/key. Perhatikan: PHP tidak otomatis merapikan index setelah unset() — lubang tetap ada sampai kamu re-index manual.

php
<?php

$fruits = ["Apple", "Banana", "Cherry", "Date"];

// Delete specific element
unset($fruits[1]);  // Hapus Banana

print_r($fruits);
// Output:
// Array
// (
//     [0] => Apple
//     [2] => Cherry
//     [3] => Date
// )
// ⚠️ Index 1 hilang! Array tidak re-index otomatis

// Delete lalu re-index
unset($fruits[0]);
$fruits = array_values($fruits);  // Re-index

print_r($fruits);
// Output:
// Array
// (
//     [0] => Cherry
//     [1] => Date
// )

// Pop (hapus last element, return it)
$last = array_pop($fruits);
echo $last;  // Output: Date

// Shift (hapus first element, return it)
$first = array_shift($fruits);
echo $first;  // Output: Cherry

?>

Perbedaan utama unset() vs array_pop()/array_shift():

Function	Menghapus	Nilai di-return	Re-index
`unset($arr[$key])`	Elemen di key tertentu	Tidak	Tidak
`array_pop($arr)`	Elemen terakhir	Ya	Tidak (index terakhir hilang)
`array_shift($arr)`	Elemen pertama	Ya	Ya (semua digeser)

array_shift() adalah satu-satunya yang otomatis re-index. Karena itu, array_shift() sedikit lebih lambat dari array_pop() untuk array besar — PHP harus menggeser semua elemen.

Menghapus dari Tengah: array_splice()

Untuk menghapus elemen di tengah dan sekaligus merapikan index, gunakan array_splice():

php
<?php

$colors = ["Red", "Green", "Blue", "Yellow", "Purple"];

// array_splice($array, $offset, $length) — hapus dari tengah
array_splice($colors, 1, 2);  // Hapus index 1 sampai 2

print_r($colors);
// Output:
// Array
// (
//     [0] => Red
//     [1] => Yellow
//     [2] => Purple
// )
// Catatan: array_splice() RE-INDEX otomatis

// array_splice() juga bisa menyisipkan elemen pengganti
$numbers = [1, 2, 3, 4];
array_splice($numbers, 1, 2, [20, 30]);

print_r($numbers);
// Output:
// Array
// (
//     [0] => 1
//     [1] => 20
//     [2] => 30
//     [3] => 4
// )

?>

💡Tip

Aturan praktis: unset() untuk menghapus satu elemen (biasanya associative array), array_pop()/array_shift() untuk ujung array, dan array_splice() untuk potongan di tengah yang butuh re-index otomatis.

Re-indexing Array

Kadang kita ingin memulai index dari 0 lagi setelah banyak unset(). PHP menyediakan array_values() untuk itu.

php
<?php

$arr = [10 => "a", 20 => "b", 30 => "c"];

// array_values() - reset ke 0, 1, 2...
$arr = array_values($arr);
print_r($arr);
// Output:
// Array
// (
//     [0] => a
//     [1] => b
//     [2] => c
// )

// array_keys() - ekstrak hanya key-nya
$keys = array_keys($arr);
print_r($keys);
// Output:
// Array
// (
//     [0] => 0
//     [1] => 1
//     [2] => 2
// )

// array_flip() - tukar posisi key dan value
$flipped = array_flip($arr);
print_r($flipped);
// Output:
// Array
// (
//     [a] => 0
//     [b] => 1
//     [c] => 2
// )

?>

array_flip() berguna ketika kamu ingin mencari "key mana yang menyimpan value X" dengan cepat — cukup flip sekali, lalu akses langsung: $flipped["b"] mengembalikan 1.

Simulasi Stack dan Queue

Dua pola klasik yang memanfaatkan indexing: stack (LIFO — Last In, First Out) dan queue (FIFO — First In, First Out).

Aspek	Stack (LIFO)	Queue (FIFO)
Operasi masuk	`push` (tambah di akhir)	`enqueue` (tambah di belakang)
Operasi keluar	`pop` — dari atas/akhir (top)	`dequeue` — dari depan (front)
Urutan keluar	Terakhir masuk, pertama keluar	Pertama masuk, pertama keluar
Visual	top: 3 → 2 → 1	front: 1 → 2 → 3

php
<?php

// STACK: push di akhir, pop dari akhir
$stack = [];

$stack[] = "Undo 1";
$stack[] = "Undo 2";
$stack[] = "Undo 3";

echo array_pop($stack);  // Output: Undo 3 (terakhir masuk, pertama keluar)
echo array_pop($stack);  // Output: Undo 2

// QUEUE: push di akhir, shift dari awal
$queue = [];

$queue[] = "Antrian 1";
$queue[] = "Antrian 2";
$queue[] = "Antrian 3";

echo array_shift($queue);  // Output: Antrian 1 (pertama masuk, pertama keluar)
echo array_shift($queue);  // Output: Antrian 2

?>

Pola stack dipakai di fitur undo/redo, pola queue dipakai di antrian job atau pesan. Keduanya tinggal kombinasi []/array_push dengan array_pop()/array_shift().

Common Mistakes

Mistake	Contoh Salah	Kenapa Salah	Solusi
Lupa bahwa index tidak otomatis rapi	`unset($arr[1])` lalu loop `for`	Lubang index membuat elemen terlewat	Re-index dengan `array_values()`
Mengharap `$arr[]` mengisi lubang	`unset($arr[1])` lalu `$arr[] = "x"`	PHP memakai index terbesar + 1, bukan lubang	Re-index dulu, atau assign ke index spesifik
Akses index yang sudah dihapus	`echo $arr[1];` setelah `unset($arr[1])`	Warning "Undefined array key"	Cek dulu dengan `isset()` atau `array_key_exists()`
Mengira `array_shift()` murah untuk array besar	`array_shift($arr)` di dalam loop	Semua elemen digeser tiap panggilan	Pertimbangkan `array_pop()` atau gunakan struktur data lain
`unset()` seluruh array padahal mau kosongkan isi	`unset($arr)`	Variabel ikut hilang, bukan cuma isinya	`$arr = [];` untuk reset isi

Exercise

Buat array, hapus element di tengah, lalu re-index dengan array_values()
Gunakan array_pop() untuk simulate stack (misalnya fitur undo 5 langkah)
Apa yang terjadi jika unset() element tanpa re-index?
Gunakan array_splice() untuk mengganti 3 elemen tengah array dengan 2 elemen baru
Buat queue antrian 4 nama, proses satu per satu dengan array_shift(), dan tampilkan sisa antrian setiap kali
Jelaskan bedanya hasil $arr[] = "x" setelah unset($arr[1]) dibanding setelah array_values($arr)

Summary

Konsep	Penjelasan
`$arr[] = $value`	Append di akhir, PHP memilih index terbesar + 1
`array_push($arr, ...)`	Append satu atau beberapa elemen sekaligus
`array_unshift($arr, $value)`	Prepend di awal, semua index digeser
`$arr[$i] = $value`	Ubah elemen pada index/key tertentu
`unset($arr[$key])`	Hapus elemen, index tidak otomatis rapi
`array_values($arr)`	Re-index array mulai dari 0
`array_pop($arr)`	Hapus + return elemen terakhir (LIFO)
`array_shift($arr)`	Hapus + return elemen pertama, otomatis re-index (FIFO)
`array_splice($arr, $off, $len, $repl)`	Hapus/insert potongan tengah, otomatis re-index
`array_key_last($arr)`	Key dari elemen terakhir (PHP 7.3+)

Klik tombol ini setelah menyelesaikan materi

📝

Quiz Bab 5

Uji pemahamanmu tentang Array

▶️ Mulai Quiz