Important PHP Array Functions; Through this tutorial, you will learn the most important and daily useful PHP array functions.
Array is a collection of similar datatype values. One array can contain set different of values. Three types of the array are available In PHP, first is indexed, associative, and multidimensional arrays in PHP.
Arrays are a fundamental data structure in programming, and PHP is no exception. PHP provides a vast array (pun intended) of built-in functions for manipulating arrays, making it easy to perform complex operations on data stored in this format.
Array Functions In PHP
In this article, you will explore some of the most useful array functions in PHP and how to use them effectively.
- array_push()
- array_pop()
- array_shift()
- array_unshift()
- array_merge()
- array_slice()
- array_search()
- array_unique
- array_diff
- array_rand
- array_replace
- array_reverse
array_sum- array_chunk
array_push()
The array_push() function allows you to add one or more elements to the end of an array. The syntax for this function is straightforward:
array_push($array, $value1, $value2, ...);
Here, $array is the array you want to modify, and $value1, $value2, and so on are the values you want to add to the end of the array.
array_pop()
The array_pop() function removes the last element from an array and returns it. This can be useful when you want to retrieve and process the last item in an array. The syntax is as follows:
$last_value = array_pop($array);
Here, $array is the array from which you want to remove the last element, and $last_value is a variable that will contain the value of the last element that was removed.
array_shift()
The array_shift() function removes the first element from an array and returns it. This is similar to array_pop() but removes the first element instead of the last. The syntax is as follows:
$first_value = array_shift($array);
Here, $array is the array from which you want to remove the first element, and $first_value is a variable that will contain the value of the first element that was removed.
array_unshift()
The array_unshift() function is the opposite of array_push(). It allows you to add one or more elements to the beginning of an array. The syntax is as follows:
array_unshift($array, $value1, $value2, ...);
Here, $array is the array you want to modify, and $value1, $value2, and so on are the values you want to add to the beginning of the array.
array_merge()
The array_merge() function allows you to combine two or more arrays into a single array. The syntax is as follows:
$merged_array = array_merge($array1, $array2, ...);
Here, $array1, $array2, and so on are the arrays you want to merge, and $merged_array is the resulting merged array.
array_slice()
The array_slice() function allows you to extract a portion of an array. This can be useful when you only need a subset of the data stored in an array. The syntax is as follows:
$sliced_array = array_slice($array, $offset, $length);
Here, $array is the array you want to slice, $offset is the index at which to start slicing, and $length is the number of elements to slice. If $length is not specified, all elements from $offset to the end of the array will be included in the resulting sliced array.
array_search()
The array_search() function allows you to search an array for a specific value and return the corresponding key. The syntax is as follows:
$key = array_search($value, $array);
Here, $value is the value you want to search for, and $array is the array you want to search. If the value is found in the array, $key will be set to the corresponding key. If the value is not found, $key will be set to false.
array_unique
In PHP, the array_unique() function is used to remove duplicate values from an array. The function takes an array as its argument and returns a new array with all duplicate values removed.
$fruits = array("apple", "banana", "orange", "banana", "grape", "apple");
$unique_fruits = array_unique($fruits);
print_r($unique_fruits);
As you will see in the output of the above code, the duplicate values “banana” and “apple” were removed from the array, leaving only the unique values.
The array_unique() function preserves the keys of the original array, so the resulting array will have the same keys as the original, except for any keys that were associated with duplicate values, which will be removed.
It’s also worth noting that the array_unique() function does not preserve the order of the elements in the original array. The resulting array will have the unique values in the order in which they first appeared in the original array.
array_diff
The array_diff() function in PHP is used to compare two or more arrays and return the values that are present in one array but not in the others. In other words, it calculates the difference between the arrays and returns the result as a new array.
The syntax for using the array_diff() function is as follows:
array_diff(array1, array2, array3, ...);
Here, array1, array2, array3, and so on are the arrays that you want to compare.
The function will return a new array that contains all the values from the first array (array1) that are not present in any of the other arrays. If there are no differences between the arrays, the function will return an empty array.
Let’s look at an example to better understand how the array_diff() function works:
$array1 = array('apple', 'banana', 'orange', 'pear');
$array2 = array('apple', 'banana', 'grape');
$result = array_diff($array1, $array2);
print_r($result);
In this example, you have two arrays – $array1 and $array2. you want to compare them and find the values that are present in $array1 but not in $array2. The resulting array will be stored in the $result variable.
the array_diff() function in PHP is a useful tool for comparing arrays and finding the differences between them. By using this function, you can easily find the values that are unique to each array and manipulate your data more efficiently.
array_rand
The array_rand() function is a built-in array function in PHP that allows you to randomly select one or more keys from an array. This function is useful when you want to retrieve a random value from an array or when you need to shuffle the order of an array.
The syntax for using the array_rand() function is as follows:
mixed array_rand ( array $array [, int $num = 1 ] )
Here, $array is the array you want to select random keys from, and $num is the number of random keys you want to select. If $num is not specified, the function will only return one random key.
Let’s look at some examples to see how the array_rand() function works:
Example 1: Selecting a random key from an array
$fruits = array('apple', 'banana', 'orange', 'mango', 'kiwi');
$random_key = array_rand($fruits);
echo $fruits[$random_key]; // Outputs a random fruit from the array
In this example, you have an array of fruits, and you use the array_rand() function to select a random key from the array. You then use this key to retrieve the corresponding fruit from the array and display it on the screen.
the array_rand() function is a useful tool in PHP for selecting random elements from an array. Whether you need to retrieve a single random value, select multiple random keys, or shuffle the order of an array, the array_rand() function can help you accomplish these tasks with ease.
array_replace
In PHP, the array_replace() function is used to replace the values of the first array with the values of the second array. This function takes two or more arrays as input and returns a new array with the updated values.
The syntax for the array_replace() function is as follows:
array_replace($array1, $array2, $array3, ...);
Here, $array1 is the array whose values you want to replace, and $array2, $array3, and so on are the arrays whose values will replace the values in $array1.
The array_replace() function works in the following way:
- The first array is copied, and the values from the second array are used to replace any matching keys in the first array.
- If there are any additional arrays passed as arguments, their values will also replace any matching keys in the copied array.
- The resulting array is returned.
Let’s take a look at the below given example to see how the array_replace() function works:
$array1 = array('a' => 1, 'b' => 2, 'c' => 3);
$array2 = array('b' => 4, 'd' => 5);
$result = array_replace($array1, $array2);
print_r($result);
Output:
Array
(
[a] => 1
[b] => 4
=> 3
[d] => 5
)
In this example, the value of $array1['b'] has been replaced with the value of $array2['b'], and the value of $array2['d'] has been added to the resulting array.
array_reverse
In PHP, you can use the built-in array_reverse() function to reverse the order of elements in an array. The array_reverse() function returns a new array with the elements in reverse order, without modifying the original array. Here is an example:
<?php
// Original array
$original_array = array('apple', 'banana', 'cherry', 'date');
// Reversed array
$reversed_array = array_reverse($original_array);
// Output reversed array
print_r($reversed_array);
?>
array_sum
The array_sum function in PHP is a built-in function that calculates and returns the sum of all the values in an array.
The syntax of the array_sum function is as follows:
array_sum(array $array): float|int
The function takes an array as its argument and returns the sum of all the values in the array. If the array is empty, the function returns 0.
Here is an example of using the array_sum function in PHP:
<?php $array = array(1, 2, 3, 4, 5); $sum = array_sum($array); echo $sum; // Outputs 15 ?>
In this example, the array_sum function is used to calculate the sum of all the values in the $array variable, which contains the numbers 1 through 5. The result of the array_sum function is assigned to the $sum variable, which is then echoed to the screen, resulting in the output of 15.
array_chunk
In PHP, an array chunk function can be used to split an array into smaller arrays of a specified size. This is useful when you need to process large arrays in smaller chunks to prevent memory issues or optimize performance.
The syntax for the array_chunk function is:
array_chunk(array $input, int $size, bool $preserve_keys = false): array
The function takes three parameters:
$input: The array to be chunked$size: The size of each chunk$preserve_keys(optional): If set totrue, the function will preserve the keys of the original array. If set tofalseor not specified, the keys will be reset to sequential integers.
The function returns a new array of arrays, where each sub-array contains the specified number of elements.
Here’s an example usage of the array_chunk function:
$input = array('a', 'b', 'c', 'd', 'e');
$chunked_array = array_chunk($input, 2);
print_r($chunked_array);
In this example, the original array was split into smaller arrays of size 2, resulting in a new array containing three sub-arrays.
Conclusion
Arrays are a powerful data structure in PHP, and understanding how to manipulate them is crucial for effective programming. The array functions you have learned in this article are just a small sample of what is available in PHP. By leveraging these functions, you can simplify complex operations on arrays and make your code more efficient and readable. Whether you are a seasoned PHP developer or just starting out, mastering these array functions will undoubtedly take your coding skills to the next level.
If you have any questions or thoughts to share, use the comment form below to reach us.
