Was machen array_sum und array_product?
Wer in PHP eine Liste von Zahlen zusammenrechnen will, etwa Bestellbeträge, Punktwerte oder Mengenangaben, sucht selten nach einer foreach-Schleife. Genau hier glänzt PHP array_sum: Die Funktion nimmt ein Array entgegen und liefert die Summe aller Werte als Integer oder Float zurück. Das Pendant array_product() macht dasselbe mit der Multiplikation und liefert das Produkt aller Werte. Beide Funktionen sparen Schleifencode und sind in C implementiert, also auch performance-technisch eine sehr gute Wahl.
Die nächsten Abschnitte zeigen Bestellsumme, Durchschnitt und Fakultät in der Praxis und liefern defensive Filter gegen unbemerkt einfließende Nicht-Zahlen.
So einfach die beiden Funktionen sind, so subtil sind ihre Sonderfälle. PHP array_sum() behandelt nicht-numerische Werte als 0, was im ersten Moment praktisch wirkt, in Wirklichkeit aber Bugs verschleiert. Das Tutorial zeigt die wichtigsten Use-Cases (Bestellsumme, Durchschnitt, Fakultät), erklärt das Type-Juggling und liefert defensive Patterns für den Produktiv-Code.
Syntax und Rückgabewerte
Beide Funktionen haben dieselbe schlanke Signatur. Sie erwarten ein Array und liefern entweder einen Integer oder einen Float zurück.
<?php
array_sum(array $array): int|float
array_product(array $array): int|float
Wichtig sind die Sonderfälle bei einem leeren Array. PHP array_sum() liefert dann 0, was mathematisch konsistent ist. array_product() liefert hingegen 1, weil das das neutrale Element der Multiplikation ist. Wer auf einer leeren Liste eine Multiplikation startet, sollte sich der Konvention bewusst sein, sonst wundert er sich über das 1 als Resultat.
Erstes Beispiel mit PHP array_sum: Summe und Produkt
Zum Einstieg ein einfaches Beispiel mit einem numerischen Array. Beide Funktionen lassen sich mit einer einzigen Zeile aufrufen.
<?php
$werte = [10, 20, 30, 40];
echo array_sum($werte);
/* Ausgabe: 100 */
echo array_product($werte);
/* Ausgabe: 240000 */
Das Ergebnis ist genau, wie es ein Taschenrechner liefern würde. PHP array_sum() summiert die vier Werte zu 100, und array_product() multipliziert sie zu 240000. Bei sehr großen Werten kann das Produkt schnell aus dem Integer-Bereich rutschen und in einen Float konvertiert werden, was bei Präzisionsanforderungen wichtig zu wissen ist.
Praxisfall Bestellsumme mit array_column
In typischen Web-Anwendungen liegen Daten als Liste assoziativer Arrays vor, etwa Bestellungen mit id und betrag. PHP array_sum() arbeitet nur auf einer Liste von Werten, deshalb wird die Spalte zuerst mit array_column() extrahiert. Auch array_values() liefert die reinen Werte eines Arrays, wenn keine Schlüssel-Auswahl nötig ist.
<?php
$bestellungen = [
['id' => 1, 'betrag' => 19.90],
['id' => 2, 'betrag' => 49.50],
['id' => 3, 'betrag' => 9.95],
];
$summe = array_sum(array_column($bestellungen, 'betrag'));
echo number_format($summe, 2, ',', '.');
/* Ausgabe: 79,35 */
Diese Pipeline ist ein One-Liner-Ersatz für eine handgeschriebene foreach-Schleife mit eigener Akkumulator-Variable. Ergänzt mit number_format() ist die Ausgabe sofort für den Kunden lesbar. Wichtig ist, dass die Spalte numerische Werte enthält. Wenn betrag als String aus der Datenbank kommt, sind PHP-Strings mit Punkt-Notation problemlos addierbar, mit Komma-Notation hingegen nicht.
Durchschnitt mit array_sum und count
Eine sehr häufige Anwendung ist der Durchschnitt einer Liste von Werten. PHP hat dafür keine eingebaute Funktion, aber array_sum() geteilt durch count() liefert das Ergebnis in einer Zeile.
<?php
$noten = [1, 2, 3, 1, 2, 4];
$schnitt = array_sum($noten) / count($noten);
echo round($schnitt, 2);
/* Ausgabe: 2.17 */
Wichtig ist die Prüfung auf ein leeres Array vor der Division, damit kein DivisionByZeroError ausgelöst wird. Eine knappe Schreibweise dafür ist count($noten) === 0 ? 0 : array_sum($noten) / count($noten). Wer den Durchschnitt oft braucht, lagert die Logik in eine kleine Helper-Funktion aus, die den Edge-Case sauber abfängt.
Fakultät mit array_product und range
Ein eleganter Ein-Zeiler ist die Fakultät einer Zahl. PHP array_product() multipliziert alle Werte des Arrays, und range() liefert die Reihe von 1 bis n.
<?php
$n = 6;
echo array_product(range(1, $n));
/* 1*2*3*4*5*6 = 720 */
Diese Berechnung ist deutlich knapper als eine eigene Schleife mit for ($i = 1; $i <= $n; $i++) { $f *= $i; }. Bei sehr großen Werten kippt das Ergebnis allerdings schnell in den Float-Bereich, weil PHP-Integer in 64 Bit nur bis ca. 9.2 Trillionen reichen. Für wirklich große Fakultäten gehört die GMP-Erweiterung oder BCMath ins Spiel, die mit beliebig großen Zahlen umgehen kann.
Type-Juggling und nicht-numerische Werte
Ein subtiler Punkt ist das Verhalten bei nicht-numerischen Werten. PHP array_sum() macht hier keinen Lärm, sondern interpretiert jeden Wert nach den üblichen Type-Juggling-Regeln und behandelt nicht-konvertierbare Werte als 0.
<?php
$gemischt = [10, '20', 'abc', true, '5.5', null];
echo array_sum($gemischt);
/* 10 + 20 + 0 + 1 + 5.5 + 0 = 36.5 */
Das Ergebnis ist 36.5. Das ist mathematisch nachvollziehbar, in der Praxis aber gefährlich, weil etwa der String 'abc' still als 0 einfließt. Wer eine Bestellsumme aus Eingabefeldern berechnet und nicht vorher validiert, kann mit fehlerhaften Werten leise Geld verlieren. Aus diesem Grund gehört in Produktiv-Code immer ein expliziter Filter vor den Aufruf.
flowchart TD
A["Array uebergeben"] --> B{"Wert numerisch?"}
B -->|Ja| C["Element zur Summe addieren"]
B -->|Nein| D["Wert als 0 behandeln"]
C --> E{"Naechstes Element?"}
D --> E
E -->|Ja| B
E -->|Nein| F["Endsumme zurueckgeben"]
Defensive Pre-Filter mit array_filter
Die saubere Lösung ist ein Pre-Filter, der vor dem Aufruf alle nicht-numerischen Werte entfernt. array_filter() lässt sich mit einem Callback wie is_numeric betreiben, der nur valide Einträge durchlässt.
<?php
$werte = ['12.5', '20', 'abc', null, '0.5', false];
$nur_zahlen = array_filter($werte, 'is_numeric');
echo array_sum($nur_zahlen);
/* 12.5 + 20 + 0.5 = 33 */
Mit dieser Pipeline werden 'abc', null und false ausgeschlossen, bevor PHP array_sum() sie als 0 interpretiert. Der Code ist damit nicht nur korrekter, sondern auch ausdrucksstärker, weil die Filter-Stufe explizit signalisiert, welche Werte erlaubt sind. Wer das Pattern häufig braucht, schreibt sich eine kleine Wrapper-Funktion safe_sum(array $w): float, die den Filter automatisch anwendet.
Mehrdimensionale Arrays summieren
Eine häufige Frage in der Praxis: Wie summiert man Werte aus einem verschachtelten Array, etwa eine Liste von Bestellungen mit jeweils mehreren Positionen? PHP array_sum() arbeitet selbst nur auf einer Ebene und würde auf Sub-Arrays als Werte ein 0 (mit einer Warning) liefern. Die saubere Lösung kombiniert PHP array_sum() mit array_column(), wenn die Struktur eine flache Liste assoziativer Arrays ist.
<?php
$bestellungen = [
['id' => 1, 'positionen' => [10.00, 5.50, 19.90]],
['id' => 2, 'positionen' => [49.00]],
['id' => 3, 'positionen' => [9.95, 14.50]],
];
/* Pro Bestellung summieren, dann ueber alle Bestellungen aggregieren */
$gesamt = array_sum(array_map('array_sum', array_column($bestellungen, 'positionen')));
echo number_format($gesamt, 2, ',', '.');
/* Ausgabe: 108,85 */
Bei tiefer geschachtelten Strukturen, etwa rekursiven Baum-Daten oder API-Antworten mit unbekannter Tiefe, kommt array_walk_recursive() ins Spiel. Die Funktion durchläuft alle Blätter und lässt sich bequem mit einer Akkumulator-Variable kombinieren.
<?php
$daten = [
'q1' => ['januar' => 1200, 'februar' => 1500, 'maerz' => 1800],
'q2' => ['april' => 2100, 'mai' => 1900, 'juni' => 2300],
];
$summe = 0;
array_walk_recursive($daten, function ($wert) use (&$summe): void {
if (is_numeric($wert)) {
$summe += $wert;
}
});
echo $summe;
/* Ausgabe: 10800 */
Das Pattern hat den Vorteil, dass die Struktur des Arrays komplett egal wird. Egal ob zwei oder fünf Ebenen tief, alle numerischen Werte werden summiert. Die is_numeric-Prüfung verhindert die stille Type-Juggling-Falle aus dem vorherigen Abschnitt. Für den umgekehrten Fall (Summe pro Schlüssel statt Gesamtsumme) ist array_reduce() mit assoziativem Akkumulator die elegantere Wahl.
Vergleich foreach und array_reduce
Drei Wege führen in PHP zur Akkumulation: foreach, array_reduce() und PHP array_sum(). Jeder hat seine Berechtigung, aber nicht jeder ist immer die richtige Wahl. Wer einen Callback für komplexere Logik braucht, kann sich auch array_map() für die Vorverarbeitung anschauen, bevor das eigentliche array_sum greift.
<?php
$werte = [10, 20, 30, 40];
/* Variante 1: foreach */
$summe = 0;
foreach ($werte as $w) {
$summe += $w;
}
/* Variante 2: array_reduce */
$summe = array_reduce($werte, fn($acc, $v) => $acc + $v, 0);
/* Variante 3: array_sum */
$summe = array_sum($werte);
Für die reine Summenbildung ist array_sum() die beste Wahl: knapp, schnell und idiomatisch. array_reduce() wird interessant, sobald die Akkumulation komplexer ist, etwa beim Sammeln von Statistiken (min, max und Summe in einem Lauf) oder beim Aufbau eines neuen Arrays. Die foreach-Schleife bleibt sinnvoll, wenn pro Iteration mehrere Aktionen passieren oder Seiteneffekte gebraucht werden.
Performance und Best Practices für PHP array_sum
PHP array_sum() und array_product() sind in C implementiert und damit deutlich schneller als ein Userland-foreach. Bei Datensets mit Millionen Elementen ist der Unterschied messbar, bei Hundert oder Tausend Einträgen kaum. Die wahre Stärke der Funktionen liegt in der Lesbarkeit, nicht primär in der Geschwindigkeit.
Drei Best Practices haben sich bewährt. Erstens, bei aggregierten Daten aus der Datenbank lieber SELECT SUM(spalte) verwenden, weil das den Index der Datenbank nutzt und keinen Speicher in PHP belegt. Zweitens, vor dem Aufruf von array_sum auf produktiven Daten immer einen is_numeric-Filter setzen, damit keine fehlerhaften Werte still als 0 einfließen. Drittens, bei Float-Werten daran denken, dass die Präzision begrenzt ist. Wer Geldbeträge summiert, sollte mit Cent-Werten als Integer arbeiten oder eine BCMath-Bibliothek nutzen.
Fazit zu PHP array_sum
PHP array_sum() und array_product() sind kompakte und sehr nützliche Funktionen, die das Akkumulieren von Werten in einem Array auf einen Aufruf reduzieren. Sie eignen sich für Bestellsummen, Durchschnitte, Fakultäten und alle Fälle, in denen ein einzelner aggregierter Wert aus einer Liste entstehen soll. Wer die Stolperfalle mit nicht-numerischen Werten kennt, mit array_filter('is_numeric') defensiv arbeitet und bei Geldbeträgen die Float-Präzision im Blick behält, kommt mit den beiden Funktionen sauber durch jeden Aggregations-Use-Case.
