Understand Arrays in PHP

In this post, you'll learn the basics of what is an array in PHP. You'll learn how to create an array and how to use associative and multidimensional arrays, and you'll see lots of examples of arrays values with PHP in action.

What Is an Array in PHP?

In PHP, an array is a data structure which allows you to store multiple elements in a single variable. These elements are stored as key-value pairs. In fact, you can use an array whenever there’s a need to store a list of elements. More often than not, all the items in an array have similar data types.

For example, let’s say you want to store fruit names. Without an array, you would end up creating multiple variables to store the different fruit names. On the other hand, if you use an array to store fruit names, it might look like this:

1	<?php
2	$array_fruits = array('Apple', 'Orange', 'Watermelon', 'Mango');
3	?>

As you can see, we’ve used the $array_fruits variable to store the different fruit names. One great thing about this approach is that you can add more elements to the $array_fruits array variable later on.

There are plenty of ways to manipulate array values in PHP—we’ll explore these in the later part of this article.

How to Initialize an Array

In this section, we’ll explore how to initialize an array variable in PHP and add values in that variable.

When it comes to array initialization, there are a few different ways. In most cases, it’s the array() language construct which is used to initialize an array.

1	<?php
2	$array = array();
3	?>

In the above snippet, the $array variable is initialized with a blank array.

As of PHP 5.4, you can also use the following syntax to initialize an array.

1	<?php
2	$array = [];
3	?>

Now, let’s see how to add elements to an array in this PHP array data structure:

<?php 
$array = []; 
$array[] = 'One'; 
$array[] = 'Two'; 
$array[] = 'Three'; 
echo '<pre>'; 
print_r($array); 
?> 

The above snippet should produce the following output:

1	Array
2	(
3	[0] => One
4	[1] => Two
5	[2] => Three
6	)

The important thing to note here is that array indices in PHP start with 0. Whenever you add a new element to an array without specifying an index, the array assigns an index automatically.

Of course, you can also create an array already initialized with values. This is the most concise way to declare an array with PHP if you already know what values it will have.

1	<?php
2	$array = ['One', 'Two', 'Three'];
3	?>

How to Access Array Elements

In the previous section, we discussed how to initialize an array variable. In this section, we’ll explore a few different ways to access array elements.

The first obvious way to access array elements is to fetch them by the array key or index.

<?php 
$array = ['One', 'Two', 'Three']; 
 
// get the first element of the $array array  
echo $array[0]; 
echo "<br>"; 
 
// get the second element of the $array array  
echo $array[1]; 
echo "<br>"; 
 
// get the third element of the $array array  
echo $array[2]; 
echo "<br>"; 
?> 

The above snippet should produce the following output:

1	One
2	Two
3	Three

A cleaner way to write the code above is to use a foreach loop to iterate through the array elements.

<?php 
$array = ['One', 'Two', 'Three']; 
 
foreach ($array as $element) { 
 echo $element; 
 echo '<br>'; 
} 
?> 

The above snippet should produce the same output, and it takes much less code.

Similarly, you can also use the for loop to go through the array elements.

<?php 
$array = ['One', 'Two', 'Three']; 
$array_length = count($array); 
 
for ($i = 0; $i < $array_length; ++$i) { 
 echo $array[$i]; 
 echo '<br>'; 
} 
?> 

Here, we're using the for loop to go through each index in the array and then echoing the value stored in that index. In this snippet, we’ve introduced one of the most important functions you’ll end up using while working with arrays: count. It’s used to count how many elements are in an array.

Types of Array in PHP

In this section, we’ll discuss the different types of array you can use in PHP.

Numerically Indexed Arrays

An array with the numeric index falls in the category of an indexed array. In fact, the examples we’ve discussed so far in this article are indexed arrays.

The numeric index is assigned automatically when you don’t specify it explicitly.

1	<?php
2	$array = ['One', 'Two', 'Three'];
3	?>

In the above example, we don't specify an index for each item explicitly, so it'll be initialized with the numeric index automatically.

Of course, you can also create an indexed array by using the numeric index, as shown in the following snippet PHP structure:

<?php 
$array = []; 
$array[0] = 'One'; 
$array[1] = 'Two'; 
$array[2] = 'Three'; 
?> 

It is also possible to have arrays with numeric keys which are not sequential or start from zero, like the following example:

1	<?php
2
3	$array = [];
4	$array[3] = 'One';
5	$array[11] = 'Two';
6	$array[] = 'Three';
7	$array[-18] = 'Four';
8	$array[] = 'Five';
9
10	print_r($array);
11	/*
12	Array
13	(
14	[3] => One
15	[11] => Two
16	[12] => Three
17	[-18] => Four
18	[13] => Five
19	)
20	*/
21	?>

