All statements must end with a semi-colon; All PHP code must be between <?php and ?> tags. PHP can also be configured to respect the [short open tags](http://www.php.net/manual/en/ini.core.php#ini.short-open-tag) <? and ?>.
Types are [weakly typed](http://en.wikipedia.org/wiki/Strong_and_weak_typing) and begin with the $ symbol. A valid variable name starts with a letter or underscore, followed by any number of letters, numbers, or underscores.
### Scalars
```php
// Boolean values are case-insensitive
$boolean = true; // or TRUE or True
$boolean = false; // or FALSE or False
// Integers
$integer = 1234; // decimal number
$integer = -123; // a negative number
$integer = 0123; // octal number (equivalent to 83 decimal)
$integer = 0x1A; // hexadecimal number (equivalent to 26 decimal)
// Floats (aka doubles)
$float = 1.234;
$float = 1.2e3;
$float = 7E-10;
// Arithmetic
$sum = $number + $float;
$difference = $number - $float;
$product = $number * $float;
$quotient = $number / $float;
// Shorthand arithmetic
$number += 1; // Will add 1 to $number
$number++; // Will add 1 to $number after it is used
++$number; // Will add 1 to $number before it is used.
$number /= $float // Will divide $number $float, and assign the quotient to $number
// Strings
$sgl_quotes = 'String'; // Strings should be enclosed in single quotes;
$dbl_quotes = "This is a $sgl_quotes." // Avoid using double quotes to embed other variables
$escaped = "This contains a \t tab character."; // Escape special characters with backslash
$money = "I have $${integer} in the bank." // Enclose a variable in curly braces if needed
echo('Hello World!'); // Prints Hello World! to stdout. Stdout is the web page if running in a browser.
print('Hello World!'); // The same as echo
echo 'Hello World!'; // echo is actually a language construct, so you can drop the parentheses.
echo 100;
echo $variable;
echo function_result(); // Output the result of a function call that returns a value. More on functions later.
// If [short open tags](http://www.php.net/manual/en/ini.core.php#ini.short-open-tag) are configured, or your PHP version is 5.4.0 or greater, you can use the short echo syntax
// Do something if $variable is either 'two' or 'three'
break;
default:
// Do something by default
}
```
### Loops
```php
$i = 0;
while ($i <5){
echo $i++;
}
$i = 0;
do {
echo $i++;
} while ($i <5);
for ($x = 0; $x <10;$x++){
echo $x; // Will echo 0 - 9
}
$wheels = ["bicycle" => 2, "car" => 4];
foreach ($wheels as $vehicle => $wheel_count) {
echo "A $vehicle has $wheel_count wheels";
}
// This loop will stop after outputting 2
$i = 0;
while ($i <5){
if ($i == 3) {
break; // Exit out of the while loop and continue.
}
echo $i++;
}
// This loop will output everything except 3
$i = 0;
while ($i <5){
if ($i == 3) {
continue; // Skip this iteration of the loop
}
echo $i++;
}
```
## Functions
Functions are created with the ```function``` keyword.
```php
function my_function($my_arg) {
$my_variable = 1;
}
// $my_variable and $my_arg cannot be accessed outside of the function
```
Functions may be invoked by name.
```php
my_function_name();
$variable = get_something(); // A function may return a value
```
A valid function name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. There are three ways to declare functions.
public $property = 'value'; // Properties must declare their visibility
}
echo MyClass::MY_CONST; // Outputs "value";
final class YouCannotExtendMe {
}
```
Classes are insantiated with the ```new``` keyword. Functions are referred to as methods if they belong to a class.
```php
class MyClass {
function myFunction() {
}
function function youCannotOverrideMe()
{
}
public static function myStaticMethod()
{
}
}
$cls = new MyClass(); // The parentheses are optional.
echo MyClass::$staticVar; // Access to static vars
echo $cls->property; // Access to properties
MyClass::myStaticMethod(); // myStaticMethod cannot be run on $cls
```
PHP offers some [magic methods](http://www.php.net/manual/en/language.oop5.magic.php) for classes.
```php
class MyClass {
private $property;
public function __get($key)
{
return $this->$key;
}
public function __set($key, $value)
{
$this->$key = $value;
}
}
$x = new MyClass();
echo $x->property; // Will use the __get() method to retrieve the value of $property
$x->property = 'Something'; // Will use the __set() method to set the value of property
```
Classes can be abstract (using the ```abstract``` keyword), extend other classes (using the ```extends``` keyword) and implement interfaces (using the ```implements``` keyword). An interface is declared with the ```interface``` keyword.
```php
interface InterfaceOne
{
public function doSomething();
}
interface InterfaceTwo
{
public function doSomething();
}
abstract class MyAbstractClass implements InterfaceOne
{
}
class MyClass extends MyAbstractClass implements InterfaceTwo
{
}
// Classes can implement more than one interface
class SomeOtherClass implements InterfaceOne, InterfaceTwo
