Alle Werte in einem Array addieren (Thema: PHP Beispiele)

1. array_sum()

Die Standardfunktion zum Berechnen der Summe aller Elemente in einem Array ist array_sum($array). Ihre Rückgabe ist ein Integer-Wert.

<?php
	$arr = array(10, 10, 10);
	var_dump(array_sum($arr));
?>

int(30)

2. Eigene foreach-Schleife

Ebenfalls ist die Berechnung der Summe über die Anwendung einer Schleife möglich. Jeder einzelne Wert muss dann nur zur Summe addiert werden. Eine Schleife ist langsamer als array_sum(), erlaubt einem aber mehr Flexibilität. Zum Beispiel könnte jedes Element zunächst darauf geprüft werden, ob es überhaupt ein Integer ist, oder es könnte nur jedes zweite Element zur Summe hinzugefügt werden.

<?php
	$arr = array(10, 10, 10);
	$sum = 0;
	foreach ($arr as $key=>$val) {
		$sum += $val;
	}
	var_dump($sum);
?>

int(30)

3. array_walk()

Sehr ähnlich zur foreach-Schleife ist die Anwendung von array_walk($array, $callback), welches über alle Elemente in $array iteriert und jedes mal $callback mit dem Wert und dem Schlüssel des Elements aufruft.

<?php
	$arr = array(10, 10, 10);
	$sum = 0;
	array_walk($arr, function($val, $key) use (&$sum) {
		$sum += $val;
	});
	var_dump($sum);
?>

int(30)

4. array_filter()

Ähnlich wiederum zu array_walk() kann array_filter($array, $callback) angewendet werden. Diese Funktion ist eigentlich dazu gedacht, aus $array bestimmte Werte herauszufiltern. (Welche genau das sind, soll dann von der Callback-Funktion bestimmt werden.) Sie lässt sich aber auch zum Iterieren über das Array zweckentfremden, indem für jedes Element zurückgegeben wird, dass es Teil des Arrays bleiben soll. Die Anwendung erfolgt analog zu array_walk(): In der Callback-Funktion wird der Wert jedes Elements zur Summe addiert. Zusätzlich muss noch für jeden Wert ein (bool)true zurückgegeben werden, sodass array_filter() diesen im Array belässt.

<?php
	$arr = array(10, 10, 10);
	$sum = 0;
	array_filter($arr, function($val) use (&$sum) {
		$sum += $val;
		return true;
	});
	var_dump($sum);
?>

int(30)

5. array_reduce()

In Anlehnung an die funktionale Programmierung kann array_reduce($array, $callback) verwendet werden. Diese Funktion wendet auf jedes Paar aus zwei Werten die Funktion $callback an und ersetzt das Paar durch die Rückgabe selbiger Callback-Funktion. Dieser Vorgang wird so lange wiederholt, bis $array nur noch aus einem Wert besteht, welcher dann wiederum von array_reduce zurückgegeben wird.

<?php
	$arr = array(10, 10, 10);
	$sum = array_reduce($arr, function($left, $right) {
		return $left + $right;
	});
	var_dump($sum);
?>

int(30)

6. Bei mehrdimensionalem Array

Auf mehrdimensionale Arrays kann array_sum() nicht angewendet werden. In diesen Fällen sollte auf das Vorgehen aus array_walk() zurückgegriffen werden. Statt array_walk() muss allerdings array_walk_recursive($array, $callback) verwendet werden. Diese Funktion wendet $callback rekursiv auf alle Elemente an. Auch über Unterarrays wird also iteriert.

<?php
	$arr = array(10, 10, array(10, 10));
	$sum = 0;
	array_walk_recursive($arr, function($val, $key) use (&$sum) {
		$sum += $val;
	});
	var_dump($sum);
?>

int(40)

7. Summe der Schlüssel

Will man nicht die Summe der Werte, sondern stattdessen die Summe aller Schlüssel bestimmen, dann sollte zuvor ein Array aller Schlüssel gebildet werden, indem man array_keys($array) auf das Ausgangsarray anwendet. Auf die Rückgabe von array_keys() kann dann wiederum array_sum() angewendet werden, da die Werte der besagten Rückgabe den Schlüsseln im Ausgangsarray entsprechen.

<?php
	$arr = array(10 => 'a', 20 => 'b', 30 => 'c');
	var_dump(array_sum(array_keys($arr)));
?>

int(60)

Ebenfalls möglich ist es, Schlüssel und Werte im Array miteinander zu vertauschen. Dies kann über array_flip($array) erreicht werden. Der Weg kann aber nur dann angewendet werden, wenn man sich sicher ist, dass jeder Wert im Ausgangsarray einmalig ist. Andernfalls müssten sich im „vertauschten” Array mehrere ehemalige Werte den selben Schlüssel teilen. Da dies nicht möglich ist, würden entsprechend mehrere Werte wegfallen und nur noch einer übrig bleiben. Die zugehörigen Schlüssel, die diesen Werten vor dem Vertauschen zugeordnet waren, würden dann ebenfalls wegfallen.

<?php
	$arr = array(10 => 'a', 20 => 'b', 30 => 'c');
	$flipped = array_flip($arr);
	var_dump(array_sum($flipped));

	// Das funktioniert nicht korrekt, da nicht jeder Wert einmalig ist
	$arr = array(10 => 1, 20 => 1, 30 => 1, 40 => 2);
	$flipped = array_flip($arr);
	print_r($flipped);
	var_dump(array_sum($flipped));
?>

int(60)
Array
(
    [1] => 30
    [2] => 40
)
int(70)