Array dan Method-nya

Array adalah struktur data paling serbaguna di PHP. Artikel ini membahas cara membuat dan mengakses indexed array, associative array, multidimensional array, method manipulasi, sorting, serta iterasi dengan foreach.

Pendahuluan

Array adalah struktur data yang menyimpan kumpulan nilai dalam satu variabel. Di PHP, array sangat fleksibel — bisa berfungsi sebagai list (indexed), map (associative), bahkan keduanya sekaligus.

Array adalah struktur data yang paling sering digunakan di PHP. Hampir setiap aplikasi menggunakan array: daftar produk, data user dari database, hasil query, konfigurasi, dan sebagainya.

Artikel ini membahas:

  • Tiga jenis array: indexed, associative, multidimensional.
  • Cara membuat dan mengakses array.
  • Method manipulasi array.
  • Sorting array.
  • Iterasi dengan foreach.
  • Fungsi array yang sering digunakan.

Asumsi: Anda sudah memahami variabel, tipe data, fungsi, dan struktur kontrol dari artikel sebelumnya.


Jenis-Jenis Array

1. Indexed Array

Array dengan index numerik (dimulai dari 0).

<?php
$buah = ["apel", "jeruk", "mangga"];
$angka = [1, 2, 3, 4, 5];
$campuran = ["Budi", 25, true, null];
$kosong = [];

Membuat dengan array() (cara lama):

<?php
$buah = array("apel", "jeruk", "mangga");

Tips: Gunakan sintaks [] (short array syntax) — lebih ringkas dan direkomendasikan sejak PHP 5.4.

2. Associative Array

Array dengan key string (atau integer non-berurutan).

<?php
$user = [
    "nama" => "Budi",
    "umur" => 25,
    "email" => "[email protected]",
    "aktif" => true,
];

$harga = [
    "keyboard" => 450000,
    "mouse" => 150000,
    "monitor" => 1500000,
];

3. Multidimensional Array

Array yang berisi array lain.

<?php
// Array 2 dimensi
$matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
];

// Array associative bertingkat
$users = [
    [
        "nama" => "Budi",
        "umur" => 25,
        "hobi" => ["coding", "membaca"],
    ],
    [
        "nama" => "Siti",
        "umur" => 30,
        "hobi" => ["memasak", "bersepeda"],
    ],
];

4. Campuran (Indexed dan Associative)

PHP mengizinkan array dengan key campuran:

<?php
$campur = [
    0 => "nol",
    "satu" => 1,
    2 => true,
    "nama" => "Budi",
];

Catatan: Meskipun valid, array campuran sulit diprediksi. Hindari dalam kode produksi.


Membuat Array

Sintaks Literal

<?php
$buah = ["apel", "jeruk", "mangga"];
$user = ["nama" => "Budi", "umur" => 25];

Menambah Elemen Satu per Satu

<?php
$buah = [];
$buah[] = "apel";        // index 0
$buah[] = "jeruk";       // index 1
$buah[] = "mangga";      // index 2

$user = [];
$user["nama"] = "Budi";
$user["umur"] = 25;

array_fill() — Array dengan Nilai yang Sama

<?php
$nol = array_fill(0, 5, 0);
print_r($nol); // [0, 0, 0, 0, 0]

$nama = array_fill(0, 3, "Anonim");
print_r($nama); // ["Anonim", "Anonim", "Anonim"]

range() — Array Berurutan

<?php
$angka = range(1, 10);
print_r($angka); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

$ganjil = range(1, 10, 2);
print_r($ganjil); // [1, 3, 5, 7, 9]

$huruf = range("a", "e");
print_r($huruf); // ["a", "b", "c", "d", "e"]

array_combine() — Menggabungkan Key dan Value

<?php
$keys = ["nama", "umur", "kota"];
$values = ["Budi", 25, "Jakarta"];

$user = array_combine($keys, $values);
print_r($user);
// ["nama" => "Budi", "umur" => 25, "kota" => "Jakarta"]

Catatan: Jumlah elemen $keys dan $values harus sama, jika tidak akan error.


Mengakses Elemen

Indexed Array

<?php
$buah = ["apel", "jeruk", "mangga"];

