Có cách nào dễ dàng để xóa một phần tử khỏi một mảng bằng PHP, sao cho foreach ($array)không còn bao gồm phần tử đó nữa không?

Tôi nghĩ rằng thiết lập nó nullsẽ làm điều đó, nhưng dường như nó không hoạt động.

Có nhiều cách khác nhau để xóa một phần tử mảng, trong đó một số hữu ích hơn cho một số tác vụ cụ thể so với các tác vụ khác.

Xóa một phần tử mảng

Nếu bạn muốn xóa chỉ một phần tử mảng, bạn có thể sử dụng unset()hoặc thay thế\array_splice() .

Ngoài ra nếu bạn có giá trị và không biết khóa để xóa phần tử bạn có thể sử dụng \array_search()để lấy khóa.

unset()

Lưu ý rằng khi bạn sử dụng unset()các khóa mảng sẽ không thay đổi / reindex. Nếu bạn muốn reindex các phím bạn có thể sử dụng \array_values()sauunset() đó sẽ chuyển đổi tất cả các khóa thành các phím liệt kê số bắt đầu từ 0.

Mã

<?php

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

?>

Đầu ra

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

\array_splice() phương pháp

Nếu bạn sử dụng \array_splice()các khóa sẽ được tự động lập lại, nhưng các khóa kết hợp sẽ không thay đổi so với\array_values() khóa sẽ chuyển đổi tất cả các khóa thành khóa số.

Cũng thế \array_splice() cần sự bù đắp, không phải là chìa khóa! làm tham số thứ hai.

Mã

<?php

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

?>

Đầu ra

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

array_splice()tương tự như unset()lấy mảng theo tham chiếu và điều này có nghĩa là bạn không muốn gán giá trị trả về của các hàm đó cho mảng.

Xóa nhiều thành phần mảng

Nếu bạn muốn xóa nhiều thành phần mảng và không muốn gọi unset()hoặc \array_splice()nhiều lần, bạn có thể sử dụng các hàm \array_diff()hoặc \array_diff_key()tùy thuộc vào việc bạn biết các giá trị hoặc khóa của các thành phần mà bạn muốn xóa.

\array_diff() phương pháp

Nếu bạn biết các giá trị của các thành phần mảng mà bạn muốn xóa, thì bạn có thể sử dụng \array_diff(). Như trước đây, unset()nó sẽ không thay đổi / reindex các khóa của mảng.

Mã

<?php

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

?>

Đầu ra

[
    [1] => b
]

\array_diff_key() phương pháp

Nếu bạn biết các phím của các thành phần mà bạn muốn xóa, thì bạn muốn sử dụng \array_diff_key(). Ở đây bạn phải chắc chắn rằng bạn chuyển các khóa dưới dạng các khóa trong tham số thứ hai chứ không phải là các giá trị. Nếu không, bạn phải lật mảng với\array_flip() . Và cũng ở đây các phím sẽ không thay đổi / reindex.

Mã

<?php

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

Đầu ra

[
    [1] => b
]

Ngoài ra nếu bạn muốn sử dụng unset()hoặc \array_splice()xóa nhiều phần tử có cùng giá trị, bạn có thể sử dụng \array_keys()để lấy tất cả các khóa cho một giá trị cụ thể và sau đó xóa tất cả các phần tử.

Cần lưu ý rằng unset()sẽ giữ cho các chỉ mục không bị ảnh hưởng, đó là những gì bạn mong đợi khi sử dụng các chỉ mục chuỗi (mảng dưới dạng hashtable), nhưng có thể khá ngạc nhiên khi xử lý các mảng được lập chỉ mục số nguyên:

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

Vì vậy, array_splice()có thể được sử dụng nếu bạn muốn bình thường hóa các khóa số nguyên của mình. Một tùy chọn khác là sử dụng array_values()sau 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);

Đây là đầu ra từ mã trên:

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
)

Bây giờ, Array_values ​​() sẽ giới thiệu lại một mảng số một cách độc đáo, nhưng nó sẽ xóa tất cả các chuỗi khóa khỏi mảng và thay thế chúng bằng các số. Nếu bạn cần giữ nguyên tên khóa (chuỗi) hoặc reindex mảng nếu tất cả các khóa là số, hãy sử dụng Array_merge ():

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

Đầu ra

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

Nếu bạn có một mảng được lập chỉ mục bằng số trong đó tất cả các giá trị là duy nhất (hoặc chúng không phải là duy nhất nhưng bạn muốn xóa tất cả các phiên bản của một giá trị cụ thể), bạn chỉ cần sử dụng Array_diff () để xóa phần tử phù hợp, như sau:

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

