Let us begin by considering the simplest array, which associates each value inside of it with an integer index (starting at 0). The following declares an empty array named days:

$days = array();

To define the contents of an array as strings for the days of the week as shown in Figure 12.12, you declare it with a comma-delimited list of values inside the ( ) braces using either of two following syntaxes:

$days = array("Mon","Tue","Wed","Thu","Fri");
$days = ["Mon","Tue","Wed","Thu","Fri"];     // alternate syntax

In these examples, because no keys are explicitly defined for the array, the default key values are 0, 1, 2, . . . , n–1. Notice that you do not have to provide a size for the array: arrays are dynamically sized as elements are added to them.

Elements within a PHP array are accessed in a manner similar to other programming languages, that is, using the familiar square bracket notation. The code example below echoes the value of our $days array for the key=1, which results in output of Tue.

echo "Value at index 1 is ". $days[1];    // index starts at zero

You could also define the array elements individually using this same square bracket notation:

$days = array();
$days[0] = "Mon";
$days[1] = "Tue";
$days[2] = "Wed";

// alternate approach
$days = [];
$days[] = "Mon";
$days[] = "Tue";
$days[] = "Wed";

In PHP, you are also able to explicitly define the keys in addition to the values. This allows you to use keys other than the classic 0, 1, 2, . . . , n to define the indexes of an array. For clarity, the exact same array defined above and shown in Figure 12.12 can also be defined more explicitly by specifying the keys and values as shown in Figure 12.13.

Figure 12.13 Explicitly assigning keys to array elements

One should be especially careful about mixing the types of the keys for an array since PHP performs cast operations on the keys that are not integers or strings. You cannot have key “1” distinct from key 1 or 1.5, since all three will be cast to the integer key 1.

Explicit control of the keys and values opens the door to keys that do not start at 0, are not sequential, and that are not even integers (but rather strings). This is why you can also consider an array to be a dictionary or hash map. All arrays in PHP are generally referred to as associative arrays. You can see in Figure 12.14 an example of an associative array and its visual representation. In the example in Figure 12.14, the keys are strings (for the weekdays) and the values are temperature forecasts for the specified day in integer degrees.

Figure 12.14 Array with strings as keys and integers as values

As can be seen in Figure 12.14, to access an element in an associative array, you simply use the key value rather than an index:

echo $forecast["Wed"];    // this will output 52

PHP also supports multidimensional arrays. Recall that the values for an array can be any PHP object, which includes other arrays. Listing 12.22 illustrates the creation of several different multidimensional arrays (each one contains two dimensions).

Figure 12.15 illustrates the structure of three of these multidimensional arrays. You will normally encounter the syntax shown in the last three example arrays in Listing 12.1. Notice that individual array elements can have keys, but so can the arrays as a whole.

Figure 12.15 Visualizing multidimensional arrays

$month = array(
array("Mon","Tue","Wed","Thu","Fri"), 
array("Mon","Tue","Wed","Thu","Fri"), 
array("Mon","Tue","Wed","Thu","Fri"), 
array("Mon","Tue","Wed","Thu","Fri") 
); 
echo $month[0][3];    // outputs Thu

$cart = []; 
$cart[] = array("id" => 37, "title" => "Burial at Ornans",  
                "quantity" => 1); 
$cart[] = array("id" => 345, "title" => "The Death of Marat",  
                "quantity" => 1); 
$cart[] = array("id" => 63, "title" => "Starry Night", "quantity" => 1); 
echo $cart[2]["title"];   // outputs Starry Night

$stocks = [
  ["AMZN", "Amazon"],
  ["APPL", "Apple"],
  ["MSFT", "Microsoft"]
];
echo $stocks[2][1];    // outputs Microsoft

$aa = [
  "AMZN" => ["Amazon", 234],
  "APPL" => ["Apple", 342],
  "MSFT" => ["Microsoft", 165]
];
echo $aa["APPL"][0];   // outputs Apple

$bb = [
  "AMZN" => ["name" =>"Amazon", "price" => 234],
  "APPL" => ["name" => "Apple", "price" => 342],
  "MSFT" => ["name" => "Microsoft", "price" => 165]
];
echo $bb["MSFT"]["price"];  // outputs 165

One of the most common programming tasks that you will perform with an array is to iterate through its contents. Listing 12.23 illustrates how to iterate and output the content of the $days array three different ways: using while, do while, and for loops. Each example uses the built-in function count(), which return the number of elements in a given array.

// while loop
$i=0;
while  ($i < count($days)) {
   echo $days[$i] . "<br>";
   $i++;
}

// do while loop
$i=0;
do  {
   echo $days[$i] . "<br>";
   $i++;
}  while  ($i < count($days));

// for loop
for  ($i=0; $i<count($days); $i++) {
   echo $days[$i] . "<br>";
}

The challenge of using the classic loop structures is that when you have non­sequential integer keys (i.e., an associative array), you can’t write a simple loop that uses the $i++ construct. To address the dynamic nature of such arrays, you have to use iterators to move through such an array. This iterator concept has been woven into the foreach loop and its use is illustrated in Listing 12.24.

// foreach: iterating through the values
foreach  ($forecast  as $value) {
   echo $value . "<br>";
}

// foreach: iterating through the values AND the keys
foreach  ($forecast  as $key => $value) {
   echo "day[" . $key . "]=" . $value;
}

print_r($days);

Array ( [0] => Mon [1] => Tue [2] => Wed [3] => Thu [4] => Fri )

In PHP, arrays are dynamic, that is, they can grow or shrink in size. An element can be added to an array simply by using a key/index that hasn’t been used, as shown below:

$days[5] = "Sat";

Since there is no current value for key 5, the array grows by one, with the new key/value pair added to the end of our array. If the key had a value already, the same style of assignment replaces the value at that key. As an alternative to specifying the index, a new element can be added to the end of any array using empty square brackets after the array name, as follows:

$days[] = "Sun";

The advantage to this approach is that we don’t have to worry about skipping an index key. PHP is more than happy to let you “skip” an index, as shown in the following example:

$days = array("Mon","Tue","Wed","Thu","Fri");
$days[7] = "Sat";
print_r($days);

What will be the output of the print_r()? It will show that our array now contains the following:

Array ([0] => Mon [1] => Tue [2] => Wed [3] => Thu [4] => Fri [7] => Sat)

That is, there is now a “gap” in our array indexes that will cause problems if we try iterating through it using the techniques shown in Listing 12.23. If we try referencing $days[6], for instance, an error message will be issued and it will return a null value, which is a special PHP value that represents a variable with no value.

You can also create “gaps” by explicitly deleting array elements using the unset() function, as shown in Listing 12.25.

$days = array("Mon","Tue","Wed","Thu","Fri");

unset($days[2]);
unset($days[3]);
print_r($days); // outputs: Array ( [0] => Mon [1] => Tue [4] => Fri )

$days = array_values($days);
print_r($days);  // outputs: Array ( [0] => Mon [1] => Tue [2] => Fri )

Listing 12.25 also demonstrates that you can remove “gaps” in arrays (which really are just gaps in the index keys) using the array_values() function, which returns a copy of the array passed in using the numerical indexes of 0, 1, 2, . . . .

$oddKeys = array(1 => "hello", 3 => "world", 5 => "!");
if (isset($oddKeys[0])) {
   // The code below will never be reached since $oddKeys[0] is not set!
   echo "there is something set for key 0";
}
if (isset($oddKeys[1])) {
   // This code will run since a key/value pair was defined for key 1
   echo "there is something set for key 1, namely ". $oddKeys[1];
}