PHP
Exécuter sur un tableau

Application d'une fonction à chaque élément d'un tableau

Pour appliquer une fonction à chaque élément d'un tableau, utilisez array_map() . Cela retournera un nouveau tableau.

$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 est maintenant array(2,3,4,5,6); .

Au lieu d'utiliser une fonction anonyme , vous pouvez utiliser une fonction nommée. Ce qui précède pourrait être écrit comme:

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

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

Si la fonction nommée est une méthode de classe, l'appel de la fonction doit inclure une référence à un objet de classe auquel la méthode appartient:

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);
    }
}

Un autre moyen d'appliquer une fonction à chaque élément d'un tableau est array_walk() et array_walk_recursive() . Le rappel transmis à ces fonctions prend à la fois la clé / l'index et la valeur de chaque élément du tableau. Ces fonctions ne renverront pas un nouveau tableau, mais un booléen pour le succès. Par exemple, pour imprimer chaque élément d'un tableau simple:

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

Le paramètre value du rappel peut être transmis par référence, ce qui vous permet de modifier la valeur directement dans le tableau d'origine:

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

$array maintenant est un array(2,3,4,5,6);

Pour les tableaux imbriqués, array_walk_recursive() ira plus loin dans chaque sous-tableau:

$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"

Remarque : array_walk et array_walk_recursive vous permettent de modifier la valeur des éléments du tableau, mais pas les clés. Passer les clés par référence dans le rappel est valide mais n'a aucun effet.

Diviser le tableau en morceaux

array_chunk () divise un tableau en morceaux

Disons que nous avons suivi un tableau à une dimension,

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

Maintenant, utilisez array_chunk () sur le tableau PHP ci-dessus,

$output_array = array_chunk($input_array, 2);

Le code ci-dessus crée des morceaux de 2 éléments de tableau et crée un tableau multidimensionnel comme suit.

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

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

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

)

Si tous les éléments du tableau ne sont pas divisés de manière égale par la taille du bloc, le dernier élément du tableau de sortie sera le reste des éléments.

Si nous passons le second argument à moins de 1 alors E_WARNING sera lancé et le tableau de sortie sera NULL .

Impliquer un tableau dans une chaîne

implode() combine toutes les valeurs du tableau mais perd toutes les informations clés:

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

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

Les clés d'implosion peuvent être faites en utilisant l' array_keys() à array_keys() :

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

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

L'implémentation de clés avec des valeurs est plus complexe mais peut être effectuée en utilisant un style fonctionnel:

$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 réduit le tableau en une seule valeur. Fondamentalement, le array_reduce parcourra chaque élément avec le résultat de la dernière itération et produira une nouvelle valeur à la prochaine itération.

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

• $ carry est le résultat du dernier tour d'itération.
• $ item est la valeur de la position actuelle dans le tableau.

Somme de tableau

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

résultat: 15

Le plus grand nombre dans le tableau

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

résultat: 211

Est-ce que tous les articles sont plus de 100

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

résultat: true

Est-ce qu'un objet moins de 100

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

résultat: true

Comme implode ($ array, $ piece)

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

résultat: "hello-world-PHP-language"

si faire une méthode d'implode, le code source sera:

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"], "-");

résultat: "hello-world-PHP-language"

Tableaux "Destructuration" à l'aide de list ()

Utilisez list () pour attribuer rapidement une liste de valeurs de variables dans un tableau. Voir aussi 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;

Avec PHP 7.1 (actuellement en version bêta), vous pourrez utiliser la syntaxe de liste courte :

// 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;

Poussez une valeur sur un tableau

Il y a deux manières de pousser un élément dans un tableau: array_push et $array[] =

Le array_push est utilisé comme ceci:

$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

Ce code va imprimer:

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

$array[] = est utilisé comme ceci:

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

Ce code va imprimer:

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