Php xóa giá trị khỏi mảng theo khóa. PHP: Loại bỏ các phần tử mảng
Các hàm làm việc với mảng và các thao tác trên mảng (Phần 2)
Hợp nhất mảng
Hợp nhất (nối) mảng là thao tác tạo ra một mảng bao gồm các phần tử của nhiều mảng khác. Hợp nhất các mảng là một hoạt động rất nguy hiểm, vì kết quả của việc hợp nhất tuân theo logic riêng của nó, mà bạn có thể quên mất dữ liệu. Việc hợp nhất các mảng được thực hiện bằng toán tử " + " hoặc sử dụng chức năng Việc hợp nhất chỉ có thể được thực hiện bằng chức năng mảng_merge().
Giả sử chúng ta có hai mảng:
$A = mảng("1"=>"Đầu tiên", "2"=>"Thứ hai");
$B = array("3"=>"Thứ ba", "4"=>"Thứ tư");
Bây giờ hãy hợp nhất hai mảng này thành một mảng $C:
Nhà điều hành " + " không giao hoán cho mảng. Điều này có nghĩa là $A + $B không công bằng $B + $A.
Theo kết quả của ví dụ đã xem xét, chúng ta sẽ nhận được một mảng $C có dạng sau:
"1"=>"Đầu tiên", "2"=>"Thứ hai", "3"=>"Thứ ba", "4"=>"Thứ tư"
Và kết quả là $B + $A chúng ta sẽ nhận được mảng này:
"3"=>"Thứ ba", "4"=>"Thứ tư", "1"=>"Đầu tiên", "2"=>"Thứ hai"
Phương pháp này không hoạt động khi hợp nhất danh sách. Hãy để chúng tôi giải thích thực tế này bằng một ví dụ:
Giả sử chúng ta có hai mảng:
$A = mảng(10,11,12);
$B = mảng(13,14,15);
Kết quả của việc hợp nhất danh sách $A Và $B ($A + $B) ta được: 10,11,12. Và đây hoàn toàn không phải là kết quả mà chúng tôi mong muốn nhận được... Điều này là do khi hợp nhất các danh sách có cùng chỉ mục, một phần tử của mảng đầu tiên vẫn nằm trong mảng kết quả và ở cùng một vị trí. Trong trường hợp này chúng ta cần sử dụng hàm
Ví dụ sử dụng hàm đếm():
$arr = 5 ;
$arr = 4 ;
$arr = 8 ;
$arr = 3 ;
$arr = 8 ;
tiếng vọng "Số phần tử mảng: "
. đếm($arr). ""
;
// Kết quả đầu ra: Số phần tử mảng: 5
?>
Xóa một mảng và các phần tử của nó
Nếu bạn muốn xóa toàn bộ mảng, hãy sử dụng hàm bỏ đặt().
Nếu bạn muốn xóa cặp khóa/giá trị, bạn cũng có thể sử dụng hàm bỏ đặt(). Dưới đây là những ví dụ cụ thể:
$arr = mảng(5 => 1, 12 => 2);
$arr = 56 ; // Tại thời điểm này trong kịch bản, nó là
// tương đương với $arr = 56;
$arr [ "x" ] = 42 ; // Điều này thêm một cái mới vào mảng
// phần tử có khóa "x"
Diễn đàn cổng thông tin PHP. S.U.
Reg.ru: tên miền và lưu trữ
Nhà đăng ký và cung cấp dịch vụ lưu trữ lớn nhất ở Nga.
Hơn 2 triệu tên miền đang được sử dụng.
Khuyến mãi, mail tên miền, giải pháp kinh doanh.
Hơn 700 nghìn khách hàng trên khắp thế giới đã đưa ra lựa chọn của mình.
Khung Bootstrap: bố cục thích ứng nhanh
Khóa học video từng bước về kiến thức cơ bản về bố cục thích ứng trong khung Bootstrap.
Tìm hiểu cách sắp chữ đơn giản, nhanh chóng và hiệu quả bằng cách sử dụng một công cụ mạnh mẽ và thiết thực.
Bố trí để đặt hàng và được trả tiền.
* Di chuột qua để tạm dừng cuộn.
Quay lại phía trước
PHP: Loại bỏ các phần tử mảng
Chúng ta phải đối mặt với một nhiệm vụ có vẻ tầm thường: loại bỏ một phần tử mảng. Hoặc một số yếu tố.
Tuy nhiên, vì sự đơn giản của nó, có những tùy chọn không hoàn toàn rõ ràng và đáng để biết nếu bạn muốn nâng cao PHP hơn một chút so với "Xin chào thế giới!"
Hãy bắt đầu với chính cơ sở: để loại bỏ một phần tử, bạn cần sử dụng hàm bỏ đặt():
Bỏ đặt ($ mảng); unset($array["foo"]);
Unset($array, $array); unset($array["foo"], $array["bar"]);
Câu hỏi hợp lý tiếp theo là: làm thế nào để xóa nhiều phần tử nối tiếp nhau (tức là liền kề)? Để loại bỏ nhiều phần tử liền kề, hãy sử dụng hàm mảng_splice():
Mảng_splice($array, $offset, $length);
Xin lưu ý rằng khi sử dụng các hàm này, tất cả các tham chiếu đến các phần tử này sẽ biến mất. Nếu bạn muốn để lại một khóa trong mảng nhưng liên kết nó với một giá trị trống, hãy gán phần tử mong muốn vào một chuỗi trống:
$array = $array["foo"] = "";
Điều quan trọng là phải hiểu rằng chức năng bỏ đặt() loại bỏ phần tử, trong khi gán "" cho phần tử không loại bỏ phần tử đó mà làm cho giá trị của nó bằng chuỗi trống.
Nếu bạn làm việc với các con số, có lẽ sẽ tốt hơn nếu kết hợp giá trị 0 với một khóa như vậy.
Giả sử, nếu một công ty đã ngừng sản xuất các bộ phận cho mẫu HBL-568 thì có thể thực hiện thay đổi đối với mảng bộ phận:
Unset($products["HBL-568"]);
Nếu bộ phận HBL-568 chỉ tạm thời không có trong kho và dự kiến sẽ được chuyển đến từ nhà máy, thì tốt hơn hết bạn nên làm khác:
$products["HBL-568"] = 0;
Điểm tiếp theo cần hiểu là khi gọi một hàm bỏ đặt()đối với phần tử mảng, PHP điều chỉnh mảng sao cho vòng lặp vẫn hoạt động chính xác.
Nói cách khác, mảng không được nén để lấp đầy các “lỗ hổng” được tạo ra. Về cơ bản, điều này có nghĩa là tất cả các mảng đều có tính kết hợp, ngay cả khi thoạt nhìn chúng có vẻ là số. Hãy xem xét các ví dụ rõ ràng để minh họa hành vi này:
// Tạo một mảng "số" $animals = array("ant", "bee", "cat", "dog", "elk", "fox"); in $động vật; // In "bee" print $animals; // In ra số đếm "cat"($animals); // Trả về 6 // unset() unset($animals); // Loại bỏ một phần tử $animals = "bee" print $animals; // Không xuất ra bất cứ thứ gì và báo lỗi E_NOTICE print $animals; // In ra số đếm "cat"($animals); // Trả về 5 trong khi phần tử $array vẫn giữ nguyên vị trí và chứa "fox" // Thêm phần tử mới $animals = "gnu"; // Thêm một phần tử mới print $animals; // Không xuất ra gì cả, đồng thời báo lỗi E_NOTICE print $animals; // In "gnu" count($animals); // Trả về 6 // Gán "" (chuỗi trống) $animals = ""; // Đặt thành "chuỗi trống" print $animals; // In "" count($animals); // Trả về 6, tức là tính đến phần tử mảng trống khi đếm
Để truy cập vào một mảng số có mật độ dân cư đông đúc, hãy sử dụng hàm mảng_values():
$animals = array_values($animals);
Ngoài ra, hàm array_splice() sẽ tự động lập chỉ mục lại các mảng để loại bỏ các “lỗ hổng”:
// Tạo một mảng "số" $animals = array("ant", "bee", "cat", "dog", "elk", "fox"); array_splice($animals, 2, 2); print_r($động vật);
Ở đầu ra, chúng tôi nhận được:
Mảng ( => kiến => ong => nai sừng tấm => cáo)
Tính năng này có thể hữu ích ở đâu?
Giả sử bạn đang làm việc với một mảng dưới dạng hàng đợi và muốn xóa các phần tử khỏi hàng đợi này mà không làm mất khả năng truy cập ngẫu nhiên, khi bạn có thể vô tình rơi vào một trong các "lỗ hổng" tạo ra.
Và cuối cùng, để loại bỏ phần tử đầu tiên hoặc cuối cùng khỏi mảng một cách an toàn, các hàm mảng_shift() Và mảng_pop() tương ứng.
Mọi thứ đều rất đơn giản với họ:
$stack = array("cam", "chuối", "táo", "mâm xôi"); $fruit = array_shift($stack); print_r($stack);
Kết quả của việc thực thi đoạn mã trên, chúng ta sẽ nhận được kết quả đầu ra sau:
Mảng ( => chuối => táo => mâm xôi)
Để loại bỏ phần tử cuối cùng, hãy sử dụng hàm mảng_pop():
$stack = array("cam", "chuối", "táo", "mâm xôi"); $fruit = array_pop($stack); print_r($stack);
Đầu ra là bản in mảng sau:
Mảng ( => cam => chuối => táo)
Đó là tất cả. Chúng ta đã thảo luận những điểm chính về việc xóa các phần tử mảng trong PHP. Nếu có bất cứ điều gì xảy ra, tài liệu chính thức luôn hữu ích.
Bạn có thích tài liệu này và muốn cảm ơn tôi không?
Chỉ cần chia sẻ với bạn bè và đồng nghiệp của bạn!
Xem thêm:
Có nhiều cách khác nhau để loại bỏ một phần tử mảng, trong đó một số cách hữu ích hơn đối với một số tác vụ cụ thể so với các cách khác.
Xóa một phần tử mảng
Nếu bạn chỉ muốn xóa một phần tử của một mảng, bạn có thể sử dụng \unset() hoặc cách khác là \array_splice() .
Ngoài ra, nếu bạn có một 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.
phương thức \unset()
Xin lưu ý rằng khi sử dụng \unset(), các khóa mảng sẽ không bị thay đổi/lập chỉ mục lại. Nếu bạn muốn lập chỉ mục lại các khóa, bạn có thể sử dụng \array_values() sau \unset() để chuyển đổi tất cả các khóa thành các khóa được đánh số bắt đầu từ 0.
[ => a => c ]
phương thức \array_splice()
Nếu bạn sử dụng \array_splice() thì các khóa sẽ tự động được lập chỉ mục lại, nhưng các khóa kết hợp sẽ không thay đổi, không giống như \array_values() chuyển đổi tất cả các khóa thành phím số.
Ngoài ra \array_splice() cần một phần bù chứ không phải khóa! làm tham số thứ hai.
[ => a => c ]
array_splice() tương tự như \unset() lấy một mảng theo tham chiếu, nghĩa là bạn không muốn gán lại các giá trị trả về của các hàm này vào mảng.
Loại bỏ nhiều phần tử mảng
Nếu bạn muốn xóa nhiều phần tử của một 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 có biết các giá trị hay không hoặc phím của thành phần bạn muốn xóa.
phương thức \array_diff()
Nếu bạn biết giá trị của các phần tử mảng muốn xóa, bạn có thể sử dụng \array_diff() . Như trước đây với \unset() nó sẽ không sửa đổi/lập chỉ mục lại các khóa mảng.
[ => b ]
\array_diff_key()
Nếu bạn biết khóa của các phần tử bạn muốn xóa thì bạn muốn sử dụng \array_diff_key() . Ở đây, bạn phải đảm bảo rằng bạn đang chuyển các khóa dưới dạng khóa trong tham số thứ hai chứ không phải dưới dạng giá trị. Nếu không, bạn phải lật mảng bằng cách sử dụng \array_flip() . Và ở đây các khóa sẽ không thay đổi/reindex.
[ => 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ể rồi xóa tất cả các phần tử.
giá trị khóa (25)
Có cách nào dễ dàng để xóa một phần tử khỏi một mảng bằng PHP để foreach ($array) không còn bao gồm phần tử đó nữa không?
Tôi nghĩ rằng việc đặt nó thành null sẽ làm được điều này, nhưng dường như nó không hiệu quả.
Câu trả lời
unset() nhiều phần tử bị phân mảnh từ một mảng
Mặc dù unset() được đề cập nhiều lần ở đây, nhưng điều chưa được đề cập là unset() nhận nhiều biến, giúp dễ dàng loại bỏ nhiều phần tử không liền kề khỏi một mảng chỉ bằng một thao tác:
// Xóa nhiều phần tử không liền kề khỏi một mảng $array = [ "foo", "bar", "baz", "quz" ]; unset($array, $array); print_r ($ mảng); // Kết quả: ["foo", "bar" ]
unset() một cách linh hoạt
unset() không chấp nhận một mảng khóa cần xóa, do đó mã bên dưới sẽ không thành công (tuy nhiên, việc sử dụng unset() một cách linh hoạt sẽ dễ dàng hơn một chút).
$ mảng = phạm vi (0,5); $xóa = ; $array = unset($remove); // LỖI: "không được đặt" bất ngờ print_r($array);
Thay vào đó, Unset() có thể được sử dụng linh hoạt trong vòng lặp foreach:
$ mảng = phạm vi (0,5); $xóa = ; foreach ($remove as $k=>$v) ( unset($array[$v]); ) print_r($array); // Đầu ra: [ 0, 3, 4, 5 ]
Xóa các khóa mảng bằng cách sao chép mảng
Có một thực tế khác vẫn chưa được đề cập. Đôi khi cách dễ nhất để loại bỏ các khóa mảng nhất định là chỉ cần sao chép $array1 sang $array2.
$array1 = phạm vi (1,10); foreach ($array1 as $v) ( // Xóa tất cả các số nguyên chẵn khỏi mảng if($v % 2) ( $array2 = $v; ) ) print_r($array2); // Kết quả: [ 1, 3, 5, 7, 9 ];
Rõ ràng, cách làm tương tự cũng áp dụng cho chuỗi văn bản:
$array1 = [ "foo", "_bar", "baz" ]; foreach ($array1 as $v) ( // Xóa tất cả các chuỗi bắt đầu bằng dấu gạch dưới if(strpos($v,"_")===false) ( $array2 = $v; ) ) print_r($array2); // Kết quả: ["foo", "baz" ]
Mảng kết hợp
Đối với mảng kết hợp, hãy sử dụng unset() :
$arr = array("a" => 1, "b" => 2, "c" => 3); unset($arr["b"]); // KẾT QUẢ: mảng("a" => 1, "c" => 3)
Mảng số
Đối với mảng số, sử dụng array_splice() :
$arr = mảng(1, 2, 3); mảng_splice($arr, 1, 1); // KẾT QUẢ: mảng(0 => 1, 1 => 3)
Ghi chú
$my_array = array("key1" => "value 1", "key2" => "value 2", "key3" => "value 3", "key4" => "value 4", "key5" => "giá trị 5",); $to_remove = mảng("key2", "key4"); $result = array_diff_key($my_array, array_flip($to_remove)); print_r($kết quả);Mảng ( => giá trị 1 => giá trị 3 => giá trị 5)
Unset($array[$index]);
Có nhiều cách khác nhau để loại bỏ một phần tử mảng, trong đó một số cách hữu ích hơn đối với một số tác vụ cụ thể so với các cách khác.
Xóa một phần tử mảng
Nếu bạn chỉ muốn xóa một phần tử của một mảng, bạn có thể sử dụng unset() hoặc array_splice() thay thế.
Ngoài ra, nếu bạn có một 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.
phương thức unset()
Xin lưu ý rằng khi sử dụng unset(), các khóa mảng sẽ không bị thay đổi/lập chỉ mục lại. Nếu bạn muốn lập chỉ mục lại các khóa, bạn có thể sử dụng array_values() sau unset() để chuyển đổi tất cả các khóa thành các khóa có thể đếm được bắt đầu từ 0.
"a", 1 => "b", 2 => "c"); bỏ đặt ($ mảng); // Khóa mà bạn muốn xóa ?>
Mảng ( => a => c)
mảng_splice()
Nếu bạn sử dụng array_splice() thì các khóa sẽ tự động được lập chỉ mục lại nhưng các khóa kết hợp sẽ không thay đổi, không giống như array_values() chuyển đổi tất cả các khóa thành phím số.
Ngoài ra, array_splice() yêu cầu phần bù chứ không phải khóa! làm tham số thứ hai.
"a", 1 => "b", 2 => "c"); mảng_splice ($ mảng, 1, 1); // Offset mà bạn muốn xóa ?>
Mảng ( => a => c)
array_splice() giống như unset() lấy một mảng theo tham chiếu, điều này có nghĩa là bạn không muốn gán các giá trị trả về của các hàm này trở lại mảng.
Loại bỏ nhiều phần tử mảng
Nếu bạn muốn loại bỏ nhiều phần tử của một 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 hàm array_diff() hoặc array_diff_key() tùy thuộc vào việc bạn có biết giá trị hoặc khóa hay không của các phần tử bạn muốn loại bỏ.
mảng_diff()
Nếu bạn biết giá trị của các phần tử mảng muốn xóa, bạn có thể sử dụng array_diff() . Như trước đây, với unset() nó sẽ không sửa đổi/lập chỉ mục lại các khóa mảng.
"a", 1 => "b", 2 => "c"); $array = array_diff($array, ["a", "c"]); //└────────┘→ Giá trị mảng mà bạn muốn xóa ?> $array = array(0, 1, 2, 3); bỏ đặt ($ mảng); $array = array_values($array); var_dump ($ mảng); /* mảng(3) ( => int(0) => int(1) => int(3) ) */
Xóa phần tử mảng dựa trên khóa:
Sử dụng chức năng unset như unset bên dưới:
$a = mảng("salam", "10", 1); bỏ đặt($a); print_r($a); /* Kết quả: Mảng ( => salam => 1) */
Xóa một phần tử mảng dựa trên giá trị:
Sử dụng hàm array_search để lấy khóa của phần tử và sử dụng phương thức trên để xóa phần tử mảng như array_search bên dưới:
$a = mảng("salam", "10", 1); $key = array_search(10, $a); if($key !== false) ( unset($a[ $key ]); ) print_r($a); /* Kết quả: Mảng ( => salam => 1) */
Các giải pháp:
- Để xóa một phần tử, hãy sử dụng unset() :
bỏ đặt ($ mảng); unset($array["foo"]);
- Để xóa nhiều phần tử không liền kề, hãy sử dụng unset() :
unset($array, $array); unset($array["foo"], $array["bar"]);
- Để loại bỏ nhiều phần tử liền kề, hãy sử dụng array_splice() :
mảng_splice($array, $offset, $length);
Giải thích thêm:
$array = $array["foo"] = "";
Bỏ cú pháp sang một bên, có một sự khác biệt logic giữa việc sử dụng unset() và gán "" cho một phần tử. Dòng đầu tiên nói rằng This không còn tồn tại và dòng thứ hai nói rằng This vẫn tồn tại, nhưng giá trị của nó là chuỗi trống.
Nếu bạn đang xử lý các con số, việc gán 0 có thể là giải pháp thay thế tốt hơn. Vì vậy, nếu một công ty ngừng sản xuất bánh xích Model 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 tạm thời hết đĩa xích XL1000 nhưng dự kiến nhận lô hàng mới từ nhà máy trong tuần này thì điều này tốt hơn:
$products["XL1000"] = 0; $animals = array_values($animals);
Ngoài ra, array_splice() sẽ tự động lập chỉ mục lại các mảng để tránh để lại lỗ hổng:
// tạo một mảng "số" $animals = array("ant", "bee", "cat", "dog", "elk", "fox"); array_splice($animals, 2, 2); print_r($động vật); Mảng ( => kiến => ong => nai sừng tấm => cáo)
Điều này hữu ích nếu bạn đang sử dụng một mảng làm hàng đợi và muốn xóa các phần tử khỏi hàng đợi trong khi vẫn duy trì quyền truy cập ngẫu nhiên. Để xóa phần tử đầu tiên hoặc cuối cùng khỏi mảng một cách an toàn, hãy sử dụng array_shift() và array_pop() tương ứng.
"giá trị 1","key2"=>"giá trị 2","key3"=>"giá trị 3"); print_r($my_array); if(array_key_exists("key1",$my_array))( unset($my_array["key1"]); print_r($my_array); )else( echo "Khóa không tồn tại"; ) ?>"giá trị 1","key2"=>"giá trị 2","key3"=>"giá trị 3"); print_r($my_array); $new_array=array_slice($my_array,1); print_r($new_array); ?>"; //Để xóa phần tử mảng đầu tiên theo chiều dài // bắt đầu từ phần tử đầu tiên và xóa hai phần tử $my_array = array("key1"=>"value 1","key2"=>"value 2","key3"=> "giá trị 3"); print_r($my_array); $new_array=array_slice($my_array,1,2);
Lối ra
Mảng ( => giá trị 1 => giá trị 2 => giá trị 3) Mảng ( => giá trị 2 => giá trị 3) Mảng ( => giá trị 1 => giá trị 2 => giá trị 3) Mảng ( => giá trị 2 => giá trị 3) Mảng ( => giá trị 1 => giá trị 2 => giá trị 3) Mảng ( => giá trị 2 => giá trị 3)
Bạn chỉ cần sử dụng unset() để xóa mảng.
Hãy nhớ rằng mảng phải được hủy liên kết sau hàm foreach.
$arr = array("cam", "chuối", "táo", "quả mâm xôi"); $result= array_pop($arr); print_r($kết quả);
Điều này có thể giúp...
"đỏ","b"=>"xanh","c"=>"xanh","d"=>"vàng"); $a2=array("a"=>"tím","b"=>"cam"); mảng_splice($a1,0,2,$a2); print_r($a1); ?>
kết quả sẽ là:
Mảng ( => tím => cam [c] => xanh [d] => vàng)
Giả sử bạn có một mảng như thế này:
Mảng ( => 193 => 5)
Để xóa bộ nhớ, hãy làm theo các bước sau:
Unset($attributes["storage"]); $attributes = array_filter($attributes);
Và bạn nhận được:
Mảng ( => 193)
Thực hiện các chức năng mặc định
I) $Array = array("test1","test2","test3","test3"); unset($Array); ii) $Array = array("test1","test2","test3","test3"); mảng_pop($Array); iii) $Array = array("test1","test2","test3","test3"); mảng_splice($Array,1,2); iv) $Array = array("test1","test2","test3","test3"); mảng_shift($Array);
Để tránh tìm kiếm, bạn có thể chơi với array_diff:
$array = mảng(3, 9, 11, 20); $array = array_diff($array, array(11)); // loại bỏ 11
Trong trường hợp này không cần phải tìm kiếm/sử dụng khóa.
Câu trả lời hàng đầu ở trên là tuyệt vời. Tuy nhiên, nếu bạn mở rộng nó theo hai cách khác nhau thì dù mở rộng theo cách nào, kết quả đầu tiên trong lệnh gọi hàm sẽ tạo bộ đệm. Bộ đệm này sẽ được sử dụng cho tất cả các cuộc gọi tiếp theo, bất kể tiện ích mở rộng nào kích hoạt cuộc gọi...
Để giải quyết vấn đề này, hãy thay thế biến và hàm đầu tiên như sau:
Tĩnh riêng $constCacheArray = null; hàm tĩnh riêng getConstants() ( if (self::$constCacheArray === null) self::$constCacheArray = array(); $gọiClass = get_gọi_class(); if (!array_key_exists($gọiClass, self::$constCacheArray) ) ( $reflect = new \ReflectionClass($gọiClass); self::$constCacheArray[$gọiClass] = $reflect->getConstants(); ) return self::$constCacheArray[$gọiClass];
Mảng là một trong những cấu trúc dữ liệu hữu ích và được sử dụng thường xuyên nhất trong bất kỳ ngôn ngữ lập trình nào. Biết cách quản lý mảng và các phần tử của chúng là rất quan trọng và hữu ích. Trong bài viết này, chúng ta sẽ xem xét cách bạn có thể loại bỏ các phần tử riêng lẻ của một mảng trong PHP.
Tác vụ này có thể được thực hiện bằng các phương pháp khác nhau, tùy thuộc vào những gì chúng ta biết về phần tử bị xóa - liệu khóa đã được biết (số hoặc mã định danh của phần tử trong mảng) hay chỉ giá trị của nó.
Loại bỏ một phần tử trong mảng bằng khóa của nó
Nếu khóa phần tử được biết thì nhiệm vụ rất đơn giản. Chức năng bỏ đặt() cho phép bạn xóa một phần tử mảng hoặc bất kỳ biến nào (bộ nhớ máy tính sử dụng cho biến đó cũng sẽ bị xóa).
Ví dụ: chúng ta có một mảng:
$myArr = mảng(1,2,3,4,5);
Để xóa phần tử có giá trị "3", hãy sử dụng mã:
unset($myArr);
Xin lưu ý rằng không phải giá trị (3) được chỉ định mà là khóa của phần tử (2), trong trường hợp này bắt đầu bằng 0. Vì vậy, nếu bạn cần loại bỏ phần tử đầu tiên của mảng, thì hãy chỉ định số 0 yếu tố:
unset($myArr);
Cũng cần lưu ý rằng sau hai lần xóa, mảng hiện chứa ba phần tử:
Mảng
=> 2
=> 4
=> 5
)
Tất cả các khóa của các phần tử còn lại được giữ nguyên. Theo đó, nếu bây giờ bạn cần xóa phần tử đầu tiên thì bạn sẽ cần chỉ định một phần tử làm khóa. Do đó, và cũng bởi vì chúng ta không phải lúc nào cũng biết số lượng phần tử trong mảng mà chỉ biết giá trị của nó, nên tùy chọn này có thể không phù hợp.
Xóa một phần tử mảng theo giá trị của nó
Nếu không biết khóa của một phần tử mà chỉ biết giá trị của mảng, thì bạn sẽ phải lặp qua tất cả các phần tử của mảng và xóa phần tử bạn đang tìm kiếm. Ví dụ: chúng tôi xóa một phần tử có giá trị "3":
$myArr = mảng(1,2,3,4,5);
foreach ($myArr as $key => $item)(
nếu ($ mục == 3)(
unset($myArr[$key]);
}
}
* Xin lưu ý rằng điều kiện kiểm tra giá trị mảng có sẵn trong vòng lặp trong biến $item và khi xóa, khóa phần tử được chỉ định (biến $key).
Thuật toán này cũng phù hợp nếu bạn cần xóa một nhóm phần tử cùng một lúc. Rốt cuộc, ở đây có một điều kiện xác định những phần tử nào cần xóa.
Loại bỏ các phần tử mảng giao nhau
Một trong những tính năng tiện lợi của PHP là khả năng lấy một mảng các phần tử không giao nhau với các phần tử của mảng khác. Để làm điều này, hãy sử dụng chức năng mảng_diff(). Nó lấy mảng làm tham số, trả về một mảng mới. Ví dụ: có một mảng ban đầu $myArr mà từ đó chúng ta chỉ cần các phần tử không có trong mảng $myArr2:
$myArr = mảng(1,2,3,4,5);
$myArr2 = mảng(3,4);
Bằng cách áp dụng hàm mảng_diff(), chúng ta nhận được một mảng mới chỉ chứa các phần tử cần thiết:
$resArr = array_diff($myArr, myArr2);
Kết quả là $resArr sẽ chứa:
Mảng
=> 1
=> 2
=> 5
)
* Điều đáng chú ý là các khóa được lưu khi tạo một mảng mới. Ngoài ra, điều đáng biết là việc lựa chọn chỉ đến từ mảng đầu tiên. Vì vậy, nếu có các phần tử duy nhất khác trong $myArr2, chẳng hạn như “6” hoặc “7”, thì điều này sẽ không ảnh hưởng đến kết quả dưới bất kỳ hình thức nào - chúng sẽ không được thêm vào mảng mới.
