Các hàm xử lý mảng phổ biến trong PHP

PHP Tutorial | 04/07/2025 by Học PHP

Từ việc lưu trữ danh sách sản phẩm, thông tin người dùng, đến dữ liệu thu thập từ biểu mẫu, mảng luôn đóng vai trò trung tâm. Tuy nhiên, việc thao tác với các phần tử trong mảng một cách thủ công có thể trở nên tốn thời gian và dễ gây lỗi, đặc biệt khi mảng chứa hàng trăm hoặc hàng nghìn phần tử.

Đây chính là lúc các hàm xử lý mảng phổ biến trong PHP trở thành những người bạn đồng hành không thể thiếu của mọi lập trình viên. PHP cung cấp một bộ sưu tập phong phú các hàm tích hợp sẵn, được thiết kế đặc biệt để giúp bạn thực hiện mọi thao tác từ cơ bản đến phức tạp với mảng một cách nhanh chóng, hiệu quả và đáng tin cậy. Thay vì phải tự mình viết các vòng lặp phức tạp để thêm, xóa, sắp xếp hay tìm kiếm phần tử, bạn có thể gọi một hàm đơn giản và để PHP lo phần còn lại. Bài viết này sẽ đưa bạn đi qua các nhóm hàm xử lý mảng quan trọng nhất, từ những hàm đơn giản giúp bạn bắt đầu đến những công cụ nâng cao để giải quyết các vấn đề phức tạp, giúp code của bạn trở nên gọn gàng, dễ đọc và tối ưu hơn.

Tại Sao Các Hàm Xử Lý Mảng Lại Quan Trọng?

Để hiểu được tầm quan trọng của các hàm xử lý mảng, trước hết chúng ta cần nhắc lại một chút về mảng.

Mảng là gì?

Trong PHP, mảng là một cấu trúc dữ liệu cơ bản cho phép bạn lưu trữ nhiều giá trị trong một biến duy nhất. Hãy hình dung nó như một "hộp" lớn có thể chứa nhiều "ngăn" nhỏ, mỗi ngăn có thể chứa một giá trị khác nhau. Các giá trị này có thể là số, chuỗi, boolean, hoặc thậm chí là các mảng khác (tạo thành mảng đa chiều).

Ví dụ về mảng:

<?php
$fruits = ["Apple", "Banana", "Cherry"]; // Mảng các chuỗi
$student_scores = ["An" => 8.5, "Binh" => 9.0, "Cuong" => 7.2]; // Mảng kết hợp (tên => điểm)
?>

Hàm xử lý mảng là gì?

Hàm xử lý mảng là các công cụ tích hợp sẵn trong PHP, được thiết kế đặc biệt để thực hiện các thao tác phổ biến và phức tạp trên mảng. Thay vì phải tự mình viết các đoạn mã dài dòng và dễ lỗi để thực hiện một tác vụ nào đó (như tìm kiếm, sắp xếp, thêm/xóa phần tử), bạn có thể gọi một hàm có sẵn chỉ với một dòng lệnh đơn giản.

Ví dụ về hàm xử lý mảng: sort(), count(), array_push(), array_filter(), v.v.

Tầm quan trọng của các hàm xử lý mảng:

Các hàm này đóng vai trò cực kỳ quan trọng trong việc phát triển ứng dụng PHP vì những lý do sau:

Tiết kiệm Thời gian và Công sức

Việc sử dụng các hàm có sẵn giúp bạn tránh phải "tái phát minh bánh xe" (reinventing the wheel). Thay vì viết logic phức tạp từ đầu cho mỗi tác vụ, bạn chỉ cần gọi một hàm đã được PHP cung cấp.

Minh họa:

Nếu không có hàm: Để đếm số phần tử trong mảng, bạn có thể phải dùng vòng lặp và một biến đếm:

<?php
$items = ["a", "b", "c"];
$count = 0;
foreach ($items as $item) {
    $count++;
}
echo "Số phần tử: " . $count; // Output: 3
?>

Với hàm count(): Mọi thứ trở nên đơn giản chỉ với một dòng:

