More on PHP Arrays

Last week, we were talking about PHP arrays. Today, we start by finishing off this discussion...

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 -- split/unsplit 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.

Quiz

Which of the following statements is true?

A PHP script starts in interpretive mode.
Bob is a legal PHP variable name. Its default value would be 0.
One could echo the elements of a PHP array $arr with the following code:
```
foreach ($arr as $var) {
   echo $var;
}
```

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:

<?php
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++;}
```

Pattern Matching

PHP supports Perl-style regular expression and POSIX regular expressions. For example,
```
$fruits = preg_split("/\s+/", "apples oranges   banana");
//notice the extra spaces between oranges and banana.
```
would split on one or more white space characters. So in this case, $fruits = ['apples', 'oranges', 'banana'].
There are also functions
```
int preg_match ( string $pattern , string $subject [, array &$matches 
    [, int $flags = 0 [, int $offset = 0 ]]] )

int preg_match_all ( string $pattern , string $subject [, array &$matches 
    [, int $flags = PREG_PATTERN_ORDER [, int $offset = 0 ]]] )
```
that let you find matches to regular expressions. In the above, [] arguments are optional. preg_match returns 1 (if pattern found), 0 otherwise. preg_match_all returns the number of matches or false if the pattern is not found. If a variable $matches is supplied to the function call, then it will be populated with either the first match found in preg_match case, or all matches in preg_match_all case. $flags controls the format of how $matches will be populated, and $offset says at what character to begin the search in $subject.
There is a preg_replace($pattern, $replacement, $subject) function that let's you substitute regex $pattern matches with a string $replacement of your choice.

Types of web forms

Recall a basic web form looks like:

<form method="get" action="script.php">
   <input type="text" name="my_textfield" 
       size="10" />
   <input type="hidden" name="secret_data"
      value="do not peak" />
   <input type="submit" name="sendform"
      value="Send this Form" />
</form>

The method can be get or post.

The get method sends the fields as urlencoded name=value pairs appended to the URL:

script.php?my_textfield=hello&secret_data=do%20not%20peak&sendform=Send%20this%20Form

Post variables are sent as part of the content of an HTTP POST command (you won't see this in URL bar)

File upload forms must use post and in addition must set an encoding type:

<form method="post" action="script.php" enctype="multipart/form-data">
<input type="file" name="my_file" />...</form>

Built-in Globals

PHP makes available several important global variables which are useful for server side scripts.
The phpinfo() function can be used to find out all of these globals.
Here are some of the main ones:

$_SERVER
an array of information about the server like $_SERVER["SERVER_NAME"], $_SERVER ["DOCUMENT_ROOT"], $_SERVER ["QUERY_STRING"], etc

$_ENV
an array of info about the runtime environment: $_ENV["PATH"], $_ENV["PWD"], etc.

$_REQUEST
an array of the variables that have been get'd or post's from forms. So if $_SERVER["QUERY_STRING"] was hi=there&hi2=there2 would have $_REQUEST["hi"] == "there" and $_REQUEST["hi2"]="there2";

$_GET
like $_REQUEST but only for get'd variables

$_POST
like $_REQUEST but for post'd variables
PHP can be configured with register_globals = On, in which case the variable $hi would be a global with value "there". This is a bit risky security-wise.

File Reading

Since PHP is a server side technology it is allowed to create, read, and write files on the server's filesystem.

To open a file for reading one can do:

$file_handle = fopen("my.dat", "r"); 
$file_string = fread($file_handle, filesize("my.dat"));
fclose($file_handle);

Here fread reads in its second parameter many bytes.

To read in a single line from a file one can use:

$line = fgets($file_handle, $max_num_bytes_line);

Alternatively, one can read the whole file in as a string using a single command like:
```
$string = file_get_contents("my.dat");
```
Similarly, sometimes it is useful to read in the whole file as an array of lines:
```
$lines = file("my.dat"); 
```

File Writing

File writing can be done in a similar fashion to file reading in PHP.

$fileHandle = fopen("my.dat", "w");  // use "a" for append
fwrite($fileHandle, $out_data);
fclose($fileHandle);

One can also write out a whole file based on a string using:
```
file_put_contents("out.dat", $str);
```

PHP: Finish Arrays, Functions, Regex, Forms, Files

Outline