Configuring PHP

Last day, we introduced PHP and gave a bit of its history. Today, we explore it in depth.
PHP should be installed and running on your machines as of HW1.
PHP can be run either using the Apache module, from the command line, or using the built-in web-server that comes with PHP (> 5.4.4).

From the command line:

php name_of_script.php #runs name_of_script.php

cd ~/public_html 
php -S localhost:8000 #starts built-in web server on port 800
    # using current dir as document root

You can fine-tune how PHP runs by editing the file php.ini
A ';' is used to indicate a comment in this file.
The most common thing for people to change is to have a line:
```
short_open_tag = On
```
so that you can escape to a PHP script using <? rather than <?php
Unfortunately, using the short open tag can mean your script is not as portable so for this class we will leave this off.
Xampp sets things this way by default so for today we will not worry about this. -- Many open source projects prefer long tags for compatibility.
Another common thing to change is the amount of error reporting PHP gives.
By default, it is assumed we are in a production environment so none is given.
For today, we want error-reporting. So find the line:
```
;error_reporting = E_ALL & ~E_NOTICE
```
and uncomment it, restart Apache

General Syntax

Recall a section of PHP code is delimited with <?php ... code here ...?>
The command include("filename.php"); can be used to include one document in another.
If the filename.php can't be found the script continues. To cause the script to fail in this case, you could use require("filename.php");
To prevent multiple inclusions of the same file you could use include_once, or require_once.
All variables in PHP begin with a $ sign. Names of variables are otherwise like in Perl or other common programming languages.
PHP can use either Perl, C++, or C comments: #, //, /* ... */
PHPDoc is a common source code documentor for PHP.
The Pear Coding Guidelines are a useful standard for the formatting of PHP code.

Primitives

PHP has four scalar types: Boolean, integer, double, and string.
There are also two compound types: array and object and two special types: resource and NULL.
As with Javascript and Perl, PHP is dynamically typed: it has no type definitions.
An unassigned variable is sometimes called an unbound variable and has value NULL. This can be coerced to one of the other types depending on the context.
To check if a variable is currently bound you can use the isset($variable_name) function. This returns TRUE or FALSE (one of the two Boolean values, case-insensitive).
You can also call error_reporting(-1), to set PHP's error reporting level to report all errors, warnings, notices, etc. so that it prints unbound variables.

Integer, String, and Boolean Type

Integers in PHP correspond to C long's (signed), so their size depends on the size of a long on a given machine.
This is usually 32 bits.
PHP's double type corresponds to C's double and literals follow the format for C (or Perl or Javascript) floating point literals: I.e., .345, 3E-7, etc.
Characters in PHP are single bytes (No Unicode! -- we'll talk about how to fake later).
String literals are built up out of these characters.
PHP distinguishes between single quote and double quote literals in the same way that Perl does. So the variable in "Bob=$bob" is interpolated but in 'Bob=$bob' is not.
There are only two values for Boolean's: TRUE or FALSE. As for coercion, the empty string or a "0" or a "0.0" is interpreted as FALSE. Otherwise, strings evaluate to TRUE. Integers and double evaluate to TRUE as long as they aren't zero.

Arithmetic Operators,etc

PHP supports the usual arithmetic operators: +, -, *, /, %, ++, --.
PHP also does type coercion.
Division should be assumed to output a double if any fractional value exists.
Some useful predefined functions are: floor, ceil, round, srand, rand, abs, min, and max.
String concatenation is done with a period: "string1". "string2" is "string1string2".
Some useful string operations are strlen, strcmp, strpos, substr, chop, trim, ltrim, strtolower, strtoupper.
Type conversion can be done using expressions like (int)$sum or intval($sum) or settype($sum, integer).
You can also check the type with is_int, is_integer, is_long, etc.
Assignment operators are like in C, Java, etc.

Quiz

Which of the following statements is true?

In CSS external style settings cannot be overridden by inline styles.
Margin, border, and padding are all components of the box model.
id selectors are used only to style the id attributes of anchor tags.

Output

You can output text from PHP interpretive mode into the page using either of the commands: print or echo For example,
```
<p> A paragraph. Let's hop into interpretive mode: <?php
print "hi there"; ?> back to copy mode </p>
```

In addition, to single and double quotes, you can use Heredocs and Nowdocs to output longer strings:

$a = "hello";
//Heredocs
$str = <<<EOD
This string that lives
on multiple lines uses heredocs
syntax. $a interpolation happens 
EOD;
echo $str;
//Nowdocs
$str2 = <<<'EOD2'
$a interpolation doesn't happens
EOD2;
echo $str2;

You can buffer copy mode data and get it as a string:

<?php
ob_start();
?>
<p>Hello World</p>
<?php
$out = ob_get_clean();
$out = strtolower($out);
echo $out;
?>

PHP also has useful functions for printing out the values of variables and arrays: var_dump, print_r.

Control Statements

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 = array("hi", array(1,2), 2);
$c = array("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";}

More on PHP Arrays

Arrays in PHP are similar to Perl hashes.
The above way to create $arr can also be written in PHP as:
```
$arr = array( 0=> 1, 1=>2, 2=>3);
```
Like hashes we can do things like
```
$arr = array("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= array(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); /*acts like split except here the first
 argument is a string rather than a regular expression. 
 So words is an array("this", "is", "a", "string"). PHP has a split function 
 but not as fast, since arg might be a regular expression. */
$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 = array("San Jose", "San Diego");
echo current($cities); // prints San Jose
$another = next($cities); // $another is now San Diego;
```
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 = array("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.
We saw last day that one can iterate through arrays using foreach($arr as $val){...} PHP also supports code like
```
$lows = array("Mon" => 23, "Tue" => 18);
foreach($lows as $day =>$temp )
{echo "$day lows were $temp";} 
```

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 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){...}
```

PHP Data Types and Functions

Outline