Eliminar un elemento de una matriz en PHP

¿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 establecerlo en null lo haría, pero aparentemente no funciona.

preguntado el 15 de diciembre de 08 a las 21:12

No creo que la respuesta de Konrad sea la más simple al problema planteado. Con unset() las iteraciones sobre la matriz ya no incluirán el valor eliminado. OTOH, es cierto que la respuesta de Stevan es amplia y, en realidad, era la respuesta que estaba buscando, pero no el OP :) -

@danip Ser fácil de encontrar en el manual no excluye una pregunta sobre StackOverflow. Si la pregunta fuera un duplicar Pregunta de StackOverflow, entonces podría no pertenecer aquí. StackOverflow es un buen lugar para encontrar respuestas como una opción de consulta incluso antes de buscar en el manual. -

@unset ($ matriz [$ clave]); $ matriz = matriz_valores ($ matriz); -

Si desea eliminar claves de la matriz de matriz (matriz asociativa), consulte la solución en stackoverflow.com/a/47978980/1045444 -

puedes hacerlo en un bucle foreach como este: pastefs.com/pid/130950 -

30 Respuestas

Hay diferentes formas de eliminar un elemento de matriz, donde algunas son más útiles para algunas tareas específicas que otras.

Eliminar un solo elemento de la matriz

Si desea eliminar solo un elemento de la matriz, puede usar unset() o alternativamente \array_splice().

Si conoce el valor y no conoce la clave para eliminar el elemento, puede usar \array_search() para conseguir la llave. Esto solo funciona si el elemento no aparece más de una vez, ya que \array_search devuelve solo el primer acierto.

unset()

Tenga en cuenta que cuando usa unset() las claves de la matriz no cambiarán. Si desea volver a indexar las claves, puede usar \array_values() Si lo envía después unset(), que convertirá todas las claves en claves enumeradas numéricamente a partir de 0.

Código:

$array = [0 => "a", 1 => "b", 2 => "c"];
unset($array[1]);
          // ↑ Key which you want to delete

Salida:

[
    [0] => a
    [2] => c
]

\array_splice() Método

Si utiliza \array_splice() las claves se volverán a indexar automáticamente, pero las claves asociativas no cambiarán, a diferencia de \array_values(), que convertirá todas las claves en claves numéricas.

\array_splice() necesita el compensar, no la clave, como segundo parámetro.

Código:

$array = [0 => "a", 1 => "b", 2 => "c"];
\array_splice($array, 1, 1);
                   // ↑ Offset which you want to delete

Salida:

[
    [0] => a
    [1] => c
]

array_splice(), igual que unset(), tome la matriz por referencia. No asigna los valores de retorno de esas funciones a la matriz.

Eliminar varios elementos de la matriz

Si desea eliminar varios elementos de la matriz y no desea llamar unset() or \array_splice() varias veces puedes usar las funciones \array_diff() or \array_diff_key() dependiendo de si conoce los valores o las claves de los elementos que desea eliminar.

\array_diff() Método

Si conoce los valores de los elementos de la matriz que desea eliminar, puede usar \array_diff(). Como antes con unset() no cambiará las claves de la matriz.

Código:

$array = [0 => "a", 1 => "b", 2 => "c", 3 => "c"];
$array = \array_diff($array, ["a", "c"]);
                          // └────────┘
                          // Array values which you want to delete

Salida:

[
    [1] => b
]

\array_diff_key() Método

Si conoce las claves de los elementos que desea eliminar, entonces desea utilizar \array_diff_key(). Debe asegurarse de pasar las claves como claves en el segundo parámetro y no como valores. Las claves no se reindexan.

Código:

$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
                               // ↑           ↑
                               // Array keys which you want to delete

Salida:

[
    [1] => b
]

Si quieres usar unset() or \array_splice() para eliminar varios elementos con el mismo valor, puede usar \array_keys() para obtener todas las claves para un valor específico y luego eliminar todos los elementos.

Respondido 13 Oct 20, 19:10

@AlexandruRada No, dijiste "no uses esto", y eso es una tontería. Puede utilizar este método de forma segura cuando trate una matriz como lo que es: un diccionario. Solo si espera índices numéricos consecutivos, necesita usar algo más. - Konrad Rudolph

@Alexander uso array_splice, como se describe en las otras respuestas. - Konrad Rudolph

@AlexandruRada No hay forma de que puedas tener array (3) { [0]=>int(0) ... cuando tú unset($x[2]) desde $x = array(1, 2, 3, 4); Resultado deber be var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) } (probablemente fue un error tipográfico) - inemanja

unset puede tener varios argumentos: void unset ( mixed $var [, mixed $... ] ). - Константин Ван

array_filter también es un método viable. Especialmente bueno si no desea mutar la matriz, pero tampoco se reindexa, lo que puede ser un problema con json_encode. php.net/manual/en/function.json-encode.php#94157 - dotnetCarpintero

