Overview

Last Wednesday we started talking about PHP.
We said it was created by Ramus Lerdorf in 1993 and that it is used by many of the top 10 internet websites as well as more than 20 million unique domains.
The web site for PHP is https://www.php.net/ and its manual is at https://php.net/manual/en/index.php.
There is more than one implementation of PHP. The most common is available at php.net of which the most recent version is PHP 7.4.
Facebook's hhvm is an alternative implementation to PHP that runs at speeds comparable to PHP 7. It also interprets the Hack language -- a typed variant of PHP. hhvm is used by Facebook and Wikipedia.
A web server determines that a page is PHP usually by looking for one of the extensions .php, .php3, .phtml
When called from the web server on a PHP page, the PHP processor takes a PHP document and starts processing in one of two modes.
When it sees XHTML it simply copies it to the output. (Copy mode).
When it sees PHP code it executes the code and writes the result to the output.(Interpretive mode)
PHP is typically interpreted but it also can be precompiled.
The syntax of PHP is closely related to Perl and Javascript.

Configuring PHP

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
php -a # run in enter interactive mode. will get a prompt...
php > echo "hello world";
hello world
php > quit
cd ~/public_html 
php -S localhost:8000 #starts built-in web server on port 8000
    # 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 alphanumeric and underscore strings beginning with a dollar sign: $my_var, $fooFOO1999, etc. The first character after the $ is not allowed to be numeric.
PHP can use either Perl, C++, or C comments: #, //, /* ... */
PHPDoc is a common source code documentor for PHP.
The PHP Framework Interoperability Group publishes many useful standard for PHP code. Two useful one are: PSR-1: Basic Coding Standard and PSR-2: Coding Style Guide.

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.

Quiz

Which of the following statements is true?

Only style attributes of one class selector are ever applied to an element.
The CSS border attribute cannot be used to control the width of the border of an element.
When the CSS position property is set to fixed for an element, it won't move when the browser window is scrolled.

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

PHP: Datatypes, Control Statements, Arrays

Outline