PHP
Auf einem Array ausführen

Anwenden einer Funktion auf jedes Element eines Arrays

Um eine Funktion auf jedes Element in einem Array array_map() , verwenden Sie array_map() . Dadurch wird ein neues Array zurückgegeben.

$array = array(1,2,3,4,5);
//each array item is iterated over and gets stored in the function parameter.
$newArray = array_map(function($item) {
    return $item + 1;
}, $array);

$newArray jetzt ein array(2,3,4,5,6); .

Anstelle einer anonymen Funktion können Sie auch eine benannte Funktion verwenden. Das Obige könnte wie folgt geschrieben werden:

function addOne($item) {
    return $item + 1;
}

$array = array(1, 2, 3, 4, 5);
$newArray = array_map('addOne', $array);

Wenn die benannte Funktion eine Klassenmethode ist, muss der Aufruf der Funktion einen Verweis auf ein Klassenobjekt enthalten, zu dem die Methode gehört:

class Example {
    public function addOne($item) {
        return $item + 1;
    }

    public function doCalculation() {
        $array = array(1, 2, 3, 4, 5);
        $newArray = array_map(array($this, 'addOne'), $array);
    }
}

Eine andere Möglichkeit, eine Funktion auf jedes Element in einem Array array_walk() ist array_walk() und array_walk_recursive() . Der an diese Funktionen übergebene Callback nimmt sowohl den Schlüssel / Index als auch den Wert jedes Arrayelements an. Diese Funktionen geben kein neues Array zurück, sondern ein Boolean für den Erfolg. So drucken Sie beispielsweise jedes Element in einem einfachen Array:

$array = array(1, 2, 3, 4, 5);
array_walk($array, function($value, $key) {
    echo $value . ' ';
});
// prints "1 2 3 4 5"

Der value-Parameter des Callbacks kann als Referenz übergeben werden, sodass Sie den Wert direkt im ursprünglichen Array ändern können:

$array = array(1, 2, 3, 4, 5);
array_walk($array, function(&$value, $key) {
    $value++;
});

$array jetzt array(2,3,4,5,6);

Bei verschachtelten Arrays geht array_walk_recursive() tiefer in jedes array_walk_recursive() :

$array = array(1, array(2, 3, array(4, 5), 6);
array_walk_recursive($array, function($value, $key) {
    echo $value . ' ';
});
// prints "1 2 3 4 5 6"

Hinweis : Mit array_walk und array_walk_recursive Sie den Wert von Array-Elementen ändern, nicht jedoch die Schlüssel. Das Übergeben der Schlüssel als Referenz an den Rückruf ist gültig, hat jedoch keine Auswirkungen.

Array in Stücke aufteilen

array_chunk () teilt ein Array in Chunks auf

Nehmen wir an, wir haben ein eindimensionales Array verfolgt,

$input_array = array('a', 'b', 'c', 'd', 'e');

Jetzt mit array_chunk () über dem PHP-Array,

$output_array = array_chunk($input_array, 2);

Mit dem obigen Code werden Blöcke aus zwei Array-Elementen und ein mehrdimensionales Array wie folgt erstellt.

Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
        )

    [1] => Array
        (
            [0] => c
            [1] => d
        )

    [2] => Array
        (
            [0] => e
        )

)

Wenn nicht alle Elemente des Arrays gleichmäßig durch die Blockgröße geteilt werden, sind das letzte Element des Ausgabearrays die verbleibenden Elemente.

Wenn wir das zweite Argument als weniger als 1 übergeben, wird E_WARNING geworfen und das Ausgabearray wird NULL .

Ein Array in einen String implodieren

implode() fasst alle Array-Werte zusammen, verliert jedoch alle wichtigen Informationen:

$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];

echo implode(" ", $arr); // AA BB CC

Implodierende Schlüssel können mit dem array_keys() von array_keys() :

$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];

echo implode(" ", array_keys($arr)); // a b c

Das Implodieren von Schlüsseln mit Werten ist komplexer, kann jedoch im funktionalen Stil erfolgen:

$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];

echo implode(" ", array_map(function($key, $val) { 
    return "$key:$val"; // function that glues key to the value
}, array_keys($arr), $arr)); 

// Output: a:AA b:BB c:CC

array_reduce

array_reduce reduziert das Array in einen einzigen Wert. Grundsätzlich array_reduce The array_reduce jedes Element mit dem Ergebnis der letzten Iteration und erzeugt einen neuen Wert für die nächste Iteration.

Verwendung: array_reduce ($array, function($carry, $item){...}, $defaul_value_of_first_carry)

• $ carry ist das Ergebnis der letzten Iterationsrunde.
• $ item ist der Wert der aktuellen Position im Array.

Summe des Arrays

$result = array_reduce([1, 2, 3, 4, 5], function($carry, $item){
    return $carry + $item;
});

Ergebnis: 15

Die größte Zahl im Array

$result = array_reduce([10, 23, 211, 34, 25], function($carry, $item){
        return $item > $carry ? $item : $carry;
});

Ergebnis: 211

Ist alles mehr als 100

$result = array_reduce([101, 230, 210, 341, 251], function($carry, $item){
        return $carry && $item > 100;
}, true); //default value must set true

Ergebnis: true

Ist ein Artikel kleiner als 100

$result = array_reduce([101, 230, 21, 341, 251], function($carry, $item){
        return $carry || $item < 100;
}, false);//default value must set false

Ergebnis: true

Wie implodieren ($ array, $ piece)

$result = array_reduce(["hello", "world", "PHP", "language"], function($carry, $item){
        return !$carry ? $item : $carry . "-" . $item ;
});

Ergebnis: "hello-world-PHP-language"

Wenn Sie eine implodierte Methode erstellen, lautet der Quellcode:

function implode_method($array, $piece){
    return array_reduce($array, function($carry, $item) use ($piece) {
            return !$carry ? $item : ($carry . $piece . $item);
    });
}

$result = implode_method(["hello", "world", "PHP", "language"], "-");

Ergebnis: "hello-world-PHP-language"

Arrays "destructuring" mit list ()

Verwenden Sie list () , um eine Liste von Variablenwerten schnell einem Array zuzuweisen. Siehe auch compact ()

// Assigns to $a, $b and $c the values of their respective array elements in           $array with keys numbered from zero
list($a, $b, $c) = $array;

Mit PHP 7.1 (derzeit in der Beta-Version) können Sie die Kurzlistensyntax verwenden :

// Assigns to $a, $b and $c the values of their respective array elements in $array with keys numbered from zero
[$a, $b, $c] = $array;

// Assigns to $a, $b and $c the values of the array elements in $array with the keys "a", "b" and "c", respectively
["a" => $a, "b" => $b, "c" => $c] = $array;

Drücken Sie einen Wert in ein Array

Es gibt zwei Möglichkeiten, ein Element in ein Array zu verschieben: array_push und $array[] =

Das array_push wird wie folgt verwendet:

$array = [1,2,3];
$newArraySize = array_push($array, 5, 6); // The method returns the new size of the array
print_r($array); // Array is passed by reference, therefore the original array is modified to contain the new elements

Dieser Code wird gedruckt:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
    [4] => 6
)

$array[] = wird wie folgt verwendet:

$array = [1,2,3];
$array[] = 5;
$array[] = 6;
print_r($array);

Dieser Code wird gedruckt:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
    [4] => 6
)