Eliminar un elemento de una matriz en PHP

2515

¿Hay una manera fácil de eliminar un elemento de una matriz usando PHP, de modo que foreach ($array)ya no incluya ese elemento?

Pensé que establecerlo lo nullharía, pero aparentemente no funciona.

Ben
fuente
14
No quisiera que la respuesta de Konrad sea la más simple para el problema planteado. Con unset()las iteraciones sobre la matriz ya no se incluirá el valor eliminado. Otoh, es cierto que Stevan respuesta es amplia y, de hecho, fue la respuesta que estaba buscando - pero no la OP :)
Brandizzi
32
@danip Ser fácil de encontrar en el manual no excluye una pregunta sobre StackOverflow. Si la pregunta fuera una pregunta duplicada de StackOverflow, entonces podría no pertenecer aquí. StackOverflow es un buen lugar para encontrar respuestas como una opción de acceso incluso antes de consultar el manual.
Dan Nissenbaum
55
@unset ($ array [$ clave]); $ array = array_values ​​($ array);
troyano
Pregunta relacionada sobre cómo eliminar esto en un bucle foreach: stackoverflow.com/questions/1949259/…
Legolas
Si desea eliminar las claves de la matriz de matriz (matriz asociativa), consulte la solución en stackoverflow.com/a/47978980/1045444
Somnath Muluk

Respuestas:

2874

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

Eliminar un elemento de matriz

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

Además, si tiene el valor y no conoce la clave para eliminar el elemento que puede usar \array_search()para obtener la clave.

unset()

Tenga en cuenta que cuando usa unset()las teclas de matriz no cambiará / reindexará. Si desea indexar las teclas que puede utilizar \array_values()después de unset()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_splice() método

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

¡También \array_splice()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
]

array_splice()igual que unset()tomar la matriz por referencia, y esto significa que no desea asignar los valores de retorno de esas funciones de nuevo a la matriz.

Eliminar múltiples elementos de la matriz

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

\array_diff() método

Si conoce los valores de los elementos de la matriz que desea eliminar, puede usarlos \array_diff(). Como antes unset(), no cambiará / reindexará 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
]

\array_diff_key() método

Si conoce las claves de los elementos que desea eliminar, entonces desea utilizarlas \array_diff_key(). Aquí debe asegurarse de pasar las claves como claves en el segundo parámetro y no como valores. De lo contrario, debe voltear la matriz con \array_flip(). Y también aquí las teclas no cambiarán / reindexarán.

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

[
    [1] => b
]

Además, si desea usar unset()o \array_splice()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.

Rizier123
fuente
26
@AlexandruRada No, dijiste "no uses esto", y eso no tiene sentido. Puede utilizar este método de forma segura cuando trata una matriz como lo que es: un diccionario. Solo si espera índices numéricos consecutivos necesita usar otra cosa.
Konrad Rudolph
2
@Alexander Use array_splice, como se describe en las otras respuestas.
Konrad Rudolph el
1
@AlexandruRada No hay forma de que puedas tenerlo array (3) { [0]=>int(0) ...cuando unset($x[2])de $x = array(1, 2, 3, 4);Resultado debe ser var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) }(probablemente fue un error tipográfico)
inemanja
55
unsetpuede tener varios argumentos: void unset ( mixed $var [, mixed $... ] ).
Константин Ван
3
array_filter también es un método viable. Especialmente bueno si no desea mutar la matriz pero tampoco reindexa, lo que puede ser un problema con json_encode. php.net/manual/en/function.json-encode.php#94157
dotnetCarpenter
1359

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 enteras:

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

