PHP Cheat Sheet
Overview
PHP is a dynamic language, running with PHP processor (interpretor). Similar to ASP, PHP uses pseudo tag <?php
/ ?>
to signify PHP code in the middle of HTML content. This once was a famous style in ASP but it failed eventually when dealing with large scale project since it can hardly be designed in modules.
According to PHP document, close tag ?>
can be omitted so guarantee no extra blank on the end of document.
Help!
- php.net - get help of any PHP functions and language spec.
Module
Import other PHP code
include "otherfile.php";
include_once "otherfile.php";
require "otherfile.php";
require_once "otherfile.php";
require
throws an exception if file is not found while include
just warns with a message.
Module in PHP can *return value*. One can retrieve return value from module by assigning it to a variable.
$value = require_once "somefile.php";
Assuming that somefile.php
has return
command at its global scope.
More detail, see PHP include document.
Language Spec
Comments
//
C style line comment/* block style */
#
shell style line comment
Data Types
- boolean - e.g.
False
,True
. Boolean literal is case-insensitive.- Equality:
$a == $b
- Inequality:
$a !== $b
- Implicit coercion:
0
,"0"
,""
,NULL
,array()
,NaN
are treated asFalse
- Equality:
- integer - e.g.
123
,0123
(octal),0x123
(hex-decimal),0b1101
(binary),(int) 1.23
(type cast),intval(1.23)
(conversion function).- Integer size is platform dependent!!
- float - e.g.
1.23
,1.2e3
,NaN
.- float size is platform dependent. Though, double-size floating point is usually used.
- string - also representing array of bytes!! e.g.
"Hello"
,'hello'
,"Hello $name, $greeter->greet!"
(string interpolation)- single-quote string does not expand escape sequence (e.g.
\n
) and not interpolate string. - PHP string is mutable.
$name[0] = 32
is valid.{}
can be used instead of[]
. e.g.$name{0} = 32
- Since representation of string is not clear, there are a lot of string-related functions that assume string in different forms. Some functions work only single-bye array. Some works with unicode. Some works with
locale
setting. Better check function document before using them. :( - support "heredoc/nowdoc" string. The token used after
<<<
must be valid PHP identifier (i.e. alphabetics or underscore).
- single-quote string does not expand escape sequence (e.g.
$show_var = 'name';
$name = 'RZ';
$heredoc = <<<TOKEN
multi-line texts.
Support string interpolation with variable: ($name), ${name}, or {${$show_var}}.
TOKEN;
$nowdoc = <<<'TOKEN'
This is like single-quote string. No $name expansion.
TOKEN;
- Associative array - e.g.
array(1,2,3,4,5)
,array("aa" => 1000, "bb" => 2000)
(as Hash!!)- PHP >= 5.4, square bracket form can be used: e.g.
[1,2,3]
,["aa" => 1000, "bb" => 2000]
. - index
[]
has its own meaning. e.g.$a[] = 123;
is to append123
into the array. - String index if containing only digits will be converted to number! So
$a['5']
is the same as$a[5]
. - As being associative, index can be changed by explicit a key.
- PHP >= 5.4, square bracket form can be used: e.g.
$a = [1,2,3, 10 => 4, 5, 6];
echo $a[10]; // got 4
echo $a[11]; // got 5
- Object - see Class section below.
- PHP Object is like Javascript Object where it is opened for modification (and headache).
- Resource - This is likely a system handle used in interop (e.g. C/C++ library).
- null -
NULL
is case-insensitive keyword.
Type casting
According to Type Juggling document, following casts are possible:
(int)
,(integer)
- cast to integer(bool)
,(boolean)
- cast to boolean(float)
,(double)
,(real)
- cast to float(string)
- cast to string(array)
- cast to array(object)
- cast to object(unset)
- cast toNULL
(PHP 5)
Common Operators
var_dump($a)
dumping value of a variable.print_r($a)
print "human-readable" of a var.
String
.
(concatenate) e.g."Hello" . " " . "World"
Array
array_diff($a,$b)
- return all members in$a
which is not in$b
.range(1,5)
- is equivalent to writing[1,2,3,4,5]
. First parameter is begin number. The last parameter is end number.unset
unset array index or remove array entirely. e.g.unset($a[6])
,unset($a)
.
Object
$a instanceof ClassA
-instanceof
checks whether an instance$a
can be up-casted to typeClassA
. Note thatinstanceof
can also be used with interface.
Variables
All variables in PHP is prefixed with $
, e.g. $x
.
Reference variable
A variable can become a reference variable by referring to other variable with &
(ampersand).
$a = 123;
$b = &$a; // $b is now a reference variable
$b = 456; // $a now contains 456
Predefined variables
Check out PHP: Predefined Variables document for more detail.
echo $_SERVER['REQUEST_TIME']; // print server's request time.
Global reference in function
global
(case-insensitive) is a keyword to refer outer variable inside a function. $GLOBALS
array can also be used!
$x = 1;
function changex() {
global $x;
$x += 1;
// or
$GLOBALS['x'] += 1;
}
Static variable in function
static
(case-insentive) is a keyword to make a local storage inside a function. Static initializer must always be a constant value.
function counter() {
static $count = 0;
static $invalid = 1 + 1; // error, assignment with an expression.
return ($count += 1);
}
Dynamic variable reference (aka Variable Variables)
Variable variables is a way to indirectly refer to a variable.
$a = 123;
$name = 'a';
var_dump($$name); // show content of $a
$$name = 456; // now $a is 456.
Class property can also be referenced similarly.
class C {
var $a = 123;
}
$c = new C;
$name = 'a';
$c->$name = 555;
$c->{'name'} = 555; // using expression
echo $c->a; // show 555
Array unpack (PHP 5.5)
$a = [1,2,3];
list($x,$y,$z) = $a; // $x = 1, $y = 2, $z = 3
list
is a helper keyword to indicate array unpack operation. This feature can also be used in foreach.
Constant
define("PI", 3.141);
// or
const PI1 = 3.141; // PHP >= 5.3
echo PI; // note that no $ needed.
echo constant("PI"); // same as using PI directly.
Note, PHP < 5.6 only boolean, integer, float, and string can be declared as constant.
To check whether a constant has been defined, use defined()
.
defined('PI') || define('PI', 3.141); // defined PI if it has not been defined.
Predefined Constants
See also: http://php.net/manual/en/language.constants.predefined.php
__LINE__
- The current line number of the file.__FILE__
- The full path and filename of the file with symlinks resolved. If used inside an include, the name of the included file is returned.__DIR__
- The directory of the file. If used inside an include, the directory of the included file is returned. This is equivalent todirname(__FILE__)
. This directory name does not have a trailing slash unless it is the root directory.__FUNCTION__
- The function name.__CLASS__
- The class name. The class name includes the namespace it was declared in (e.g.Foo\Bar
). Note that as of PHP 5.4__CLASS__
works also in traits. When used in a trait method,__CLASS__
is the name of the class the trait is used in.__TRAIT__
- The trait name. The trait name includes the namespace it was declared in (e.g.Foo\Bar
).__METHOD__
- The class method name.__NAMESPACE__
- The name of the current namespace.
Operators
- Ternary operator:
$a? $b : $c
.
Namespace (PHP 5.3)
... see
Function
Anonymous function
$f = function($x) { echo "Hello $x\n"; };
$f('Rux');
To refer variable outside its function scope, declare with use
:
$bad_global = 'Hello';
$f = function() use ($bad_global) { echo $bad_global; };
$f();
Named function
All PHP functions are global.
function my_func($param1, $param2, $option = true) {
return $param1 + $param2;
}
Just like Javascript, a function exists to be called only if its declaration gets executed!
if (false) {
function mystery() {
echo 'I cannot be called!';
}
}
Variable-length argument list
(PHP 5.6)
function print_to(&$buffer, ...$options) {
foreach($options as $opt)
$buffer += $opt;
}
$b = "";
print_to($b, 1,2,3);
function sum($x, $y){
return $x + $y;
}
$p = [123, 456];
echo sum(...$p); // unpack function arguments
(PHP < 5.6)
function print_to(&$buffer) {
if (func_num_args() > 1) {
foreach(func_get_args() as $opt)
$buffer += $opt;
}
}
Type Declaration/Annotation (PHP 5.0)
More info see Function Arguments.
function add(int $x, int $y): int {
return $x + $y;
}
Callback / Variable function
Functions can be indirectly called with a string variable:
function myprint(){
echo "hello";
}
$any_code = 'myprint';
call_user_func($any_code);
$any_code(); // Variable function
Object method can be indirectly called with an array:
class A {
static function static_say() {
echo 'hello from static';
}
function say() {
echo 'hello from instance';
}
}
$x = new A;
$instance = [$x, 'say'];
$static_x = ['A', 'static_say'];
call_user_func($instance);
$instance(); // PHP 7(?)
call_user_func($static_x);
$static_x(); // PHP 7(?)
call_user_func('A::static_say'); // PHP >= 5.2.3
class B extends A {}
call_user_func('B', 'parent::static_say'); // PHP >= 5.3
See also: Variable Function.
Code Control
if-else
if ($x > 0) {
echo "greater than 0"
}
elseif ($x == 0) {
echo "equal 0"
}
else {
echo "less than 0"
}
// or...
if ($x > 0):
echo "greater than 0"
elseif ($x == 0):
echo "equal 0"
else:
echo "less than 0"
endif;
switch
switch($x) {
case 1: echo '1'; break;
default: echo 'not 1'; break;
}
C-style for loop
for($var = 1; $var < 10; ++$var) {
echo "$var\n";
}
foreach
To iterate values in an array:
$a = [1,2,3];
foreach($a as $value) {
echo "$value\n";
}
To iterate key/value pairs:
$a = [1 => 'Hello', 2 => 'World'];
foreach($a as $key => $value) {
echo "$key => $value\n";
}
C-style while loop
while(True) {
echo "Infinite.\n";
}
do {
echo 'Infinite\n';
continue;
break;
} while(True);
Goto (PHP 5.3)
function goto_demo(){
goto just_wanna_jump;
echo "Do NOT use GOTO!!!";
just_wanna_jump:
echo 'OK';
}
Execution Directive
See http://php.net/manual/en/control-structures.declare.php
Exception
try {
function();
} catch(Exception $ex) {
var_dump($ex);
}
throw new Exception("Just like C#/Java");
Class
Class property can be declared with public
, private
, or protected
. Before PHP 5, class property is declared with var
, which is still compatible.
class A {
public $x;
private $y;
const zzzz = 111;
static $z = 123;
function __construct() {
$this->x = 1;
$this->y = 123;
}
function __destruct() {
$this->x = 0;
}
function show() {
echo $this->x;
}
final function cannot_overriden() {}
private function myprivate() {}
protected function myprotected() {}
}
class B extends A {
function show() {
parent::show();
echo 'Show is overriden.';
}
}
$a = new A;
$a->show();
echo $a->x;
Property/Method Overloading (PHP 7)
This feature is best to implement proxy object. Not for common usage.
Property
class WeirdPerson {
private $nick;
function __get($name) {
if ($name == 'name') return 'anonymous';
if ($name == 'nick') return $this->nick;
return null;
}
function __set($name, $value) {
if ($name == 'nick') $this->nick = $value;
}
function __isset($name) {
return $name == 'name' || ($this->nick && $name == 'nick');
}
function __unset($name) {
if ($name == 'nick') unset($this->nick);
}
}
$p = new WeirdPerson;
echo $p->$name; // anonymous
Method
class Person extends WeirdPerson {
function __call($name, $args) {
if ($name == 'greet')
echo "$this->name: Hello $args[0]";
}
static function __callStatic($name, $args) {
if ($name == 'greet')
echo "Hi $args[0]";
}
}
Person::greet();
$p = new Person;
$p->greet();
Abstract class
Like C#, abstract
keyword is used to indicate abstract class. If a class contains an abstract method, it must also be an abstract class.
class abstract A {
abstract public function say_anything();
}
Final class / method
Keyword final
can mark either method or class to disallow extension. If it's used on a class, that class cannot be inherited. If it's used on a method, the method cannot be overridden in derived classes.
Anonymous Class (PHP 7)
$silly = new class {
function greet() { echo "Hello\n"; }
};
$silly->greet();
class A {}
$with_construction = new class('RZ') extends A {
public $name;
function __construct($name) {
$this->name = $name;
}
};
Get Class Name
class A {}
$name = A::class; // string "A"
String representation
Class can implement __toString()
to allow conversion of a class to a string.
class A {
function __toString() {
return "My name is " . A::class;
}
}
Debug Info
Define __debugInfo
to specify the properties that should be shown with var_dump()
.
class A {
private $a, $b;
function __debugInfo() {
// only "a" should be shown.
// custom debug content for "b"
return ['a', 'b' => '(hidden)'];
}
}
Object as function (PHP 5.3)
__invoke
method can be defined so an object can be "callable".
class A {
function __invoke($x) {
echo "Hi $x\n";
}
}
$a = new A;
$a('Rux');
Variable Class
class A {}
$class_name = 'A';
$a = new $class_name();
Cloning
Keyword self
and parent
can be used in Class context to help with cloning.
class A {
function clone_me() {
$new_me = new self; // new A
return $new_me;
}
}
There is clone
keyword which can clone any object.
class Person {
public $name;
function __construct($name) { $this->name = $name; }
}
$p = new Person('RZ');
$q = clone $p;
echo $q->name; // RZ
A class can implement __clone()
that is activated after a cloned object is created.
class TalkativePerson extends Person {
function __clone() {
echo "I'm a clone of $this->name";
}
}
Autoloading
Autoload is a way to resolve unknown class name. Before PHP 5.3, function __autoload()
is used to handle this. The newer recommended method is to use spl_autoload_register()
instead.
Function that is registered with spl_autoload_register
will be called before the resolution fails.
spl_autoload_register(function($classname) {
include $classname . 'php'; // dynamic load PHP file.
});
$a = new AClass; // this trigs the autoload function.
class A extends SomeClass {} // SomeClass will also trig the autoload.
Late Binding
See http://php.net/manual/en/language.oop5.late-static-bindings.php
Interface
PHP has similar interface features like Java/C#, but it can also define some constant in interface.
interface iDoable {
function do_something();
}
interface iDoMore extends iDoable {
const NormalTimes = 3;
function do_more($times = NormalTimes);
}
Iteration (PHP 5)
All objects in PHP are iterable by default. It uses public properties in iteration (e.g. foreach
). By implementing Iterator, a class can custom its iteration behaviors.
class Infinity implements Iterator {
private $n = 1;
function current() { return $this->n; }
function key() { return $this->n; }
function rewind() { $this->n = 1; }
function next() { return ++$this->n; }
function valid() { return true; }
}
$inf = new Infinity;
foreach($inf as $i)
echo 'Infinity $i!';
There is also IteratorAggregate which can also be used for iteration.
class ContentBox implements IteratorAggregate {
private $data = [1,2,3,4,5];
function getIterator() { return new ArrayIterator($this->data); }
}
Traits
Trait is a group of functions that can be integrated (reuse) in any class.
traits Eatable {
function eat() {
echo "Eating $this->favorite";
}
}
class Me {
public $favorite = 'Crabs';
use Eatable;
}
More about traits and name resolution see Traits.
Object Serialization
serialize()
converts any PHP data into a string representation. unserialize()
converts the string back to PHP data.
A class can control serialization by implementing __sleep()
and __wakeup()
methods. __sleep
is called before serialization start and __wakeup
is called after object deserialization is done and the new object is ready to go.
function get_new_id(): int { ... }
class A {
public $name;
public $id;
private $secret;
function __construct() {
}
function __sleep() {
// only $name and $secret should be serialized.
return ['name', 'secret'];
}
function __wakeup() {
$this->id = get_new_id();
}
}
Web interface
Form data from POST/GET is stored in $_REQUEST
array and also in $_POST
or $_GET
respectively. (See Predefined Variables)
Cookies
HTTP Cookies can be accessed from $_COOKIE
and can be set by setcookie()
function.
Package Manager
Use composer ...