Don't rely on an unknown array in PHP to have sequential numeric keys unless you explicitly set its keys to be that way.

Associative Arrays

An associative array is similar to an indexed array, but you can use string values for array keys.

Let’s see how to define an associative array.

<?php 
$employee = [ 
 'name' => 'John', 
 'email' => 'john@example.com', 
 'phone' => '1234567890', 
]; 

Alternatively, you can use the following syntax as well.

<?php 
$employee = []; 
$employee['name'] = 'John'; 
$employee['email'] = 'john@example.com'; 
$employee['phone'] = '1234567890'; 
?> 

To access values of an associative array, you can use either the index or the foreach loop.

<?php 
$employee = [ 
 'name' => 'John', 
 'email' => 'john@example.com', 
 'phone' => '1234567890', 
]; 
 
// get the value of employee name  
echo $employee['name']; 
 
// get all values  
foreach ($employee as $key => $value) { 
 echo $key . ':' . $value; 
 echo '<br>'; 
} 
?> 

As you can see, here we got the name by querying it directly, and then we used the foreach loop to get all the key-value pairs in the array.

Multidimensional Arrays

In the examples we’ve discussed so far, we’ve used scalar values as array elements. In fact, you can even store arrays as elements within other arrays—this is a multidimensional array.

Let’s look at this PHP array example:

<?php 
$employee = [ 
 'name' => 'John', 
 'email' => 'john@example.com', 
 'phone' => '1234567890', 
 'hobbies' => ['Football', 'Tennis'], 
 'profiles' => ['facebook' => 'johnfb', 'twitter' => 'johntw'] 
]; 
?> 

As you can see, the hobbies key in the $employee array holds an array of hobbies. In the same way, the profiles key holds an associative array of the different profiles.

Let’s see how to access values of a multidimensional array.

<?php 
$employee = [ 
 'name' => 'John', 
 'email' => 'john@example.com', 
 'phone' => '1234567890', 
 'hobbies' => ['Football', 'Tennis'], 
 'profiles' => ['facebook' => 'johnfb', 'twitter' => 'johntw'] 
]; 
 
// access hobbies  
echo $employee['hobbies'][0]; 
// Football  
 
echo $employee['hobbies'][1]; 
// Tennis  
 
// access profiles  
echo $employee['profiles']['facebook']; 
// johnfb  
 
echo $employee['profiles']['twitter']; 
// johntw  
?> 

As you can see, the elements of a multidimensional array can be accessed with the index or key of that element in each array part.

Unpacking Array Values with PHP

Starting from version 7.4, PHP has added the ability to expand arrays in place using the spread (...) operator.

<?php 
 
$plant_eaters = ["Horse", "Goat", "Rabbit"]; 
$meat_eaters = ["Lion", "Tiger", "Crocodile"]; 
 
$animals = ["Dog", ...$plant_eaters, ...$meat_eaters, "Cat"]; 
print_r($animals); 
/*  
Array  
(  
 [0] => Dog  
 [1] => Horse  
 [2] => Goat  
 [3] => Rabbit  
 [4] => Lion  
 [5] => Tiger  
 [6] => Crocodile  
 [7] => Cat  
)  
*/ 
 
?> 

Initially, we could only unpack array values in PHP with numeric keys. However, PHP 8.1 came with support for unpacking arrays with string keys. Here are some examples:

<?php 
 
$default_colors = ["body" => "red", "heading" => "blue", "sidebar" => "yellow"]; 
$user_colors = ["body" => "white", "paragraph" => "black"]; 
 
$theme_colors = [...$default_colors, ...$user_colors]; 
 
print_r($theme_colors); 
/*  
Array  
(  
 [body] => white  
 [heading] => blue  
 [sidebar] => yellow  
 [paragraph] => black  
)  
*/ 
 
?> 

You should note that array unpacking in this manner results in overwriting existing values stored in string-based keys, while numeric keys simply get renumbered. Unpacking $user_colors before $default_colors in the above example would have set the value of the body key to "red" in the $theme_colors array.

Some Useful PHP Array Functions

In this section, we'll go through a handful of useful array functions that are used frequently for array operations.

The `count()` Function

The count() function is used to count the number of elements in an array. This is often useful if you want to iterate an array with a for loop.

<?php 
$array = ['One', 'Two', 'Three']; 
 
echo count($array); 
// Output: 3  
?> 

However, you should be careful when looping over an array with a for loop. This is because there is no guarantee that the numeric keys in an array will always be sequential, start from zero, or be in simple ascending order.

The `is_array()` Function

This is one of the most useful functions for dealing with arrays. It's used to check if a variable is an array or some other data type.

<?php 
$array = ['One', 'Two', 'Three']; 
 
// check if the variable is an array  
if (is_array($array)) 
{ 
 // perform some array operation  
} 
?> 