Por array_splice()lo tanto, puede usarse si desea normalizar sus teclas enteras. Otra opción es usar array_values()después de 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)
} */
Stefan Gehrig
fuente
43
Vale la pena señalar que cuando usa array_splice () necesita saber el DESPLAZAMIENTO, no la clave, sino el desplazamiento (!) De cualquier elemento que desee eliminar
Tom
18
@Tom: para una matriz regular (que está continuamente indexada con enteros), el desplazamiento es el índice. Ahí es donde array_splicepuede tener sentido (entre otros).
Stefan Gehrig
55
Sí, por supuesto, pero es algo para recordar si manipula la matriz antes de usar el empalme
Tom
44
Desde solo 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
44
array_values ​​es un enfoque útil cuando elimina elementos en un bucle y desea que los índices sean consistentes, pero luego desea comprimirlos después del bucle.
Rorrik
370
  // 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á una matriz numérica muy bien, pero eliminará todas las cadenas de teclas de la matriz y las reemplazará con números. Si necesita preservar los nombres de clave (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
)
Marcel Cozma
fuente
$ 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] => Plant [menu_order_no] => 1) [1] => Array ([menu_code] => 3 [menu_name] => Line [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 ] [menu_name]. por favor ayúdame a hacer esto?
pirata informático del corazón
203
$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}
liamvictor
fuente
44
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; para encontrar todas las claves para un valor, use array_keys
ToolmakerSteve
84
unset($array[$index]);
Eran Galperin
fuente
65

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 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 sizeof () que informan un tamaño de 4 para la matriz inicial y 3 después de la eliminación.

Robin Nixon
fuente
64

Además, para un elemento con nombre:

unset($array["elementName"]);
Día de defenestración
fuente
$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 )
DefenestrationDay
Parece que no puede desarmar elementos de matriz indexados por una cadena (genera "Error grave: no se pueden desarmar las compensaciones de cadena"). No creo que este fuera siempre el caso, pero ciertamente a partir de PHP 5.3.10 y probablemente antes
carpii
66
@carpii PHP puede desarmar elementos de una matriz asociativa. El error fatal se produce cuando intenta usar unset ($ var ['key']) en una cadena en lugar de una matriz. Por ejemplo: $ array = array ('test' => 'value', 'another' => ' valor ',); unset ($ array ['prueba']); // Elimina el elemento "prueba" de la matriz como se esperaba $ array = 'prueba'; unset ($ array ['prueba']); // Lanza "Error fatal: no se pueden desfasar las compensaciones de cadena" como se esperaba
Jimbo
Aquí debe conocer el nombre de la clave, es mejor: stackoverflow.com/a/52826684/1407491
Nabi KAZ
33

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

El resultado 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"
}

Extraiga el elemento del final de la matriz : devuelva 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

Elimine el primer elemento (rojo) de una matriz , - devuelva 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);

El resultado será:

Array
(
    [b] => green
    [c] => blue
)
First Color: red
KTAnj
fuente
1
El array_shiftíndice de re los elementos clave si es número entero, por lo que es malo, por lo que puede utilizar esto: stackoverflow.com/a/52826684/1407491
Nabi KAZ
33
<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Salida:

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

fruit1
Saurabh Chandra Patel
fuente
14
Tenga en cuenta que array_shiftsolo puede eliminar el primer elemento de la matriz. de manera similar, use array_poppara eliminar el último elemento de la matriz.
Jasir
1
La respuesta solo es aplicable al primer elemento de una matriz y no responde a la pregunta general.
sweisgerber.dev
@sebweisgerber tienes razón, pero no creo que eso sea incorrecto y necesito rechazarlo. La pregunta es eliminar un elemento sin mencionar ninguna posición.
Saurabh Chandra Patel
27

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 / usar la clave.

Mugoma J. Okomba
fuente
21

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 opción. Las entradas que devuelven un verdadero de la función de devolución de llamada se conservarán.

$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']]
espiar
fuente
20

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

El uso unsetde matrices numéricas no producirá un error, pero desordenará sus índices:

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

// RESULT: array(0 => 1, 2 => 3)
John Slegers
fuente
19

Si necesita eliminar varios elementos de una matriz asociativa, puede usar array_diff_key () (aquí se usa 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 ) 
Simón
fuente
¿Por qué es esto tan subestimado?
Fr0zenFyr
19

unset() destruye las variables especificadas.