echo $buah[0]; // "apel"
echo $buah[1]; // "jeruk"
echo $buah[2]; // "mangga"

// Di luar batas — warning
echo $buah[3] ?? "Tidak ada"; // "Tidak ada"

Associative Array

<?php
$user = ["nama" => "Budi", "umur" => 25];

echo $user["nama"]; // "Budi"
echo $user["umur"]; // 25

// Key tidak ada — warning
echo $user["email"] ?? "Tidak ada"; // "Tidak ada"

Multidimensional Array

<?php
$matrix = [
    [1, 2, 3],
    [4, 5, 6],
];

echo $matrix[0][0]; // 1
echo $matrix[1][2]; // 6

$users = [
    ["nama" => "Budi", "umur" => 25],
    ["nama" => "Siti", "umur" => 30],
];

echo $users[0]["nama"]; // "Budi"
echo $users[1]["umur"]; // 30

Cek Keberadaan Key

<?php
$user = ["nama" => "Budi", "umur" => 25, "email" => null];

// array_key_exists — true meskipun nilai null
var_dump(array_key_exists("nama", $user));  // bool(true)
var_dump(array_key_exists("email", $user)); // bool(true) — meskipun null
var_dump(array_key_exists("kota", $user));  // bool(false)

// isset — false jika nilai null
var_dump(isset($user["nama"]));  // bool(true)
var_dump(isset($user["email"])); // bool(false) — karena null
var_dump(isset($user["kota"]));  // bool(false)

Perbedaan isset() dan array_key_exists():

Key Nilai isset() array_key_exists()
"nama" "Budi" true true
"email" null false true
"kota" (tidak ada) false false

Tips: Gunakan array_key_exists() jika perlu membedakan key yang tidak ada dari key yang bernilai null.


Mengubah dan Menghapus Elemen

Mengubah Nilai

<?php
$buah = ["apel", "jeruk", "mangga"];
$buah[1] = "pisang";
print_r($buah); // ["apel", "pisang", "mangga"]

$user = ["nama" => "Budi"];
$user["nama"] = "Budi Santoso";

Menambah Elemen

<?php
$buah = ["apel"];
$buah[] = "jeruk";        // tambah di akhir
$buah[5] = "mangga";      // index spesifik

$user = ["nama" => "Budi"];
$user["umur"] = 25;       // tambah key baru

Menghapus Elemen

<?php
$buah = ["apel", "jeruk", "mangga"];

unset($buah[1]);
print_r($buah); // [0 => "apel", 2 => "mangga"] — index tidak di-reset!

// Reset index dengan array_values
$buah = array_values($buah);
print_r($buah); // [0 => "apel", 1 => "mangga"]

// Associative
$user = ["nama" => "Budi", "umur" => 25];
unset($user["umur"]);

Peringatan: unset() tidak me-reset index array. Jika perlu index berurutan, gunakan array_values().


Method Manipulasi Array

Menambah dan Menghapus

array_push() — tambah di akhir:

<?php
$buah = ["apel", "jeruk"];
array_push($buah, "mangga", "pisang");
print_r($buah); // ["apel", "jeruk", "mangga", "pisang"]

// Setara dengan
$buah[] = "anggur";

array_pop() — hapus dari akhir:

<?php
$buah = ["apel", "jeruk", "mangga"];
$terakhir = array_pop($buah);
echo $terakhir; // "mangga"
print_r($buah); // ["apel", "jeruk"]

array_unshift() — tambah di awal:

<?php
$buah = ["jeruk", "mangga"];
array_unshift($buah, "apel");
print_r($buah); // ["apel", "jeruk", "mangga"]

array_shift() — hapus dari awal:

<?php
$buah = ["apel", "jeruk", "mangga"];
$pertama = array_shift($buah);
echo $pertama; // "apel"
print_r($buah); // ["jeruk", "mangga"]

Catatan: array_unshift() dan array_shift() lebih lambat dari array_push() dan array_pop() karena harus menggeser index.

Menggabungkan dan Memotong

array_merge() — menggabungkan array:

<?php
$arr1 = [1, 2];
$arr2 = [3, 4];
$arr3 = [5, 6];