You should always use this function before you perform any array operation if you're uncertain of the data type.

The `in_array()` Function

If you want to check if an element exists in the array, it's the in_array() function which comes to the rescue.

<?php 
$array = ['One', 'Two', 'Three']; 
 
// check if a variable is an array  
if (in_array('One', $array)) 
{ 
 echo 'Yes'; 
} 
else 
{ 
 echo 'No'; 
} 
?> 

The first argument of the in_array() function is an element which you want to check, and the second argument is the array itself.

The `explode()` Function

The explode() function splits a string into multiple parts and returns it as an array. For example, let's say you have a comma-separated string and you want to split it at the commas.

<?php 
$string = "One,Two,Three"; 
 
// explode a string by comma  
$array = explode(",", $string); 
 
// output should be an array  
echo '<pre>'; 
print_r($array); 
 
// output  
/*Array  
(  
 [0] => One  
 [1] => Two  
 [2] => Three  
)*/ 
?> 

The first argument of the explode() function is a delimiter string (the string you're splitting on), and the second argument is the string itself.

The `implode()` Function

This is the opposite of the explode() function—given an array and a glue string, the implode() function can generate a string by joining all the elements of an array with a glue string between them.

<?php 
$array = ['One', 'Two', 'Three']; 
 
$string = implode(",", $array); 
 
// output should be a string  
echo $string; 
 
// output: One,Two,Three  
?> 

The first argument of the implode() function is a glue string, and the second argument is the array to implode.

The `array_push()` Function

The array_push() function is used to add new elements to the end of an array.

<?php 
$array = ['One', 'Two', 'Three']; 
array_push($array, 'Four'); 
 
echo '<pre>'; 
print_r($array); 
 
// output  
/*Array  
(  
 [0] => One  
 [1] => Two  
 [2] => Three  
 [3] => Four  
)*/ 
?> 

The first argument is an array, and the subsequent arguments are elements that will be added to the end of an array.

The `array_pop()` Function

The array_pop() function removes an element from the end of an array.

<?php 
$array = ['One', 'Two', 'Three']; 
$element = array_pop($array); 
 
echo '<pre>'; 
print_r($array); 
 
// output  
/*Array  
(  
 [0] => One  
 [1] => Two  
)*/ 
?> 

The array_pop() function returns the element which is removed from an array, so you can pull it into the variable. Along with array_push(), this function is useful for implementing data structures like stacks.

The `array_slice()` Function

The array_slice() function is useful when you want to extract some portion of a given array. It accepts four parameters: the array, the index from which to slice, the number of elements to slice, and whether to preserve the numerical key. The function will always preserve string keys, irrespective of the fourth parameter.

<?php 
 
$people = ["Adam", "Amanda", "Andrew", "Laura", "Monty", "Sally", "Sajal", "Steven"]; 
 
$members = array_slice($people, 2, 4); 
print_r($members); 
/*  
Array  
(  
 [0] => Andrew  
 [1] => Laura  
 [2] => Monty  
 [3] => Sally  
)  
*/ 
?> 

The offset value can also be negative. In that case, the slicing position will be determined from the end of the array.

The `array_splice()` Function

Th array_splice() function is useful when you want to get rid of a portion of an array and/or replace it with something else. It also accepts four parameters: the array, the offset index from which to begin the removal, the length to remove, and an optional replacement for the removed values.

<?php 
 
$all_items = ["Charger", "Keyboard", "Smartphone", "Baseball", "Bat", "Mouse"]; 
$replacements = ["Pen", "Headphones"]; 
 
array_splice($all_items, 3, 2, $replacements); 
print_r($all_items); 
/*  
Array  
(  
 [0] => Charger  
 [1] => Keyboard  
 [2] => Smartphone  
 [3] => Pen  
 [4] => Headphones  
 [5] => Mouse  
)  
*/ 
?> 

That's It—Now You Know What an Array in PHP is!

That's all you need to know to get you started coding with arrays in PHP. You saw how to create arrays and how to retrieve elements from them. You learned the different types of arrays in PHP, and you got a look at some of the most useful built-in PHP functions for working with arrays.

Editorial Note: This post has been updated with contributions from Gonzalo Angulo. Gonzalo is a staff writer with Envato Tuts+.

Understand Arrays in PHP

What Is an Array in PHP?

How to Initialize an Array

How to Access Array Elements

Types of Array in PHP

Numerically Indexed Arrays

Associative Arrays

Multidimensional Arrays

Unpacking Array Values with PHP

Some Useful PHP Array Functions

The count() Function

The is_array() Function

The in_array() Function

The explode() Function

The implode() Function

The array_push() Function

The array_pop() Function

The array_slice() Function

The array_splice() Function