Penggunaan fungsi ARRAY_SPLICE pada PHP

Apakah ada cara mudah untuk menghapus elemen dari array menggunakan PHP, sehingga foreach ($array) tidak lagi menyertakan elemen itu?

Saya pikir menetapkannya ke null akan melakukannya, tetapi ternyata tidak berhasil.

Ada berbagai cara untuk menghapus elemen array, di mana beberapa lebih berguna untuk beberapa tugas tertentu daripada yang lain.

Hapus satu elemen array

Jika Anda ingin menghapus hanya satu elemen array, Anda dapat menggunakan \unset() atau sebagai alternatif \array_splice() .

Juga jika Anda memiliki nilai dan tidak tahu kunci untuk menghapus elemen Anda dapat menggunakan \array_search() untuk mendapatkan kunci.

\unset() metode

Perhatikan bahwa ketika Anda menggunakan \unset() kunci array tidak akan berubah/indeks ulang. Jika Anda ingin mengindeks ulang tombol, Anda dapat menggunakan \array_values() setelah \unset() yang akan mengonversi semua kunci menjadi kunci numerik yang dihitung mulai dari 0.

Kode

<?php

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

?>

Keluaran

[
    [0] => a
    [2] => c
]

\array_splice() metode

Jika Anda menggunakan \array_splice() kunci akan secara otomatis diindeks ulang, tetapi kunci asosiatif tidak akan berubah dibandingkan dengan \array_values() yang akan mengonversi semua kunci menjadi kunci numerik.

Juga \array_splice() membutuhkan offset, bukan kuncinya! sebagai parameter kedua.

Kode

<?php

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

?>

Keluaran

[
    [0] => a
    [1] => c
]

array_splice() sama dengan \unset() mengambil array dengan referensi, dan ini berarti Anda tidak ingin menetapkan nilai kembali fungsi-fungsi tersebut kembali ke array.

Hapus beberapa elemen array

Jika Anda ingin menghapus beberapa elemen array dan tidak ingin memanggil \unset() atau \array_splice() beberapa kali Anda dapat menggunakan fungsi \array_diff() atau \array_diff_key() tergantung pada apakah Anda mengetahui nilai atau kunci elemen yang ingin Anda hapus.

\array_diff() metode

Jika Anda tahu nilai-nilai elemen array yang ingin Anda hapus, maka Anda bisa menggunakan \array_diff(). Seperti sebelumnya dengan \unset() tidak akan mengubah/mengindeks kembali kunci array.

Kode

<?php

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

?>

Keluaran

[
    [1] => b
]

\array_diff_key() metode

Jika Anda tahu kunci elemen yang ingin Anda hapus, maka Anda ingin menggunakan \array_diff_key(). Di sini Anda harus memastikan bahwa Anda meneruskan kunci sebagai kunci di parameter kedua dan bukan sebagai nilai. Jika tidak, Anda harus membalik array dengan \array_flip() . Dan juga di sini tombol tidak akan berubah/indeks ulang.

Kode

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    $array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
                                    //↑           ↑ Array keys which you want to delete
?>

Keluaran

[
    [1] => b
]

Juga jika Anda ingin menggunakan \unset() atau \array_splice() untuk menghapus beberapa elemen dengan nilai yang sama Anda dapat menggunakan \array_keys() untuk mendapatkan semua kunci untuk nilai tertentu dan kemudian menghapus semua elemen.

Perlu dicatat bahwa unset() akan membuat indeks tidak tersentuh, yang akan Anda harapkan saat menggunakan indeks string (array sebagai hashtable), tetapi bisa sangat mengejutkan ketika berhadapan dengan array berindeks integer:

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

Jadi array_splice() dapat digunakan jika Anda ingin menormalkan kunci integer Anda. Pilihan lain menggunakan array_values() after 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);

Ini adalah output dari kode di atas:

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
)

Sekarang, array_values ​​() akan memasang kembali array numerik dengan baik, tetapi itu akan menghapus semua string kunci dari array dan menggantinya dengan angka. Jika Anda perlu mempertahankan nama kunci (string), atau memasukkan kembali array jika semua kunci numerik, gunakan array_merge ():

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

Keluaran

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

$key = array_search($needle, $array);
if ($key !== false) {
    unset($array[$key]);
}

Jika Anda memiliki array yang diindeks secara numerik di mana semua nilai unik (atau tidak unik tetapi Anda ingin menghapus semua instance dari nilai tertentu), Anda dapat menggunakan array_diff () untuk menghapus elemen yang cocok, seperti ini:

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

Sebagai contoh:

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

Ini menampilkan yang berikut:

4
3

Dalam contoh ini, elemen dengan nilai 'Charles' dihapus karena dapat diverifikasi oleh sizeof () panggilan yang melaporkan ukuran 4 untuk array awal, dan 3 setelah penghapusan.