$gabungan = array_merge($arr1, $arr2, $arr3);
print_r($gabungan); // [1, 2, 3, 4, 5, 6]

// Associative — key dari array kanan menimpa
$user1 = ["nama" => "Budi", "umur" => 25];
$user2 = ["umur" => 30, "kota" => "Jakarta"];
$user = array_merge($user1, $user2);
print_r($user); // ["nama" => "Budi", "umur" => 30, "kota" => "Jakarta"]

array_slice() — mengambil bagian array:

<?php
$buah = ["apel", "jeruk", "mangga", "pisang", "anggur"];

print_r(array_slice($buah, 1, 3));  // ["jeruk", "mangga", "pisang"]
print_r(array_slice($buah, 2));     // ["mangga", "pisang", "anggur"]
print_r(array_slice($buah, -2));    // ["pisang", "anggur"]

array_splice() — menghapus/mengganti bagian array (mutasi):

<?php
$buah = ["apel", "jeruk", "mangga", "pisang"];

// Hapus 1 elemen di index 1
array_splice($buah, 1, 1);
print_r($buah); // ["apel", "mangga", "pisang"]

// Hapus 2 elemen, tambah 2 baru
$buah = ["apel", "jeruk", "mangga", "pisang"];
array_splice($buah, 1, 2, ["anggur", "kiwi"]);
print_r($buah); // ["apel", "anggur", "kiwi", "pisang"]

Mencari dan Memeriksa

in_array() — cek keberadaan nilai:

<?php
$buah = ["apel", "jeruk", "mangga"];

var_dump(in_array("jeruk", $buah));  // bool(true)
var_dump(in_array("pisang", $buah)); // bool(false)

// SELALU gunakan parameter ketiga true (strict)
var_dump(in_array("1", [1, 2, 3], true)); // bool(false)
var_dump(in_array(1, [1, 2, 3], true));   // bool(true)

array_search() — cari index/key dari nilai:

<?php
$buah = ["apel", "jeruk", "mangga"];

$index = array_search("jeruk", $buah);
echo $index; // 1

$index = array_search("pisang", $buah);
var_dump($index); // bool(false) — tidak ditemukan

// Strict
$index = array_search("1", [1, 2, 3], true);
var_dump($index); // bool(false)

array_keys() — ambil semua key:

<?php
$user = ["nama" => "Budi", "umur" => 25, "kota" => "Jakarta"];

print_r(array_keys($user));
// ["nama", "umur", "kota"]

print_r(array_keys($user, "Budi"));
// ["nama"] — key yang nilainya "Budi"

array_values() — ambil semua value:

<?php
$user = ["nama" => "Budi", "umur" => 25];

print_r(array_values($user));
// ["Budi", 25]

array_key_exists() — cek key:

<?php
$user = ["nama" => "Budi", "email" => null];

var_dump(array_key_exists("nama", $user));  // bool(true)
var_dump(array_key_exists("email", $user)); // bool(true)
var_dump(array_key_exists("kota", $user));  // bool(false)

array_flip() — tukar key dan value:

<?php
$user = ["nama" => "Budi", "umur" => 25];
$flipped = array_flip($user);
print_r($flipped); // ["Budi" => "nama", 25 => "umur"]

Transformasi

array_map() — terapkan fungsi ke setiap elemen:

<?php
$angka = [1, 2, 3, 4, 5];

$kuadrat = array_map(fn($n) => $n * $n, $angka);
print_r($kuadrat); // [1, 4, 9, 16, 25]

// Dengan beberapa array
$a = [1, 2, 3];
$b = [10, 20, 30];
$hasil = array_map(fn($x, $y) => $x + $y, $a, $b);
print_r($hasil); // [11, 22, 33]

array_filter() — menyaring elemen:

<?php
$angka = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

$genap = array_filter($angka, fn($n) => $n % 2 === 0);
print_r($genap); // [1 => 2, 3 => 4, 5 => 6, 7 => 8, 9 => 10]
// Index tetap! Gunakan array_values jika perlu reset
print_r(array_values($genap)); // [2, 4, 6, 8, 10]

// Tanpa callback — hapus nilai falsy
$campur = [0, 1, "", "Hello", null, [], "0"];
$bersih = array_filter($campur);
print_r($bersih); // [1 => 1, 3 => "Hello"]

