Mis notas favoritas sobre informática, siempre a mano..

Los basicos

Hay dos formas diferentes de crear matrices. Uno es para array() especificar los elementos como pares clave-valor. El otro método es poner todos los elementos dentro []. Hay dos puntos importantes que debe recordar al crear matrices asociadas con pares de claves.

Primero, la clave siempre tiene que ser única. Si intenta usar la misma clave varias veces en una matriz, PHP ignorará todos los demás pares clave-valor excepto el último. En segundo lugar, si una clave se crea como flotantes, booleanos y representaciones de cadenas válidas de enteros, se convertirá en enteros.

Aquí hay algunos ejemplos de creación de matrices en PHP:

$first = array(10, "Apple", 20, -18, "Monkey");
print_r($first);
/* Array
(
    [0] => 10
    [1] => Apple
    [2] => 20
    [3] => -18
    [4] => Monkey
) */
 
$second = [10, "Apple", 20, -18, "Monkey"];
print_r($second);
/* Array
(
    [0] => 10
    [1] => Apple
    [2] => 20
    [3] => -18
    [4] => Monkey
) */
 
$third = [10, 5 => "Apple", 2 => 20, -18, "Monkey"];
print_r($third);
/* Array
(
    [0] => 10
    [5] => Apple
    [2] => 20
    [6] => -18
    [7] => Monkey
) */

Como puede ver, usar array() o []es equivalente al crear matrices. La notación abreviada ha estado disponible a partir de PHP 5.4.

Tampoco necesita especificar una clave para cada valor de matriz. Cuando se omite, PHP establece la clave en uno más que la clave entera especificada más grande. Todas las claves asignadas automáticamente serán mayores o iguales a 0.

Trabajar con claves y valores

Comencemos con las funciones básicas que funcionan con claves de matriz y valores. Uno de ellos es array_combine(), que crea una matriz utilizando una matriz para claves y otra para sus valores:

$keys = ['sky', 'grass', 'orange'];
$values = ['blue', 'green', 'orange'];
 
$array = array_combine($keys, $values);
print_r($array);
 
// Array
// (
//     [sky] => blue
//     [grass] => green
//     [orange] => orange
// )

Debe saber que la array_values()función devuelve una matriz indexada de valores, array_keys() devuelve una matriz de claves de una matriz determinada e array_flip() intercambia claves con valores:

print_r(array_keys($array)); // ['sky', 'grass', 'orange']
print_r(array_values($array)); // ['blue', 'green', 'orange']
print_r(array_flip($array));
 
// Array
// (
//     [blue] => sky
//     [green] => grass
//     [orange] => orange
// )

Puede verificar si una matriz contiene un valor específico y obtener su primera clave correspondiente usando la array_search() función. También puede usarlo in_array() si solo desea saber si una matriz contiene un elemento específico y no está interesado en su posición. Considere usar la array_key_exists() función cuando desee verificar si la matriz usa una clave determinada.

$values = ["Apples", "Bananas", "Mangoes", "100", "200"];
 
if(in_array(100, $values)) {
    echo '100 is one of the values';
}
// 100 is one of the values
 
if(in_array(200, $values) !== false) {
    echo '200 is not one of the values';
}
// 200 is not one of the values
 
$values = ["Apples", "Bananas", "Mangoes", "100", "200", 100];
 
echo array_search(100, $values);
// 3
 
echo array_search(100, $values, true);
// 5
 
$values = ["Apples" => 100, "Bananas" => 10, "Mangoes" => 45];
 
if(array_key_exists("Apples", $values)) {
    echo 'We have apples.';
}
// We have apples.

Como muestra el ejemplo anterior, asegúrese de utilizar una verificación estricta de tipos si no desea obtener resultados inesperados.

Si desea buscar varios elementos en una matriz, generalmente es más rápido verificar si contiene un valor en particular primero volteando la matriz con array_flip() y luego usando array_key_exists().

Haz tu código más corto

