PHP
Ejecutando sobre una matriz

Aplicando una función a cada elemento de una matriz.

Para aplicar una función a cada elemento de una matriz, use array_map() . Esto devolverá una nueva matriz.

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

En lugar de usar una función anónima , podría usar una función nombrada. Lo anterior podría escribirse como:

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

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

Si la función nombrada es un método de clase, la llamada de la función debe incluir una referencia a un objeto de clase al que pertenece el método:

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

Otra forma de aplicar una función a cada elemento de una matriz es array_walk() y array_walk_recursive() . La devolución de llamada pasada a estas funciones toma tanto la clave / índice como el valor de cada elemento de la matriz. Estas funciones no devolverán una nueva matriz, en lugar de un booleano para el éxito. Por ejemplo, para imprimir cada elemento en una matriz simple:

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

El parámetro de valor de la devolución de llamada se puede pasar por referencia, lo que le permite cambiar el valor directamente en la matriz original:

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

$array ahora es array(2,3,4,5,6);

Para matrices anidadas, array_walk_recursive() irá más profundo en cada sub-matriz:

$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 y array_walk_recursive permiten cambiar el valor de los elementos de la matriz, pero no las claves. Pasar las claves por referencia a la devolución de llamada es válido pero no tiene ningún efecto.

Dividir matriz en trozos

array_chunk () divide una matriz en trozos

Digamos que estamos siguiendo una matriz unidimensional,

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

Ahora usando array_chunk () en la matriz de PHP anterior,

$output_array = array_chunk($input_array, 2);

El código anterior creará fragmentos de 2 elementos de matriz y creará una matriz multidimensional como sigue.

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

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

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

)

Si todos los elementos de la matriz no están divididos equitativamente por el tamaño del fragmento, el último elemento de la matriz de salida serán los elementos restantes.

Si pasamos el segundo argumento como menos de 1, se lanzará E_WARNING y la matriz de salida será NULL .

Implementando una matriz en una cadena

implode() combina todos los valores de la matriz pero pierde toda la información clave:

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

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

Las claves de array_keys() se pueden hacer usando array_keys() call:

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

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

Implodificar claves con valores es más complejo, pero se puede hacer usando un estilo funcional:

$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 reduce la matriz en un solo valor. Básicamente, el array_reduce pasará por cada elemento con el resultado de la última iteración y producirá un nuevo valor para la siguiente iteración.

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

• $ carry es el resultado de la última ronda de iteración.
• $ item es el valor de la posición actual en la matriz.

Suma de la matriz

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

resultado: 15

El número más grande en la matriz

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

resultado: 211

Es todo el artículo más de 100

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

resultado: true

Es cualquier artículo menos de 100

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

resultado: true

Como implosionar ($ array, $ pieza)

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

resultado: "hello-world-PHP-language"

Si se hace un método de implosión, el código fuente será:

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

resultado: "hello-world-PHP-language"

Arreglos de "destrucción" usando list ()

Use list () para asignar rápidamente una lista de valores variables a una matriz. Ver también compacta ()

// 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 (actualmente en versión beta) podrá usar la sintaxis de la lista corta :

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

Presionar un valor en una matriz

Hay dos formas de insertar un elemento en una matriz: array_push y $array[] =

El array_push se usa así:

$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

Este código se imprimirá:

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

$array[] = se usa así:

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

Este código se imprimirá:

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