<?php
$items = ["a", "b", "c"];
echo "Số phần tử: " . count($items); // Output: 3
?>

Bạn thấy đó, thời gian và công sức tiết kiệm được là đáng kể, đặc biệt với các tác vụ phức tạp hơn như sắp xếp hay lọc dữ liệu.

Code Gọn gàng và Dễ đọc

Việc sử dụng các hàm tích hợp sẵn giúp mã nguồn của bạn trở nên minh bạch và dễ hiểu hơn. Khi nhìn vào một hàm như sort(), người đọc code (kể cả bạn sau này) sẽ ngay lập tức biết được mục đích của đoạn code đó là gì.

Minh họa (sắp xếp mảng):

Code thủ công (ví dụ sắp xếp nổi bọt - bubble sort): Rất dài dòng và khó đọc nếu không quen thuộc.

<?php
$numbers = [5, 2, 8, 1];
$n = count($numbers);
for ($i = 0; $i < $n - 1; $i++) {
    for ($j = 0; $j < $n - $i - 1; $j++) {
        if ($numbers[$j] > $numbers[$j + 1]) {
            $temp = $numbers[$j];
            $numbers[$j] = $numbers[$j + 1];
            $numbers[$j + 1] = $temp;
        }
    }
}
print_r($numbers); // Output: Array ( [0] => 1 [1] => 2 [2] => 5 [3] => 8 )
?>

Với hàm sort(): Ngắn gọn và dễ hiểu mục đích.

<?php
$numbers = [5, 2, 8, 1];
sort($numbers); // Sắp xếp tăng dần
print_r($numbers); // Output: Array ( [0] => 1 [1] => 2 [2] => 5 [3] => 8 )
?>

Sự khác biệt về tính gọn gàng và dễ đọc là rất rõ ràng.

Hiệu suất cao

Các hàm xử lý mảng trong PHP không chỉ tiện lợi mà còn được tối ưu hóa cao độ ở cấp độ ngôn ngữ (thường được viết bằng C). Điều này có nghĩa là chúng thực thi nhanh hơn rất nhiều so với việc bạn tự viết logic tương tự bằng PHP.

Lợi ích: Khi làm việc với các mảng lớn (hàng ngàn hoặc hàng triệu phần tử), việc sử dụng hàm tích hợp sẵn sẽ giúp ứng dụng của bạn chạy nhanh hơn và tiêu tốn ít tài nguyên hơn.

Các Nhóm Hàm Xử Lý Mảng Cơ Bản trong PHP

PHP cung cấp một bộ sưu tập phong phú các hàm tích hợp sẵn để làm việc với mảng. Dưới đây là những nhóm hàm cơ bản và phổ biến nhất mà bạn sẽ thường xuyên sử dụng trong các dự án của mình.

Hàm Tạo/Khởi Tạo Mảng

Các hàm này giúp bạn định nghĩa và điền dữ liệu vào mảng.

array(): Đây là cách phổ biến và cơ bản nhất để khai báo một mảng trong PHP. Bạn có thể khởi tạo một mảng rỗng hoặc điền ngay các giá trị ban đầu.

<?php
echo "<h4>`array()`: Khai báo mảng</h4>";
$emptyArray = array(); // Mảng rỗng
echo "Mảng rỗng: ";
print_r($emptyArray);

$numbers = array(1, 2, 3, 4, 5); // Mảng có chỉ số
echo "Mảng số: ";
print_r($numbers);

$person = array("name" => "Alice", "age" => 30); // Mảng kết hợp
echo "Mảng người: ";
print_r($person);
?>

range(): Hàm này tạo ra một mảng chứa một dãy các phần tử, thường là số hoặc ký tự, giữa hai giá trị được chỉ định.

<?php
echo "<h4>`range()`: Tạo dãy số/ký tự</h4>";
$numSequence = range(1, 5); // Tạo mảng từ 1 đến 5
echo "Dãy số từ 1 đến 5: ";
print_r($numSequence); // Output: Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 )

$alphabet = range('a', 'e'); // Tạo mảng các ký tự từ 'a' đến 'e'
echo "Dãy chữ cái từ 'a' đến 'e': ";
print_r($alphabet); // Output: Array ( [0] => a [1] => b [2] => c [3] => d [4] => e )

