Array Operators in PHP: Interesting but Less Spoken

Share this article

Operators in PHP can be organized into seven different categories: arithmetic, assignment, bitwise, comparison, error control, execution, incrementing/decrementing, logical, string, array, and type operators. This article details working with array operators, but also covers how some of the other operators work when used with arrays.

Array Operators

The official documentation provides just a quick description of each of the array operators, which sometimes can make it ambiguous as to what to expect from which each operator. Let’s take a look at each of the array operators for a much clearer understanding of what they do. All these operators are binary, that is each operates on exactly two arrays.

Array Union

First is the union operator (+) which gives the union of two arrays based on the arrays’ keys. It does loose key matching and all keys of the second array are ignored if their equivalent key already exists in the first array. The rest of the keys (and the corresponding values) of the second array are appended to the first.
<?php
$array1 = array('a', 'b', 'c');
$array2 = array('d', 'e', 'f', 'g', 'h', 'i');
print_r($array1 + $array2);
print_r($array2 + $array1);
Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => g
    [4] => h
    [5] => i
)
Array
(
    [0] => d
    [1] => e
    [2] => f
    [3] => g
    [4] => h
    [5] => i
)
With the first print_r(), the first three elements in $array2 have keys that already exist in $array1, so ‘d’, ‘e’, and ‘f’ are ignored in the resulting array. With the second print_r(), all of the keys of $array1 already exist in array $array2 so all of its elements are ignored. The loose matching behavior may give you totally unexpected results, but also opens up exciting opportunities for optimization and loose coding.
<?php
$array1 = array('0' => 'a', '1' => 'b', '2' => 'c', '3' => 'd');
$array2 = array(false => 'e', 1 => 'f', 2 => 'g', 3 => 'h', 4 => 'i');
print_r($array1 + $array2);
Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => i
)
It is often misunderstood that the union is based on the array values, while in reality this operator implements the union of array keys. For value-based union, you can use a combination of array_merge() and array_unique():
<?php
$union = array_unique(array_merge($array1, $array2));
print_r($union);
Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => e
    [5] => f
    [6] => g
    [7] => h
    [8] => i
)

Array Equality

The equality operator (==) checks whether two arrays are similar. The operator returns true if all key-value pairs in first array have equivalent key-value pairs in the second array. It matches values and keys loosely and the sequence of elements is ignored.
<?php
$array1 = array('1' => 1, '2' => 2, '3' => 3, '0' => 0);
$array2 = array(false => '0', 1 => '1', 2 => '2', 3 => '3');
var_dump($array1 == $array2);
bool(true)
The sequence of elements in the two arrays is different, but the same values are tied to similar keys in each array. However, the following are not equivalent because both arrays have different key value pairs:
<?php
$array1 = array(1, 2);
$array2 = array(2, 1);
var_dump($array1 == $array2);
bool(false)
The inequality operator (!= or <>) checks whether two arrays are not similar, and is a perfect opposite of the equality operator. Anything that the equality operator returns false for, this operator returns true, and vice versa.
<?php
$array1 = array('1' => 1, '2' => 2, '3' => 3, '0' => 0);
$array2 = array(false => '0', 1 => '1', 2 => '2', 3 => '3');
var_dump($array1 != $array2);
bool(false)

Array Identity

The identity operator (===) checks if two arrays are identical. The arrays are identical if both arrays:
  • have the same number of elements
  • have the same key-value pairs
  • have the same sequence of elements
  • have the same data type of all corresponding values
However, for array keys, the identity operator matches loosely if a key is an integer and a similar string notation of the integer exists as a key in the other array. For a float vs. string key match, this operator goes strict. The PHP manual does not clarify this difference.
<?php
// arrays are almost identical but keys have different types
$array1 = array('0' => '0', '1' => '1', '2' => '2', '3' => '3');
$array2 = array(0 => '0', 1 => '1', 2 => '2', 3 => '3');
var_dump($array1 === $array2);
bool(true)
<?php
// the sequence of elements in both arrays is not the same
$array1 = array('0' => '0', '1' => '1', '2' => '2', '3' => '3');
$array2 = array(1 => '1', 2 => '2', 3 => '3', 0 => '0');
var_dump($array1 === $array2);
bool(false)
<?php
// the key in the first array is a string and in the second is a float
$array1 = array('0.5' => '0');
$array2 = array(0.5 => '0');
var_dump($array1 === $array2);
bool(false)
The non-identity operator (!==) checks if two arrays are not identical. Again, this operator is the exact opposite of the identity operator, which means this operator returns false for a comparison of arrays if they are identical.
<?php
$array1 = array('0' => '0', '1' => '1', '2' => '2', '3' => '3');
$array2 = array(0 => '0', 1 => '1', 2 => '2', 3 => '3');
var_dump($array1 !== $array2);
bool(false)

Using Arrays with Other Operators

PHP behaves differently when operators other than those mentioned above are applied to arrays. Here is a list of those operators and the behavior when they are applied to arrays.

Fatal Error: Unexpected Operand Type

