Die PHP-Funktion array_values() extrahiert alle Werte eines Arrays und gibt sie mit fortlaufenden numerischen Indizes zurück. Das klingt zunächst simpel, ist in der Praxis aber unverzichtbar: Nach dem Filtern oder Löschen von Elementen bleiben im Array Lücken im Index, die zu Problemen führen können. array_values() schließt diese Lücken und stellt einen sauberen, fortlaufenden Index her.
Grundsyntax von array_values()
Die Funktion erwartet genau einen Parameter und gibt ein neues Array zurück. Das Original-Array wird dabei nicht verändert.
array_values(array $array): array
Ein einfaches Beispiel zeigt die Wirkung: Aus einem assoziativen Array mit benannten Schlüsseln wird ein numerisch indexiertes Array.
<?php
$person = [
"name" => "Max",
"alter" => 28,
"beruf" => "Entwickler"
];
$werte = array_values($person);
print_r($werte);
/*
Array
(
[0] => Max
[1] => 28
[2] => Entwickler
)
*/
?>
Die Reihenfolge der Werte bleibt erhalten. Nur die Schlüssel werden durch fortlaufende Zahlen ab 0 ersetzt.
Wann wird array_values() gebraucht?
In vielen PHP-Projekten wird array_values() nicht direkt zum Extrahieren von Werten eingesetzt, sondern zum Reparieren des Index nach einer Filterung oder Löschung. Die folgenden drei Szenarien sind die häufigsten Anwendungsfälle.
Index-Lücken nach array_filter() schließen
Wenn array_filter() Elemente aus einem Array entfernt, bleiben die ursprünglichen Schlüssel erhalten. Das führt zu Lücken im Index, die bei einer for-Schleife oder einem Zähler zu Fehlern führen können.
<?php
$zahlen = [10, 0, 25, 0, 42, 0, 7];
/* Nullen entfernen */
$gefiltert = array_filter($zahlen);
var_dump($gefiltert);
/*
array(4) {
[0] => int(10)
[2] => int(25)
[4] => int(42)
[6] => int(7)
}
*/
/* Index reparieren */
$sauber = array_values($gefiltert);
var_dump($sauber);
/*
array(4) {
[0] => int(10)
[1] => int(25)
[2] => int(42)
[3] => int(7)
}
*/
?>
Korrektes JSON-Array mit json_encode()
Ein Array mit Lücken im Index wird von json_encode() als JSON-Objekt statt als JSON-Array kodiert. Das kann im Frontend zu unerwartetem Verhalten führen, wenn JavaScript ein Array erwartet.
<?php
$farben = ["rot", "grün", "blau", "gelb"];
/* Element entfernen */
unset($farben[1]);
echo json_encode($farben);
/* {"0":"rot","2":"blau","3":"gelb"} */
/* Mit array_values() wird es ein JSON-Array */
echo json_encode(array_values($farben));
/* ["rot","blau","gelb"] */
?>
Dieser Unterschied ist besonders wichtig bei REST-APIs und AJAX-Antworten. Ein JavaScript-Frontend, das response.forEach() aufruft, erhält bei einem JSON-Objekt einen Fehler.
Neuindexierung nach unset()
Nach dem Löschen einzelner Elemente mit unset() bleibt der Index lückenhaft. Eine for-Schleife, die von 0 bis count($array) - 1 zählt, überspringt dann Einträge oder greift auf nicht existierende Indizes zu.
<?php
$namen = ["Anna", "Ben", "Clara", "David"];
unset($namen[1]); /* Ben entfernen */
/* Problem: for-Schleife überspringt */
for ($i = 0; $i < count($namen); $i++) {
/* Warning bei $i = 1: Undefined index */
echo $namen[$i] . "\n";
}
/* Lösung: Index reparieren */
$namen = array_values($namen);
for ($i = 0; $i < count($namen); $i++) {
echo $namen[$i] . "\n";
}
/* Anna, Clara, David */
?>
array_values() bei mehrdimensionalen Arrays
Bei mehrdimensionalen Arrays wirkt array_values() nur auf die oberste Ebene. Die Schlüssel der inneren Arrays bleiben unverändert. Das ist in den meisten Fällen das gewünschte Verhalten.
<?php
$daten = [
"team_a" => ["name" => "Alpha", "punkte" => 12],
"team_c" => ["name" => "Gamma", "punkte" => 8]
];
$liste = array_values($daten);
print_r($liste);
/*
Array
(
[0] => Array
(
[name] => Alpha
[punkte] => 12
)
[1] => Array
(
[name] => Gamma
[punkte] => 8
)
)
*/
?>
Wenn auch die inneren Arrays neu indexiert werden sollen, muss eine eigene rekursive Funktion geschrieben werden. Ein typischer Anwendungsfall ist das Bereinigen einer verschachtelten API-Antwort nach einer Filterung.
<?php
function array_values_recursive(array $array): array
{
$ergebnis = [];
foreach ($array as $wert) {
if (is_array($wert)) {
$ergebnis[] = array_values_recursive($wert);
} else {
$ergebnis[] = $wert;
}
}
return $ergebnis;
}
$verschachtelt = [
"x" => ["a1" => "Wert1", "a2" => "Wert2"],
"y" => ["c1" => "Wert3", "c2" => "Wert4"]
];
print_r(array_values_recursive($verschachtelt));
/*
Array
(
[0] => Array
(
[0] => Wert1
[1] => Wert2
)
[1] => Array
(
[0] => Wert3
[1] => Wert4
)
)
*/
?>
Verwandte Funktionen: array_keys() und array_is_list()
Während array_values() die Werte extrahiert, gibt array_keys() die Schlüssel eines Arrays zurück. Zusammen bilden sie ein Paar, mit dem sich ein Array vollständig in seine Bestandteile zerlegen lässt.
<?php
$config = [
"host" => "localhost",
"port" => 3306,
"datenbank" => "shop"
];
$schluessel = array_keys($config);
$werte = array_values($config);
print_r($schluessel);
/* ["host", "port", "datenbank"] */
print_r($werte);
/* ["localhost", 3306, "shop"] */
/*
* Werte und Schlüssel mit implode()
* zu einem String verbinden
*/
echo implode(", ", $werte);
/* localhost, 3306, shop */
?>
Seit PHP 8.1 gibt es außerdem array_is_list(). Diese Funktion prüft, ob ein Array eine sogenannte "Liste" ist, also ob die Schlüssel bei 0 beginnen und lückenlos aufsteigen. Genau das ist der Zustand, den array_values() herstellt.
<?php
/* PHP 8.1+ */
$liste = ["rot", "grün", "blau"];
var_dump(array_is_list($liste)); // true
/* Nach unset() keine Liste mehr */
unset($liste[1]);
var_dump(array_is_list($liste)); // false
/* array_values() stellt den Listen-Zustand her */
$repariert = array_values($liste);
var_dump(array_is_list($repariert)); // true
?>
Wann array_values() nicht nötig ist
Nicht jedes Array braucht einen lückenlosen numerischen Index. Wenn ein Array mit einer foreach-Schleife durchlaufen wird, spielt der Index keine Rolle. foreach iteriert über alle Elemente, unabhängig von ihren Schlüsseln.
<?php
$produkte = ["Laptop", "Maus", "Tastatur", "Monitor"];
unset($produkte[2]); /* Tastatur entfernen */
/*
* foreach funktioniert problemlos,
* auch mit Lücken im Index
*/
foreach ($produkte as $produkt) {
echo $produkt . "\n";
}
/* Laptop, Maus, Monitor */
/*
* array_values() ist hier unnötig und
* verbraucht nur zusätzlichen Speicher
*/
?>
Bei großen Arrays mit tausenden Einträgen erzeugt array_values() eine vollständige Kopie. Wenn der fortlaufende Index nicht wirklich benötigt wird, spart man durch den Verzicht auf array_values() Speicher und Rechenzeit.
Häufige Fragen zu array_values()
Einige Fragen tauchen im Zusammenhang mit array_values() immer wieder auf. Die folgenden Antworten klären die wichtigsten Missverständnisse.
Verändert array_values() das Original-Array?
Nein. array_values() gibt ein neues Array zurück und lässt das Original unverändert. Wenn das Ergebnis verwendet werden soll, muss es einer Variable zugewiesen werden:
<?php
$original = ["a" => 1, "c" => 3];
/* Nur das neue Array hat numerische Keys */
$neu = array_values($original);
print_r($original);
/* ["a" => 1, "c" => 3] */
print_r($neu);
/* [0 => 1, 1 => 3] */
?>
Was passiert bei einem leeren Array?
Bei einem leeren Array gibt array_values() ebenfalls ein leeres Array zurück. Es werden weder Fehler noch Warnungen erzeugt.
<?php
$leer = [];
$ergebnis = array_values($leer);
var_dump($ergebnis); // array(0) { }
?>
Kann ich array_values() mit array_search() kombinieren?
Ja, und das ist sogar ein gängiges Muster. Nach dem Entfernen eines Elements per array_search() und unset() repariert array_values() den Index:
<?php
$tags = ["php", "html", "css", "javascript"];
/* "html" finden und entfernen */
$pos = array_search("html", $tags);
if ($pos !== false) {
unset($tags[$pos]);
}
/* Index reparieren */
$tags = array_values($tags);
print_r($tags);
/* ["php", "css", "javascript"] */
?>
Wie wandle ich Array-Werte in einen String um?
Die Funktion implode() verbindet Array-Werte mit einem Trennzeichen zu einem String. In Kombination mit array_values() lassen sich auch die Werte eines assoziativen Arrays direkt zusammenfügen:
<?php
$config = [
"host" => "localhost",
"port" => "3306",
"db" => "shop"
];
echo implode(" | ", array_values($config));
/* localhost | 3306 | shop */
?>
Zusammenfassung
array_values() ist eine kleine Funktion mit großer Wirkung. Ihr wichtigster Einsatzzweck ist das Schließen von Index-Lücken, die nach array_filter() oder unset() entstehen. Besonders bei der JSON-Ausgabe mit json_encode() ist die Neuindexierung oft unverzichtbar, damit das Ergebnis ein JSON-Array und kein JSON-Objekt wird. Mit array_keys() bildet die Funktion ein Paar, um Arrays in Schlüssel und Werte zu zerlegen. Und seit PHP 8.1 lässt sich mit array_is_list() prüfen, ob ein Array bereits einen sauberen Index hat.