Cabe señalar que unset() mantendrá los índices intactos, que es lo que esperaría al usar índices de cadena (matriz como tabla hash), pero puede ser bastante sorprendente cuando se trata de matrices indexadas de enteros:

$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)
} */

So array_splice() se puede utilizar si desea normalizar sus claves enteras. Otra opción es usar array_values() Si lo envía después unset():

$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)
} */

Respondido el 13 de enero de 12 a las 21:01

Vale la pena señalar que cuando usa array_splice () necesita conocer el DESPLAZAMIENTO, no la clave, sino el desplazamiento (!) De cualquier elemento que desee eliminar - tom

@Tom: Para una matriz regular (que está continuamente indexada con números enteros), el desplazamiento es el índice. Ahí es donde array_splice puede tener sentido (entre otros). - Stefan Gehrig

Sí, por supuesto, pero algo para recordar si manipula la matriz antes de usar el empalme: tom

A partir de una prueba básica de eliminar una tonelada de elementos de una matriz gigantesca, array_splice parece ser mucho más rápido y requiere menos memoria. Esto coincide con lo que esperaría: array_values ​​() parece estar haciendo una copia de la matriz, mientras que array_splice funciona en su lugar. - Doug Kavendek

array_values ​​es un enfoque útil cuando está eliminando elementos en un bucle y desea que los índices sean consistentes, pero luego desea comprimirlos después del bucle. - Rorrik

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

Esta es la salida 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á una matriz numérica muy bien, pero eliminará todas las cadenas de claves de la matriz y las reemplazará con números. Si necesita conservar los nombres de las claves (cadenas), o reindexar 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
)

Respondido 19 Feb 19, 13:02

$ get_merged_values ​​= array_merge ($ datos ['res'], $ datos ['check_res']); cuando imprimo este print_r ($ get_merged_values); muestra lo siguiente. Array ([0] => Array ([menu_code] => 2 [menu_name] => Planta [menu_order_no] => 1) [1] => Array ([menu_code] => 3 [menu_name] => Línea [menu_order_no] => 2)) Pero necesito obtener los valores de menu_code y menu_name usando $ get_merged_values ​​['menu_code'] y $ get_merged_values ​​['menu_name'] respectivamente, en lugar de usar $ get_merged_values ​​[0] [menu_code], $ get_merged_values ​​[0 ] [nombre_menú]. por favor ayúdame a hacer esto - hacker de corazón

La redacción de la pregunta es engañosa por la forma en que se enuncia. Esto no funcionará si desea eliminar $ arr [$ i] en un bucle foreach si más de un elemento tiene el mismo valor. - Jed Lynch

$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}

Respondido 19 Feb 19, 13:02

Sería bueno aclarar que esta respuesta es para eliminar un elemento, cuando conoce el valor, pero no la clave. Tenga en cuenta que solo elimina la PRIMERA instancia del valor; encontrar todas claves para un valor, use array_keys - ToolmakerSteve

Si más de un elemento tiene el mismo valor, esto no funcionará. - Jed Lynch

unset($array[$index]);

Respondido el 15 de diciembre de 08 a las 23:12

Si tiene una matriz indexada numéricamente donde todos los valores son únicos (o no son únicos pero desea eliminar todas las instancias de un valor en particular), simplemente puede usar 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 elimina como se puede verificar mediante las llamadas de sizeof () que informan un tamaño de 4 para la matriz inicial y 3 después de la eliminación.

respondido 26 nov., 12:12

Si dos elementos tienen el mismo valor, esto no funcionará. - Jed Lynch

Además, para un elemento con nombre:

unset($array["elementName"]);

respondido 13 nov., 18:14

$a = array("A"=>1, "B"=>2, "C"=>"a"); print_r($a); unset($a["B"]); print_r($a); da (formateado): Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a ) - DefenestraciónDía

Parece que no puede desarmar los elementos de la matriz indexados por una cadena (genera "Error fatal: No se pueden desarmar las compensaciones de cadena"). No creo que este haya sido siempre el caso, pero ciertamente a partir de PHP 5.3.10 y probablemente antes - carpii

@carpii PHP puede desarmar elementos de una matriz asociativa. El error fatal se produce cuando intenta utilizar unset ($ var ['clave']) en una cadena en lugar de una matriz Por ejemplo: $ matriz = matriz ('prueba' => 'valor', 'otro' => ' valor', ); unset ($ matriz ['prueba']); // Elimina el elemento "prueba" de la matriz como se esperaba $ matriz = 'prueba'; unset ($ matriz ['prueba']); // Lanza "Error fatal: No se pueden desarmar las compensaciones de cadena" como se esperaba - Jimbo

