PHP
Esecuzione su una matrice

Applicazione di una funzione a ciascun elemento di una matrice

Per applicare una funzione a ogni elemento in una matrice, utilizzare array_map() . Ciò restituirà un nuovo array.

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

Invece di usare una funzione anonima , potresti usare una funzione con nome. Quanto sopra potrebbe essere scritto come:

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

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

Se la funzione named è un metodo di classe, la chiamata della funzione deve includere un riferimento a un oggetto classe a cui appartiene il metodo:

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 altro modo per applicare una funzione a ogni elemento di un array è array_walk() e array_walk_recursive() . Il callback passato a queste funzioni prende sia la chiave / l'indice sia il valore di ciascun elemento dell'array. Queste funzioni non restituiranno un nuovo array, bensì un booleano per il successo. Ad esempio, per stampare ogni elemento in un array semplice:

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

Il parametro value del callback può essere passato per riferimento, consentendo di modificare il valore direttamente nell'array originale:

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

$array ora è array(2,3,4,5,6);

Per gli array annidati, array_walk_recursive() andrà più in profondità in ogni sotto-array:

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

Nota : array_walk e array_walk_recursive consentono di modificare il valore degli elementi dell'array, ma non le chiavi. Il passaggio delle chiavi per riferimento nel callback è valido ma non ha alcun effetto.

Dividi l'array in blocchi

array_chunk () divide una matrice in blocchi

Diciamo che abbiamo seguito un array monodimensionale,

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

Ora usando array_chunk () sopra l'array PHP sopra,

$output_array = array_chunk($input_array, 2);

Sopra il codice verranno creati blocchi di 2 elementi di array e verrà creato un array multidimensionale come segue.

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

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

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

)

Se tutti gli elementi dell'array non sono equamente divisi per la dimensione del blocco, l'ultimo elemento dell'array di output saranno gli elementi rimanenti.

Se passiamo il secondo argomento meno di 1, verrà generato E_WARNING e l'array di output sarà NULL .

Implodendo un array in una stringa

implode() combina tutti i valori dell'array ma perde tutte le informazioni chiave:

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

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

Le chiavi di impaginazione possono essere eseguite usando la chiamata a array_keys() :

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

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

Implodere chiavi con valori è più complesso ma può essere fatto usando lo stile funzionale:

$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 riduce l'array in un singolo valore. Fondamentalmente, array_reduce attraverserà ogni elemento con il risultato dell'ultima iterazione e produrrà un nuovo valore alla successiva iterazione.

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

• $ carry è il risultato dell'ultimo round di iterazione.
• $ item è il valore della posizione corrente nell'array.

Somma dell'array

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

risultato: 15

Il numero più grande nella matrice

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

risultato: 211

È tutto l'oggetto più di 100

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

risultato: true

È un articolo inferiore a 100

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

risultato: true

Come implode ($ array, $ pezzo)

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

risultato: "hello-world-PHP-language"

se si esegue un metodo implode, il codice sorgente sarà:

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

risultato: "hello-world-PHP-language"

"Distruzione" di array usando list ()

Utilizzare list () per assegnare rapidamente un elenco di valori variabili a un array. Vedi anche 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;

Con PHP 7.1 (attualmente in beta) sarai in grado di utilizzare la sintassi della short list :

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

Spingere un valore su una matrice

Esistono due modi per array_push un elemento in un array: array_push e $array[] =

Array_push è usato in questo modo:

$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

Questo codice stamperà:

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

$array[] = è usato in questo modo:

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

Questo codice stamperà:

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