$evenNumbers = range(0, 10, 2); // Tạo dãy số chẵn từ 0 đến 10, bước nhảy là 2
echo "Dãy số chẵn từ 0 đến 10: ";
print_r($evenNumbers); // Output: Array ( [0] => 0 [1] => 2 [2] => 4 [3] => 6 [4] => 8 [5] => 10 )
?>

Hàm Kiểm Tra/Thông Tin Mảng

Các hàm này giúp bạn xác định kiểu dữ liệu của biến hoặc lấy thông tin về mảng.

is_array(): Kiểm tra xem một biến có phải là một mảng hay không, trả về true hoặc false.

<?php
echo "<h4>`is_array()`: Kiểm tra mảng</h4>";
$myArray = [1, 2, 3];
$myString = "hello";

if (is_array($myArray)) {
    echo "\$myArray là một mảng.<br>"; // Output: $myArray là một mảng.
} else {
    echo "\$myArray không phải là một mảng.<br>";
}

if (is_array($myString)) {
    echo "\$myString là một mảng.<br>";
} else {
    echo "\$myString không phải là một mảng.<br>"; // Output: $myString không phải là một mảng.
}
?>

count(): Đếm số phần tử trong mảng.

<?php
echo "<h4>`count()`: Đếm phần tử</h4>";
$fruits = ["Apple", "Banana", "Cherry", "Date"];
echo "Số lượng trái cây: " . count($fruits) . "<br>"; // Output: 4

$user = ["name" => "John", "age" => 25];
echo "Số lượng thông tin user: " . count($user) . "<br>"; // Output: 2
?>

in_array(): Kiểm tra xem một giá trị cụ thể có tồn tại trong mảng hay không.

<?php
echo "<h4>`in_array()`: Kiểm tra giá trị tồn tại</h4>";
$colors = ["red", "green", "blue"];

if (in_array("green", $colors)) {
    echo "Có màu xanh lá cây trong mảng.<br>"; // Output: Có màu xanh lá cây trong mảng.
} else {
    echo "Không có màu xanh lá cây trong mảng.<br>";
}

if (in_array("yellow", $colors)) {
    echo "Có màu vàng trong mảng.<br>";
} else {
    echo "Không có màu vàng trong mảng.<br>"; // Output: Không có màu vàng trong mảng.
}
?>

array_key_exists(): Kiểm tra xem một khóa (key) cụ thể có tồn tại trong mảng hay không. Rất hữu ích với mảng kết hợp.

<?php
echo "<h4>`array_key_exists()`: Kiểm tra khóa tồn tại</h4>";
$student = ["name" => "Mai", "age" => 18, "grade" => "A"];

if (array_key_exists("age", $student)) {
    echo "Khóa 'age' tồn tại trong mảng student.<br>"; // Output: Khóa 'age' tồn tại trong mảng student.
} else {
    echo "Khóa 'age' không tồn tại trong mảng student.<br>";
}

if (array_key_exists("city", $student)) {
    echo "Khóa 'city' tồn tại trong mảng student.<br>";
} else {
    echo "Khóa 'city' không tồn tại trong mảng student.<br>"; // Output: Khóa 'city' không tồn tại trong mảng student.
}
?>

Hàm Thêm/Xóa Phần Tử

Các hàm này giúp bạn thay đổi kích thước và nội dung của mảng bằng cách thêm hoặc bớt các phần tử.

Thêm vào cuối:

array_push(): Thêm một hoặc nhiều phần tử vào cuối mảng.

<?php
echo "<h4>Thêm vào cuối: `array_push()`</h4>";
$fruits = ["Apple", "Banana"];
echo "Ban đầu: "; print_r($fruits);
array_push($fruits, "Cherry", "Date");
echo "Sau array_push(): "; print_r($fruits); // Output: Array ( [0] => Apple [1] => Banana [2] => Cherry [3] => Date )
?>

Cú pháp [] (cách phổ biến và ngắn gọn hơn): Thêm một phần tử vào cuối mảng.

