Arrays

Arrays can be declared with the syntax:

$a = array("hi", 1, 2);
//for PHP >= 5.4 you can also use the syntax:
$a = ["hi", 1, 2];

You can nest arrays:

$b = ["hi", [1,2], 2];
$c = ["a" => "c"];

You can dereference arrays as in most languages:
```
echo $a[0]." ".$c['a'];
```

You can cycle over elements of an array using foreach:

foreach($arr as $var){echo $var;}

foreach($assoc_arr as $key => $value){echo "Key $key Value $value";}

To quickly get elements out of arrays you can also use the list syntax:

list($first, $second, ) = $arr; 
//$first will be $arr[0], $second will be $arr[1].

PHP Arrays

Arrays in PHP can in some sense always be viewed as associative.
For example, the array $arr = [1,2,3]; can also be written in PHP as:
```
$arr = [0=> 1, 1=>2, 2=>3];
```
We can do things like:
```
$arr = ["joe"=> 5, "mary" =>6];
```

To get the keys and values we can use the functions:

$keys = array_keys($arr) and $values = array_values($arr);

Arrays can also be created by an assignment:

$barr[1] = 5; // creates array $barr if doesn't exist

If we did the assignment $barr[] = 6; then since the argument to [] wasn't specified PHP will assign $barr[2] = 6;

Yet More on PHP Arrays

You can call the unset function on an element in an array to delete it from the array:
```
$list=[2,4,6,8];
unset($list[2]);
// $list is now [0=>2,1=>4,3=>8]
```
Some useful array functions:
- count($arr) -- returns the number of elements in the array $arr
- is_array($my_var) -- returns whether $my_var contains something of array type
- in_array($elt, $arr) -- does $elt belong to the array $arr
- implode, explode -- unsplit/split arrays into elements
- sort($arr) -- sort an array by value (lots of variant functions in PHP ksort, asort, krsort, arsort, etc)

To see how implode/explode work consider:

$str="this is a string";
$words = explode(" ", $str); /*make an array of tokens 
 of items between consecutive spaces.
 So words is the array ["this", "is", "a", "string"]. */
$str2 = implode(" ", $words); //undoes the explode.

Iterating Through Arrays

The function current($arr) can be used to return a pointer to the current element in an array $arr. The next($arr) function can be used to advance this pointer and get its value:
```
$cities = ["San Jose", "San Diego"];
echo current($cities); // prints San Jose
$another = next($cities); // $another is now San Diego;
```
There are also the functions each, prev, end, and reset to facilitate moving through array.
The function each is similar to next except after advancing the current pointer, it returns the old pointer as a two element array consisting of a key/value pair.

Functions

The general format of a PHP function declaration is:

function nameOfFunction([parameter_list]){ 
/* function definition */}

For example,
```
function inc($i){return ++$i;} 
```
A return value can be sent back using a return call as in many programming languages.
You can modularize your code by putting several function definitions into a file and then use the include (preferably require_once) function to include them into any document that needs those functions.
It is completely fine and sometimes useful to use copy mode in a function:
```
function helloWorld()
{
    ?>
    <h1>Hello World</h1>
    <?php
}
```
Parameters are passed by value. So the function call:
```
$b = inc($a); // leaves the value of $a unchanged
```

You can call by reference by using an ampersand (before php7):

$b = inc(&$a); //here the value of $a is changed (one is added to it).

You can also create functions with pass by reference parameters: function inc(&$i){...}

Variable Scope

The default scope of a variable in PHP is only within the function that it is used. That is local scope:
```
$bob = 5;
function test()
{ 
   $bob = 6; 
   echo $bob; //echo's 6
}
test();
echo $bob; //echo's 5
```
In order to access global variables within a local function one would need to use the global declaration:
```
$bob = 5;
function test()
{
   global $bob; # if did not do bob would be NULL 

   echo $bob; 
}
test();
```
PHP also supports static local variables. These preserve states between function calls:
```
function addone() {
    static $count =0; echo $count++;
}
```

In-Class Exercise

Write a PHP function traverse($tree, $value) which traverses the associative array given $tree and counts the number of elements that appear in this array or its sub-arrays with value $value, and outputs the result.
Write a couple of test cases showing your function in action.
Post your solution to the Sep 23 In-class Exercise Thread.

PHP: Arrays, Functions, Regex, Forms, Files