array_reduce() — ringkas array menjadi satu nilai:

<?php
$angka = [1, 2, 3, 4, 5];

$total = array_reduce($angka, fn($sum, $n) => $sum + $n, 0);
echo $total; // 15

// Dengan string
$kata = ["Hello", "World", "dari", "PHP"];
$kalimat = array_reduce($kata, fn($carry, $item) => $carry . " " . $item, "");
echo trim($kalimat); // "Hello World dari PHP"

array_unique() — hapus duplikat:

<?php
$angka = [1, 2, 2, 3, 3, 3, 4, 5, 5];

$unik = array_unique($angka);
print_r($unik); // [0 => 1, 1 => 2, 3 => 3, 6 => 4, 7 => 5]

// Reset index
print_r(array_values($unik)); // [1, 2, 3, 4, 5]

array_reverse() — balik urutan:

<?php
$buah = ["apel", "jeruk", "mangga"];
$terbalik = array_reverse($buah);
print_r($terbalik); // ["mangga", "jeruk", "apel"]

array_column() — ambil kolom dari array multidimensi:

<?php
$users = [
    ["id" => 1, "nama" => "Budi", "umur" => 25],
    ["id" => 2, "nama" => "Siti", "umur" => 30],
    ["id" => 3, "nama" => "Andi", "umur" => 28],
];

$nama = array_column($users, "nama");
print_r($nama); // ["Budi", "Siti", "Andi"]

// Dengan index key
$byId = array_column($users, "nama", "id");
print_r($byId); // [1 => "Budi", 2 => "Siti", 3 => "Andi"]

array_sum() — jumlahkan semua nilai:

<?php
$angka = [1, 2, 3, 4, 5];
echo array_sum($angka); // 15

array_product() — kalikan semua nilai:

<?php
$angka = [2, 3, 4];
echo array_product($angka); // 24

count() — jumlah elemen:

<?php
$buah = ["apel", "jeruk", "mangga"];
echo count($buah); // 3

array_chunk() — pecah array menjadi potongan:

<?php
$angka = [1, 2, 3, 4, 5, 6, 7];
$chunks = array_chunk($angka, 3);
print_r($chunks);
// [[1, 2, 3], [4, 5, 6], [7]]

array_diff() — elemen yang ada di array pertama tetapi tidak di array lain:

<?php
$arr1 = [1, 2, 3, 4, 5];
$arr2 = [2, 4];

$diff = array_diff($arr1, $arr2);
print_r($diff); // [0 => 1, 2 => 3, 4 => 5]

array_intersect() — elemen yang ada di semua array:

<?php
$arr1 = [1, 2, 3, 4, 5];
$arr2 = [2, 4, 6, 8];

$intersect = array_intersect($arr1, $arr2);
print_r($intersect); // [1 => 2, 3 => 4]

array_diff_key() dan array_intersect_key() — berdasarkan key:

<?php
$arr1 = ["a" => 1, "b" => 2, "c" => 3];
$arr2 = ["a" => 10, "b" => 20];

print_r(array_diff_key($arr1, $arr2));      // ["c" => 3]
print_r(array_intersect_key($arr1, $arr2)); // ["a" => 1, "b" => 2]

Ringkasan Method Manipulasi

Kategori Fungsi
Tambah/hapus array_push, array_pop, array_unshift, array_shift
Gabung/potong array_merge, array_slice, array_splice, array_chunk
Cari in_array, array_search, array_keys, array_values, array_key_exists
Transformasi array_map, array_filter, array_reduce, array_unique, array_reverse, array_column, array_flip
Agregasi array_sum, array_product, count
Diff/intersect array_diff, array_intersect, array_diff_key, array_intersect_key

Sorting Array

sort() — Urutkan Berdasarkan Nilai (Ascending)

Mutasi array asli dan me-reset index.

<?php
$angka = [3, 1, 4, 1, 5];
sort($angka);
print_r($angka); // [1, 1, 3, 4, 5]

$buah = ["mangga", "apel", "jeruk"];
sort($buah);
print_r($buah); // ["apel", "jeruk", "mangga"]

rsort() — Descending