Aquí debes saber el nombre de la clave, es mejor: stackoverflow.com/a/52826684/1407491 - Nabi KAZ

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 necesita volver a indexar la matriz:

$array1 = array_values($array1);
var_dump($array1);

Entonces la salida será:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [2]=>
  string(1) "D"
  [3]=>
  string(1) "E"
}

Pop el elemento del final de la matriz - devuelve 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, - devuelve 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

contestado el 25 de mayo de 16 a las 21:05

La array_shift vuelva a indexar los elementos clave si es un número entero, por lo que es malo, por lo que puede usar esto: stackoverflow.com/a/52826684/1407491 - Nabi KAZ

<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Salida:

[
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
]

fruit1

Respondido el 03 de Septiembre de 19 a las 05:09

Tenga en cuenta que array_shift solo puede eliminar el primer elemento de la matriz. uso similar array_pop para eliminar el último elemento de la matriz. - Jasir

La respuesta solo se aplica al primer elemento de una matriz y no responde a la pregunta general. - sweisgerber.dev

@sebweisgerber, tiene razón, pero no creo que sea una respuesta incorrecta y deba rechazar esta respuesta. La pregunta es eliminar un elemento sin mencionar ninguna posición. - Saurabh Chandra Patel

Esto solo cubre un caso de borde - Jed Lynch

Para evitar hacer una búsqueda, uno puede jugar con array_diff:

$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11

En este caso, no es necesario buscar / usar la clave.

Respondido el 23 de Septiembre de 16 a las 01:09

Esto solo funcionará si todos los elementos son únicos. - Jed Lynch

Si tiene que eliminar varios valores en una matriz y las entradas en esa matriz son objetos o datos estructurados, [array_filter][1] es tu mejor apuesta. Se conservarán aquellas entradas que devuelvan un verdadero de la función de devolución de llamada.

$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']]

Respondido 18 Feb 16, 04:02

Matrices asociativas

Para matrices asociativas, use 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, use array_splice:

$arr = array(1, 2, 3);
array_splice($arr, 1, 1);

// RESULT: array(0 => 1, 1 => 3)

Nota:

Usar unset para matrices numéricas no producirá un error, pero estropeará sus índices:

$arr = array(1, 2, 3);
unset($arr[1]);

// RESULT: array(0 => 1, 2 => 3)

Respondido 22 Feb 19, 12:02

unset() destruye las variables especificadas.

El comportamiento de unset() dentro de una función puede variar según el tipo de variable que esté intentando destruir.

Si una variable globalizada es unset() dentro de una función, solo se destruye la variable local. La variable en el entorno de llamada conservará el mismo valor que antes. unset() fue llamado.

<?php
    function destroy_foo()
    {
        global $foo;
        unset($foo);
    }

    $foo = 'bar';
    destroy_foo();
    echo $foo;
?>

La respuesta del código anterior será bar.

A unset() una variable global dentro de una función:

<?php
    function foo()
    {
        unset($GLOBALS['bar']);
    }

    $bar = "something";
    foo();
?>

Respondido 19 Feb 19, 13:02

Si se especifica el índice:

$arr = ['a', 'b', 'c'];
$index = 0;    
unset($arr[$index]);  // $arr = ['b', 'c']

Si NO se especifica el índice:

$arr = ['a', 'b', 'c'];
$index = array_search('a', $arr); // search the value to find index
if($index !== false){
   unset($arr[$index]);  // $arr = ['b', 'c']
}

La if la condición es necesaria porque si index no se encuentra, unset() eliminará automáticamente el primer elemento de la matriz que no es lo que queremos.

Respondido el 21 de junio de 20 a las 15:06

Si necesita eliminar varios elementos de una matriz asociativa, puede usar array_diff_key () (aquí usado 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 ) 

Respondido 21 Abr '16, 00:04

¿Por qué esto está tan subestimado? - Fr0zenFyr

// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}

Respondido 30 Jul 18, 15:07

Soluciones:

  1. Para eliminar un elemento, use desarmado ():
unset($array[3]);
unset($array['foo']);
  1. Para eliminar varios elementos no contiguos, utilice también desarmado ():
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. Para eliminar varios elementos contiguos, use array_splice ():
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, hay una diferencia lógica entre usar desarmado () y asignando '' al elemento. El primero dice This doesn't exist anymore, mientras el segundo dice This still exists, but its value is the empty string.

Si está tratando con números, asignar 0 puede ser una mejor alternativa. Entonces, si una empresa detuviera la producción del piñón modelo XL1000, actualizaría su inventario con:

unset($products['XL1000']);

Sin embargo, si se le acabaron temporalmente las ruedas dentadas XL1000, pero tenía previsto recibir un nuevo envío de la planta a finales de esta semana, es mejor:

$products['XL1000'] = 0;

