# Using Arrays

• Print
This chapter is from the book

## Multidimensional Arrays

Arrays do not have to be a simple list of keys and values—each location in the array can hold another array. This way, we can create a two-dimensional array. You can think of a two dimensional array as a matrix, or grid, with width and height or rows and columns.

If we want to store more than one piece of data about each of Bob's products, we could use a two-dimensional array.

Figure 3.3 shows Bob's products represented as a two-dimensional array with each row representing an individual product and each column representing a stored product attribute. Figure 3.3 We can store more information about Bob's products in a two- dimensional array.

Using PHP, we would write the following code to set up the data in the array shown in Figure 3.3.

```\$products = array( array( 'TIR', 'Tires', 100 ),
array( 'OIL', 'Oil', 10 ),
array( 'SPK', 'Spark Plugs', 4 ) );```

You can see from this definition that our products array now contains three arrays.

To access the data in a one-dimensional array, recall that we need the name of the array and the index of the element. A two-dimensional array is similar, except that each element has two indices—a row and a column. (The top row is row 0 and the far left column is column 0.)

To display the contents of this array, we could manually access each element in order like this:

```echo '|'.\$products.'|'.\$products.'|'.\$products.'|<br />';
echo '|'.\$products.'|'.\$products.'|'.\$products.'|<br />';
echo '|'.\$products.'|'.\$products.'|'.\$products.'|<br />';```

Alternatively, we could place a for loop inside another for loop to achieve the same result.

```for ( \$row = 0; \$row < 3; \$row++ )
{
for ( \$column = 0; \$column < 3; \$column++ )
{
echo '|'.\$products[\$row][\$column];
}
echo '|<br />';
}```

Both versions of this code produce the same output in the browser:

```|TIR|Tires      |100|
|OIL|Oil        |10 |
|SPK|Spark Plugs|4  |```

The only difference between the two examples is that your code will be shorter if you use the second version with a large array.

You might prefer to create column names instead of numbers as shown in Figure 3.3. To do this, you can use associative arrays. To store the same set of products, with the columns named as they are in Figure 3.3, you would use the following code:

```\$products = array( array( Code => 'TIR',
Description => 'Tires',
Price => 100
),
array( Code => 'OIL',
Description => 'Oil',
Price => 10
),
array( Code => 'SPK',
Description => 'Spark Plugs',
Price =>4
)
);```

This array is easier to work with if you want to retrieve a single value. It is easier to remember that the description is stored in the Description column than to remember that it is stored in column 1. Using associative arrays, you do not need to remember that an item is stored at [x][y]. You can easily find your data by referring to a location with meaningful row and column names.

We do however lose the ability to use a simple for loop to step through each column in turn. Here is one way to write code to display this array:

```for ( \$row = 0; \$row < 3; \$row++ )
{
echo '|'.\$products[\$row]['Code'].'|'.\$products[\$row]['Description'].
'|'.\$products[\$row]['Price'].'|<br />';
}```

Using a for loop, we can step through the outer, numerically indexed \$products array. Each row in our \$products array is an associative array. Using the each() and list() functions in a while loop, we can step through the associative arrays. Therefore, we need a while loop inside a for loop.

```for ( \$row = 0; \$row < 3; \$row++ )
{
while ( list( \$key, \$value ) = each( \$products[ \$row ] ) )
{
echo "|\$value";
}
echo '|<br />';
}```

We do not need to stop at two dimensions—in the same way that array elements can hold new arrays, those new arrays in turn can hold more arrays.

A three-dimensional array has height, width, and depth. If you are comfortable thinking of a two-dimensional array as a table with rows and columns, imagine a pile or deck of those tables. Each element will be referenced by its layer, row, and column.

If Bob divided his products into categories, we could use a three-dimensional array to store them. Figure 3.4 shows Bob's products in a three-dimensional array. Figure 3.4 This three-dimensional array allows us to divide products into categories.

From the code that defines this array, you can see that a three-dimensional array is an array containing arrays of arrays.

```\$categories = array( array ( array( 'CAR_TIR', 'Tires', 100 ),
array( 'CAR_OIL', 'Oil', 10 ),
array( 'CAR_SPK', 'Spark Plugs', 4 )
),
array ( array( 'VAN_TIR', 'Tires', 120 ),
array( 'VAN_OIL', 'Oil', 12 ),
array( 'VAN_SPK', 'Spark Plugs', 5 )
),
array ( array( 'TRK_TIR', 'Tires', 150 ),
array( 'TRK_OIL', 'Oil', 15 ),
array( 'TRK_SPK', 'Spark Plugs', 6 )
)
);```

Because this array has only numeric indices, we can use nested for loops to display its contents.

```for ( \$layer = 0; \$layer < 3; \$layer++ )
{
echo "Layer \$layer<br />";
for ( \$row = 0; \$row < 3; \$row++ )
{
for ( \$column = 0; \$column < 3; \$column++ )
{
echo '|'.\$categories[\$layer][\$row][\$column];
}
echo '|<br />';
}
}```

Because of the way multidimensional arrays are created, we could create four-, five-, or six-dimensional arrays. There is no language limit to the number of dimensions, but it is difficult for people to visualize constructs with more than three dimensions. Most real-world problems match logically with constructs of three or fewer dimensions.