PHP
Manipulando una matriz

Eliminar elementos de una matriz

Para eliminar un elemento dentro de una matriz, por ejemplo, el elemento con el índice 1.

$fruit = array("bananas", "apples", "peaches");
unset($fruit[1]);

Esto eliminará las manzanas de la lista, pero tenga en cuenta que unset no cambia los índices de los elementos restantes. Así que $fruit ahora contiene los índices 0 y 2 .

Para matrices asociativas puedes eliminar así:

$fruit = array('banana', 'one'=>'apple', 'peaches');

print_r($fruit);
/*
    Array
    (
        [0] => banana
        [one] => apple
        [1] => peaches
    )
*/

unset($fruit['one']); 

Ahora $ fruta es

print_r($fruit);

/*
Array
(
    [0] => banana
    [1] => peaches
)
*/

Tenga en cuenta que

unset($fruit);

anula la variable y, por lo tanto, elimina toda la matriz, lo que significa que ninguno de sus elementos es accesible.

Eliminando elementos terminales

array_shift () : desplaza un elemento fuera del principio de la matriz.

Ejemplo:

  $fruit = array("bananas", "apples", "peaches");
  array_shift($fruit);
  print_r($fruit);

Salida:

 Array
(
    [0] => apples
    [1] => peaches
)

array_pop () : saca el elemento del final de la matriz.

Ejemplo:

  $fruit = array("bananas", "apples", "peaches");
  array_pop($fruit);
  print_r($fruit);

Salida:

 Array
(
    [0] => bananas
    [1] => apples
)

Filtrando una matriz

Para filtrar los valores de una matriz y obtener una nueva matriz que contenga todos los valores que satisfacen la condición del filtro, puede utilizar la función array_filter .

Filtrado de valores no vacíos

El caso más simple de filtrado es eliminar todos los valores "vacíos":

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$non_empties = array_filter($my_array); // $non_empties will contain [1,2,3,4,5,6,7,8]; 

Filtrado por devolución de llamada

Esta vez definimos nuestra propia regla de filtrado. Supongamos que queremos obtener solo números pares:

$my_array = [1,2,3,4,5,6,7,8];

$even_numbers = array_filter($my_array, function($number) {
    return $number % 2 === 0;   
});

La función array_filter recibe la matriz que se filtra como su primer argumento y una devolución de llamada que define el predicado del filtro como su segundo.

$numbers = [16,3,5,8,1,4,6];

$even_indexed_numbers = array_filter($numbers, function($index) {
    return $index % 2 === 0;
}, ARRAY_FILTER_USE_KEY);

Índices en matriz filtrada

Tenga en cuenta que array_filter conserva las claves de matriz originales. Un error común sería intentar un uso for un bucle sobre la matriz filtrada:

<?php

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$filtered = array_filter($my_array); 

error_reporting(E_ALL); // show all errors and notices

// innocently looking "for" loop
for ($i = 0; $i < count($filtered); $i++) {
   print $filtered[$i];
}

/*
Output:
1
Notice: Undefined offset: 1
2
Notice: Undefined offset: 3
3
Notice: Undefined offset: 5
4
Notice: Undefined offset: 7
*/

Esto sucede porque los valores que estaban en las posiciones 1 (había 0 ), 3 ( null ), 5 (cadena vacía '' ) y 7 (matriz vacía [] ) se eliminaron junto con sus claves de índice correspondientes.

Si necesita recorrer el resultado de un filtro en una matriz indexada, primero debe llamar a array_values en el resultado de array_filter para crear una nueva matriz con los índices correctos:

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$filtered = array_filter($my_array); 
$iterable = array_values($filtered);

error_reporting(E_ALL); // show all errors and notices

for ($i = 0; $i < count($iterable); $i++) {
   print $iterable[$i];
}

// No warnings!

Añadiendo elemento al inicio del array.

A veces desea agregar un elemento al principio de una matriz sin modificar ninguno de los elementos actuales ( orden ) dentro de la matriz . Siempre que este sea el caso, puede usar array_unshift() .