<?php
$angka = [3, 1, 4, 1, 5];
rsort($angka);
print_r($angka); // [5, 4, 3, 1, 1]

asort() — Urutkan Berdasarkan Nilai (Pertahankan Key)

<?php
$harga = [
    "keyboard" => 450000,
    "mouse" => 150000,
    "monitor" => 1500000,
];

asort($harga);
print_r($harga);
// ["mouse" => 150000, "keyboard" => 450000, "monitor" => 1500000]

arsort() — Descending (Pertahankan Key)

<?php
arsort($harga);
print_r($harga);
// ["monitor" => 1500000, "keyboard" => 450000, "mouse" => 150000]

ksort() — Urutkan Berdasarkan Key

<?php
$user = ["umur" => 25, "nama" => "Budi", "kota" => "Jakarta"];
ksort($user);
print_r($user);
// ["kota" => "Jakarta", "nama" => "Budi", "umur" => 25]

krsort() — Key Descending

<?php
krsort($user);
print_r($user);
// ["umur" => 25, "nama" => "Budi", "kota" => "Jakarta"]

usort() — Urutkan dengan Callback (Berdasarkan Nilai)

<?php
$angka = [3, 1, 4, 1, 5];
usort($angka, fn($a, $b) => $a <=> $b);
print_r($angka); // [1, 1, 3, 4, 5]

// Descending
usort($angka, fn($a, $b) => $b <=> $a);
print_r($angka); // [5, 4, 3, 1, 1]

uasort() — Callback (Pertahankan Key)

<?php
$harga = ["keyboard" => 450000, "mouse" => 150000, "monitor" => 1500000];

uasort($harga, fn($a, $b) => $a <=> $b);
print_r($harga);
// ["mouse" => 150000, "keyboard" => 450000, "monitor" => 1500000]

uksort() — Callback Berdasarkan Key

<?php
$user = ["umur" => 25, "nama" => "Budi", "kota" => "Jakarta"];

uksort($user, fn($a, $b) => strcmp($a, $b));
print_r($user);
// ["kota" => "Jakarta", "nama" => "Budi", "umur" => 25]

Sorting Array Multidimensi

<?php
$users = [
    ["nama" => "Budi", "umur" => 30],
    ["nama" => "Andi", "umur" => 25],
    ["nama" => "Siti", "umur" => 35],
];

// Urutkan berdasarkan umur
usort($users, fn($a, $b) => $a["umur"] <=> $b["umur"]);
print_r($users);
// [["nama" => "Andi", "umur" => 25], ["nama" => "Budi", "umur" => 30], ["nama" => "Siti", "umur" => 35]]

// Urutkan berdasarkan nama
usort($users, fn($a, $b) => strcmp($a["nama"], $b["nama"]));

Ringkasan Sorting

Fungsi Urut Berdasarkan Pertahankan Key Arah
sort() Value ❌ Ascending
rsort() Value ❌ Descending
asort() Value ✅ Ascending
arsort() Value ✅ Descending
ksort() Key ✅ Ascending
krsort() Key ✅ Descending
usort() Value (callback) ❌ Custom
uasort() Value (callback) ✅ Custom
uksort() Key (callback) ✅ Custom

Tips: Gunakan operator spaceship (<=>) untuk perbandingan di callback sorting — ringkas dan mudah dibaca.


Iterasi Array

foreach — Cara Utama

<?php
$buah = ["apel", "jeruk", "mangga"];

// Tanpa key
foreach ($buah as $item) {
    echo $item . "\n";
}

// Dengan key
foreach ($buah as $index => $item) {
    echo "$index: $item\n";
}

// Associative
$user = ["nama" => "Budi", "umur" => 25];
foreach ($user as $key => $value) {
    echo "$key: $value\n";
}

foreach dengan Referensi

<?php
$angka = [1, 2, 3, 4, 5];

foreach ($angka as &$n) {
    $n *= 2;
}
unset($n); // PENTING — putuskan referensi!

print_r($angka); // [2, 4, 6, 8, 10]

Peringatan: Selalu unset($n) setelah foreach dengan referensi. Jika tidak, iterasi berikutnya bisa menghasilkan bug yang sulit dilacak.