Si es que desarmado () un elemento, PHP ajusta la matriz para que el bucle siga funcionando correctamente. No compacta la matriz para rellenar los agujeros que faltan. Esto es lo que queremos decir cuando decimos que todas las matrices son asociativas, incluso cuando parecen ser 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 array_values ​​():

$animals = array_values($animals);

Alternativamente, array_splice () reindexa automáticamente las matrices para evitar dejar huecos:

// 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 una 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 array_shift () y array_pop (), respectivamente.

Respondido 22 Feb 19, 13:02

Solo me gustaría decir que tenía un objeto en particular que tenía atributos variables (básicamente estaba mapeando una tabla y estaba cambiando las columnas en la tabla, por lo que los atributos en el objeto, reflejando la tabla también variarían):

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 tengo que buscar en todas partes en el código cuando se cambian, solo miro al comienzo de la clase y cambio la lista de atributos y el $ campos contenido de la matriz para reflejar los nuevos atributos.

Respondido 19 Feb 19, 13:02

Use array_search para obtener la clave y elimínela con unset si la encuentra:

if (($key = array_search('word', $array)) !== false) {
    unset($array[$key]);
}

Respondido 24 Feb 19, 14:02

Siga las funciones predeterminadas:

  • PHP: desarmado

unset() destruye las variables especificadas. Para obtener más información, puede consultar PHP desarmado

$Array = array("test1", "test2", "test3", "test3");

unset($Array[2]);
  • PHP: array_pop

La array_pop() La función elimina el último elemento de una matriz. Para obtener más información, puede consultar PHP array_pop

$Array = array("test1", "test2", "test3", "test3");

array_pop($Array);
  • PHP: array_splice

La array_splice() La función elimina los elementos seleccionados de una matriz y la reemplaza con elementos nuevos. Para obtener más información, puede consultar PHP array_splice

$Array = array("test1", "test2", "test3", "test3");

array_splice($Array,1,2);
  • PHP: array_shift

La array_shift() La función elimina el primer elemento de una matriz. Para obtener más información, puede consultar PHP array_shift

$Array = array("test1", "test2", "test3", "test3");

array_shift($Array);

Respondido 16 Oct 20, 15:10

Suponga que tiene la siguiente matriz:

Array
(
    [user_id] => 193
    [storage] => 5
)

Borrar storage, hacer:

unset($attributes['storage']);
$attributes = array_filter($attributes);

Y obtienes:

Array
(
    [user_id] => 193
)

Respondido 14 Feb 19, 09:02

¿Qué es? array_filter ¿usado para? - David

para eliminar elementos falsos - Tebas

<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

Crea tu matriz en la variable $array y luego, donde puse 'elemento que desea eliminar', pones algo como: "a". Y si desea eliminar varios elementos, entonces: "a", "b".

Respondido 22 Feb 19, 13:02

Dos formas de eliminar el primer elemento de una matriz manteniendo el orden del índice y también si no conoce el nombre clave del primer elemento.

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 estos datos de muestra:

$array = array(10 => "a", 20 => "b", 30 => "c");

Debes tener este resultado:

array(2) {
  [20]=>
  string(1) "b"
  [30]=>
  string(1) "c"
}

Respondido 22 Feb 19, 13:02

unset () múltiples elementos fragmentados de una matriz

Aunque la unset() se ha mencionado aquí varias veces, aún no se ha mencionado que unset() acepta múltiples variables, lo que facilita la eliminación de múltiples elementos no contiguos 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 matriz de claves para eliminar, por lo que el código siguiente fallará (aunque habría facilitado un poco el uso dinámico de unset ()).

$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);

En cambio, unset () se puede usar dinámicamente 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 copiando la matriz

También hay 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 $ matriz1 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 las 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' ]

Respondido 14 Feb 19, 09:02

Eliminar un elemento de matriz basado en una clave:

Utiliza unset funciona 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 según el valor:

Utiliza array_search función para obtener una clave de elemento y use la forma anterior para eliminar un elemento de matriz como se muestra 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
        )

*/

Respondido 22 Feb 19, 13:02

Utilice el siguiente código:

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);

Respondido 19 Feb 19, 13:02

php5: simplemente ejecutando array_pop($arr) elimina la entrada final. No se necesita "=". - Chris K

<?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 )

Respondido 22 Feb 19, 12:02

Para matrices asociativas, con claves no enteras:

Simplemente, unset($array[$key]) funcionaría.

Para matrices que tienen claves enteras y si desea mantener sus claves:

  1. $array = [ 'mango', 'red', 'orange', 'grapes'];

    unset($array[2]);
    $array = array_values($array);
    
  2. array_splice($array, 2, 1);

Respondido 22 Feb 19, 13:02

$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);

print_r($arrayName);

contestado el 29 de mayo de 19 a las 08:05

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 )

Respondido 22 Feb 19, 12:02

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.