PHP issues a fatal error when the following operators are applied to arrays:
  • bitwise-not operator (~)
  • arithmetic negation Operator (-)
  • arithmetic subtraction operator (-)
  • arithmetic multiplication operator (*)
  • arithmetic division operator (/)

Arrays Treated as Integers

Arrays are treated as integers when used with the following operators. An empty array (with no elements) is considered as int(0) and non-empty arrays are considered int(1).
  • Logical-not (!) returns true for an empty array and false when the operand array has one or more elements.
  • Bitwise-and (&) returns 1 if both of its operands are non-empty and 0 if one or both of its operands are empty.
  • Bitwise-or (|) returns 0 if both of its operands are empty, otherwise it returns 1.
  • Bitwise-xor (^) returns 0 if both arrays are either empty or filled. If one of the arrays is empty, it returns 1.
  • Shifting an array n-steps to the left with the left-shit operator (<<) returns the integer equivalent of 1 << n if the array is non-empty. Otherwise it returns 0 (the outcome of 0 << n).
  • The right-shift operator (>>) has similar behavior as left-shift except that it shifts rightward.
  • Modulus (%) returns true if both of the arrays are non-empty. If the second array is empty, it issues a “Division by Zero” error. If the first array is empty, it returns 0 (the result of 0 % 1).
  • Logical-and (&& and AND) return false if any of the arrays are empty. If both arrays are non empty, it returns true.
  • Logical-or (|| and OR) return true if any of the operand arrays are non-empty. If both arrays are empty, it returns false.
  • If both of the arrays are either empty or non empty, logical-xor (XOR) returns false. Otherwise, it returns true if one of the arrays is empty.
  • Casting an array to bool gives false if the array is empty, otherwise true.

Arrays Treated as Strings

When concatenating two arrays, the string concatenation operator (.) takes each array as the string “Array” and concatenates these strings.
<?php
$array1 = array(0, 1, 2, 3);
$array1 = array(0, 1, 2, 3);
var_dump($array1 . $array2);
string(10) "ArrayArray"

No Effect

The incrementing/decrementing category of operators (++ and --) have no impact on arrays.
<?php
$array1 = $array2;
var_dump((++$array1) === $array2);
bool(true)

Conclusion

The actual documentation on how PHP’s operators behave when used with arrays is sparse, but for more information you can look at the user submitted comments in the array operators page. Your questions and comments are welcome here too, and I shall happily explain things further. Image via Fotolia

Frequently Asked Questions (FAQs) about Array Operators in PHP

What are the different types of array operators in PHP?

PHP supports several types of array operators, including Union (+), Equality (==), Identity (===), Inequality (!= or <>), and Non-Identity (!==). Each of these operators performs a different function. For instance, the Union operator (+) combines arrays, the Equality operator (==) checks if two arrays are equal, and the Identity operator (===) checks if two arrays are identical.

How does the Union (+) operator work in PHP?

The Union (+) operator in PHP merges two arrays into one. It takes the union of arrays, meaning that it returns an array containing all the elements from both arrays. If the arrays have the same string keys, then the value from the first array will be used and the matching key’s value from the second array will be ignored.

What is the difference between the Equality (==) and Identity (===) operators?

The Equality (==) operator checks if two arrays have the same key/value pairs, regardless of their order or data types. On the other hand, the Identity (===) operator checks if two arrays have the same key/value pairs in the same order and of the same data types.

How does the Inequality (!= or <>) operator work in PHP?

The Inequality operator in PHP, represented by either != or <>, checks if two arrays are not equal. It returns true if the arrays are not equal and false if they are equal.

What does the Non-Identity (!==) operator do in PHP?

The Non-Identity (!==) operator in PHP checks if two arrays are not identical. It returns true if the arrays are not identical and false if they are identical.

Can you combine array operators in PHP?

Yes, you can combine array operators in PHP to perform more complex operations. However, you should be careful when doing so to avoid unexpected results. Always ensure that the combined operators make logical sense in the context of your code.

How can I check if an array contains a specific value using array operators?

You can use the in_array() function in PHP to check if an array contains a specific value. This function returns true if the value is found in the array and false otherwise.

How can I remove a specific value from an array in PHP?

You can use the array_diff() function in PHP to remove a specific value from an array. This function compares the values in an array against the values in another array and returns the differences.

How can I sort an array in PHP?

PHP provides several functions to sort arrays, including sort(), asort(), ksort(), and usort(). Each of these functions sorts an array in a different way, so you should choose the one that best fits your needs.

How can I reverse the order of an array in PHP?

You can use the array_reverse() function in PHP to reverse the order of an array. This function returns a new array with the order of the elements reversed.

Hamid SarfrazHamid Sarfraz
View Author

Hamid Sarfraz is a freelance writer and web developer at Page Config with six years of experience in front/back-end development and search engine optimization. Hamid publishes most of his work on his blog and occasionally writes for PHPMaster.com.

Intermediate
Share this article
Read Next
Get the freshest news and resources for developers, designers and digital creators in your inbox each week
Loading form