Juga, untuk elemen bernama:

unset($array["elementName"]);

Hancurkan satu elemen array

unset()

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

Outputnya adalah:

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

Jika Anda perlu mengindeks ulang array:

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

Maka outputnya adalah:

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

Pop elemen dari ujung array - mengembalikan nilai elemen yang dihapus

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

Outputnya adalah

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

Hapus elemen pertama (merah) dari array , - kembalikan nilai elemen yang dihapus

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

Outputnya adalah:

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

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

    echo $fruit;
?>

Keluaran: 

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

fruit1

Untuk menghindari pencarian, orang dapat bermain-main dengan array_diff:

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

Dalam hal ini seseorang tidak perlu mencari/menggunakan kunci.

unset() menghancurkan variabel yang ditentukan.

Perilaku unset() di dalam fungsi dapat bervariasi tergantung pada jenis variabel apa yang Anda coba hancurkan.

Jika variabel global adalah unset() di dalam suatu fungsi, hanya variabel lokal yang dihancurkan. Variabel dalam lingkungan panggilan akan mempertahankan nilai yang sama seperti sebelum unset() dipanggil.

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

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

Jawaban dari kode di atas adalah bar .

Untuk unset() variabel global di dalam suatu fungsi:

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

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

Jika Anda harus menghapus beberapa nilai dalam array dan entri dalam array itu adalah objek atau data terstruktur, [array_filter][1] adalah taruhan terbaik Anda. Entri yang mengembalikan true dari fungsi callback akan dipertahankan. 

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

Array asosiatif

Untuk array asosiatif, gunakan unset :

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

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

Array angka

Untuk array numerik, gunakan array_splice :

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

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

Catatan

Menggunakan unset untuk array numerik tidak akan menghasilkan kesalahan, tetapi akan mengacaukan indeks Anda:

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

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

// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}

Jika Anda perlu menghapus beberapa elemen dari array asosiatif, Anda dapat menggunakan array_diff_key () (di sini digunakan dengan 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);

Keluaran:

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

Ikuti fungsi default:

saya)

$Array = array("test1", "test2", "test3", "test3");

unset($Array[2]);

ii)

$Array = array("test1", "test2", "test3", "test3");

array_pop($Array);

aku aku aku)

$Array = array("test1", "test2", "test3", "test3");

array_splice($Array,1,2);

iv)

$Array = array("test1", "test2", "test3", "test3");

array_shift($Array);

Misalkan Anda memiliki array berikut:

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

Untuk menghapus storage, lakukan:

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

Dan Anda mendapatkan:

Array
(
    [user_id] => 193
)

Saya hanya ingin mengatakan bahwa saya memiliki objek tertentu yang memiliki atribut variabel (pada dasarnya memetakan tabel dan saya mengubah kolom dalam tabel, sehingga atribut dalam objek, yang mencerminkan tabel akan bervariasi juga):

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

Seluruh tujuan $fields hanya, jadi saya tidak perlu mencari di mana-mana dalam kode ketika mereka diubah, saya hanya melihat di awal kelas dan mengubah daftar atribut dan $ bidang array konten untuk mencerminkan atribut baru.

Solusi:

1. Untuk menghapus satu elemen, gunakan unset () :

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

1. Untuk menghapus beberapa elemen yang tidak bersebelahan, gunakan juga unset () :

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

1. Untuk menghapus beberapa elemen yang berdekatan, gunakan array_splice () :

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

Penjelasan lebih lanjut:

Menggunakan fungsi-fungsi ini menghapus semua referensi ke elemen-elemen ini dari PHP. Jika Anda ingin menyimpan kunci dalam array, tetapi dengan nilai kosong, tetapkan string kosong ke elemen:

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

Selain sintaks, ada perbedaan logis antara menggunakan unset () dan menugaskan '' ke elemen. Yang pertama mengatakan This doesn't exist anymore, sedangkan yang kedua mengatakan This still exists, but its value is the empty string.

Jika Anda berurusan dengan angka, menetapkan 0 mungkin merupakan alternatif yang lebih baik. Jadi, jika perusahaan menghentikan produksi sproket model XL1000, itu akan memperbarui inventarisnya dengan:

unset($products['XL1000']);

Namun, jika kehabisan sementara sprocket XL1000, tetapi berencana untuk menerima pengiriman baru dari pabrik akhir pekan ini, ini lebih baik:

$products['XL1000'] = 0;

Jika Anda tidak disetel () sebuah elemen, PHP menyesuaikan array sehingga perulangan masih berfungsi dengan benar. Itu tidak memadatkan array untuk mengisi lubang yang hilang. Inilah yang kami maksud ketika kami mengatakan bahwa semua array adalah asosiatif, bahkan ketika mereka tampak numerik. Ini sebuah contoh:

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

Untuk memadatkan array menjadi array numerik yang padat, gunakan array_values ​​() :