Ví dụ:

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

Điều này sẽ hiển thị như sau:

4
3

Trong ví dụ này, phần tử có giá trị 'Charles' được loại bỏ như có thể được xác minh bằng các lệnh gọi sizeof () báo cáo kích thước 4 cho mảng ban đầu và 3 sau khi xóa.

Ngoài ra, đối với một yếu tố được đặt tên:

unset($array["elementName"]);

Phá hủy một phần tử duy nhất của một mảng

unset()

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

Đầu ra sẽ là:

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

Nếu bạn cần lập chỉ mục lại mảng:

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

Sau đó, đầu ra sẽ là:

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

Đưa phần tử ra khỏi cuối mảng - trả về giá trị của phần tử bị xóa

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

Đầu ra sẽ là

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

Xóa phần tử đầu tiên (màu đỏ) khỏi một mảng , - trả về giá trị của phần tử bị xóa

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

Đầu ra sẽ là:

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

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

    echo $fruit;
?>

Đầu ra:

[
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
]

fruit1

Để tránh thực hiện tìm kiếm, người ta có thể chơi xung quanh với array_diff:

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

Trong trường hợp này, người ta không phải tìm kiếm / sử dụng khóa.

Nếu bạn phải xóa nhiều giá trị trong một mảng và các mục trong mảng đó là các đối tượng hoặc dữ liệu có cấu trúc, thì đó [array_filter][1]là cách tốt nhất của bạn. Những mục trả về giá trị true từ hàm gọi lại sẽ được giữ lại.

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

Mảng liên kết

Đối với mảng kết hợp, sử dụng unset:

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

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

Mảng số

Đối với mảng số, sử dụng array_splice:

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

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

Ghi chú

Sử dụng unsetcho mảng số sẽ không tạo ra lỗi, nhưng nó sẽ làm rối các chỉ mục của bạn:

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

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

Nếu bạn cần xóa nhiều phần tử khỏi một mảng kết hợp, bạn có thể sử dụng Array_diff_key () (ở đây được sử dụng với 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);

Đầu ra:

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

unset() phá hủy các biến được chỉ định.

Hành vi unset()bên trong của một chức năng có thể thay đổi tùy thuộc vào loại biến bạn đang cố gắng phá hủy.

Nếu một biến toàn cầu hóa nằm unset()trong hàm, chỉ biến cục bộ bị hủy. Biến trong môi trường gọi sẽ giữ nguyên giá trị như trước unset()được gọi.

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

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

Câu trả lời của đoạn mã trên sẽ là thanh .

Để unset()một biến toàn cục bên trong một hàm:

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

Nếu chỉ số được chỉ định:

$arr = ['a', 'b', 'c'];
$index = 0;    
unset($arr[$index]);  // $arr = ['b', 'c']

Nếu chỉ mục KHÔNG được chỉ định:

$arr = ['a', 'b', 'c'];
$index = array_search('a', $arr); // search the value to find index
if($index !== false){
   unset($arr[$index]);  // $arr = ['b', 'c']
}

Điều ifkiện là cần thiết bởi vì nếu indexkhông tìm thấy, unset()sẽ tự động xóa phần tử đầu tiên của mảng không phải là thứ chúng ta muốn

Các giải pháp:

1. Để xóa một phần tử, sử dụng unset () :

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

2. Để xóa nhiều phần tử không liên tục, cũng sử dụng unset () :

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

3. Để xóa nhiều phần tử liền kề, hãy sử dụng mảng_splice () :

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

Giải thích thêm:

Sử dụng các hàm này sẽ loại bỏ tất cả các tham chiếu đến các phần tử này khỏi PHP. Nếu bạn muốn giữ một khóa trong mảng, nhưng với một giá trị trống, hãy gán chuỗi trống cho phần tử:

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

Bên cạnh cú pháp, có một sự khác biệt logic giữa việc sử dụng unset () và gán '' cho phần tử. Cái thứ nhất nói This doesn't exist anymore,trong khi cái thứ hai nóiThis still exists, but its value is the empty string.

Nếu bạn đang xử lý các số, gán 0 có thể là một lựa chọn tốt hơn. Vì vậy, nếu một công ty ngừng sản xuất bánh xích XL1000, công ty sẽ cập nhật hàng tồn kho của mình với:

unset($products['XL1000']);

