Existe uma maneira fácil de excluir um elemento de uma matriz usando PHP, de modo que foreach ($array)
não inclua mais esse elemento?
Eu pensei que defini-lo para null
fazê-lo, mas aparentemente não funciona.
Existe uma maneira fácil de excluir um elemento de uma matriz usando PHP, de modo que foreach ($array)
não inclua mais esse elemento?
Eu pensei que defini-lo para null
fazê-lo, mas aparentemente não funciona.
Respostas:
Existem diferentes maneiras de excluir um elemento da matriz, em que alguns são mais úteis para algumas tarefas específicas do que outros.
Se você deseja excluir apenas um elemento da matriz, pode usar unset()
ou alternativamente \array_splice()
.
Além disso, se você tiver o valor e não souber a chave para excluir o elemento, poderá usar \array_search()
para obtê-la.
unset()
Observe que, quando você usa unset()
as chaves da matriz, não muda / reindexa. Se você deseja reindexar as chaves, poderá usá-las e \array_values()
depois unset()
converterá todas as chaves em chaves numéricas enumeradas, começando em 0.
Código
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
unset($array[1]);
//↑ Key which you want to delete
?>
Resultado
[
[0] => a
[2] => c
]
\array_splice()
métodoSe você usar \array_splice()
as chaves, elas serão reindexadas automaticamente, mas as chaves associativas não serão alteradas, ao contrário do \array_values()
que converterá todas as chaves em chaves numéricas.
Também \array_splice()
precisa do deslocamento, não da chave! como o segundo parâmetro.
Código
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
\array_splice($array, 1, 1);
//↑ Offset which you want to delete
?>
Resultado
[
[0] => a
[1] => c
]
array_splice()
É o mesmo que unset()
levar a matriz por referência, e isso significa que você não deseja atribuir os valores de retorno dessas funções de volta à matriz.
Se você deseja excluir vários elementos da matriz e não deseja chamar unset()
ou \array_splice()
várias vezes, você pode usar as funções \array_diff()
ou \array_diff_key()
dependendo de conhecer os valores ou as chaves dos elementos que deseja excluir.
\array_diff()
métodoSe você souber os valores dos elementos da matriz que deseja excluir, poderá usar \array_diff()
. Como antes, unset()
ele não altera / reindexa as chaves da matriz.
Código
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff($array, ["a", "c"]);
//└────────┘→ Array values which you want to delete
?>
Resultado
[
[1] => b
]
\array_diff_key()
métodoSe você conhece as chaves dos elementos que deseja excluir, deseja usar \array_diff_key()
. Aqui você deve certificar-se de passar as chaves como chaves no segundo parâmetro e não como valores. Caso contrário, você precisará inverter a matriz \array_flip()
. E também aqui as chaves não serão alteradas / reindexadas.
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
?>
Resultado
[
[1] => b
]
Além disso, se você desejar usar unset()
ou \array_splice()
excluir vários elementos com o mesmo valor, poderá \array_keys()
obter todas as chaves de um valor específico e excluir todos os elementos.
array_splice
, conforme descrito nas outras respostas.
array (3) { [0]=>int(0) ...
quando você unset($x[2])
de $x = array(1, 2, 3, 4);
resultado deve ser var_dump($x); // array(3) { [0]=> int(1) [1]=> int(2) [3]=> int(4) }
(provavelmente foi erro de digitação)
unset
pode ter vários argumentos: void unset ( mixed $var [, mixed $... ] )
.
Deve-se observar que unset()
manterá os índices intocados, o que você esperaria ao usar índices de string (matriz como hashtable), mas pode ser bastante surpreendente ao lidar com matrizes indexadas inteiras:
$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)
} */
Portanto, array_splice()
pode ser usado se você deseja normalizar suas chaves inteiras. Outra opção é usar array_values()
depois 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)
} */
array_splice
pode fazer sentido (entre outros).
// 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 é a saída do código acima:
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
)
Agora, array_values () reindexará muito bem um array numérico, mas removerá todas as cadeias de teclas do array e as substituirá por números. Se você precisar preservar os nomes das chaves (cadeias) ou reindexar a matriz se todas as chaves forem numéricas, use array_merge ():
$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);
Saídas
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]);
Se você possui uma matriz indexada numericamente em que todos os valores são únicos (ou não são únicos, mas deseja remover todas as instâncias de um valor específico), basta usar array_diff () para remover um elemento correspondente, como este:
$my_array = array_diff($my_array, array('Value_to_remove'));
Por exemplo:
$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);
Isso exibe o seguinte:
4
3
Neste exemplo, o elemento com o valor 'Charles' é removido, como pode ser verificado pelas chamadas sizeof () que relatam um tamanho de 4 para a matriz inicial e 3 após a remoção.
Além disso, para um elemento nomeado:
unset($array["elementName"]);
$a = array("A"=>1, "B"=>2, "C"=>"a");
print_r($a);
unset($a["B"]);
print_r($a);
dá (formatado): Array ( [A] => 1 [B] => 2 [C] => a ), Array ( [A] => 1 [C] => a )
Destruir um único elemento de uma matriz
unset()
$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);
A saída será:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[3]=>
string(1) "D"
[4]=>
string(1) "E"
}
Se você precisar indexar novamente a matriz:
$array1 = array_values($array1);
var_dump($array1);
Então a saída será:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[2]=>
string(1) "D"
[3]=>
string(1) "E"
}
Retire o elemento do final da matriz - retorne o valor do elemento removido
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
A saída será
Array
(
[0] => orange
[1] => banana
[2] => apple
)
Last Fruit: raspberry
Remova o primeiro elemento (vermelho) de uma matriz , - retorne o valor do elemento removido
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);
A saída será:
Array
(
[b] => green
[c] => blue
)
First Color: red
array_shift
índice de re os principais itens Se for inteiro, por isso é ruim, então você pode usar isto: stackoverflow.com/a/52826684/1407491
<?php
$stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
Resultado:
[
[0] => fruit2
[1] => fruit3
[2] => fruit4
]
fruit1
array_shift
só é possível excluir o primeiro elemento da matriz. Da mesma forma, use array_pop
para excluir o último elemento da matriz.
Para evitar fazer uma pesquisa, pode-se brincar com array_diff
:
$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11
Nesse caso, não é necessário pesquisar / usar a chave.
Se você precisar excluir vários valores em uma matriz e as entradas nessa matriz forem objetos ou dados estruturados, [array_filter][1]
é sua melhor aposta. As entradas que retornarem um valor verdadeiro da função de retorno de chamada serão mantidas.
$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']]
Para matrizes associativas, use unset
:
$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);
// RESULT: array('a' => 1, 'c' => 3)
Para matrizes numéricas, use array_splice
:
$arr = array(1, 2, 3);
array_splice($arr, 1, 1);
// RESULT: array(0 => 1, 1 => 3)
O uso unset
de matrizes numéricas não produzirá um erro, mas atrapalhará seus índices:
$arr = array(1, 2, 3);
unset($arr[1]);
// RESULT: array(0 => 1, 2 => 3)
Se você precisar remover vários elementos de uma matriz associativa, poderá usar array_diff_key () (aqui usado com 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);
Resultado:
Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 )
unset()
destrói as variáveis especificadas.
O comportamento de unset()
dentro de uma função pode variar dependendo do tipo de variável que você está tentando destruir.
Se uma variável globalizada estiver unset()
dentro de uma função, somente a variável local será destruída. A variável no ambiente de chamada reterá o mesmo valor que antes unset()
foi chamado.
<?php
function destroy_foo()
{
global $foo;
unset($foo);
}
$foo = 'bar';
destroy_foo();
echo $foo;
?>
A resposta do código acima será bar .
Para unset()
uma variável global dentro de uma função:
<?php
function foo()
{
unset($GLOBALS['bar']);
}
$bar = "something";
foo();
?>
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
Se o índice for especificado:
$arr = ['a', 'b', 'c'];
$index = 0;
unset($arr[$index]); // $arr = ['b', 'c']
Se o índice NÃO for especificado:
$arr = ['a', 'b', 'c'];
$index = array_search('a', $arr); // search the value to find index
if($index !== false){
unset($arr[$index]); // $arr = ['b', 'c']
}
A if
condição é necessária porque, se index
não for encontrada, unset()
excluirá automaticamente o primeiro elemento da matriz que não é o que queremos
Soluções:
unset($array[3]); unset($array['foo']);
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
array_splice($array, $offset, $length);
Mais explicações:
O uso dessas funções remove todas as referências a esses elementos do PHP. Se você deseja manter uma chave na matriz, mas com um valor vazio, atribua a cadeia vazia ao elemento:
$array[3] = $array['foo'] = '';
Além da sintaxe, há uma diferença lógica entre usar unset () e atribuir '' ao elemento. O primeiro dizThis doesn't exist anymore,
enquanto o segundo dizThis still exists, but its value is the empty string.
Se você estiver lidando com números, atribuir 0 pode ser uma alternativa melhor. Portanto, se uma empresa parasse a produção do pinhão modelo XL1000, atualizaria seu inventário com:
unset($products['XL1000']);
No entanto, se ficou temporariamente sem as rodas dentadas XL1000, mas planejava receber uma nova remessa da fábrica no final desta semana, isso é melhor:
$products['XL1000'] = 0;
Se você desmarcar () um elemento, o PHP ajustará a matriz para que o loop ainda funcione corretamente. Não compacta a matriz para preencher os orifícios ausentes. É isso que queremos dizer quando afirmamos que todas as matrizes são associativas, mesmo quando parecem ser numéricas. Aqui está um exemplo:
// 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 a matriz em uma matriz numérica densamente preenchida, use array_values () :
$animals = array_values($animals);
Como alternativa, array_splice () reindexa automaticamente matrizes para evitar deixar orifícios:
// 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
)
Isso é útil se você estiver usando a matriz como uma fila e quiser remover itens da fila enquanto ainda permite acesso aleatório. Para remover com segurança o primeiro ou o último elemento de uma matriz, use array_shift () e array_pop () , respectivamente.
Suponha que você tenha a seguinte matriz:
Array
(
[user_id] => 193
[storage] => 5
)
Para excluir storage
, faça:
unset($attributes['storage']);
$attributes = array_filter($attributes);
E você obtém:
Array
(
[user_id] => 193
)
array_filter
utilizado?
Gostaria apenas de dizer que tinha um objeto específico que tinha atributos variáveis (basicamente mapeava uma tabela e estava alterando as colunas na tabela, para que os atributos no objeto, refletindo a tabela, também variassem):
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 o objetivo de $fields
era justo, então não preciso procurar em todo lugar no código quando eles são alterados, apenas observo o início da classe e altero a lista de atributos e o conteúdo da matriz $ fields para refletir o novo atributos.
Siga as funções padrão:
Eu)
$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);
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>
Crie sua matriz na variável $array
e, em seguida, onde coloquei 'elemento que você deseja excluir', coloque algo como: "a". E se você deseja excluir vários itens, então: "a", "b".
Use array_search para obter a chave e remova-a com a opção se não encontrada:
if (($key = array_search('word', $array)) !== false) {
unset($array[$key]);
}
Embora unset()
tenha sido mencionado aqui várias vezes, ainda não foi mencionado que unset()
aceita várias variáveis, facilitando a exclusão de vários elementos não-contíguos de uma matriz em uma operação:
// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]
unset () não aceita uma matriz de chaves para remover, portanto, o código abaixo falhará (isso tornaria um pouco mais fácil usar dinamicamente unset () embora).
$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);
Em vez disso, unset () pode ser usado dinamicamente em um loop foreach:
$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]
Há também outra prática que ainda não foi mencionada. Às vezes, a maneira mais simples de se livrar de certas chaves de matriz é simplesmente copiar $ array1 em $ 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, a mesma prática se aplica a cadeias 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' ]
Use a unset
função como abaixo:
$a = array(
'salam',
'10',
1
);
unset($a[1]);
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
Use a array_search
função para obter uma chave de elemento e use a maneira acima para remover um elemento da matriz como abaixo:
$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
)
*/
Duas maneiras de remover o primeiro item de uma matriz mantendo a ordem do índice e também se você não souber o nome da chave do primeiro item.
// 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);
// 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 esses dados de amostra:
$array = array(10 => "a", 20 => "b", 30 => "c");
Você deve ter este resultado:
array(2) {
[20]=>
string(1) "b"
[30]=>
string(1) "c"
}
<?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);
?>
Resultado
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 )
Para matrizes associativas, com chaves não inteiras:
Simplesmente, unset($array[$key])
funcionaria.
Para matrizes com chaves inteiras e se você deseja manter suas chaves:
$array = [ 'mango', 'red', 'orange', 'grapes'];
unset($array[2]);
$array = array_values($array);
array_splice($array, 2, 1);
Isso pode ajudar ...
<?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);
?>
O 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()
as iterações sobre a matriz, não incluirá mais o valor removido. OTOH, é verdade que Stevan resposta é ampla e, na verdade, era a resposta que eu estava procurando - mas não o OP :)