Eliminar un elemento de una matriz en PHP
https://stackoverflow.com/questions/369602
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Existe una manera fácil de eliminar un elemento de una matriz usando PHP, de modo que foreach ($array) ya no incluye ese elemento?
Pensé que configurarlo en null Lo haría, pero aparentemente no funciona.
Solución
Hay diferentes formas de eliminar un elemento de matriz, en los que algunos son más útiles para algunas tareas específicas que otros.
Eliminar un elemento de la matriz
Si desea eliminar un solo elemento de la matriz se puede utilizar \unset() o alternativamente \array_splice() .
Además, si usted tiene el valor y no conoce la clave para eliminar el elemento que se puede utilizar \array_search() para obtener la clave.
\array_values() método
Tenga en cuenta que cuando se utiliza array_splice() las claves de matriz no cambiarán / reindex. Si desea indexar las teclas que puede utilizar \array_diff() después < => que convertirá todas las teclas a las teclas numéricas enumerados a partir de 0.
Código
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
\unset($array[1]);
//↑ Key which you want to delete
?>
salida
[
[0] => a
[2] => c
]
\array_diff_key() método
Si utiliza las teclas \array_flip() es re-indexada de forma automática, pero las claves asociativos no va a cambiar en contraposición a \array_keys() que convertirá todas las teclas para teclas numéricas.
También <=> necesita el desplazamiento, no la clave! como el segundo parámetro.
Código
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
\array_splice($array, 1, 1);
//↑ Offset which you want to delete
?>
salida
[
[0] => a
[1] => c
]
<=> mismo que <=> tomar la matriz por referencia, y esto significa que usted no desea asignar los valores de retorno de las funciones de nuevo a la matriz.
Eliminar múltiples elementos de la matriz
Si desea eliminar varios elementos de la matriz y no quiere llamar <=> o <=> varias veces se pueden utilizar las funciones <=> o <=> dependiendo de si se conocen los valores o las teclas de los elementos que se quieren eliminar.
<=> método
Si conoce los valores de los elementos de la matriz que desea eliminar y, a continuación, puede utilizar <=>. Al igual que antes con <=> no va a cambiar / reindex las claves de la matriz.
Código
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff($array, ["a", "c"]);
//└────────┘→ Array values which you want to delete
?>
salida
[
[1] => b
]
<=> método
Si conoce las claves de los elementos que desea eliminar y, a continuación, desea utilizar <=>. Aquí usted tiene que asegurarse de que pase las llaves como claves en el segundo parámetro y no como valores. De lo contrario, hay que voltear la matriz con <=> . Y también aquí las claves no cambiarán / reindex.
Código
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
//↑ ↑ Array keys which you want to delete
?>
salida
<*>Además, si desea utilizar o <=> <=> a eliminar varios elementos con el mismo valor que puede usar <=> para obtener todas las claves para un valor específico y luego eliminar todos los elementos.
Otros consejos
Debe tenerse en cuenta que unset() mantendrá índices sin tocar, que es lo que se espera cuando se usa índices de cadena (array como tabla hash), pero puede ser bastante sorprendente cuando se trata de matrices de enteros indexadas:
$array = array(0, 1, 2, 3);
unset($array[2]);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[3]=>
int(3)
} */
$array = array(0, 1, 2, 3);
array_splice($array, 2, 1);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[2]=>
int(3)
} */
array_splice() se puede utilizar si desea normalizar sus claves enteras. Otra opción es usar array_values() después <=> :
$array = array(0, 1, 2, 3);
unset($array[2]);
$array = array_values($array);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[2]=>
int(3)
} */
// Our initial array
$arr = array("blue", "green", "red", "yellow", "green", "orange", "yellow", "indigo", "red");
print_r($arr);
// Remove the elements who's values are yellow or red
$arr = array_diff($arr, array("yellow", "red"));
print_r($arr);
Este es el resultado del código anterior:
Array
(
[0] => blue
[1] => green
[2] => red
[3] => yellow
[4] => green
[5] => orange
[6] => yellow
[7] => indigo
[8] => red
)
Array
(
[0] => blue
[1] => green
[4] => green
[5] => orange
[7] => indigo
)
Ahora, array_values() reindexará correctamente una matriz numérica, pero eliminará todas las cadenas clave de la matriz y las reemplazará con números.Si necesita conservar los nombres de las claves (cadenas) o volver a indexar la matriz si todas las claves son numéricas, use array_merge():
$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);
Salidas
Array
(
[0] => blue
[1] => green
[2] => green
[3] => orange
[4] => indigo
)
$key = array_search($needle, $array);
if ($key !== false) {
unset($array[$key]);
}
unset($array[$index]);
Si usted tiene un arreglo indexado numéricamente que todos los valores son únicos (o que no son únicas, pero que desea eliminar todas las instancias de un valor particular), puede simplemente utilizar array_diff () para eliminar un elemento coincidente, como este :
$my_array = array_diff($my_array, array('Value_to_remove'));
Por ejemplo:
$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);
Esto muestra lo siguiente:
4
3
En este ejemplo, el elemento con el valor 'Charles' se retira como se puede verificar por el sizeof () llamadas que informar de un tamaño de 4 para la matriz inicial, y 3 después de la eliminación.
Además, para un elemento con nombre:
unset($array["elementName"]);
Destruye un solo elemento de una matriz
unset()
$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);
La salida será:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[3]=>
string(1) "D"
[4]=>
string(1) "E"
}
Si es necesario volver a índice de la matriz:
$array1 = array_values($array1);
var_dump($array1);
A continuación, la salida será:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[2]=>
string(1) "D"
[3]=>
string(1) "E"
}
Extrae el último elemento final de la matriz - devolver el valor del elemento eliminado
mixed array_pop(array &$array)
$stack = array("orange", "banana", "apple", "raspberry");
$last_fruit = array_pop($stack);
print_r($stack);
print_r('Last Fruit:'.$last_fruit); // Last element of the array
La salida será
Array
(
[0] => orange
[1] => banana
[2] => apple
)
Last Fruit: raspberry
Eliminar el primer elemento (rojo) de una matriz , - devolver el valor del elemento eliminado
mixed array_shift ( array &$array )
$color = array("a" => "red", "b" => "green" , "c" => "blue");
$first_color = array_shift($color);
print_r ($color);
print_r ('First Color: '.$first_color);
La salida será:
Array
(
[b] => green
[c] => blue
)
First Color: red
<?php
$stack = array("fruit1", "fruit2", "fruit3", "fruit4");
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
Salida:
Array
(
[0] => fruit2
[1] => fruit3
[2] => fruit4
)
fruit1
Para evitar hacer una búsqueda se puede jugar con array_diff:
$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11
En este caso, uno no tiene que buscar / use la tecla.
Si tiene que eliminar varios valores en una matriz y las entradas en esa matriz son objetos o datos estructurados [array_filter][1], es su mejor apuesta. Esas entradas que devuelven un verdadero de la función de devolución de llamada serán retenidos.
$array = [
['x'=>1,'y'=>2,'z'=>3],
['x'=>2,'y'=>4,'z'=>6],
['x'=>3,'y'=>6,'z'=>9]
];
$results = array_filter($array, function($value) {
return $value['x'] > 2;
}); //=> [['x'=>3,'y'=>6,z=>'9']]
unset() destruye las variables especificadas.
El comportamiento de <=> interior de una función puede variar dependiendo de qué tipo de variable que intenta destruir.
Si una variable globalizado se <=> interior de una función, solo la variable local es destruida. La variable en el entorno de la llamada mantendrá el mismo valor que antes se llamaba <=>.
<?php
function destroy_foo()
{
global $foo;
unset($foo);
}
$foo = 'bar';
destroy_foo();
echo $foo;
?>
La respuesta del código anterior será bar .
Para <=> una variable global dentro de una función:
<?php
function foo()
{
unset($GLOBALS['bar']);
}
$bar = "something";
foo();
?>
matrices asociativas
Para matrices asociativas, utilice unset:
$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);
// RESULT: array('a' => 1, 'c' => 3)
matrices numéricas
Para matrices numéricas, utilice array_splice:
$arr = array(1, 2, 3);
array_splice($arr, 1, 1);
// RESULT: array(0 => 1, 1 => 3)
Nota
Usando unset para matrices numéricas no producirá un error, pero arruinará sus índices:
$arr = array(1, 2, 3);
unset($arr[1]);
// RESULT: array(0 => 1, 2 => 3)
Si necesita eliminar varios elementos de un array asociativo, puede utilizar array_diff_key () (aquí se utiliza con array_flip () ):
$my_array = array(
"key1" => "value 1",
"key2" => "value 2",
"key3" => "value 3",
"key4" => "value 4",
"key5" => "value 5",
);
$to_remove = array("key2", "key4");
$result = array_diff_key($my_array, array_flip($to_remove));
print_r($result);
Salida:
Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 )
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
Supongamos que tenemos la siguiente matriz:
Array
(
[user_id] => 193
[storage] => 5
)
Para eliminar storage, hacer:
unset($attributes['storage']);
$attributes = array_filter($attributes);
Y se obtiene:
Array
(
[user_id] => 193
)
sólo me gustaría decir que tenía un objeto particular que tenía los atributos de variable (que fue básicamente el mapeo de una mesa y yo estaba cambiando las columnas en la tabla, por lo que los atributos del objeto, lo que refleja la tabla podría variar también ):
class obj {
protected $fields = array('field1','field2');
protected $field1 = array();
protected $field2 = array();
protected loadfields(){}
// This will load the $field1 and $field2 with rows of data for the column they describe
protected function clearFields($num){
foreach($fields as $field) {
unset($this->$field[$num]);
// This did not work the line below worked
unset($this->{$field}[$num]); // You have to resolve $field first using {}
}
}
}
Todo el propósito de $fields era justo, por lo que no tiene que buscar en todas partes en el código cuando están cambiados, acabo de mirar al comienzo de la clase y cambiar la lista de atributos y la campos $ contenido de matriz para reflejar los nuevos atributos.
Siga las funciones por defecto:
i)
$Array = array("test1", "test2", "test3", "test3");
unset($Array[2]);
ii)
$Array = array("test1", "test2", "test3", "test3");
array_pop($Array);
iii)
$Array = array("test1", "test2", "test3", "test3");
array_splice($Array,1,2);
iv)
$Array = array("test1", "test2", "test3", "test3");
array_shift($Array);
Soluciones:
- Para eliminar un elemento, utilice desarmado():
unset($array[3]); unset($array['foo']);
- Para eliminar varios elementos no contiguos, utilice también desarmado():
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
- Para eliminar varios elementos contiguos, utilice empalme_array():
array_splice($array, $offset, $length);
Explicación adicional:
El uso de estas funciones elimina todas las referencias a estos elementos de PHP.Si desea mantener una clave en la matriz, pero con un valor vacío, asigne la cadena vacía al elemento:
$array[3] = $array['foo'] = '';
Además de la sintaxis, existe una diferencia lógica entre usar desarmado() y asignando '' al elemento.El primero dice This doesn't exist anymore, mientras que el segundo dice This still exists, but its value is the empty string.
Si se trata de números, asignar 0 puede ser una mejor alternativa.Entonces, si una empresa dejara de producir la rueda dentada modelo XL1000, actualizaría su inventario con:
unset($products['XL1000']);
Sin embargo, si se quedó temporalmente sin ruedas dentadas XL1000, pero planeaba recibir un nuevo envío de la planta a finales de esta semana, esto es mejor:
$products['XL1000'] = 0;
Si usted desarmado() un elemento, PHP ajusta la matriz para que el bucle siga funcionando correctamente.No compacta la matriz para rellenar los huecos que faltan.Esto es lo que queremos decir cuando decimos que todas las matrices son asociativas, incluso cuando parecen numéricas.He aquí un ejemplo:
// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
print $animals[1]; // Prints 'bee'
print $animals[2]; // Prints 'cat'
count($animals); // Returns 6
// unset()
unset($animals[1]); // Removes element $animals[1] = 'bee'
print $animals[1]; // Prints '' and throws an E_NOTICE error
print $animals[2]; // Still prints 'cat'
count($animals); // Returns 5, even though $array[5] is 'fox'
// Add a new element
$animals[ ] = 'gnu'; // Add a new element (not Unix)
print $animals[1]; // Prints '', still empty
print $animals[6]; // Prints 'gnu', this is where 'gnu' ended up
count($animals); // Returns 6
// Assign ''
$animals[2] = ''; // Zero out value
print $animals[2]; // Prints ''
count($animals); // Returns 6, count does not decrease
Para compactar la matriz en una matriz numérica densamente llena, use valores_matriz():
$animals = array_values($animals);
Alternativamente, empalme_array() reindexa automáticamente las matrices para evitar dejar agujeros:
// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
array_splice($animals, 2, 2);
print_r($animals);
Array
(
[0] => ant
[1] => bee
[2] => elk
[3] => fox
)
Esto es útil si está utilizando la matriz como cola y desea eliminar elementos de la cola sin dejar de permitir el acceso aleatorio.Para eliminar de forma segura el primer o último elemento de una matriz, utilice cambio_matriz() y matriz_pop(), respectivamente.
unset () múltiple, elementos fragmentados de una matriz
Mientras unset() se ha mencionado aquí varias veces, todavía tiene que ser mencionado que <=> acepta múltiples variables por lo que es fácil de eliminar varios elementos, no contiguas de una matriz en una sola operación:
// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]
unset () dinámicamente
unset () no acepta una gran variedad de llaves para retirar, por lo que a continuación el código fallará (hubiera hecho un poco más fácil de usar unset () de forma dinámica sin embargo).
$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);
En su lugar, unset () se puede utilizar de forma dinámica en un bucle foreach:
$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]
Eliminar claves de matriz mediante la copia del array
Hay también otra práctica que aún no se ha mencionado. A veces, la forma más sencilla de deshacerse de ciertas claves de matriz es simplemente copiar array1 $ en $ matriz2.
$array1 = range(1,10);
foreach ($array1 as $v) {
// Remove all even integers from the array
if( $v % 2 ) {
$array2[] = $v;
}
}
print_r($array2);
// Output: [ 1, 3, 5, 7, 9 ];
Obviamente, la misma práctica se aplica a cadenas de texto:
$array1 = [ 'foo', '_bar', 'baz' ];
foreach ($array1 as $v) {
// Remove all strings beginning with underscore
if( strpos($v,'_')===false ) {
$array2[] = $v;
}
}
print_r($array2);
// Output: [ 'foo', 'baz' ]
<?php
// If you want to remove a particular array element use this method
$my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
print_r($my_array);
if (array_key_exists("key1", $my_array)) {
unset($my_array['key1']);
print_r($my_array);
}
else {
echo "Key does not exist";
}
?>
<?php
//To remove first array element
$my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
print_r($my_array);
$new_array = array_slice($my_array, 1);
print_r($new_array);
?>
<?php
echo "<br/> ";
// To remove first array element to length
// starts from first and remove two element
$my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
print_r($my_array);
$new_array = array_slice($my_array, 1, 2);
print_r($new_array);
?>
Salida
Array ( [key1] => value 1 [key2] => value 2 [key3] =>
value 3 ) Array ( [key2] => value 2 [key3] => value 3 )
Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
Array ( [key2] => value 2 [key3] => value 3 )
Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
Array ( [key2] => value 2 [key3] => value 3 )
Eliminar un elemento de matriz basado en una clave:
Utilice la función unset, como a continuación:
$a = array(
'salam',
'10',
1
);
unset($a[1]);
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
Eliminar un elemento de matriz basado en el valor:
Utilice la array_search función para obtener una clave de elemento y utilizar de la manera anterior para eliminar un elemento de matriz, como a continuación:
$a = array(
'salam',
'10',
1
);
$key = array_search(10, $a);
if ($key !== false) {
unset($a[$key]);
}
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>
Crea tu array en la variable $array y luego donde puse 'elemento que deseas eliminar' pones algo como:"a".Y si desea eliminar varios elementos, entonces:"a", "b".
Utiliza el siguiente código:
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
Dos maneras para eliminar el primer elemento de una matriz con mantener el orden del índice y también si usted no sabe el nombre de clave del primer artículo.
Solución # 1
// 1 is the index of the first object to get
// NULL to get everything until the end
// true to preserve keys
$array = array_slice($array, 1, null, true);
Solución # 2
// Rewinds the array's internal pointer to the first element
// and returns the value of the first array element.
$value = reset($array);
// Returns the index element of the current array position
$key = key($array);
unset($array[$key]);
Para obtener estos datos de ejemplo:
$array = array(10 => "a", 20 => "b", 30 => "c");
Debe tener este resultado:
array(2) {
[20]=>
string(1) "b"
[30]=>
string(1) "c"
}
Utilice array_search para conseguir la llave y extraerla con desactivada si se encuentran:
if (($key = array_search('word', $array)) !== false) {
unset($array[$key]);
}
Para matrices asociativas, con claves no enteros:
Simplemente, unset($array[$key]) funcionaría.
Para las matrices que tienen claves enteras y si se quiere mantener sus claves:
-
$array = [ 'mango', 'red', 'orange', 'grapes'];unset($array[2]); $array = array_values($array); -
array_splice($array, 2, 1);
Esto puede ayudar ...
<?php
$a1 = array("a"=>"red", "b"=>"green", "c"=>"blue", "d"=>"yellow");
$a2 = array("a"=>"purple", "b"=>"orange");
array_splice($a1, 0, 2, $a2);
print_r($a1);
?>
El resultado será:
Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )
$arrayName = array( '1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
);
print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);
print_r($arrayName);
unset no cambia el índice, pero array_splice hace:
$arrayName = array('1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
500 => 'somevalue500',
);
echo $arrayName['500'];
//somevalue500
array_splice($arrayName, 1, 2);
print_r($arrayName);
//Array ( [0] => somevalue [1] => somevalue500 )
$arrayName = array( '1' => 'somevalue',
'2' => 'somevalue1',
'3' => 'somevalue3',
500 => 'somevalue500',
);
echo $arrayName['500'];
//somevalue500
unset($arrayName[1]);
print_r($arrayName);
//Array ( [0] => somevalue [1] => somevalue500 )
