PHP Spread Operator encapsulates the idea that the operator is a syntax or language feature in PHP, and it conveys the spreading or expanding nature of its functionality when used with arrays or function arguments.

In this article, we will explore the various examples of the PHP spread operator, investigating its potential to optimize your code for enhanced efficiency.

PHP Spread Operator ( Unpack Array )

Firstly, let’s understand how to write its syntax.

Understanding the PHP Spread Syntax

In PHP, the ellipsis (...) is used for unpacking elements from arrays or traversable objects. This behavior is often referred to as the “splat” operator. It allows you to expand an array or iterable into individual elements. The primary use cases include function arguments and array literals.

Here’s the syntax:


Let’s explore more examples of the PHP spread operator.

Unpack Arrays using PHP Spread Operator

We can explore how to use the PHP spread operator for unpacking arrays. This process involves expanding the elements of an array into a new one. Such a technique becomes particularly useful when you want to combine two or more arrays into a single array. For instance, consider the following code:


$array1 = [1, 2, 3];
$array2 = [4, 5, 6];
$combinedArray = [...$array1, ...$array2];

In this example, the spread operator is employed to unpack both $array1 and $array2 into a new array named $combinedArray. The resulting array contains all the elements of both arrays, maintaining the order in which they were unpacked.

As you may know, in PHP, objects are similar to arrays in their structure. While arrays can use the spread operator, objects generally cannot use it unless they implement specific interfaces. Let’s delve into why objects may not directly support the spread operator.

Why the PHP Spread Operator Fails with Objects

The answer lies in the way PHP handles objects and arrays. In PHP, arrays are considered to be ordered maps, where each element is associated with a key. On the other hand, objects are instances of a class and can have properties and methods. When the spread operator is used with an array, PHP takes the array and expands it into separate elements while maintaining their original order intact.

However, when it comes to objects, PHP does not have a defined order for properties and methods. This makes it difficult to expand them in a meaningful way.

Furthermore, employing the spread operator with objects can result in unintended consequences. For example.


class Foo {
    public $bar = 'Hello';

$obj = new Foo();
$arr = ['world'];

$newArr = [...$obj, ...$arr]; // Cannot unpack an object of class Foo

In this example, we attempt to use the spread operator to merge the object $obj and the array $arr.

However, as the object does not have a defined order for its properties, PHP will throw a fatal error, stating ‘Cannot unpack an object of class Foo‘.

However, you can utilize the get_object_vars function to obtain an array of an object’s properties and their values. Subsequently, you may use the spread operator to unpack the array into another array if necessary. Here’s an example:


class Foo {
    public $bar = 'Hello';

$obj = new Foo();
$arr1 = get_object_vars($obj);
$arr2 = ['world'];

$newArr = [...$arr1, ...$arr2];
print_r($newArr); // [[bar] => Hello, [0] => world]

How can the spread operator be used with array references? Let’s delve further into this concept in the upcoming section.

Unpacking Arrays Using References

To use the spread operator with an array reference, you can simply include the reference variable before the spread operator. Here’s an example:

$array = [1, 2, 3];
$ref =& $array; // create a reference to $array
$result = [...$ref, 4, 5]; // use spread operator with $ref

// Output: Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 )

In this example, we create an array $array and then establish a reference $ref to it using the & operator. Subsequently, we employ the spread operator with $ref to unpack the array values into a new array, $result. The resulting array contains not only the values from $array, but also includes the values 4 and 5

Note that any changes made to $array will also affect $result since they both point to the same underlying array.

One more thing: if you use the reference directly with the PHP spread operator, it will show you an error similar to the example below:

$array = [1, 2, 3]; 
$result = [...&$array , 4, 5]; 

The output:

Parse error: syntax error, unexpected token “&” in index.php

Moreover, let’s move to the paragraph below to learn how to use the spread operator within function parameters.

Use the PHP Spread Operator as a Function Parameter

The PHP spread operator ... can be used as a function parameter to unpack an array or iterable into individual arguments. This allows for more flexible and concise function calls, as well as easier manipulation of arrays.

To use the spread operator as a function parameter, you simply place it before the array or iterable variable name in the function call. For example.

function myFunction($arg1, $arg2, $arg3) {
  // function code here

Typically, you would have to pass three separate values as arguments:

myFunction(1, 2, 3);

However, using the spread operator allows you to pass an array of values and have them automatically unpacked as individual arguments:

$array = [1, 2, 3];

This is particularly useful when working with variable-length argument lists, as you can easily pass in an array of any length and have it unpacked into the function call.

Let’s move on to the following section to understand how to use type hinting with the spread operator.

Using PHP Spread Operator with Type Hinting

The PHP spread operator with type hinting is a feature introduced in PHP 8.0. This enables you to pass an array or iterable as distinct arguments to a function or method. While also enforcing the type of the individual elements being passed.

The syntax for using the spread operator with type hinting is as follows:

function myFunction(Type ...$params) {
  // function body

In this example, the ...$params syntax, known as the spread operator, allows you to pass multiple arguments to the function, where each argument is an element of an array or iterable.

The type in the parameter list serves as a type hint, specifying the type of the individual elements being passed in the array or iterable. For instance, you could specify int, string, float, or any other valid PHP data type

When calling the function, you can pass an array or iterable as the argument, and the spread operator will automatically expand the array or iterable into individual arguments. For example:


In this case, $myArray could be an array or iterable containing elements of the specified type, and the spread operator will expand each element into individual arguments for the function.

Wrapping Up

With the spread operator, you can effortlessly combine, extract, and manipulate data from arrays without the need for complex code or loops. This significantly reduces the amount of code, making it more manageable and easier to debug.

A key advantage of the spread operator is its capability to pass an arbitrary number of arguments to a function or method, eliminating the need to define each argument individually. This feature saves time and effort by allowing you to pass multiple arguments in a single operation.

The PHP spread operator stands as a valuable asset in the PHP programming language, enhancing developers’ productivity and improving code readability. Its versatility simplifies code and enhances efficiency, whether working with arrays or functions.