La list()función, que no es realmente una función sino una construcción del lenguaje, está diseñada para asignar variables de forma breve. Por ejemplo, aquí hay un ejemplo básico del uso de la list() función:

// define array
$array = ['a', 'b', 'c'];
 
// without list()
$a = $array[0];
$b = $array[1];
$c = $array[2];
 
// with list()
list($a, $b, $c) = $array;

Esta construcción funciona perfectamente con funciones como preg_slit() o explode() . Además, puede omitir algunos parámetros si no necesita definirlos:

$string = 'hello|wild|world';
list($hello, , $world) = explode('|', $string);
echo("$hello, $world"); // hello, world

Además, list() se puede usar con foreach, lo que hace que esta construcción sea aún mejor:

$arrays = [[1, 2], [3, 4], [5, 6]];
 
foreach ($arrays as list($a, $b)) {
    $c = $a + $b;
    echo($c . ', '); // 3, 7, 11, 
}

Con la extract() función, puede exportar una matriz asociativa a variables. Para cada elemento de una matriz, se creará una variable con el nombre de una clave y un valor como valor del elemento:

$array = [
    'clothes' => 't-shirt',
    'size'    => 'medium',
    'color'   => 'blue',
];
 
extract($array);
 
echo("$clothes $size $color"); // t-shirt medium blue

Tenga en cuenta que extract() no es seguro si está trabajando con datos de usuario (como resultados de solicitudes), por lo que es mejor usar esta función con las banderas EXTR_IF_EXISTS y EXTR_PREFIX_ALL.

Lo contrario de la función anterior es la compact() función, que hace una matriz asociativa a partir de variables:

$clothes = 't-shirt';
$size = 'medium';
$color = 'blue';
 
$array = compact('clothes', 'size', 'color');
print_r($array);
 
// Array
// (
//     [clothes] => t-shirt
//     [size] => medium
//     [color] => blue
// )

Funciones de filtrado

Hay una gran función para el filtrado de matrices, y se llama array_filter(). Pase la matriz como primer parámetro y una función anónima como segundo parámetro. Regrese true en una función de devolución de llamada si desea dejar este elemento en la matriz, y false si no lo desea:

$numbers = [20, -3, 50, -99, 55];
 
$positive = array_filter($numbers, function($number) {
    return $number > 0;
});
 
print_r($positive); // [0 => 20, 2 => 50, 4 => 55]

Hay una manera de filtrar no solo por los valores. Puede usar ARRAY_FILTER_USE_KEY o ARRAY_FILTER_USE_BOTH como tercer parámetro para pasar la clave o tanto el valor como la clave a la función de devolución de llamada.

Además, puede llamar array_filter() sin una devolución de llamada para eliminar todos los valores vacíos:

$numbers = [-1, 0, 1];
 
$not_empty = array_filter($numbers);
 
print_r($not_empty); // [0 => -1, 2 => 1]

Solo puede obtener valores únicos de una matriz usando la array_unique() función. Tenga en cuenta que la función conservará las claves de los primeros elementos únicos:

$array = [1, 1, 1, 1, 2, 2, 2, 3, 4, 5, 5];
$uniques = array_unique($array);
 
print_r($uniques);
 
// Array
// (
//     [0] => 1
//     [4] => 2
//     [7] => 3
//     [8] => 4
//     [9] => 5
// )

Con array_column(), puede obtener una lista de valores de columna de una matriz multidimensional, como una respuesta de una base de datos SQL o una importación de un archivo CSV. Simplemente pase una matriz y un nombre de columna:

$array = [
    ['id' => 1, 'title' => 'tree'],
    ['id' => 2, 'title' => 'sun'],
    ['id' => 3, 'title' => 'cloud'],
];
 
$ids = array_column($array, 'id');
 
print_r($ids); // [1, 2, 3]

A partir de PHP 7, array_column() se vuelve aún más poderoso, porque ahora se le permite trabajar con una matriz de objetos . Así que trabajar con una variedad de modelos se volvió más fácil:

$cinemas = Cinema::find()->all();
$cinema_ids = array_column($cinemas, 'id'); // php7 forever!

