PHP Manual
Prev | Chapter 7. Types | Next

# Arrays

An array in PHP is actually an ordered map. A map is a type that maps values to keys. This type is optimized in several ways, so you can use it as a real array, or a list (vector), hashtable (which is an implementation of a map), dictionary, collection, stack, queue and probably more. Because you can have another PHP-array as a value, you can also quite easily simulate trees.

Explanation of those structures is beyond the scope of this manual, but you'll find at least one example for each of those structures. For more information about those structures, we refer you to external literature about this broad topic.

## Syntax

### Specifying with array()

An array can be created by the array() language-construct. It takes a certain number of comma-separated ``key` => `value`` pairs.

A `key` is either an integer or a string. If a key is the standard representation of an integer, it will be interpreted as such (i.e. `"8"` will be interpreted as `8`, while `"08"` will be interpreted as `"08"`).

A value can be anything.

If you omit a key, the maximum of the integer-indices is taken, and the new key will be that maximum + 1. As integers can be negative, this is also true for negative indices. Having e.g. the highest index being `-6` will result in being `-5` the new key. If no integer-indices exist yet, the key will be `0` (zero). If you specify a key that already has a value assigned to it, that value will be overwritten.

Using `true` as a key will evalute to integer `1` as key. Using `false` as a key will evalute to integer `0` as key. Using `NULL` as a key will evaluate to an empty string. Using an emptry string as key will create (or overwrite) a key with an empty string and its value, it is not the same as using empty brackets.

You cannot use arrays or objects as keys. Doing so will result in a warning: `Illegal offset type`.

    array( [key =>] value
         , ...
         )
    // key is either string or nonnegative integer
    // value can be anything

### Creating/modifying with square-bracket syntax

You can also modify an existing array, by explicitly setting values.

This is done by assigning values to the array while specifying the key in brackets. You can also omit the key, add an empty pair of brackets ("`[]`") to the variable-name in that case.

    $arr[key] = value;
    $arr[] = value;
    // key is either string or nonnegative integer
    // value can be anything

If `$arr` doesn't exist yet, it will be created. So this is also an alternative way to specify an array. To change a certain value, just assign a new value to it. If you want to remove a key/value pair, you need to unset() it.

## Useful functions

There are quite some useful function for working with arrays, see the array-functions section.

> Note: The unset() function allows unsetting keys of an array. Be aware that the array will NOT be reindexed.

>     $a = array( 1 => 'one', 2 => 'two', 3 => 'three' );
>     unset( $a[2] );
>     /* will produce an array that would have been defined as
>        $a = array( 1=>'one', 3=>'three');
>        and NOT
>        $a = array( 1 => 'one', 2 => 'three');
>     */

The foreach control structure exists specifically for arrays. It provides an easy way to traverse an array.

## Array do's and don'ts

### Why is `$foo[bar]` wrong?

You should always use quotes around an associative array index. For example, use $foo['bar'] and not $foo[bar]. But why is $foo[bar] wrong? You might have seen the following syntax in old scripts:

    $foo[bar] = 'enemy';
    echo $foo[bar];
    // etc

This is wrong, but it works. Then, why is it wrong? The reason is that this code has an undefined constant (bar) rather than a string ('bar' - notice the quotes), and PHP may in future define constants which, unfortunately for your code, have the same name. It works, because the undefined constant gets converted to a string of the same name.

As stated in the syntax section, there must be an expression between the square brackets ('`[`' and '`]`'). That means that you can write things like this:

    echo $arr[ foo(true) ];

This is an example of using a function return value as the array index. PHP knows also about constants, and you may have seen the `E_*` before.

    $error_descriptions[E_ERROR] = "A fatal error has occured";
    $error_descriptions[E_WARNING] = "PHP issued a warning";
    $error_descriptions[E_NOTICE] = "This is just an informal notice";

Note that `E_ERROR` is also a valid identifier, just like `bar` in the first example. But the last example is in fact the same as writing:

    $error_descriptions[1] = "A fatal error has occured";
    $error_descriptions[2] = "PHP issued a warning";
    $error_descriptions[8] = "This is just an informal notice";

because `E_ERROR` equals `1`, etc.

