In this guide, we’ll explore PHP array_slice — a built-in PHP array function that lets you extract a specific portion of an array with precision and flexibility. It is one of the most useful PHP array functions, letting you grab a specific portion of an array for many practical tasks.
If you’re new to PHP, figuring out how to extract part of an array might seem tricky. That’s why this guide is here! We’ll explain how array_slice() works in simple terms and walk you through practical examples to help you understand and start using it with confidence.
What is the array_slice function?
The array_slice() function is the standard PHP way to extract array elements — it lets you specify a starting point and length to pull out exactly the subset you need. It enables you to specify the starting and ending points, providing flexibility in selecting the desired array elements.
What can you achieve with ‘array_slice()’?
Using ‘array_slice()’, you can perform various operations on an array, such as extracting a specific portion of data, creating subsets for further processing, or reorganizing the elements based on specific requirements. This method offers a wide range of applications in PHP programming.
How does ‘array_slice()’ work?
The ‘array_slice()’ method takes in three parameters: the original array, the starting index, and the length of the desired slice. By providing the appropriate values for these parameters, you can easily extract the desired subset of the array.
Syntax:
array_slice(array, offset, length, preserve_keys)
Let’s discuss the parameters that the array_slice method accepts
- array: It’s a required parameter that contains the array from which a slice will be extracted.
- offset: Another required integer parameter indicates the slice’s numeric index/starting index.
- length: It is an optional integer parameter and defines the length of the slice/extracted new array. If no value is passed, the extracted array will contain elements from the offset index to the end of the original array.
- preserve_keys: Another optional parameter that defines where the index of elements in the extracted array should be preserved or not. You can pass boolean values; true means the index will be preserved, and vice-versa for false. By default, its value is false.
This function returns an output of the array data type.
You are confused. Well, don’t worry. Go through the below-listed examples, and most of your queries will be answered automatically.
PHP array_slice Examples: 4 Practical Use Cases
#1: Array slicing with Just the required parameters.
<?php
// Sample array
$shades = array("deep red", "lemon green", "sky blue", "baby pink", "magenta yellow", "matte black");
// Slicing the shades array
$res = array_slice($shades, 2);
print_r($res);
?>
In the above example, the array_slice function extracts all the elements starting from index two, i.e., sky blue, till the last element of the $shades array because the length of the slice is not defined. Also, the index of the elements will reset as the preserve_keys parameter is not specified.
Output:
Array
(
[0] => sky blue
[1] => baby pink
[2] => magenta yellow
[3] => matte black
)
#2: Array Slicing with Specified Length
<?php
//sample array
$nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
//array slicing with length 4
$slice = array_slice($nums, 3, 4);
print_r($slice);
?>
Copy
In the above example, we have an array $nums containing integers from 1 to 10. We are extracting 4 elements starting from index 3 (value 4). Using the array_slice() function with the parameters $nums, 3, and 4, we will get an array of elements [4, 5, 6, 7]. The resulting slice is then printed using print_r(). Array_slice return a new array containing the slice/extracted elements without modifying the original array.
Output:
Array
(
[0] => 4
[1] => 5
[2] => 6
[3] => 7
)
3: PHP Array Slice with preserve_keys — Keep Original Index
<?php
//sample array
$firstNames = ['John', 'Sarah', 'Michael', 'Emily', 'David', 'Emma'];
//slicing the array
$slice = array_slice($firstNames, 2, 3, true);
print_r($slice);
?>
In the above example, the preserve keys parameter is passed as true and as a result, the output array would retain the original index of the elements.
Output:
Array
(
[2] => Michael
[3] => Emily
[4] => David
)
#4: Array Slicing with Negative Value Parameters
<?php
//sample array
$studentdetails = [
['name' => 'John', 'age' => 20, 'grade' => 'A'],
['name' => 'Sarah', 'age' => 18, 'grade' => 'B'],
['name' => 'Michael', 'age' => 19, 'grade' => 'A'],
['name' => 'Emily', 'age' => 21, 'grade' => 'B'],
['name' => 'David', 'age' => 22, 'grade' => 'C'],
['name' => 'Emma', 'age' => 20, 'grade' => 'A']
];
//slicing array
$slice = array_slice($studentdetails, 0, -4);
print_r($slice);
?>
In the above example, $studentdetails is the input array storing a list of student records. Each record is an array with name, age and grade as keys. We have passed a negative integer as the location parameter and 0 as the offset parameter. In the output, the resulting array will have all elements starting with index 0 in the $studentdetails till index 4 from the end of the array, excluding the fourth element as well.
Also Read:
Laravel Blade: How to Check if a @yield is Empty (Modern Guide)
Output:
Array
(
[0] => Array
(
[name] => John
[age] => 20
[grade] => A
)
[1] => Array
(
[name] => Sarah
[age] => 18
[grade] => B
)
)
Tips and Best Practices while working with the array_slice function
Empty Array: Often, developers pass an empty array as the input array in the function, resulting in an array with no elements. It is strongly suggested to use a check before calling the function. Handling Negative Parameters: While passing negative integers value in the offset and length parameters, you must ensure that the offset parameter value is always smaller than the length of the slice. Otherwise, you will be getting an empty array. Example:
<?php
//sample array
$nums = [10, 20, 30, 40, 50, 60];
//array slicing with length 4
$slice = array_slice($nums, -4, -3);
$revslice = array_slice($nums, -4, -6);
print_r($slice);
print_r($revslice);
?>
Output:
Array
(
[0] => 30
)
Array
(
)
Conclusion
PHP array_slice() is a valuable tool for array manipulation — by mastering it alongside other PHP array functions, you’ll handle data extraction cleanly and efficiently. By mastering its usage and understanding its various parameters, you will enhance your ability to work with arrays effectively and efficiently. In the following sections, we will provide detailed examples and explanations to solidify your understanding of this powerful array manipulation function.