Caminando a través de las matrices

Usando array_map(), puede aplicar una devolución de llamada a cada elemento de una matriz. Puede pasar un nombre de función o una función anónima para obtener una nueva matriz basada en la matriz dada:

$cities = ['Berlin', 'KYIV', 'Amsterdam', 'Riga'];
$aliases = array_map('strtolower', $cities);
 
print_r($aliases); // ['berlin', 'kyiv, 'amsterdam', 'riga']
 
$numbers = [1, -2, 3, -4, 5];
$squares = array_map(function($number) {
    return $number ** 2;
}, $numbers);
 
print_r($squares);  // [1, 4, 9, 16, 25]

Existe el mito de que no hay forma de pasar valores y claves de una matriz a una devolución de llamada, pero podemos romperlo:

$model = ['id' => 7, 'name'=>'James'];
 
$callback = function($key, $value) {
    return "$key is $value";
};
 
$res = array_map($callback, array_keys($model), $model);
print_r($res);
 
// Array
// (
//     [0] => id is 7
//     [1] => name is James
// )

Pero esto parece sucio. Es mejor usar en su array_walk() lugar. Esta función tiene el mismo aspecto que array_map(), pero funciona de manera diferente. En primer lugar, una matriz se pasa mediante una referencia, por lo array_walk() que no crea una nueva matriz, sino que cambia una matriz determinada. Entonces, como una matriz de origen, puede pasar el valor de la matriz usando una referencia en una devolución de llamada. Las claves de matriz también se pueden pasar fácilmente:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
$fruits = [
    'banana' => 'yellow',
    'apple' => 'green',
    'orange' => 'orange',
];
 
array_walk($fruits, function(&$value, $key) {
    $value = "$key is $value";
});
 
print_r($fruits);
 
// Array
// (
//     [banana] => banana is yellow
//     [apple] => apple is green
//     [orange] => orange is orange
// )

Unirse a las matrices

La mejor manera de fusionar dos o más arreglos en PHP es usar la array_merge() función. Los elementos de las matrices se fusionarán y los valores con las mismas claves de cadena se sobrescribirán con el último valor:

$array1 = ['a' => 'a', 'b' => 'b', 'c' => 'c'];
$array2 = ['a' => 'A', 'b' => 'B', 'D' => 'D'];
 
$merge = array_merge($array1, $array2);
print_r($merge);
// Array
// (
//     [a] => A
//     [b] => B
//     [c] => c
//     [D] => D
// )

Para eliminar valores de matriz de otra matriz (o matrices), use array_diff(). Para obtener valores que están presentes en matrices dadas, use array_intersect(). Los siguientes ejemplos mostrarán cómo funciona:

$array1 = [1, 2, 3, 4];
$array2 =       [3, 4, 5, 6];
 
$diff = array_diff($array1, $array2);
print_r($diff); // [0 => 1, 1 => 2]
 
$intersect = array_intersect($array1, $array2);
print_r($intersect);  // [2 => 3, 3 => 4]

Haz las matemáticas con valores de matriz

Úselo array_sum() para obtener una suma de valores de matriz, array_product() para multiplicarlos o crear su propia fórmula con array_reduce():

$numbers = [1, 2, 3, 4, 5];
 
echo(array_sum($numbers)); // 15
echo(array_product($numbers)); // 120
 
echo(array_reduce($numbers, function($carry, $item) {
    return $carry ? $carry / $item : 1;
})); // 0.0083 = 1/2/3/4/5

Para contar todos los valores de una matriz, utilice array_count_values(). Dará todos los valores únicos de una matriz determinada como claves y un recuento de estos valores como valor:

$things = ['apple', 'apple', 'banana', 'tree', 'tree', 'tree'];
$values = array_count_values($things);
 
print_r($values);
 
// Array
// (
//     [apple] => 2
//     [banana] => 1
//     [tree] => 3
// )

Generación de matrices

Para generar una matriz con un tamaño dado y el mismo valor, use array_fill():