array_unshift() anula los elementos pasados ​​al frente de la matriz. Tenga en cuenta que la lista de elementos está precedida como un todo, de modo que los elementos prefabricados permanecen en el mismo orden. Todas las teclas de matriz numérica se modificarán para comenzar a contar desde cero, mientras que las teclas literales no se tocarán.

^{Tomado de la documentación de PHP para array_unshift() .}

Si desea lograr esto, todo lo que necesita hacer es lo siguiente:

$myArray = array(1, 2, 3);

array_unshift($myArray, 4);

Esto ahora agregará 4 como el primer elemento en su matriz. Puedes verificar esto por:

print_r($myArray);

^{Esto devuelve una matriz en el siguiente orden: 4, 1, 2, 3 .}

Dado que array_unshift obliga a la matriz a restablecer los pares clave-valor, ya que el nuevo elemento permite que las siguientes entradas tengan las claves n+1 , es más inteligente crear una nueva matriz y agregar la matriz existente a la nueva matriz creada.

Ejemplo:

$myArray = array('apples', 'bananas', 'pears');
$myElement = array('oranges');
$joinedArray = $myElement;

foreach ($myArray as $i) {
  $joinedArray[] = $i;
}

Salida ($ joinedArray):

Array ( [0] => oranges [1] => apples [2] => bananas [3] => pears ) 

Eaxmple / Demo

Lista blanca solo algunas claves de matriz

Cuando quiera permitir solo ciertas claves en sus arreglos, especialmente cuando el arreglo proviene de parámetros de solicitud, puede usar array_intersect_key junto con array_flip .

$parameters = ['foo' => 'bar', 'bar' => 'baz', 'boo' => 'bam'];
$allowedKeys = ['foo', 'bar'];
$filteredParameters = array_intersect_key($parameters, array_flip($allowedKeys));

// $filteredParameters contains ['foo' => 'bar', 'bar' => 'baz]

Si el parameters variable no contiene ninguna clave permitido, entonces el filteredParameters variable de consistirá en una matriz vacía.

Desde PHP 5.6 también puede usar array_filter para esta tarea, pasando el indicador ARRAY_FILTER_USE_KEY como tercer parámetro:

$parameters  = ['foo' => 1, 'hello' => 'world'];
$allowedKeys = ['foo', 'bar'];
$filteredParameters = array_filter(
    $parameters,
    function ($key) use ($allowedKeys) {
        return in_array($key, $allowedKeys);
    },
    ARRAY_FILTER_USE_KEY
);

El uso de array_filter brinda la flexibilidad adicional de realizar una prueba arbitraria contra la clave, por ejemplo, $allowedKeys podría contener patrones de $allowedKeys regulares en lugar de cadenas simples. También establece más explícitamente la intención del código que array_intersect_key() combinado con array_flip() .

Ordenar una matriz

Hay varias funciones de clasificación para arreglos en php:

ordenar()

Ordenar una matriz en orden ascendente por valor.

$fruits = ['Zitrone', 'Orange', 'Banane', 'Apfel'];
sort($fruits);
print_r($fruits);

resultados en

Array
(
    [0] => Apfel
    [1] => Banane
    [2] => Orange
    [3] => Zitrone
)

rsort ()

Ordenar una matriz en orden descendente por valor.

$fruits = ['Zitrone', 'Orange', 'Banane', 'Apfel'];
rsort($fruits);
print_r($fruits);

resultados en

Array
(
    [0] => Zitrone
    [1] => Orange
    [2] => Banane
    [3] => Apfel
)

un tipo()

Ordena una matriz en orden ascendente por valor y preserva los indecisos.

$fruits = [1 => 'lemon', 2 => 'orange',  3 => 'banana', 4 => 'apple'];
asort($fruits);
print_r($fruits);

resultados en

Array
(
    [4] => apple
    [3] => banana
    [1] => lemon
    [2] => orange
)

Arsort ()

Ordene una matriz en orden descendente por valor y conserve los indecisos.

$fruits = [1 => 'lemon', 2 => 'orange',  3 => 'banana', 4 => 'apple'];
arsort($fruits);
print_r($fruits);

resultados en

