Control Statements

On Monday, we started introducing the PHP language. We learned a little about its history and configuration. We also learned about its copy and interpretive mode, its types, literals, operators, and outputing mechanisms. Today, we start by looking at some of its control structures.

PHP supports: if, elseif, else if, else: For example,

//if
if($a) print "hello";
//switch case:
switch($a)
{
   case 5:
      echo "hello";
}

for:

for($a = 0; $a<10; $a++){echo "hello $a";}

while:
```
while(!$var) { /*do something*/}
```
do while:
```
do {/*do something */} while (!$var);
```
To make it easier to switch back and forth between copy and interpretive mode PHP has an alternative format for control statements illustrated by:
```
<?php if ($the_world_is_round == true): ?>
The word is not flat.
<?php endif; ?>
```

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].

More on 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 the element in an array: $list=[2,4,6,8]; unset($list[2]);
Some useful array functions: count -- returns the number of elements in an array, is_array, in_array, implode, explode, sort.

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 can be used to return a pointer to the current element in an array. The next 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 functions is:
```
function name([parameter]){...}
```
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.
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:

$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");
```
would split on one or more white space characters.
There are also function preg_match, preg_match_all that let you find matches to regular expressions.
There is a preg_replace that let's you substitute regex matches with a string 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 and 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.

Let's Build Something

Create a PHP script, message.php which would live under your web server's document root, and would be run when you visited the url in your browser corresponding to http://your-websvers-url/message.php.

This script initially outputs a form with a labeled text field and a submit button. The label says: "Enter your message here:".

When a user submits the form, it outputs a page with heading "Words Seen". Beneath this it outputs each word seen in the submitted text field data, each in a separate div tag.

Beneath this it has a link back to the form page.

Your code should use the following template code and is not allowed to output anything or have any control while in the global scope.

<?php
function messageController()
{
   //decide which view to use and set up data for output
}
function formView($data)
{
   // $data has any data set up from the controller
   //outputs the message form
}
function seenWordsView($data)
{
   //outputs seen words, allowed a foreach loop and to
   //echo variables. Not allowed to call preg_ functions or explode
}
messageController();

Post your solution to the Feb 24 Class Thread.

PHP: Control Statements, Functions, Regex Patterns, Forms

Outline