Excluindo um elemento de uma matriz em PHP
https://stackoverflow.com/questions/369602
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Existe uma maneira fácil de apagar um elemento de uma matriz usando PHP, de tal forma que foreach ($array) já não inclui esse elemento?
Eu pensei que defini-la para null iria fazê-lo, mas, aparentemente, ele não funciona.
Solução
Existem diferentes maneiras para excluir um elemento da matriz, onde alguns são mais útil para algumas tarefas específicas do que outros.
um Excluir elemento array
Se você deseja excluir apenas um elemento matriz que você pode usar \unset() ou alternativamente \array_splice() .
Além disso, se você tem o valor e não sei a chave para eliminar o elemento que você pode usar \array_search() para obter a chave.
\unset() método
Note que quando você usa \unset() as chaves do array não vai mudar / reindexar. Se você quiser reindexar as teclas que você pode usar \array_values() após \unset() que irá converter todas as chaves para as 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
?>
saída
[
[0] => a
[2] => c
]
\array_splice() método
Se você usar \array_splice() as chaves serão reindexed automaticamente, mas as chaves associativas não vai mudar em oposição a \array_values() que irá converter todas as chaves para as teclas numéricas.
Além disso \array_splice() precisa o deslocamento, não a 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
?>
saída
[
[0] => a
[1] => c
]
array_splice() 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 voltar para a matriz.
excluir vários elementos do array
Se você quiser excluir vários elementos da matriz e não quer chamar \unset() ou \array_splice() várias vezes você pode usar as funções \array_diff() ou \array_diff_key() dependendo se você souber os valores ou as chaves dos elementos que você deseja excluir.
\array_diff() método
Se você sabe os valores dos elementos da matriz que você deseja excluir, em seguida, você pode usar \array_diff(). Como antes com \unset() não vai mudar / reindexar as chaves do array.
Código
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff($array, ["a", "c"]);
//└────────┘→ Array values which you want to delete
?>
saída
[
[1] => b
]
\array_diff_key() método
Se você sabe as chaves dos elementos que você deseja excluir, em seguida, você quer usar \array_diff_key(). Aqui você tem que ter certeza que você passar as chaves como chaves no segundo parâmetro e não como valores. Caso contrário, você tem que virar a matriz com \array_flip() . E também aqui as chaves não mudará / reindex.
Código
<?php
$array = [0 => "a", 1 => "b", 2 => "c"];
$array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
//↑ ↑ Array keys which you want to delete
?>
saída
[
[1] => b
]
Além disso, se você quiser usar \unset() ou \array_splice() para excluir vários elementos com o mesmo valor que você pode usar \array_keys() para obter todas as chaves para um valor específico e, em seguida, apagar todos os elementos.
Outras dicas
Deve-se notar que unset() irá manter índices intocada, que é o que você esperaria quando utilizando índices de cordas (array como hashtable), mas pode ser bastante surpreendente quando se lida com números inteiros matrizes indexadas:
$array = array(0, 1, 2, 3);
unset($array[2]);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[3]=>
int(3)
} */
$array = array(0, 1, 2, 3);
array_splice($array, 2, 1);
var_dump($array);
/* array(3) {
[0]=>
int(0)
[1]=>
int(1)
[2]=>
int(3)
} */
Assim array_splice() pode ser usado se você gostaria de normalizar suas chaves inteiras. Outra opção é usar array_values() depois 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)
} */
// 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 ??() irá reindexar uma matriz numérica muito bem, mas ele irá remover todas as cordas principais da matriz e substituí-los com números. Se você precisa para preservar os nomes das teclas (strings), ou reindexar a matriz se todas as chaves são numéricos, 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ê tiver uma matriz numericamente indexados, onde todos os valores são únicos (ou eles são não-exclusivo, mas que deseja remover todas as ocorrências de um determinado valor), você pode simplesmente usar array_diff () para remover um elemento correspondente, como esta :
$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 pela sizeof () chamadas que relatam um tamanho de 4 para a matriz inicial, e 3 após a remoção.
Além disso, para um elemento chamado:
unset($array["elementName"]);
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 índice de re a matriz:
$array1 = array_values($array1);
var_dump($array1);
Em seguida, a saída será:
array(4) {
[0]=>
string(1) "A"
[1]=>
string(1) "B"
[2]=>
string(1) "D"
[3]=>
string(1) "E"
}
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
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
<?php
$stack = array("fruit1", "fruit2", "fruit3", "fruit4");
$fruit = array_shift($stack);
print_r($stack);
echo $fruit;
?>
Output:
Array
(
[0] => fruit2
[1] => fruit3
[2] => fruit4
)
fruit1
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
Neste caso, a pessoa não tem que procurar / usar a chave.
Se você tem que excluir vários valores em uma matriz e as entradas na matriz que são objetos ou dados estruturados, [array_filter][1] é sua melhor aposta. Essas entradas que retornam um verdadeiro a partir da função de retorno de chamada será mantida.
$array = [
['x'=>1,'y'=>2,'z'=>3],
['x'=>2,'y'=>4,'z'=>6],
['x'=>3,'y'=>6,'z'=>9]
];
$results = array_filter($array, function($value) {
return $value['x'] > 2;
}); //=> [['x'=>3,'y'=>6,z=>'9']]
unset() destrói as variáveis ??especificadas.
O comportamento do unset() dentro de uma função pode variar dependendo do tipo de variável que você está tentando destruir.
Se uma variável globalizado está dentro unset() de uma função, apenas a variável local será destruída. A variável no ambiente chamando manterá o mesmo valor de 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() um interior variável global de uma função:
<?php
function foo()
{
unset($GLOBALS['bar']);
}
$bar = "something";
foo();
?>
associativa matrizes
Para matrizes associativas, uso unset :
$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);
// RESULT: array('a' => 1, 'c' => 3)
Numeric matrizes
Para arrays numéricos, o uso array_splice :
$arr = array(1, 2, 3);
array_splice($arr, 1, 1);
// RESULT: array(0 => 1, 1 => 3)
Nota
Usando unset para arrays numéricos vai não produzir um erro, mas vai 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, você pode 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);
Output:
Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 )
// Remove by value
function removeFromArr($arr, $val)
{
unset($arr[array_search($val, $arr)]);
return array_values($arr);
}
Suponha que você tenha o seguinte array:
Array
(
[user_id] => 193
[storage] => 5
)
Para storage de exclusão, faça:
unset($attributes['storage']);
$attributes = array_filter($attributes);
E você tem:
Array
(
[user_id] => 193
)
Eu apenas gostaria de dizer que eu tinha um objeto particular que tinha atributos variáveis ??(foi basicamente o mapeamento de uma mesa e eu estava mudando as colunas na tabela, de modo que os atributos no objeto, refletindo a mesa iria variar bem ):
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 {}
}
}
}
A propósito de $fields era justo, então eu não tenho que olhar em todos os lugares no código quando está mudado, eu só olhar para o início da classe e mudar a lista de atributos e o $ campos conteúdo matriz para refletir os novos atributos.
Siga as funções padrão:
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);
Soluções:
- Para excluir um elemento, use unset () :
unset($array[3]); unset($array['foo']);
- Para excluir vários elementos não contíguos, também usam unset () :
unset($array[3], $array[5]); unset($array['foo'], $array['bar']);
- Para excluir vários elementos contíguos, use array_splice () :
array_splice($array, $offset, $length);
Mais explicações:
Usando estas funções remove todas as referências a esses elementos de PHP. Se você quiser manter uma chave na matriz, mas com um valor vazio, atribuir a cadeia vazia ao elemento:
$array[3] = $array['foo'] = '';
Além de sintaxe, há uma diferença lógica entre usando unset () atribuindo '' para o elemento. O primeiro diz This doesn't exist anymore, enquanto o segundo diz This still exists, but its value is the empty string.
Se você está lidando com números, atribuindo 0 pode ser uma alternativa melhor. Assim, se uma empresa parou a produção da roda dentada modelo XL1000, seria atualizar seu inventário com:
unset($products['XL1000']);
No entanto, se temporariamente ficou sem XL1000 rodas dentadas, mas estava planejando para receber uma nova remessa a partir da planta no final desta semana, este é melhor:
$products['XL1000'] = 0;
Se você unset () um elemento, PHP ajusta a matriz para que looping ainda funciona corretamente. Não compactar a matriz para preencher os buracos desaparecidas. Isto é o que queremos dizer quando dizemos que todas as matrizes são associativas, mesmo quando eles parecem ser numérico. 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 preenchido, usar array_values ??() :
$animals = array_values($animals);
Como alternativa, array_splice () reindexa automaticamente matrizes para evitar deixar buracos:
// 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
)
Isto é útil se você estiver usando a matriz como uma fila e deseja remover itens da fila, enquanto ainda permitindo acesso aleatório. Para remover com segurança o primeiro ou o último elemento de uma matriz, use array_shift () array_pop () , respectivamente.
unset () múltiplos, elementos fragmentados de uma matriz
Enquanto unset() foi mencionado aqui várias vezes, ele ainda tem de ser mencionado que unset() aceita múltiplas variáveis ??tornando mais fácil para múltiplos de exclusão, elementos não contíguos de uma matriz em uma única 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 () dinamicamente
unset () não aceita um conjunto de chaves para retirar, de modo que o código abaixo irá falhar (que teria feito um pouco mais fácil de usar unset () dinamicamente embora).
$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);
Em vez disso, unset () pode ser usado de forma dinâmica 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 ]
chaves Remove matriz copiando a matriz
Há também uma outra prática que ainda tem de ser mencionado. Às vezes, a maneira mais simples para se livrar de certas chaves do array é 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' ]
<?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);
?>
saída
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 )
Remover um elemento de matriz baseada em uma chave:
Use a função unset como abaixo:
$a = array(
'salam',
'10',
1
);
unset($a[1]);
print_r($a);
/*
Output:
Array
(
[0] => salam
[2] => 1
)
*/
Remover um elemento de matriz com base no valor:
Use a função array_search para obter uma chave de elemento e usar da 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
)
*/
<?php
$array = array("your array");
$array = array_diff($array, ["element you want to delete"]);
?>
Crie a sua matriz no $array variável e, em seguida, onde eu ter colocado 'elemento que deseja excluir' você colocar algo como: "a". E se você deseja excluir vários itens, em seguida:. "A", "b"
Use o seguinte código:
$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);
Duas maneiras para remover o primeiro item de uma matriz de manter a ordem do índice e também se você não sabe o nome da chave do primeiro item.
Solução # 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);
Solução # 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 estes 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"
}
Use array_search para pegar a chave e removê-lo com unset se encontrado:
if (($key = array_search('word', $array)) !== false) {
unset($array[$key]);
}
Para matrizes associativas, com chaves não-inteiros:
Simplesmente, unset($array[$key]) iria funcionar.
Para matrizes com chaves inteiras e se você quiser manter suas chaves:
-
$array = [ 'mango', 'red', 'orange', 'grapes'];unset($array[2]); $array = array_values($array); -
array_splice($array, 2, 1);
Isto 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 não muda o índice, mas array_splice faz:
$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 )