foreach dengan Destructuring

<?php
$koordinat = [
    [1, 2],
    [3, 4],
    [5, 6],
];

foreach ($koordinat as [$x, $y]) {
    echo "X: $x, Y: $y\n";
}

// Associative
$users = [
    ["nama" => "Budi", "umur" => 25],
    ["nama" => "Siti", "umur" => 30],
];

foreach ($users as ["nama" => $nama, "umur" => $umur]) {
    echo "$nama ($umur tahun)\n";
}

Alternative Syntax

<?php foreach ($buah as $item): ?>
    <li><?= htmlspecialchars($item) ?></li>
<?php endforeach; ?>

array_walk() — Terapkan Fungsi ke Setiap Elemen

<?php
$angka = [1, 2, 3, 4, 5];

array_walk($angka, function(&$nilai, $key) {
    $nilai *= 2;
});

print_r($angka); // [2, 4, 6, 8, 10]

Catatan: array_walk() memodifikasi array asli (pass by reference). Untuk transformasi tanpa mutasi, gunakan array_map().


Spread Operator pada Array (PHP 7.4+)

<?php
$arr1 = [1, 2, 3];
$arr2 = [4, 5, 6];

// Gabung
$gabungan = [...$arr1, ...$arr2];
print_r($gabungan); // [1, 2, 3, 4, 5, 6]

// Sisipkan
$baru = [0, ...$arr1, 10];
print_r($baru); // [0, 1, 2, 3, 10]

// Associative (PHP 8.1+)
$user1 = ["nama" => "Budi"];
$user2 = ["umur" => 25];
$user = [...$user1, ...$user2];
print_r($user); // ["nama" => "Budi", "umur" => 25]

Catatan: Spread pada array associative hanya didukung sejak PHP 8.1. Di versi sebelumnya, gunakan array_merge().


Contoh Praktis

1. Keranjang Belanja

<?php
$keranjang = [
    ["produk" => "Keyboard", "harga" => 450000, "jumlah" => 2],
    ["produk" => "Mouse", "harga" => 150000, "jumlah" => 1],
    ["produk" => "Monitor", "harga" => 1500000, "jumlah" => 1],
];

// Total
$total = array_reduce(
    $keranjang,
    fn($sum, $item) => $sum + $item["harga"] * $item["jumlah"],
    0
);
echo "Total: Rp" . number_format($total, 0, ",", ".");
// "Total: Rp2.550.000"

// Daftar nama produk
$namaProduk = array_column($keranjang, "produk");
print_r($namaProduk);
// ["Keyboard", "Mouse", "Monitor"]

// Produk di atas 200rb
$mahal = array_filter($keranjang, fn($item) => $item["harga"] > 200000);
print_r($mahal);

2. Menghapus Duplikat

<?php
$angka = [1, 2, 2, 3, 3, 4, 5, 5, 5];

$unik = array_values(array_unique($angka));
print_r($unik); // [1, 2, 3, 4, 5]

3. Mengelompokkan Data

<?php
$transaksi = [
    ["tanggal" => "2022-12-01", "total" => 100000],
    ["tanggal" => "2022-12-01", "total" => 250000],
    ["tanggal" => "2022-12-02", "total" => 300000],
    ["tanggal" => "2022-12-02", "total" => 150000],
];

$perHari = array_reduce($transaksi, function($acc, $t) {
    $tanggal = $t["tanggal"];
    if (!isset($acc[$tanggal])) {
        $acc[$tanggal] = 0;
    }
    $acc[$tanggal] += $t["total"];
    return $acc;
}, []);

print_r($perHari);
// ["2022-12-01" => 350000, "2022-12-02" => 450000]

4. Pencarian dan Filter

<?php
$produk = [
    ["nama" => "Keyboard Mechanical", "harga" => 450000, "kategori" => "aksesoris"],
    ["nama" => "Mouse Wireless", "harga" => 150000, "kategori" => "aksesoris"],
    ["nama" => "Monitor 24 inch", "harga" => 1500000, "kategori" => "display"],
    ["nama" => "Headset Gaming", "harga" => 350000, "kategori" => "audio"],
];

