Ist der erste und einzige Parameter ein Array, gibt
max() den größten Wert dieses Arrays zurück. Werden
mindestens zwei Parameter übergeben, gibt max() den
größeren dieser Werte zurück.
Hinweis:
Werte unterschiedlichen Typs werden unter Verwendung der
Standard-Vergleichsregeln
verglichen. Zum Beispiel wird ein nichtnumerischer string mit
einem int verglichen, als ob er 0 wäre,
aber mehrere nichtnumerische string-Werte werden
alphanumerisch verglichen. Der tatsächlich zurückgegebene Wert ist vom
ursprünglichen Typ ohne angewandte Umwandlung.
Achtung
Vorsicht ist geboten, wenn Argumente verschiedenen Typs übergeben werden,
da max() in diesem Fall unvorhersehbare Ergebnisse
liefert.
max() gibt den gemäß den Standard-Vergleichen als
"größten" angesehenen Parameter-Wert zurück. Evaluieren mehrere Werte
unterschiedlichen Typs als gleich (z. B. 0 und
'abc'), wird der zuerst übergebene zurückgegeben.
max() löst bei einem Fehler nun einen
ValueError aus; vorher wurde false
zurückgegeben und ein Fehler der Stufe E_WARNING
ausgegeben.
8.0.0
Die Art und Weise, wie
Zeichenketten und Zahlen verglichen werden,
wurde geändert, sodass max() in solchen Fällen nicht
mehr je nach Reihenfolge der Argumente unterschiedliche Werte
zurückgibt.
// Hier vergleichen wir -1 < 0, sodass 'hallo' der größte Wert ist echo max('hallo', -1), PHP_EOL; // hallo
// Bei mehreren Arrays unterschiedlicher Länge, gibt max das längste zurück $val = max(array(2, 2, 2), array(1, 1, 1, 1)); // array(1, 1, 1, 1) var_dump($val);
// Mehrere Arrays gleicher Länge werden von links nach rechts verglichen, // daher ist in unserem Beispiel 2 == 2, aber 5 > 4 $val = max(array(2, 4, 8), array(2, 5, 1)); // array(2, 5, 1) var_dump($val);
// Sind ein Array und ein Nicht-Array-Parameter gegeben, wird das Array zurückgegeben, // da Vergleiche Arrays als größer behandeln als alle anderen Werte $val = max('string', array(2, 5, 7), 42); // array(2, 5, 7) var_dump($val);
// Ist ein Argument NULL oder ein boolescher Wert, wird es mit anderen Werten // unter Verwendung der Regel FALSE < TRUE verglichen, ohne Rücksicht auf die anderen beteiligten Typen // Im folgenden Beispiel wird -10 im Vergleich wie TRUE behandelt $val = max(-10, FALSE); // -10 var_dump($val);
// Andererseits wird 0 wie FALSE behandelt, so dass es "kleiner" ist als TRUE $val = max(0, TRUE); // TRUE var_dump($val); ?>
With modern PHP versions supporting the array spread operator for function arguments, it's tempting to call max() like this:
<?php function stuff(): iterable { // This function might yield 0, 1 or n values. }
$foo = max(...stuff()); ?>
However, this is dangerous if you cannot guarantee that your generator yields **minimum** two values.
The gotcha here is that when max() receives a single argument, it must be an array of values. (When the generator doesn't yield any values, max() will throw an ArgumentCountError.)
If you can guarantee that your generator yields at least one value, then it's safe to call max by relying on the aforementioned array expectation:
<?php function stuff(): iterable { // This function will yield 1...n values. }
// Note that here the generator is first read into an array. $foo = max([...stuff()]); ?>
If the array is empty, max() will throw a ValueError.
The added burden is that faulty code could appear to appear to function just fine but fails at random, probably causing a lot of head-scratching at first.
(a) If any of your parameters is boolean, max and min will cast the rest of them to boolean to do the comparison. (b) true > false (c) However, max and min will return the actual parameter value that wins the comparison (not the cast).
Be aware if a array like this is used (e.g. values from a shopping cart): <?php Array ( [0] => 142,80 [1] => 39,27 [2] => 22,80 [3] => 175,80 )?> The result will be: 39,27 and not - as expected - 175,80
So, to find the max value, use integer only like: <?php Array ( [0] => 14280 [1] => 3927 [2] => 2280 [3] => 17580 )?> and you will get the correct result: 17580
If you want to find the specific key(s) that match the maximum value in an array where the values may be duplicated, you can loop through and perform a simple check: <?php
# Create a new array containing all keys which have the max value foreach($a as $key => $val) { if($val === $max) $b[] = $key; }
# If you want a string list, just do this $b = implode(' ', $b); ?>
This produces consistent results and will scale well in terms of performance, whereas functions like array_search and array_flip can lead to degraded performance when dealing with large amounts of data.