ultimo primer posicion eliminar elementos elemento comparar buscar array agregar php arrays

primer - eliminar posicion de un array php



PHP: Eliminar un elemento de una matriz (30)

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

Pensé que ponerlo en null lo haría, pero aparentemente no funciona.

unset no cambia el índice pero array_splice sí lo 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 )

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 de unset() para 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)

unset () elementos múltiples, fragmentados de una matriz

Si bien 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 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 hecho un poco más fácil usar Unset () de forma dinámica).

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

En su lugar, 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 $ 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'' ]

Además, para un elemento con nombre:

unset($array["elementName"]);

Cuando se elimina un elemento de una matriz en PHP, una buena función para usar es la función unset. Aquí hay un ejemplo de su uso:

$anArray = array("X", "Y", "Z"); unset($anArray[0]); //''dumps'' the content of $anArray to the page: var_dump($anArray);

La salida de la función var_dump será:

array(2) { [1]=> string(1) "Y" [2]=> string(1) "Z" }

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 )

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 del arreglo, puede usar unset() o un array_splice() alternativo array_splice() .

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

método unset()

Tenga en cuenta que cuando utiliza unset() las claves de matriz no cambiarán / reindexarán. Si desea reindexar las claves, puede usar array_values() después de unset() que convertirá todas las claves en claves numeradas enumeradas a partir de 0.

Código

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

Salida

Array ( [0] => a [2] => c )

método array_splice()

Si usa 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.

¡También array_splice() necesita el desplazamiento, no la clave! como el segundo parámetro.

Código

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

Salida

Array ( [0] => a [1] => c )

array_splice() igual que unset() toma la matriz por referencia, esto significa que no desea asignar 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() o array_splice() varias veces, puede usar las funciones array_diff() o array_diff_key() dependiendo de si conoce los valores o las claves de los elementos que quieres borrar

método array_diff()

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

Código

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

Salida

Array ( [1] => b )

método array_diff_key()

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

Código

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

Salida

Array ( [1] => b )

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

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.

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

  1. array_splice($array, 2, 1);

Se debe tener en cuenta que unset() mantendrá los índices intactos, que es lo que cabría esperar al usar índices de cadenas (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) } */

Por array_splice() tanto, array_splice() se puede usar si desea normalizar sus claves de enteros. 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) } */

Seguir funciones predeterminadas

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

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 )

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. Se retendrán aquellas entradas que devuelvan un verdadero desde 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'']]

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

Simplemente puede usar unset() para eliminar una matriz.

Recuerde que la matriz debe estar desactivada después de la función foreach

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 fue solo para que no tenga que buscar en todas partes en el 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 Nuevos atributos.

Me tomó un poco de tiempo para resolver esto. Espero que esto pueda ayudar a alguién.

Supongamos que tienes tal matriz:

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

Para borrar el storage , haz:

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

Y usted obtiene:

Array ( [user_id] => 193 )

unset() destruye las variables especificadas.

El comportamiento de unset() dentro de una función puede variar según el tipo de variable que intenta 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 de llamar a unset() .

<?php function destroy_foo() { global $foo; unset($foo); } $foo = ''bar''; destroy_foo(); echo $foo; ?>

La respuesta del código anterior será barra.

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

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

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

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

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

Eliminar un elemento de matriz basado en clave:

Utilice la función de 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:

Use la función array_search para obtener la clave del elemento y use la manera anterior para eliminar el elemento de la 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 ) */

Soluciones:

  1. Para eliminar un elemento, use unset() :

unset($array[3]); unset($array[''foo'']);

  1. Para eliminar varios elementos no contiguos, también use unset() :

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 unset() y asignar '''' al elemento. El primero dice que This doesn''t exist anymore, mientras que el segundo dice que This still exists, but its value is the empty string.

Si estás 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 agotaron temporalmente las ruedas dentadas XL1000, pero planeaba recibir un nuevo envío de la planta esta semana, esto es mejor:

$products[''XL1000''] = 0;

Si unset() un elemento, PHP ajusta la matriz para que el bucle aún funcione 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. 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 new element $animals[ ] = ''gnu''; // add 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 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 mientras sigue permitiendo el acceso aleatorio. Para eliminar de forma segura el primer o último elemento de una matriz, use array_shift () y array_pop () , respectivamente.

$x = array(1, 2, 3, 4, 5); var_dump($x); unset($x[3]); // here is key to be delete echo ''<br>''; array_values($x); var_dump($x);

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

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

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

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

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

Cree su matriz en la variable $ matriz y luego, donde haya puesto el ''elemento que desea eliminar'', debe poner algo como: "a". Y si desea eliminar múltiples, entonces: "a", "b".

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

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

unset($array[$index]);