<?php
echo "<h4>Thêm vào cuối: Cú pháp `[]`</h4>";
$colors = ["red", "green"];
echo "Ban đầu: "; print_r($colors);
$colors[] = "blue"; // Thêm "blue" vào cuối
echo "Sau cú pháp []: "; print_r($colors); // Output: Array ( [0] => red [1] => green [2] => blue )
?>

Xóa cuối:

array_pop(): Xóa và trả về phần tử cuối cùng của mảng.

<?php
echo "<h4>Xóa cuối: `array_pop()`</h4>";
$numbers = [1, 2, 3, 4];
echo "Ban đầu: "; print_r($numbers);
$lastNumber = array_pop($numbers);
echo "Phần tử đã xóa: " . $lastNumber . "<br>"; // Output: 4
echo "Sau array_pop(): "; print_r($numbers); // Output: Array ( [0] => 1 [1] => 2 [2] => 3 )
?>

Thêm vào đầu:

array_unshift(): Thêm một hoặc nhiều phần tử vào đầu mảng. Các chỉ số số nguyên sẽ được điều chỉnh lại.

<?php
echo "<h4>Thêm vào đầu: `array_unshift()`</h4>";
$letters = ["b", "c"];
echo "Ban đầu: "; print_r($letters);
array_unshift($letters, "a", "z");
echo "Sau array_unshift(): "; print_r($letters); // Output: Array ( [0] => a [1] => z [2] => b [3] => c )
?>

Xóa đầu:

array_shift(): Xóa và trả về phần tử đầu tiên của mảng. Các chỉ số số nguyên sẽ được điều chỉnh lại.

<?php
echo "<h4>Xóa đầu: `array_shift()`</h4>";
$queue = ["task1", "task2", "task3"];
echo "Ban đầu: "; print_r($queue);
$firstTask = array_shift($queue);
echo "Phần tử đã xóa: " . $firstTask . "<br>"; // Output: task1
echo "Sau array_shift(): "; print_r($queue); // Output: Array ( [0] => task2 [1] => task3 )
?>

Xóa theo chỉ số/khóa:

unset(): Hủy bỏ một biến hoặc một phần tử cụ thể của mảng bằng chỉ số hoặc khóa của nó. Lưu ý: Với mảng có chỉ số, unset() sẽ tạo ra một khoảng trống chỉ số; bạn cần dùng array_values() nếu muốn chỉ số được gán lại liên tục.

<?php
echo "<h4>Xóa theo chỉ số/khóa: `unset()`</h4>";
$data = ["itemA", "itemB", "itemC"];
echo "Mảng chỉ số ban đầu: "; print_r($data);
unset($data[1]); // Xóa "itemB"
echo "Sau unset(chỉ số 1): "; print_r($data); // Output: Array ( [0] => itemA [2] => itemC )
$data = array_values($data); // Gán lại chỉ số
echo "Sau unset() và array_values(): "; print_r($data); // Output: Array ( [0] => itemA [1] => itemC )

$person = ["name" => "Mike", "age" => 28, "city" => "NYC"];
echo "Mảng kết hợp ban đầu: "; print_r($person);
unset($person["age"]); // Xóa khóa "age"
echo "Sau unset(khóa 'age'): "; print_r($person); // Output: Array ( [name] => Mike [city] => NYC )
?>

Hàm Sắp Xếp Mảng

Các hàm này thay đổi thứ tự các phần tử trong mảng theo một tiêu chí nhất định (tăng dần, giảm dần, theo giá trị, theo khóa).

sort(): Sắp xếp các phần tử của mảng theo giá trị tăng dần và gán lại chỉ số số nguyên bắt đầu từ 0.

<?php
echo "<h4>`sort()`: Sắp xếp tăng dần (gán lại chỉ số)</h4>";
$numbers = [3, 1, 4, 2];
sort($numbers);
print_r($numbers); // Output: Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )
?>

rsort(): Sắp xếp các phần tử của mảng theo giá trị giảm dần và gán lại chỉ số số nguyên.

<?php
echo "<h4>`rsort()`: Sắp xếp giảm dần (gán lại chỉ số)</h4>";
$scores = [90, 75, 88, 92];
rsort($scores);
print_r($scores); // Output: Array ( [0] => 92 [1] => 90 [2] => 88 [3] => 75 )
?>