Array
(
    [2] => orange
    [1] => lemon
    [3] => banana
    [4] => apple
)

ksort ()

Ordenar una matriz en orden ascendente por clave

$fruits = ['d'=>'lemon', 'a'=>'orange', 'b'=>'banana', 'c'=>'apple'];
ksort($fruits);
print_r($fruits);

resultados en

Array
(
    [a] => orange
    [b] => banana
    [c] => apple
    [d] => lemon
)

krsort ()

Ordenar una matriz en orden descendente por clave.

$fruits = ['d'=>'lemon', 'a'=>'orange', 'b'=>'banana', 'c'=>'apple'];
krsort($fruits);
print_r($fruits);

resultados en

Array
(
    [d] => lemon
    [c] => apple
    [b] => banana
    [a] => orange
)

natsort ()

Ordene una matriz de la forma en que lo haría un ser humano (orden natural).

$files = ['File8.stack', 'file77.stack', 'file7.stack', 'file13.stack', 'File2.stack'];
natsort($files);
print_r($files);

resultados en

Array
(
    [4] => File2.stack
    [0] => File8.stack
    [2] => file7.stack
    [3] => file13.stack
    [1] => file77.stack
)

natcasesort ()

Ordene una matriz de la forma en que lo haría un ser humano (orden natural), pero con uso intensivo de casos.

$files = ['File8.stack', 'file77.stack', 'file7.stack', 'file13.stack', 'File2.stack'];
natcasesort($files);
print_r($files);

resultados en

Array
(
    [4] => File2.stack
    [2] => file7.stack
    [0] => File8.stack
    [3] => file13.stack
    [1] => file77.stack
)

barajar()

Baraja una matriz (ordenada al azar).

$array = ['aa', 'bb', 'cc'];
shuffle($array);
print_r($array);

Como está escrito en la descripción, es aleatorio, por lo que aquí solo hay un ejemplo de lo que puede resultar

Array
(
    [0] => cc
    [1] => bb
    [2] => aa
)

usort ()

Ordenar una matriz con una función de comparación definida por el usuario.

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

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

resultados en

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

uasort ()

Ordene una matriz con una función de comparación definida por el usuario y conserve las claves.

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = ['a' => 1, 'b' => -3, 'c' => 5, 'd' => 3, 'e' => -5];
uasort($array, 'compare');
print_r($array);

resultados en

Array
(
    [e] => -5
    [b] => -3
    [a] => 1
    [d] => 3
    [c] => 5
)

uksort ()

Ordenar una matriz por claves con una función de comparación definida por el usuario.

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = ['ee' => 1, 'g' => -3, '4' => 5, 'k' => 3, 'oo' => -5];

uksort($array, 'compare');
print_r($array);

resultados en

Array
(
    [ee] => 1
    [g] => -3
    [k] => 3
    [oo] => -5
    [4] => 5
)

Intercambiar valores con claves.

array_flip función array_flip intercambiará todas las claves con sus elementos.

$colors = array(
    'one' => 'red',
    'two' => 'blue',
    'three' => 'yellow',
);

array_flip($colors); //will output

array(
    'red' => 'one',
    'blue' => 'two',
    'yellow' => 'three'
)

Fusionar dos matrices en una matriz

$a1 = array("red","green");
$a2 = array("blue","yellow");
print_r(array_merge($a1,$a2));

/*
    Array ( [0] => red [1] => green [2] => blue [3] => yellow )
*/

Matriz asociativa:

$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge($a1,$a2));
/*
    Array ( [a] => red [b] => yellow [c] => blue )
*/

1. Fusiona los elementos de uno o más arreglos juntos para que los valores de uno se agreguen al final del anterior. Devuelve la matriz resultante.
2. Si las matrices de entrada tienen las mismas claves de cadena, el valor posterior de esa clave sobrescribirá a la anterior. Sin embargo, si las matrices contienen claves numéricas, el valor posterior no sobrescribirá el valor original, sino que se agregará.
3. Los valores en la matriz de entrada con claves numéricas se volverán a numerar con claves incrementales que comienzan desde cero en la matriz de resultados.