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 nullfazê-lo, mas aparentemente não funciona.

Existem diferentes maneiras de excluir um elemento da matriz, em que alguns são mais úteis para algumas tarefas específicas do que outros.

Excluir um elemento da matriz

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étodo

Se 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.

Excluir vários elementos da 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étodo

Se 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étodo

Se 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.

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

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

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

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

    echo $fruit;
?>

Resultado:

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

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

Matrizes associativas

Para matrizes associativas, use unset:

$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);

// RESULT: array('a' => 1, 'c' => 3)

Matrizes numéricas

Para matrizes numéricas, use array_splice:

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

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

Nota

O uso unsetde 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 ifcondição é necessária porque, se indexnão for encontrada, unset()excluirá automaticamente o primeiro elemento da matriz que não é o que queremos

Soluções:

1. Para excluir um elemento, use unset () :

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

2. Para excluir vários elementos não contíguos, use também unset () :

unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);

3. Para excluir vários elementos contíguos, use array_splice () :

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
)

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 $fieldsera 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 $arraye, 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]);
}

unset () vários elementos fragmentados de uma matriz

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 () dinamicamente

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 ]

Remova as chaves da matriz, copiando a matriz

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

Remova um elemento da matriz com base em uma chave:

Use a unsetfunção como abaixo:

$a = array(
       'salam',
       '10',
       1
);

unset($a[1]);

print_r($a);

/*

    Output:

        Array
        (
            [0] => salam
            [2] => 1
        )

*/

Remova um elemento da matriz com base no valor:

Use a array_searchfunçã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.

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

Use o seguinte código:

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

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

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

   unset($array[2]);
   $array = array_values($array);

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