asort(): Sắp xếp mảng kết hợp theo giá trị tăng dần, duy trì liên kết giữa khóa và giá trị.

<?php
echo "<h4>`asort()`: Sắp xếp giá trị tăng dần (giữ khóa)</h4>";
$grades = ["Alice" => 85, "Bob" => 92, "Charlie" => 78];
asort($grades);
print_r($grades); // Output: Array ( [Charlie] => 78 [Alice] => 85 [Bob] => 92 )
?>

arsort(): Sắp xếp mảng kết hợp theo giá trị giảm dần, duy trì liên kết giữa khóa và giá trị.

<?php
echo "<h4>`arsort()`: Sắp xếp giá trị giảm dần (giữ khóa)</h4>";
$productPrices = ["TV" => 500, "Phone" => 300, "Laptop" => 1200];
arsort($productPrices);
print_r($productPrices); // Output: Array ( [Laptop] => 1200 [TV] => 500 [Phone] => 300 )
?>

krsort(): Sắp xếp mảng kết hợp theo khóa giảm dần, duy trì liên kết giữa khóa và giá trị.

<?php
echo "<h4>`krsort()`: Sắp xếp khóa giảm dần (giữ khóa)</h4>";
$settings = ["version" => "1.0", "name" => "App", "id" => "XYZ"];
krsort($settings);
print_r($settings); // Output: Array ( [version] => 1.0 [name] => App [id] => XYZ )
?>

Hàm Biến Đổi/Chuyển Đổi Mảng

Các hàm này giúp bạn trích xuất các thành phần của mảng hoặc chuyển đổi mảng sang dạng dữ liệu khác và ngược lại.

array_values(): Trích xuất tất cả các giá trị từ một mảng và trả về một mảng mới với các chỉ số số nguyên liên tục, bắt đầu từ 0.

<?php
echo "<h4>`array_values()`: Lấy tất cả giá trị</h4>";
$data = [0 => "a", 2 => "b", 4 => "c"]; // Mảng có chỉ số không liên tục
echo "Mảng ban đầu: "; print_r($data);
$newArray = array_values($data);
echo "Sau array_values(): "; print_r($newArray); // Output: Array ( [0] => a [1] => b [2] => c )
?>

array_keys(): Trích xuất tất cả các khóa (key) từ một mảng và trả về một mảng mới chứa các khóa đó.

<?php
echo "<h4>`array_keys()`: Lấy tất cả các khóa</h4>";
$userInfo = ["id" => 1, "username" => "dev", "email" => "[email protected]"];
$keys = array_keys($userInfo);
print_r($keys); // Output: Array ( [0] => id [1] => username [2] => email )
?>

array_merge(): Gộp hai hoặc nhiều mảng thành một mảng mới.

<?php
echo "<h4>`array_merge()`: Gộp mảng</h4>";
$array1 = ["red", "green"];
$array2 = ["blue", "yellow"];
$mergedArray = array_merge($array1, $array2);
print_r($mergedArray); // Output: Array ( [0] => red [1] => green [2] => blue [3] => yellow )

$user1 = ["name" => "A", "age" => 20];
$user2 = ["city" => "HCM", "age" => 25]; // 'age' bị trùng
$mergedUser = array_merge($user1, $user2);
print_r($mergedUser); // Output: Array ( [name] => A [age] => 25 [city] => HCM ) - key trùng sẽ bị ghi đè bởi mảng sau
?>

implode(): Chuyển đổi tất cả các phần tử của một mảng thành một chuỗi duy nhất, được nối với nhau bằng một ký tự phân tách (delimiter) mà bạn chỉ định.

<?php
echo "<h4>`implode()`: Chuyển mảng thành chuỗi</h4>";
$fruits = ["Apple", "Banana", "Cherry"];
$fruitString = implode(", ", $fruits);
echo $fruitString; // Output: Apple, Banana, Cherry

echo "<br>";
$tags = ["php", "web", "development"];
$tagString = implode("-", $tags);
echo $tagString; // Output: php-web-development
?>