Then, how is it possible that `$foo[bar]` works? It works, because `bar` is due to its syntax expected to be a constant expression. However, in this case no constant with the name `bar` exists. PHP now assumes that you meant `bar` literally, as the string `"bar"`, but that you forgot to write the quotes.

#### So why is it bad then?

At some point in the future, the PHP team might want to add another constant or keyword, and then you get in trouble. For example, you already cannot use the words `empty` and `default` this way, since they are special reserved keywords.

> Note: When you turn error_reporting to `E_ALL`, you will see that PHP generates notices whenever an `index` is used which is not defined (put the line `error_reporting(E_ALL);` in your script).

> Note: Inside a double-quoted string, an other syntax is valid. See variable parsing in strings for more details.

## Examples

The array type in PHP is very versatile, so here will be some examples to show you the full power of arrays.

    // this
    $a = array( 'color' => 'red'
              , 'taste' => 'sweet'
              , 'shape' => 'round'
              , 'name'  => 'apple'
              ,            4        // key will be 0
              );

    // is completely equivalent with
    $a['color'] = 'red';
    $a['taste'] = 'sweet';
    $a['shape'] = 'round';
    $a['name'] = 'apple';
    $a[]        = 4;        // key will be 0

    $b[] = 'a';
    $b[] = 'b';
    $b[] = 'c';
    // will result in the array array( 0 => 'a' , 1 => 'b' , 2 => 'c' ),
    // or simply array('a', 'b', 'c')

Example 7-4. Using array()
    // Array as (property-)map
    $map = array( 'version'    => 4
                , 'OS'         => 'Linux'
                , 'lang'       => 'english'
                , 'short_tags' => true
                );

    // strictly numerical keys
    $array = array( 7
                  , 8
                  , 0
                  , 156
                  , -10
                  );
    // this is the same as array( 0 => 7, 1 => 8, ...)

    $switching = array(         10 // key = 0
                      , 5    =>  6
                      , 3    =>  7
                      , 'a'  =>  4
                      ,         11 // key = 6 (maximum of integer-indices was 5)
                      , '8'  =>  2 // key = 8 (integer!)
                      , '02' => 77 // key = '02'
                      , 0    => 12 // the value 10 will be overwritten by 12
                      );

    // empty array
    $empty = array();

Example 7-5. Collection
    $colors = array('red','blue','green','yellow');

    foreach ( $colors as $color ) {
        echo "Do you like $color?\n";
    }

    /* output:
    Do you like red?
    Do you like blue?
    Do you like green?
    Do you like yellow?
    */

Note that it is currently not possible to change the values of the array directly in such a loop. A workaround is the following:

Example 7-6. Collection
    foreach ($colors as $key => $color) {
        // won't work:
        //$color = strtoupper($color);

        //works:
        $colors[$key] = strtoupper($color);
    }
    print_r($colors);

    /* output:
    Array
    (
        [0] => RED
        [1] => BLUE
        [2] => GREEN
        [3] => YELLOW
    )
    */

This example creates a one-based array.

Example 7-7. One-based index
    $firstquarter  = array(1 => 'January', 'February', 'March');
    print_r($firstquarter);

    /* output:
    Array
    (
        [1] => 'January'
        [2] => 'February'
        [3] => 'March'
    )
    */

Example 7-8. Filling real array
    // fill an array with all items from a directory
    $handle = opendir('.');
    while ($file = readdir($handle))
    {
        $files[] = $file;
    }
    closedir($handle);

Arrays are ordered. You can also change the order using various sorting-functions. See array-functions for more information.

Example 7-9. Sorting array
    sort($files);
    print_r($files);

Because the value of an array can be everything, it can also be another array. This way you can make recursive and multi-dimensional arrays.

Example 7-10. Recursive and multi-dimensional arrays
    $fruits = array ( "fruits"  => array ( "a" => "orange"
                                         , "b" => "banana"
                                         , "c" => "apple"
                                         )
                    , "numbers" => array ( 1
                                         , 2
                                         , 3
                                         , 4
                                         , 5
                                         , 6
                                         )
                    , "holes"   => array (      "first"
                                         , 5 => "second"
                                         ,      "third"
                                         )
                    );

Prev | Home | Next
Strings | Up | Objects