Note-se que unset() irá manter os índices intocados, que é o que você esperaria ao usar os índices de string (array como hashtable), mas pode ser bastante surpreendente ao lidar com arrays indexados inteiros:

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

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

Este é o resultado 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á reindex um array numérico bem, mas irá remover todas as cadeias de caracteres chave do array e substituí-las por números. Se necessitar de preservar os nomes das chaves (strings), ou reindex a lista 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 tiver uma matriz indexada numericamente onde todos os valores são únicos (ou não são únicos, mas deseja remover todas as instâncias de um determinado valor), poderá simplesmente usar o 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);

Isto mostra o seguinte:

4
3

Neste exemplo, o elemento com o valor 'Charles' é removido como pode ser verificado pelo tamanho () chamadas que relatam um tamanho de 4 para a matriz inicial, e 3 após remocao.

Também, 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 precisar de indexar novamente o array:

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

Remove o elemento do fim da lista - devolve 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

Remover o primeiro elemento (vermelho) de uma matriz , - devolve 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 = array("fruit1", "fruit2", "fruit3", "fruit4");
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

Resultado:

Array
(
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
)

fruit1

$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11

Neste caso, não é preciso procurar/usar a chave.

unset() destrói as variáveis indicadas.

O comportamento de unset() dentro de uma função pode variar dependendo do tipo de variável que está a tentar destruir.

Se uma variável globalizada estiver unset() dentro de uma função, apenas a variável local é destruída. A variável no ambiente chamador manterá o mesmo valor que antes de unset() ter sido chamado.

<?php
function destroy_foo() 
{
    global $foo;
    unset($foo);
}

$foo = 'bar';
destroy_foo();
echo $foo;
?>

A resposta do código acima será bar

A {[2] } uma variável global no interior de uma função

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

$bar = "something";
foo();
?>

Se tiver de apagar vários valores num array e as entradas nesse array forem objectos ou dados estruturados, [array_filter][1] é a sua melhor aposta. Aqueles itens que retornam um verdadeiro da função callback serão retidos.

$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, usar unset :

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

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

Matrizes numéricas

Para as matrizes numéricas, usar array_splice :

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

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

Nota

Utilizar unset para arrays numéricos não irá produzir um erro, mas irá alterar os 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);

Resultado:

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

Eu só gostaria de dizer que eu tinha um objeto em particular, que tinha atributos variáveis (ele estava basicamente mapeando uma tabela e eu estava mudando as colunas na tabela, de modo que os atributos no objeto, refletindo a tabela iria variar também

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 propósito de $fields era só para não ter de olhar para todo o lado no código quando são alterados, basta olhar para o início da classe e mudar a lista de atributos e os $fields array content to refletir os novos atributos.

Seguir as funções predefinidas

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

Suponha que você tem tal array:

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

Para apagar storage, Faça:

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

E tu recebes:

Array
(
    [user_id] => 193
)

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

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

Crie o seu array na variável $array e, em seguida, onde pus 'elemento que deseja apagar', coloque algo como:"a". E se você quiser excluir vários, então: "a", "b".

Unset () múltiplos elementos fragmentados de uma matriz

Embora o unsset() tenha sido mencionado aqui várias vezes, ainda não foi mencionado que o unsset () aceita múltiplas variáveis tornando fácil a remoçã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' ]

Desativado() dinamicamente

O Unsset () não aceita uma lista de teclas para remover, por isso o código abaixo irá falhar (teria tornado um pouco mais fácil usar o unsset() dinamicamente embora).

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

Em vez disso, o unset () pode ser usado dinamicamente num laço foreach:

$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
    unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]

Remover as chaves da matriz copiando a matriz

$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 aplica-se às 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' ]

Soluções:

1. para apagar um elemento, use desactivado( ):

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

1. para apagar vários elementos não contíguos, use também desactivado( ):

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

1. para apagar vários elementos contíguos, use array_ Splice( ):

array_splice($array, $offset, $length);

Outras explicações:

A utilização destas funções remove todas as referências a estes elementos da PHP. Se quiser manter uma chave na lista, mas com um valor vazio, atribua o texto vazio ao elemento:

$array[3] = $array['foo'] = '';

Além da sintaxe, há uma diferença lógica entre usar desactivado () e atribuir " ao elemento. O primeiro diz This doesn't exist anymore, enquanto o segundo diz This still exists, but its value is the empty string.

unset($products['XL1000']);

No entanto, se acabou temporariamente de xl1000 sprockets, mas estava a planear receber um novo carregamento da fábrica no final desta semana, isto é melhor:

$products['XL1000'] = 0;

Se você desligar () um elemento, o PHP ajusta o array de modo que o looping ainda funciona corretamente. Não compacta a matriz para preencher os buracos que faltam. Isto é o que queremos dizer quando dizemos 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 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

To compactar a matriz numa matriz numérica de preenchimento intenso, usar matrizes_ valores_ matrizes( ):

$animals = array_values($animals);

Em alternativa, array_ Splice () reindexes automaticamente arrays 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 estiver a usar o array como uma fila e quiser remover os itens da fila, ao mesmo tempo que permite o acesso aleatório. Para remover com segurança o primeiro ou o último elemento de uma matriz, use array_shift( ) e array_pop( ), respectivamente.

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

Remover um elemento de lista com base na chave:

Utilizar unset função abaixo:

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

unset( $a[1] );

print_r( $a );

/*

Output:

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

*/

Remover um elemento de lista com base no valor:

Usar a função array_search para obter a chave do elemento e usar a forma acima para remover o elemento array como em baixo:

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

*/

Para matrizes associativas, com teclas não inteiras:

Simplesmente, {[[0]} funcionaria.

Para arrays com teclas inteiras e se quiser manter as suas teclas:

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

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

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

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

Ao excluir um elemento de um array em PHP, uma boa função a usar é a função unset. Aqui está um exemplo de seu uso:

$anArray = array("X", "Y", "Z");

unset($anArray[0]);

//'dumps' the content of $anArray to the page:
var_dump($anArray);  

O resultado da função var_dump será:

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

Pode simplesmente usar unset() para apagar uma matriz.

Lembre-se que o array deve estar desactivado após a função foreach.

O Unset não altera o índice, mas o array_splice fá-lo

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