Tuy nhiên, nếu nó tạm thời hết sprockets XL1000, nhưng đã có kế hoạch nhận một lô hàng mới từ nhà máy vào cuối tuần này, điều này tốt hơn:

$products['XL1000'] = 0;

Nếu bạn bỏ đặt () một phần tử, PHP sẽ điều chỉnh mảng để vòng lặp vẫn hoạt động chính xác. Nó không nén các mảng để điền vào các lỗ còn thiếu. Đây là những gì chúng tôi muốn nói khi chúng tôi nói rằng tất cả các mảng là kết hợp, ngay cả khi chúng có vẻ là số. Đây là một ví dụ:

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

Để nén mảng thành một mảng số đầy mật độ, sử dụng mảng_values ​​() :

$animals = array_values($animals);

Ngoài ra, mảng_splice () tự động lập lại các mảng để tránh để lại lỗ hổng:

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

Điều này hữu ích nếu bạn đang sử dụng mảng dưới dạng hàng đợi và muốn xóa các mục khỏi hàng đợi trong khi vẫn cho phép truy cập ngẫu nhiên. Để xóa phần tử đầu tiên hoặc cuối cùng khỏi một mảng một cách an toàn, hãy sử dụng mảng_shift () và Array_pop () tương ứng.

Giả sử bạn có mảng sau:

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

Để xóa storage, hãy làm:

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

Và bạn nhận được:

Array
(
    [user_id] => 193
)

Tôi chỉ muốn nói rằng tôi có một đối tượng cụ thể có các thuộc tính biến đổi (về cơ bản là ánh xạ một bảng và tôi đang thay đổi các cột trong bảng, vì vậy các thuộc tính trong đối tượng, phản ánh bảng cũng sẽ khác nhau):

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

Toàn bộ mục đích $fieldschỉ là, vì vậy tôi không phải tìm mọi nơi trong mã khi chúng được thay đổi, tôi chỉ nhìn vào phần đầu của lớp và thay đổi danh sách các thuộc tính và nội dung mảng $ trường để phản ánh cái mới thuộc tính.

Thực hiện theo các chức năng mặc định:

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

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

Tạo mảng của bạn trong biến $arrayvà sau đó tôi đặt 'phần tử bạn muốn xóa', bạn đặt một cái gì đó như: "a". Và nếu bạn muốn xóa nhiều mục thì: "a", "b".

Sử dụng mảng_search để lấy khóa và xóa nó nếu không tìm thấy:

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

unset () nhiều phần tử phân mảnh từ một mảng

Mặc dù unset()đã được đề cập ở đây nhiều lần, nhưng vẫn chưa được đề cập đến việc unset()chấp nhận nhiều biến giúp dễ dàng xóa nhiều phần tử không liên tục khỏi một mảng trong một thao tác:

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

unset () động

unset () không chấp nhận một loạt các khóa để loại bỏ, do đó, mã bên dưới sẽ thất bại (mặc dù nó sẽ làm cho việc sử dụng unset () một cách dễ dàng hơn một chút).

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

Thay vào đó, unset () có thể được sử dụng linh hoạt trong vòng lặp foreach:

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

Xóa khóa mảng bằng cách sao chép mảng

Ngoài ra còn có một thực tế khác chưa được đề cập. Đôi khi, cách đơn giản nhất để loại bỏ các khóa mảng nhất định là chỉ cần sao chép $ Array1 vào $ 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 ];

Rõ ràng, thực tế tương tự áp dụng cho các chuỗi văn bản:

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

Xóa phần tử mảng dựa trên khóa:

Sử dụng unsetchức năng như dưới đây:

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

unset($a[1]);

print_r($a);

/*

    Output:

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

*/

Xóa phần tử mảng dựa trên giá trị:

Sử dụng array_searchhàm để lấy khóa phần tử và sử dụng cách trên để xóa phần tử mảng như bên dưới:

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

*/

Hai cách để loại bỏ mục đầu tiên của một mảng với việc giữ trật tự của chỉ mục và nếu bạn không biết tên khóa của mục đầu tiên.

Giải pháp số 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);

Giải pháp số 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]);

Đối với dữ liệu mẫu này:

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

Bạn phải có kết quả này:

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

Sử dụng mã sau đây:

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

Đầu ra

 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 )

Đối với mảng kết hợp, với các khóa không nguyên:

Đơn giản, unset($array[$key]) sẽ làm việc.

Đối với các mảng có khóa số nguyên và nếu bạn muốn duy trì khóa của mình:

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

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

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

Điều này có thể giúp ...

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

Kết quả sẽ là:

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