// Cari berdasarkan kata kunci
function cariProduk(array $produk, string $keyword): array {
    $lower = mb_strtolower($keyword);
    return array_filter($produk, function($p) use ($lower) {
        return str_contains(mb_strtolower($p["nama"]), $lower);
    });
}

print_r(cariProduk($produk, "gaming"));
// [["nama" => "Headset Gaming", ...]]

// Filter berdasarkan kategori dan harga
function filterProduk(array $produk, ?string $kategori = null, ?float $hargaMax = null): array {
    return array_filter($produk, function($p) use ($kategori, $hargaMax) {
        if ($kategori !== null && $p["kategori"] !== $kategori) return false;
        if ($hargaMax !== null && $p["harga"] > $hargaMax) return false;
        return true;
    });
}

print_r(filterProduk($produk, "aksesoris", 200000));
// [["nama" => "Mouse Wireless", ...]]

5. Sorting Data Kompleks

<?php
$users = [
    ["nama" => "Budi", "umur" => 30],
    ["nama" => "Andi", "umur" => 25],
    ["nama" => "Siti", "umur" => 35],
];

// Urutkan berdasarkan umur (ascending)
usort($users, fn($a, $b) => $a["umur"] <=> $b["umur"]);
print_r($users);

// Urutkan berdasarkan nama (ascending)
usort($users, fn($a, $b) => strcmp($a["nama"], $b["nama"]));
print_r($users);

Tips dan Best Practice

  1. Gunakan sintaks [] daripada array() — lebih ringkas.

  2. Selalu gunakan true sebagai parameter ketiga in_array() dan array_search() — perbandingan ketat.

  3. Gunakan array_key_exists() jika perlu membedakan key yang tidak ada dari key bernilai null.

  4. array_filter() mempertahankan key — gunakan array_values() jika perlu reset index.

  5. sort() me-reset index — gunakan asort() jika perlu mempertahankan key.

  6. Selalu unset($n) setelah foreach dengan referensi.

  7. Gunakan array_column() untuk mengekstrak kolom dari array multidimensi — lebih ringkas daripada array_map().

  8. Gunakan operator spaceship <=> di callback sorting — ringkas dan mudah dibaca.

  9. Gunakan array_reduce() untuk agregasi kompleks — lebih fleksibel daripada loop manual.

  10. Gunakan array_map(), array_filter(), array_reduce() daripada loop manual — lebih deklaratif dan mudah dibaca.

  11. Hati-hati dengan array campuran (indexed dan associative) — sulit diprediksi.

  12. Gunakan count() untuk menghitung elemen — bukan sizeof() (alias, tetapi kurang umum).


Ringkasan

Kategori Fungsi Utama
Membuat [], array(), range(), array_fill(), array_combine()
Akses $arr[key], $arr[index], $arr[i][j]
Cek isset(), array_key_exists(), in_array(), array_search()
Tambah/hapus array_push, array_pop, array_unshift, array_shift, unset
Gabung/potong array_merge, array_slice, array_splice, array_chunk
Transformasi array_map, array_filter, array_reduce, array_unique, array_reverse, array_column, array_flip
Sorting sort, rsort, asort, arsort, ksort, krsort, usort, uasort, uksort
Agregasi array_sum, array_product, count
Diff/intersect array_diff, array_intersect, array_diff_key, array_intersect_key
Iterasi foreach, array_walk
Spread [...$arr1, ...$arr2] (PHP 7.4+)

Poin penting:

  • PHP memiliki indexed array, associative array, dan multidimensional array.
  • unset() tidak me-reset index — gunakan array_values() jika perlu.
  • array_filter() mempertahankan key — gunakan array_values() untuk reset.
  • sort() me-reset index; asort() mempertahankan key.
  • Selalu unset($n) setelah foreach dengan referensi.
  • Gunakan array_column() untuk ekstrak kolom dari array multidimensi.
  • in_array() dan array_search() — selalu gunakan mode ketat (true).
  • Gunakan array_map/array_filter/array_reduce daripada loop manual.
  • Spread operator (...) tersedia sejak PHP 7.4 (associative: PHP 8.1+).

Pada artikel berikutnya, kita akan membahas String dan Manipulasi — fungsi string, regex, dan formatting.

Top