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.
PHP is dynamically typed: it has no type declarations (we will see we can type hint object later).
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).
empty($variable_name) can be used for isset($variable_name) && $variable_name != null.
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.
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 to decide whether to do variable interpolation.
```
$bob = 6;
echo "Bob=$bob"; // outputs Bob=6 
echo 'Bob=$bob'; // outputs Bob=$bob
```
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.

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>
```

To echo a variable into a large copy mode section, one use the syntax <?= ... ?>. For example,

<p> A paragraph. Let's hop into interpretive mode to echo 
the variable $foo: <?= $foo ?> 
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";
if ($a) {
   print "hello";
   print "there";
}
if ($a) {
   $b = 1;
   echo  $b;
} else if ($b) {
   $b = 2;
   echo $b;
} else {
   $c = 1;
   echo $c;
}
//switch case:
switch($a)
{
   case 5:
      echo "hello";
      /* if $a matches the label (5 in this case)
         then execute the code after it;
       */
      break; //if hit then jump out of switch
   case "a label made from a string":
      echo "weird labels still work";
      break;
   default:
      echo "if all else fails do this";
}

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

In-class Exercise -- Let's Build Something

Create a PHP file: favorites.php
This file should output in copy mode the start of an XHTML 5 document up to and including a body tag.
The title of the document should be Favorite Songs.
In interpretive mode, output an h1 tag with Favorite Songs.
Then create an array $favorites with your top 5 favorite songs, who sang them, and when they were released.
Using foreach output these songs in a table with a 3mm, dashed border.
Switch back to copy mode to complete your XHTML 5 document closing the appropriate tags.
Post your solution to the Feb 22 Class Thread.

PHP: Datatypes, Control Statements, Arrays