El comportamiento del unset()interior de una función puede variar según el tipo de variable que intente destruir.

Si una variable globalizada está 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()se llamó.

<?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();
?>
Ankit Aggarwal
fuente
17
// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}
GigolNet Guigolachvili
fuente
12

Si se especifica el índice:

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

Si el índice NO se especifica:

$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 ifcondición es necesaria porque si indexno se encuentra, unset()eliminará automáticamente el primer elemento de la matriz que no es lo que queremos

Ahmad Mobaraki
fuente
1
Si no se encuentra el valor, eliminará el primer elemento. agregue una prueba para unset: if ($ index! == false) unset ($ arr [$ index]);
MyRealNameIsBlaze
@ MyRealNameIsBlaze gracias, arreglado
Ahmad Mobaraki
9

Soluciones:

  1. Para eliminar un elemento, use unset () :
unset($array[3]);
unset($array['foo']);
  1. Para eliminar múltiples elementos no contiguos, también use unset () :
unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);
  1. Para eliminar múltiples 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 unset () y asignar '' al elemento. El primero dice This doesn't exist anymore,mientras que el segundo diceThis 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 compañía dejara de producir el piñón modelo XL1000, actualizaría su inventario con:

unset($products['XL1000']);

Sin embargo, si temporalmente se quedó sin piñones XL1000, pero planeaba recibir un nuevo envío de la planta a finales de esta semana, esto es mejor:

$products['XL1000'] = 0;

Si desarma () un elemento, PHP ajusta la matriz para que el bucle siga funcionando correctamente. No compacta la matriz para completar los agujeros faltantes. Esto es lo que queremos decir cuando decimos que todas las matrices son asociativas, incluso cuando parecen ser numéricas. Aquí hay 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 rellenada, use array_values ​​() :

$animals = array_values($animals);

Alternativamente, array_splice () 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 una cola y desea eliminar elementos de la cola al tiempo que permite el acceso aleatorio. Para eliminar con seguridad el primer o el último elemento de una matriz, use array_shift () y array_pop () , respectivamente.

Estrella
fuente
8

Supongamos que tiene la siguiente matriz:

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

Para eliminar storage, haz:

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

Y obtienes:

Array
(
    [user_id] => 193
)
Tebe
fuente
¿Para qué se array_filterusa?
David
eliminar elementos falsos
Tebe
8

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 $fieldsera justo, por lo que no tengo que buscar en todas partes del código cuando se cambian, solo miro el comienzo de la clase y cambio la lista de atributos y el contenido de la matriz $ fields para reflejar el nuevo atributos.

Oxydel
fuente
8

Siga las funciones predeterminadas:

yo)

$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);
msvairam
fuente
7
<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

Cree su matriz en la variable $arrayy luego, donde he puesto 'elemento que desea eliminar', coloca algo como: "a". Y si desea eliminar varios elementos, entonces: "a", "b".

Joshua Charles Pickwell
fuente
7

Use array_search para obtener la clave y eliminarla con unset si se encuentra:

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

fuente
6

unset () múltiples elementos fragmentados de una matriz

Si bien unset()se ha mencionado aquí varias veces, aún no se ha mencionado que unset()acepte 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 siguiente código fallará (aunque habría facilitado un poco el uso de unset () dinámicamente).

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

Elimine las claves de la 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 $ array1 en $ array2.

$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' ]
Kristoffer Bohmann
fuente
6

Eliminar un elemento de matriz basado en una clave:

Use la unsetfunción 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:

Use la array_searchfunción para obtener una clave de elemento y use 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
        )

*/
MahdiY
fuente
6

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

Debe tener este resultado:

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

Utiliza el siguiente código:

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
Jens Erat
fuente
44
php5: simplemente ejecutar array_pop($arr)elimina la entrada final. No se necesita `=`.
Chris K
5
<?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 )
UMAR FAROOQUE KHAN
fuente
4

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

Rahul Patel
fuente
2

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 )
Klajdi Dosti
fuente
2
$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

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

print_r($arrayName);
Javed Khan
fuente