explode(): Chuyển đổi một chuỗi thành một mảng, chia chuỗi tại mỗi lần xuất hiện của một ký tự phân tách (delimiter) đã cho. Đây là hàm ngược lại của implode().

<?php
echo "<h4>`explode()`: Chuyển chuỗi thành mảng</h4>";
$csvData = "item1,item2,item3,item4";
$itemsArray = explode(",", $csvData);
print_r($itemsArray); // Output: Array ( [0] => item1 [1] => item2 [2] => item3 [3] => item4 )

echo "<br>";
$sentence = "Hello world this is PHP";
$words = explode(" ", $sentence);
print_r($words); // Output: Array ( [0] => Hello [1] => world [2] => this [3] => is [4] => PHP )
?>

Các Nhóm Hàm Xử Lý Mảng Nâng Cao trong PHP

Ngoài các hàm cơ bản đã học, PHP còn cung cấp một số hàm mạnh mẽ giúp bạn thực hiện các thao tác phức tạp hơn như lọc, biến đổi và sắp xếp mảng đa chiều một cách hiệu quả. Những hàm này thường sử dụng hàm callback (một hàm được truyền như một đối số cho hàm khác) để cung cấp logic tùy chỉnh.

Hàm Lọc/Biến Đổi Nâng Cao

Những hàm này cho phép bạn thao tác linh hoạt với dữ liệu trong mảng dựa trên các điều kiện hoặc phép biến đổi cụ thể.

array_filter(): Lọc các phần tử theo điều kiện

Hàm array_filter() dùng để tạo một mảng mới chứa chỉ những phần tử từ mảng gốc mà thỏa mãn một điều kiện nhất định. Điều kiện này được định nghĩa bởi một hàm callback.

Cách thức hoạt động: Duyệt qua từng phần tử của mảng. Với mỗi phần tử, nó gọi hàm callback. Nếu hàm callback trả về true, phần tử đó sẽ được giữ lại trong mảng kết quả; nếu trả về false, phần tử đó sẽ bị loại bỏ.
Cú pháp:

array_filter(array $array, ?callable $callback = null, int $mode = 0): array

$array: Mảng bạn muốn lọc.
$callback: Hàm callback chứa logic lọc. Hàm này nhận giá trị của phần tử làm đối số.
$mode (tùy chọn): Cách truyền đối số cho callback (ARRAY_FILTER_USE_KEY, ARRAY_FILTER_USE_BOTH). Mặc định chỉ truyền giá trị.

Ví dụ code minh họa: Lọc ra các số chẵn trong một mảng.

<?php
echo "<h4>`array_filter()`: Lọc phần tử theo điều kiện</h4>";
$numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
echo "Mảng số ban đầu: ";
print_r($numbers);

// Lọc các số chẵn
$evenNumbers = array_filter($numbers, function($number) {
    return $number % 2 == 0;
});

echo "Các số chẵn trong mảng: ";
print_r($evenNumbers); // Output: Array ( [1] => 2 [3] => 4 [5] => 6 [7] => 8 [9] => 10 )

// Lưu ý: array_filter giữ nguyên chỉ số gốc. Dùng array_values() nếu muốn chỉ số liên tục
$evenNumbers = array_values($evenNumbers);
echo "Các số chẵn (chỉ số liên tục): ";
print_r($evenNumbers); // Output: Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 [4] => 10 )
?>

array_map(): Áp dụng hàm cho từng phần tử

Hàm array_map() dùng để áp dụng một hàm callback cho tất cả các phần tử của một hoặc nhiều mảng và trả về một mảng mới chứa các kết quả sau khi áp dụng hàm đó. Nó dùng để biến đổi dữ liệu.

Cách thức hoạt động: Duyệt qua từng phần tử của mảng. Với mỗi phần tử, nó gọi hàm callback và sử dụng giá trị trả về của callback để tạo phần tử tương ứng trong mảng mới.

Cú pháp:

array_map(?callable $callback, array $array, array ...$arrays): array

$callback: Hàm callback sẽ được áp dụng cho từng phần tử.
$array, ...$arrays: Một hoặc nhiều mảng đầu vào.

