learnxinyminutes-docs/php.html.markdown

language	author	author_url
php	Malcolm Fell	http://emarref.net/

PHP

This document describes PHP 5+.

Basic Syntax

All statements must end with a semi-colon; All PHP code must be between tags. PHP can also be configured to respect the short open tags .

Comments

// Two forward slashes start a one-line comment.

# So will a hash (aka pound symbol) but // is more common

/*
     Surrounding text in slash-asterisk and asterisk-slash
     makes it a multi-line comment.
*/

Types

Types are weakly typed 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

// 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
$nowdoc = <<<'END'
Multi line
string
END;
$heredoc = <<<END
Multi line
$sgl_quotes
END; // Nowdoc syntax is available in PHP 5.3.0

// Manipulation
$concatinated = $sgl_quotes + $dbl_quotes;

Compound

// Arrays
$array = array(1, 2, 3);
$array = [1, 2, 3]; // As of PHP 5.4
$string = ["One", "Two", "Three"];
$string[0]; // Holds the value "One";

// Associative arrays, known as hashmaps in some languages.
$associative = ["One" => 1, "Two" => 2, "Three" => 3];
$associative["One"]; // Holds the value 1

Output

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
<?= $variable ?>

Operators

Assignment

$a = 1;
$b = 2;
$a = $b; // A now contains the same value sa $b
$a =& $b; // A now contains a reference to $b. Changing the value of $a will change the value of $b also, and vice-versa.

Comparison

$a == $b // TRUE if $a is equal to $b after type juggling.
$a === $b // TRUE if $a is equal to $b, and they are of the same type.
$a != $b // TRUE if $a is not equal to $b after type juggling.
$a <> $b // TRUE if $a is not equal to $b after type juggling.
$a !== $b // TRUE if $a is not equal to $b, or they are not of the same type.
$a < $b	// TRUE if $a is strictly less than $b.
$a > $b // TRUE if $a is strictly greater than $b.
$a <= $b // TRUE if $a is less than or equal to $b.
$a >= $b // TRUE if $a is greater than or equal to $b.

Type Juggling

Variables can be converted between types, depending on their usage.

$integer = 1;
echo $integer + $integer; // Outputs 2;

$string = '1';
echo $string + $string; // Also outputs 2 because the + operator converts the strings to integers

$string = 'one';
echo $string + $string; // Outputs 0 because the + operator cannot cast the string 'one' to a number

$boolean = (boolean) $integer; // $boolean is true

$zero = 0;
$boolean = (boolean) $zero; // $boolean is false

$integer = 5;
$string = strval($integer); // There are also dedicated functions for casting most types

$var = null; // Null value

Control Structures

If Statements

if (/* test */) {
	// Do something
}

if (/* test */) {
	// Do something
} else {
	// Do something else
}

if (/* test */) {
	// Do something
} elseif(/* test2 */) {
	// Do something else, only if test2
}

if (/* test */) {
	// Do something
} elseif(/* test2 */) {
	// Do something else, only if test2
} else {
	// Do something default
}

<?php if (/* test */): ?>
<!-- Do something that isn't PHP -->
<?php else: ?>
<!-- Do something default -->
<?php endif; ?>

Switch statements

switch ($variable) {
	case 'one':
    	// Do something if $variable == 'one'
        break;
    case 'two':
    case 'three':
    	// Do something if $variable is either 'two' or 'three'
        break;
    default:
    	// Do something by default
}

Loops

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

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.

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.

User-defined

function my_function_name ($arg_1, $arg_2) { // $arg_1 and $arg_2 are required
	// Do something with $arg_1 and $arg_2;
}

// Functions may be nested to limit scope
function outer_function ($arg_1 = null) { // $arg_1 is optional
	function inner_function($arg_2 = 'two') { // $arg_2 will default to 'two'
    }
}

// inner_function() does not exist and cannot be called until outer_function() is called

Variable

$function_name = 'my_function_name';

$function_name(); // will execute the my_function_name() function

Anonymous

Similar to variable functions, functions may be anonymous.

my_function(function () {
	// do something
});

// Closure style
$my_function = function() {
	// Do something
};

$my_function();

Classes

Classes are defined with the class keyword.

class MyClass {
	const MY_CONST = 'value';
    static $staticVar = 'something';
	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.

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 for classes.

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.

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
{
}

Namespaces

By default, classes exist in the global namespace, and can be explicitly called with a backslash.

$cls = new \MyClass();

namespace My\Namespace;

class MyClass
{
}

$cls = new My\Namespace\MyClass;

Or from within another namespace.

namespace My\Other\Namespace;

use My\Namespace\MyClass;

$cls = new MyClass();

Or you can alias the namespace;

namespace My\Other\Namespace;

use My\Namespace as SomeOtherNamespace;

$cls = new SomeOtherNamespace\MyClass();

Traits

Traits are available since PHP 5.4.0 and are declared using the trait keyword.

trait MyTrait {
	public function myTraitMethod()
    {
    	// Do something
    }
}

class MyClass
{
	use MyTrait;
}

$cls = new MyClass();
$cls->myTraitMethod();

More Information

Visit the official PHP documentation for reference and community input.

If you're interested in up-to-date best practices, visit PHP The Right Way.

If you're coming from a language with good package management, check out Composer.