valore - unset php




PHP: cancella un elemento da una matrice (20)

C'è un modo semplice per eliminare un elemento da un array usando PHP , in modo tale che foreach ($array) non includa più quell'elemento?

Pensavo che impostarlo su null avrebbe fatto, ma a quanto pare non funziona.


unset non cambia l'indice ma array_splice fa

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

Matrici associative

Per gli array associativi, utilizzare unset() :

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

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

Array numerici

Per gli array numerici, usa array_splice() :

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

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

Nota

L'utilizzo di unset() per gli array numerici non produrrà un errore, ma rovinerà i tuoi indici:

$arr = array(1, 2, 3);
unset($arr[1]);

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

Esistono diversi modi per eliminare un elemento dell'array, in cui alcuni sono più utili di alcuni compiti specifici di altri.

Elimina un elemento dell'array

Se si desidera eliminare solo un elemento dell'array, è possibile utilizzare unset() o array_splice() alternativo array_splice() .

Inoltre se hai il valore e non conosci la chiave per cancellare l'elemento puoi usare array_search() per ottenere la chiave.

metodo unset()

Nota che quando usi unset() le chiavi dell'array non cambieranno / reindicheranno. Se vuoi reindicizzare le chiavi puoi usare array_values() dopo unset() che convertirà tutte le chiavi in ​​chiavi numeriche enumerate a partire da 0.

Codice

<?php

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

?>

Produzione

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

metodo array_splice()

Se si utilizza array_splice() le chiavi verranno array_splice() automaticamente, ma le chiavi associative non cambieranno rispetto a array_values() che convertirà tutte le chiavi in ​​chiavi numeriche.

Anche array_splice() bisogno dell'offset, non della chiave! come secondo parametro

Codice

<?php

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

?>

Produzione

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

array_splice() uguale a unset() prende la matrice per riferimento, questo significa che non si desidera assegnare i valori di ritorno di tali funzioni all'array.

Elimina più elementi di matrice

Se si desidera eliminare più elementi di matrice e non si desidera chiamare unset() o array_splice() più volte è possibile utilizzare le funzioni array_diff() o array_diff_key() seconda se si conoscono i valori o le chiavi degli elementi che vuoi cancellare.

metodo array_diff()

Se si conoscono i valori degli elementi dell'array che si desidera eliminare, è possibile utilizzare array_diff() . Come prima con unset() non cambierà / reindicherà le chiavi dell'array.

Codice

<?php

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

?>

Produzione

Array (
    [1] => b
)

metodo array_diff_key()

Se conosci le chiavi degli elementi che vuoi eliminare, allora vuoi usare array_diff_key() . Qui devi assicurarti di passare le chiavi come chiavi nel secondo parametro e non come valori. Altrimenti, devi capovolgere la matrice con array_flip() . E anche qui le chiavi non cambieranno / reindicizzare.

Codice

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

Produzione

Array (
    [1] => b
)

Inoltre, se si desidera utilizzare unset() o array_splice() per eliminare più elementi con lo stesso valore, è possibile utilizzare array_keys() per ottenere tutte le chiavi per un valore specifico e quindi eliminare tutti gli elementi.


Inoltre, per un elemento denominato:

unset($array["elementName"]);


Per gli array associativi, con chiavi non intero:

Semplicemente, unset($array[$key]) funzionerebbe.

Per gli array con chiavi intere e se si desidera mantenere le chiavi:

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

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

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

Puoi semplicemente usare unset() per cancellare un array.

Ricordare che la matrice deve essere disinserita dopo la funzione foreach .


Questo può aiutare ...

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

il risultato sarà:

Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )

Se è necessario rimuovere più elementi da un array associativo, è possibile utilizzare array_diff_key() (qui utilizzato 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);

Produzione:

Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 ) 

Se si dispone di un array indicizzato numericamente in cui tutti i valori sono univoci (o non sono univoci ma si desidera rimuovere tutte le istanze di un valore particolare), è sufficiente utilizzare array_diff () per rimuovere un elemento corrispondente, come questo:

$my_array = array_diff($my_array, array('Value_to_remove'));

Per esempio:

$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);

Questo mostra quanto segue:

4
3

In questo esempio, l'elemento con il valore 'Charles' viene rimosso come può essere verificato dalle chiamate sizeof () che riportano una dimensione di 4 per l'array iniziale e 3 dopo la rimozione.


Seguire le funzioni predefinite

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

Va notato che unset() manterrà gli indici inalterati, che è quello che ci si aspetterebbe quando si usano gli indici di stringa (array come hashtable), ma può essere abbastanza sorprendente quando si tratta di array con indice intero:

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

Quindi array_splice() può essere usato se desideri normalizzare le tue chiavi integer. Un'altra opzione sta usando array_values() dopo 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)
} */

Vorrei solo dire che avevo un oggetto particolare, che aveva attributi variabili (essenzialmente stava mappando una tabella e stavo cambiando le colonne nella tabella, quindi anche gli attributi nell'oggetto, riflettendo la tabella, sarebbero cambiati

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

L'intero scopo dei $ fields era proprio così non devo cercare dappertutto nel codice quando sono cambiati, guardo solo all'inizio della classe e cambio l'elenco degli attributi e il contenuto dell'array $ fields per riflettere nuovi attributi.

Mi ci è voluto un po 'per capirlo. Spero che questo possa aiutare qualcuno.


Distruggi un singolo elemento di un array

unset()

$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);

L'output sarà:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [3]=>
  string(1) "D"
  [4]=>
  string(1) "E"
}

Se è necessario reind indicizzare la matrice:

$array1 = array_values($array1);
var_dump($array1);

Quindi l'output sarà:

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [2]=>
  string(1) "D"
  [3]=>
  string(1) "E"
}

Esponi l'elemento alla fine dell'array - restituisce il valore dell'elemento rimosso

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

L'output sarà

Array
(
    [0] => orange
    [1] => banana
    [2] => apple
)
Last Fruit: raspberry

Rimuovi il primo elemento (rosso) da un array , - restituisce il valore dell'elemento rimosso

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

L'output sarà:

Array
(
    [b] => green
    [c] => blue
)
First Color: red

Rimuovi un elemento dell'array in base alla chiave:

Usa la funzione unset come di seguito:

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

unset( $a[1] );

print_r( $a );

/*

Output:

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

*/

Rimuovi un elemento dell'array in base al valore:

Usa la funzione array_search per ottenere la chiave dell'elemento e usa la modalità sopra per rimuovere l'elemento dell'array come di seguito:

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

*/

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

Questo è l'output dal codice sopra:

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
)

Ora, array_values ​​() reinditerà piacevolmente un array numerico, ma rimuoverà tutte le stringhe chiave dall'array e le sostituirà con i numeri. Se è necessario conservare i nomi delle chiavi (stringhe) o reindicizzare l'array se tutte le chiavi sono numeriche, utilizzare array_merge ():

$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);

uscite

Array
(
    [0] => blue
    [1] => green
    [2] => green
    [3] => orange
    [4] => indigo
)

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

Produzione:

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

fruit1

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

Produzione

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




arrays