How to find the sum of a key in an array in php

For PHP developers, it is often necessary to perform various operations on arrays, such as merging, searching, sorting, etc. When we need to sum the values ​​of a key in an array, how do we do it?

In PHP, you can use a variety of methods to find the sum of a key in an array. The four different summation methods are demonstrated below through cases:

1. Use a loop to traverse the array And summing

The first way to sum is to use a loop to traverse the array and add each key value, and finally get the summation result:

<?php
$array = array(1, 2, 3, 4, 5);
$sum = 0;
for ($i = 0; $i < count($array); $i++) {
    $sum += $array[$i];
}
echo "数组求和结果为：".$sum;
?>

Yes As you can see, we use the for loop to traverse the entire array, use $sum to store the final summation result, and add the elements in the array each time. The final output result is: The array summation result is: 15

The disadvantage of this method is that it needs to loop the array over and over again. When the amount of data in the array is large, it will affect the performance of the script.

2. Use the array_sum() function to sum

PHP provides the array_sum() function, which can easily sum all the elements in an array. Usage As follows:

<?php
$array = array(1, 2, 3, 4, 5);
echo "数组求和结果为：" . array_sum($array);
?>

You can see that when the array is passed as a parameter to the array_sum() function, the function will sum all the elements in the array and return the result. The final output result is: Array sum The result is: 15

Compared with the first method, using the array_sum() function to directly provide the sum operation, the code is simpler and easier to understand, but the disadvantage is that there may be restrictions on the keys of the array.

3. Use the array_reduce() function for summation

There is another way to sum in PHP, which is to use the array_reduce() function to loop through the array and compare the keys The value is processed iteratively, and the code is as follows:

<?php
$array = array(1, 2, 3, 4, 5);
$sum = array_reduce($array, function($carry, $item) {
    $carry += $item;
    return $carry;
});
echo "数组求和结果为：" . $sum;
?>

This method needs to pass in two parameters, an array and a processing function. In the function, $carry represents the last calculation result, and $item represents the currently processed element.

array_reduce() function will iteratively process the incoming array, passing one element into the processing function each time, operating on the elements, and finally returning the processing result. The final output result is: The array summation result is: 15

The advantage of this method is that compared with the first method, arbitrary operations can be performed on the elements of the array through the closure function. Compared with the array_sum() function, it is more efficient in some cases. flexible.

4. Use recursion to calculate the sum of a key of a multi-dimensional array

The above three methods are used to solve the key and value of a one-dimensional array. When it comes to multi-dimensional arrays When , the array needs to be recursively expanded before summation processing can be performed.

Let’s take a look at how to use recursion to implement the summation processing of multi-dimensional arrays:

<?php
$array = array(
        1, 
        2, 
        array(
            3, 
            4,
            array(5, 6, 7)
        )
);
function array_sum_recursive($input)
{
    $sum = 0;
    foreach ($input as $item) {
        if (is_array($item)) {
            $sum += array_sum_recursive($item);
        } else if (is_numeric($item)) {
            $sum += $item;
        }
    }
    return $sum;
}
echo "多维数组求和结果为：".array_sum_recursive($array);
?>

Through the above function array_sum_recursive(), we can traverse each element of the multi-dimensional array, and Each sub-array is summed recursively, and the summation result of the multi-dimensional array is finally returned. The output result is: The sum result of multi-dimensional arrays is: 28

Although the recursive method to implement the sum of multi-dimensional arrays is more cumbersome, it is extremely flexible and can handle multiple levels of nesting. Very useful for arrays.

In actual project development, we can choose the above different methods to calculate the sum of array keys according to different needs, and balance them according to performance and readability.

The above is the detailed content of How to find the sum of a key in an array in php. For more information, please follow other related articles on the PHP Chinese website!