Ví dụ code minh họa: Nhân đôi tất cả các số trong một mảng.

<?php
echo "<h4>`array_map()`: Áp dụng hàm cho từng phần tử</h4>";
$numbers = [1, 2, 3, 4, 5];
echo "Mảng số ban đầu: ";
print_r($numbers);

// Nhân đôi mỗi số
$doubledNumbers = array_map(function($number) {
    return $number * 2;
}, $numbers);

echo "Mảng sau khi nhân đôi: ";
print_r($doubledNumbers); // Output: Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 [4] => 10 )

// Ví dụ với nhiều mảng: cộng các phần tử tương ứng
$arr1 = [1, 2, 3];
$arr2 = [4, 5, 6];
$sumArrays = array_map(function($num1, $num2) {
    return $num1 + $num2;
}, $arr1, $arr2);
echo "Tổng hai mảng: ";
print_r($sumArrays); // Output: Array ( [0] => 5 [1] => 7 [2] => 9 )
?>

Hàm Xử Lý Mảng Đa Chiều

Khi làm việc với dữ liệu dạng bảng (mảng chứa các mảng con), các hàm này trở nên cực kỳ hữu ích.array_column(): Trích xuất một cột từ mảng đa chiều

Hàm này giúp bạn dễ dàng lấy ra tất cả các giá trị từ một "cột" (một khóa cụ thể) trong một mảng các mảng, tạo thành một mảng một chiều mới.

Cách thức hoạt động: Duyệt qua từng mảng con trong mảng đa chiều và thu thập giá trị của khóa được chỉ định.

Cú pháp:

array_column(array $array, mixed $column_key, mixed $index_key = null): array

$array: Mảng đa chiều đầu vào.
$column_key: Tên của khóa mà bạn muốn lấy giá trị.
$index_key (tùy chọn): Khóa để sử dụng làm chỉ số cho mảng kết quả.

Ví dụ code minh họa: Lấy danh sách tên của tất cả học sinh.

<?php
echo "<h4>`array_column()`: Trích xuất một cột từ mảng đa chiều</h4>";
$students = [
    ["id" => 1, "name" => "An", "age" => 15],
    ["id" => 2, "name" => "Binh", "age" => 16],
    ["id" => 3, "name" => "Cuong", "age" => 15],
];
echo "Mảng học sinh ban đầu:<br>";
echo "<pre>"; print_r($students); echo "</pre>";

$studentNames = array_column($students, 'name');
echo "Danh sách tên học sinh:<br>";
echo "<pre>"; print_r($studentNames); echo "</pre>";
/* Output:
Array
(
    [0] => An
    [1] => Binh
    [2] => Cuong
)
*/

// Lấy tuổi học sinh với ID làm khóa
$studentAgesById = array_column($students, 'age', 'id');
echo "Tuổi học sinh theo ID:<br>";
echo "<pre>"; print_r($studentAgesById); echo "</pre>";
/* Output:
Array
(
    [1] => 15
    [2] => 16
    [3] => 15
)
*/
?>

array_multisort(): Sắp xếp mảng đa chiều theo nhiều tiêu chí

Đây là một hàm rất mạnh mẽ, cho phép bạn sắp xếp một hoặc nhiều mảng, hoặc sắp xếp một mảng đa chiều dựa trên các giá trị của một hoặc nhiều "cột" (khóa) khác nhau.

Cách thức hoạt động: Coi các mảng đầu vào như các cột và sắp xếp chúng đồng bộ. Bạn có thể chỉ định nhiều tiêu chí sắp xếp (ví dụ: sắp xếp theo điểm giảm dần, nếu điểm bằng nhau thì sắp xếp theo tên tăng dần).

Cú pháp:

array_multisort(array &array1, mixed $sort_order1 = SORT_ASC, mixed $sort_flags1 = SORT_REGULAR, mixed ...$arrays): bool

$array1, ...$arrays: Các mảng bạn muốn sắp xếp. Với mảng đa chiều, bạn thường dùng array_column() để trích xuất các cột trước.
$sort_order (tùy chọn): SORT_ASC (tăng dần) hoặc SORT_DESC (giảm dần).
$sort_flags (tùy chọn): SORT_NUMERIC (số), SORT_STRING (chuỗi), SORT_REGULAR (mặc định).