$animals = array_values($animals);

Atau, array_splice () secara otomatis mengindeks ulang array untuk menghindari meninggalkan lubang:

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

Ini berguna jika Anda menggunakan array sebagai antrian dan ingin menghapus item dari antrian sambil tetap memungkinkan akses acak. Untuk menghapus elemen pertama atau terakhir dengan aman dari array, gunakan array_shift () dan array_pop () .

unset () beberapa, elemen terfragmentasi dari array

Walaupun unset() telah disebutkan di sini beberapa kali, belum disebutkan bahwa unset() menerima beberapa variabel sehingga mudah untuk menghapus beberapa elemen yang tidak bersebelahan dari sebuah array dalam satu operasi:

// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]

tidak disetel () secara dinamis

unset () tidak menerima larik kunci untuk dihapus, sehingga kode di bawah ini akan gagal (itu akan membuatnya sedikit lebih mudah untuk menggunakan unset () secara dinamis).

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

Sebaliknya, unset () dapat digunakan secara dinamis dalam 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 ]

Hapus kunci array dengan menyalin array

Ada juga praktik lain yang belum disebutkan . Kadang-kadang, cara paling sederhana untuk menghilangkan kunci array tertentu adalah dengan cukup menyalin $ array1 ke $ 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 ];

Jelas, praktik yang sama berlaku untuk string teks:

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

Hapus elemen array berdasarkan pada kunci:

Gunakan fungsi unset seperti di bawah ini:

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

unset($a[1]);

print_r($a);

/*

    Output:

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

*/

Hapus elemen array berdasarkan nilai:

Gunakan fungsi array_search untuk mendapatkan kunci elemen dan gunakan cara di atas untuk menghapus elemen array seperti di bawah ini:

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

*/

Gunakan kode berikut:

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

Buat array Anda di variabel $array dan kemudian di mana saya telah meletakkan 'elemen yang ingin Anda hapus' Anda meletakkan sesuatu seperti: "a". Dan jika Anda ingin menghapus banyak item, maka: "a", "b".

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

Output

 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 )

Untuk array asosiatif, dengan kunci non-integer:

Sederhananya, unset($array[$key]) akan berfungsi.

Untuk array memiliki kunci integer dan jika Anda ingin mempertahankan kunci Anda:

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

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

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

Dua cara untuk menghapus item pertama dari array dengan menjaga urutan indeks dan juga jika Anda tidak tahu nama kunci dari item pertama.

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

Solusi # 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]);

Untuk data sampel ini:

$array = array(10 => "a", 20 => "b", 30 => "c");

Anda harus memiliki hasil ini:

array(2) {
  [20]=>
  string(1) "b"
  [30]=>
  string(1) "c"
}

Gunakan array_search untuk mendapatkan kunci dan menghapusnya dengan tidak disetel jika ditemukan:

if (($key = array_search('Word', $array)) !== false) {
    unset($array[$key]);
}

$x = array(1, 2, 3, 4, 5);
var_dump($x);
unset($x[3]); // Here is the key to be deleted
echo '<br>';
array_values($x);
var_dump($x);

Ini dapat membantu ...

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

Hasilnya adalah:

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

unset tidak mengubah indeks, tetapi array_splice tidak:

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

Jika Anda tahu indeksnya:

$arr = ['a', 'b', 'c'];
$index = 0;

unset($arr[$index]);  // result: $arr = ['b', 'c']

Jika Anda tidak tahu indeksnya, Anda harus mencari nilainya terlebih dahulu:

$arr = ['a', 'b', 'c'];
$index = array_search('a',$arr);

unset($arr[$index]);  // result: $arr = ['b', 'c']

Kami dapat memodifikasi konten variabel dengan referensi, menggunakan foreach:

<?php
    // Remove all elements in the array
    foreach ($array as &$arr) {
        $arr = null;
    }

$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);

print_r($arrayName);

Ada dua metode untuk melakukan tugas ini: unset () dan array_splice ()

Mari kita asumsikan dua array:

$array_1 = array('a'=>'One', 'b'=>'Two', 'c'=>'Three');

$array_2 = array('Red', 'Yellow', 'White', 'Black', 'Green');

Dengan tidak disetel ()

syntax - unset(array_element)

unset($array_1['a']); // Any valid key
unset($array_2[0]); // Any valid index

• setelah menghapus elemen array, indeks array tidak berubah

Dengan array_splice ()

syntax - array_splice(array, index, length)

array_splice($array_1, 1, 1); // Remove one element from $array_1 from index 1
array_splice($array_2, 3, 1); // Remove one element from $array_2 from index 3

• Semua elemen array diindeks ulang setelah menghapus elemen dari array

Anda cukup menggunakan unset() untuk menghapus array.

Ingatlah bahwa array harus tidak disetel setelah fungsi foreach.