$bind = array_fill(0, 5, '?');
print_r($bind); // ['?', '?', '?', '?', '?']

Para generar una matriz con un rango de claves y valores, como horas del día o letras, use range() :

$letters = range('a', 'z');
print_r($letters); // ['a', 'b', ..., 'z']
 
$hours = range(0, 23);
print_r($hours); // [0, 1, 2, ..., 23]

Para obtener una parte de una matriz, por ejemplo, solo los primeros tres elementos, use array_slice():

$numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
$top = array_slice($numbers, 0, 3);
print_r($top); // [1, 2, 3]

Si alguna vez desea generar una matriz asociativa con diferentes claves y el mismo valor asignado a cada tecla, simplemente puede usar la array_fill_keys() función.

$keys = ["Apples", "Bananas", "Mangoes"];
$fruit_count = array_fill_keys($keys, 100);
 
print_r($fruit_count);
 
/* Array
(
    [Apples] => 100
    [Bananas] => 100
    [Mangoes] => 100
) */

Clasificación de matrices

Es bueno recordar que cada función de clasificación en PHP funciona con matrices por una referencia y devuelve verdadero en caso de éxito o falso en caso de falla. Hay una función de clasificación básica llamada sort(), y clasifica los valores en orden ascendente sin conservar las claves. La función de clasificación se puede anteponer con las siguientes letras:

a , ordenar preservando claves
k , ordenar por claves
r , ordenar en orden inverso/descendente
u , ordenar con una función de usuario

Puedes ver las combinaciones de estas letras en la siguiente tabla:

	un	k	r	tu
un	`asort()`		`arsort()`	`uasort()`
k		`ksort()`	`krsort()`
r	`arsort()`	`krsort()`	`rsort()`
tu	`uasort()`			`usort()`

Combinar funciones de matriz como un jefe

La verdadera magia comienza cuando comienzas a combinar funciones de matriz. Así es como puede recortar y eliminar valores vacíos en una sola línea de código con array_filter() y array_map():

$values = ['say  ', '  bye', ' ', ' to', ' spaces ', '   '];
 
$words = array_filter(array_map('trim', $values));
print_r($words); // ['say', 'bye', 'to', 'spaces']

Para crear una identificación para un mapa de título a partir de una serie de modelos, podemos usar una combinación de array_combine() y array_column():

$models = [$model1, $model2, $model3];
 
$id_to_title = array_combine(
    array_column($models, 'id'),
    array_column($models, 'title')
);

Para obtener los tres primeros valores de una matriz, podemos usar array_count_values(), arsort()y array_slice():

$letters = ['a', 'a', 'a', 'a', 'b', 'b', 'c', 'd', 'd', 'd', 'd', 'd'];
 
$values = array_count_values($letters); // get key to count array
arsort($values); // sort descending preserving key
$top = array_slice($values, 0, 3); // get top 3
 
print_r($top);
// Array
// (
//     [d] => 5
//     [a] => 4
//     [b] => 2
// )

Es fácil de usar array_sum() y array_map() calcular la suma del pedido en unas pocas filas:

$order = [
    ['product_id' => 1, 'price' => 99, 'count' => 1],
    ['product_id' => 2, 'price' => 50, 'count' => 2],
    ['product_id' => 2, 'price' => 17, 'count' => 3],
];
 
$sum = array_sum(array_map(function($product_row) {
    return $product_row['price'] * $product_row['count'];
}, $order));
 
print_r($sum); // 250

Conclusión

Como puede ver, el conocimiento de las funciones principales de la matriz puede hacer que su código sea mucho más breve y legible. Por supuesto, PHP tiene muchas más funciones de matriz, e incluso las funciones dadas tienen muchas variaciones para usar con parámetros y banderas adicionales, pero creo que en este tutorial hemos cubierto los conceptos básicos que todo desarrollador de PHP debería saber.

Fuente en ingles:

https://code.tutsplus.com/tutorials/working-with-php-arrays-in-the-right-way--cms-28606