Ví dụ code minh họa: Sắp xếp danh sách học sinh theo tuổi tăng dần, nếu tuổi bằng nhau thì sắp xếp theo tên tăng dần.

<?php
echo "<h4>`array_multisort()`: Sắp xếp mảng đa chiều</h4>";
$students = [
    ["name" => "Charlie", "age" => 15, "score" => 80],
    ["name" => "Alice", "age" => 16, "score" => 90],
    ["name" => "Bob", "age" => 15, "score" => 85], // Cùng tuổi với Charlie
    ["name" => "David", "age" => 17, "score" => 75],
];
echo "Mảng học sinh ban đầu:<br>";
echo "<pre>"; print_r($students); echo "</pre>";

// Bước 1: Trích xuất các cột cần sắp xếp
$ages = array_column($students, 'age');
$names = array_column($students, 'name');

// Bước 2: Sắp xếp mảng $students gốc
// Tiêu chí 1: Tuổi (ages) tăng dần
// Tiêu chí 2 (nếu tuổi bằng nhau): Tên (names) tăng dần
array_multisort($ages, SORT_ASC,
                $names, SORT_ASC,
                $students);

echo "Học sinh sau khi sắp xếp (tuổi tăng, tên tăng):<br>";
echo "<pre>"; print_r($students); echo "</pre>";
/* Output:
Array
(
    [0] => Array ( [name] => Bob [age] => 15 [score] => 85 )     // Tuổi 15, tên Bob
    [1] => Array ( [name] => Charlie [age] => 15 [score] => 80 ) // Tuổi 15, tên Charlie (Bob trước Charlie)
    [2] => Array ( [name] => Alice [age] => 16 [score] => 90 )
    [3] => Array ( [name] => David [age] => 17 [score] => 75 )
)
*/
?>

Kết bài

Việc thành thạo các hàm xử lý mảng phổ biến trong PHP là một bước tiến quan trọng trong hành trình trở thành một lập trình viên PHP giỏi. Mảng là cấu trúc dữ liệu nền tảng, và khả năng thao tác hiệu quả với chúng sẽ giúp bạn giải quyết vô số vấn đề trong các ứng dụng thực tế.

Chúng ta đã cùng nhau điểm qua các nhóm hàm chính:

Tạo/Khởi tạo mảng: Từ array() cơ bản đến range() tiện lợi để tạo dãy.
Kiểm tra/Thông tin mảng: Các hàm như is_array(), count(), in_array(), và array_key_exists() giúp bạn hiểu rõ hơn về cấu trúc và nội dung của mảng.
Thêm/Xóa phần tử: Bạn đã học cách sử dụng array_push(), array_pop(), array_unshift(), array_shift(), và unset() để quản lý các phần tử ở đầu, cuối hoặc bất kỳ vị trí nào trong mảng.
Sắp xếp mảng: Các hàm sort(), rsort(), asort(), arsort(), ksort(), và krsort() cung cấp sự linh hoạt tuyệt vời để tổ chức dữ liệu theo nhiều tiêu chí khác nhau, có hoặc không giữ lại khóa.
Biến đổi/Chuyển đổi mảng: array_values(), array_keys(), array_merge(), implode(), và explode() là những công cụ đắc lực để chuyển đổi cấu trúc mảng hoặc biến đổi giữa mảng và chuỗi.
Nâng cao: array_filter(), array_map(), array_column(), và array_multisort() giúp bạn thực hiện các tác vụ phức tạp hơn như lọc, biến đổi và sắp xếp mảng đa chiều với hiệu suất cao.

Việc sử dụng những hàm này không chỉ giúp bạn tiết kiệm thời gian, công sức mà còn làm cho code của bạn trở nên gọn gàng, dễ đọc và tối ưu hơn về hiệu suất. Thay vì tự mình viết các đoạn mã phức tạp, hãy tận dụng sức mạnh của thư viện hàm tích hợp sẵn của PHP.