PHP array_column(): eine Spalte aus Zeilen holen

array_column($rows, $column) liefert den Wert von $column aus jeder Zeile einer Liste von Zeilen. Es macht aus einer Tabelle von Datensätzen ein flaches Array eines Felds, und genau das brauchst du vor implode, in_array, array_sum oder array_search.

<?php
$users = [
    ["id" => 3, "name" => "Ada", "email" => "ada@example.com"],
    ["id" => 7, "name" => "Bob", "email" => "bob@example.com"],
    ["id" => 9, "name" => "Cy", "email" => "cy@example.com"],
];

$emails = array_column($users, "email");
print_r($emails);

echo implode(", ", array_column($users, "name")), "\n";

Die Zeilen können von überall kommen: aus einer dekodierten JSON-Antwort, einer CSV-Datei oder einer Datenbankabfrage, die ein Array von assoziativen Arrays geliefert hat.

Mit dem Index-Schlüssel Schlüssel/Wert-Paare bauen

Das dritte Argument nennt ein Feld, dessen Wert zum Schlüssel jedes Ergebnisses wird. array_column($users, 'name', 'id') ist der übliche Weg, eine Zuordnung von ID zu Name zu bauen, etwa für eine <select>-Liste.

<?php
$users = [
    ["id" => 3, "name" => "Ada", "role" => "admin"],
    ["id" => 7, "name" => "Bob", "role" => "editor"],
    ["id" => 9, "name" => "Cy", "role" => "viewer"],
];

$names = array_column($users, "name", "id");
print_r($names);

echo $names[7], "\n";

Wenn zwei Zeilen denselben Indexwert haben, überschreibt die spätere Zeile die frühere.

Ganze Zeilen mit null nach ID indizieren

Übergib null als Spalte, um jede vollständige Zeile zu behalten, neu verschlüsselt nach dem Indexfeld. Eine Zeile über ihre ID nachzuschlagen ist dann ein direkter Schlüsselzugriff statt einer Schleife.

<?php
$products = [
    ["sku" => "A12", "name" => "Lamp", "price" => 29],
    ["sku" => "B07", "name" => "Desk", "price" => 199],
    ["sku" => "C33", "name" => "Chair", "price" => 89],
];

$bySku = array_column($products, null, "sku");

$sku = "B07";
if (isset($bySku[$sku])) {
    echo "{$bySku[$sku]['name']} costs {$bySku[$sku]['price']}\n";
}

print_r(array_keys($bySku));

Bau den Index einmal, und jeder spätere Lookup geht sofort, was zählt, wenn du in einer Schleife viele IDs nachschlägst.

Eine Zeile mit array_column und array_search finden

Um herauszufinden, welche Zeile einen bestimmten Wert hat, durchsuchst du die Spalte und verwendest die Position, die du zurückbekommst. Prüfe das Ergebnis mit !== false, denn ein Treffer in der ersten Zeile liefert 0.

<?php
$users = [
    ["name" => "Ada", "email" => "ada@example.com"],
    ["name" => "Bob", "email" => "bob@example.com"],
    ["name" => "Cy", "email" => "cy@example.com"],
];

$wanted = "bob@example.com";
$index = array_search($wanted, array_column($users, "email"));

if ($index !== false) {
    echo "Found: {$users[$index]['name']} at position $index\n";
} else {
    echo "No user with $wanted\n";
}

// Just checking existence
var_dump(in_array("zoe@example.com", array_column($users, "email"), true));

Das setzt voraus, dass $users die Schlüssel 0, 1, 2 hat, weil array_column eine Liste liefert. Wurde das Array gefiltert und hat Lücken, rufst du vorher array_values($users) auf. Die Seite zu array_search behandelt die Falle false gegen 0 im Detail.

Eine Spalte summieren, zählen oder mitteln

array_column passt gut zu den Mathe-Helfern: Feld herausziehen, dann aufaddieren.

<?php
$cart = [
    ["item" => "Book", "qty" => 2, "price" => 12.5],
    ["item" => "Pen", "qty" => 10, "price" => 1.2],
    ["item" => "Bag", "qty" => 1, "price" => 30.0],
];

$qtys = array_column($cart, "qty");
echo "Items: " . array_sum($qtys) . "\n";

$prices = array_column($cart, "price");
echo "Most expensive: " . max($prices) . "\n";
echo "Average price: " . round(array_sum($prices) / count($prices), 2) . "\n";

$total = array_sum(array_map(fn($row) => $row["qty"] * $row["price"], $cart));
echo "Total: $total\n";

Für einen Wert, der aus mehreren Feldern berechnet wird, etwa Menge mal Preis, ist array_map das Werkzeug, wie in der letzten Zeile.

array_column mit Objekten

Bei einer Liste von Objekten liest array_column öffentliche Eigenschaften. Private und geschützte Eigenschaften sieht es nicht.

<?php
class User
{
    public function __construct(
        public int $id,
        public string $name,
        private string $password,
    ) {}
}

$users = [
    new User(1, "Ada", "x"),
    new User(2, "Bob", "y"),
];

print_r(array_column($users, "name", "id"));
var_dump(array_column($users, "password"));

Der zweite Aufruf liefert ein leeres Array: password ist privat, also wird jedes Objekt übersprungen.

Zeilen ohne das Feld werden übersprungen

array_column setzt keinen Platzhalter für eine Zeile ein, der das Feld fehlt. Das Ergebnis kann kürzer sein als die Eingabe, sodass seine Positionen nicht mehr zu den Zeilen passen.

<?php
$people = [
    ["name" => "Ada", "phone" => "555-0101"],
    ["name" => "Bob"],
    ["name" => "Cy", "phone" => "555-0199"],
];

print_r(array_column($people, "phone"));

// Keep the link to each person with an index key
print_r(array_column($people, "phone", "name"));

Das erste Ergebnis hat zwei Telefonnummern und keinen Hinweis darauf, dass Bob keine hatte. Mit dem Namen als Index-Schlüssel siehst du, wem welche Nummer gehört, und das ist die sicherere Form, wann immer manchen Zeilen das Feld fehlen kann.