Some HTML code goes here

Some HTML code goes here

' . print_r($myarray, true) . '

 tag. 
Alternatively you can tell the browser that what you're outputting is plain text, and not HTML: 
header('Content-Type: text/plain; charset=utf-8'); 
print_r($myarray); 
var_dump() - Output human-readable debugging information about content of the argument(s) including its type and value 
The output is more detailed as compared to print_r because it also outputs the type of the variable along with its value and other information like object IDs, array sizes, string lengths, reference markers, etc. 
You can use var_dump to output a more detailed version for debugging. 
var_dump($myobject, $myarray, $mystring, $myint); 
Output is more detailed: 
object(stdClass)#12 (1) { 
["myvalue"]=> 
 string(11) "Hello World" 
} 
array(2) { 
 [0]=> 
 string(5) "Hello" 
 [1]=> 
 string(5) "World" 
} 
string(11) "Hello World" 
int(42) 
Note: If you are using xDebug in your development environment, the output of var_dump is limited / truncated by default. See the official documentation for more info about the options to change this. 
var_export() - Output valid PHP Code 
var_export() dumps a PHP parseable representation of the item.
GoalKicker.com – PHP Notes for Professionals 34 
You can pass true as the second parameter to return the contents into a variable. 
var_export($myarray); 
var_export($mystring); 
var_export($myint); 
Output is valid PHP code: 
array ( 
 0 => 'Hello', 
 1 => 'World', 
) 
'Hello World' 
42 
To put the content into a variable, you can do this: 
$array_export = var_export($myarray, true); 
$string_export = var_export($mystring, true); 
$int_export = var_export($myint, 1); // any `Truthy` value 
After that, you can output it like this: 
printf('$myarray = %s; %s', $array_export, PHP_EOL); 
printf('$mystring = %s; %s', $string_export, PHP_EOL); 
printf('$myint = %s; %s', $int_export, PHP_EOL); 
This will produce the following output: 
$myarray = array ( 
 0 => 'Hello', 
 1 => 'World', 
); 
$mystring = 'Hello World'; 
$myint = 42; 
Section 5.3: String concatenation with echo 
You can use concatenation to join strings "end to end" while outputting them (with echo or print for example). You can concatenate variables using a . (period/dot). 
// String variable 
$name = 'Joel'; 
// Concatenate multiple strings (3 in this example) into one and echo it once done. // 1. ↓ 2. ↓ 3. ↓ - Three Individual string items echo '
Hello ' . $name . ', Nice to see you.
'; 
// ↑ ↑ - Concatenation Operators 
#> "
Hello Joel, Nice to see you.
" 
Similar to concatenation, echo (when used without parentheses) can be used to combine strings and variables together (along with other arbitrary expressions) using a comma (,). 
$itemCount = 1;
GoalKicker.com – PHP Notes for Professionals 35 
echo 'You have ordered ', $itemCount, ' item', $itemCount === 1 ? '' : 's'; // ↑ ↑ ↑ - Note the commas 
#> "You have ordered 1 item" 
String concatenation vs passing multiple arguments to echo 
Passing multiple arguments to the echo command is more advantageous than string concatenation in some circumstances. The arguments are written to the output in the same order as they are passed in. 
echo "The total is: ", $x + $y; 
The problem with the concatenation is that the period . takes precedence in the expression. If concatenated, the above expression needs extra parentheses for the correct behavior. The precedence of the period affects ternary operators too. 
echo "The total is: " . ($x + $y); 
Section 5.4: printf vs sprintf 
printf will output a formatted string using placeholders 
sprintf will return the formatted string 
$name = 'Jeff'; 
// The `%s` tells PHP to expect a string 
// ↓ `%s` is replaced by ↓ 
printf("Hello %s, How's it going?", $name); 
#> Hello Jeff, How's it going? 
// Instead of outputting it directly, place it into a variable ($greeting) 
$greeting = sprintf("Hello %s, How's it going?", $name); 
echo $greeting; 
#> Hello Jeff, How's it going? 
It is also possible to format a number with these 2 functions. This can be used to format a decimal value used to represent money so that it always has 2 decimal digits. 
$money = 25.2; 
printf('%01.2f', $money); 
#> 25.20 
The two functions vprintf and vsprintf operate as printf and sprintf, but accept a format string and an array of values, instead of individual variables. 
Section 5.5: Outputting large integers 
On 32-bits systems, integers larger than PHP_INT_MAX are automatically converted to float. Outputting these as integer values (i.e. non-scientific notation) can be done with printf, using the float representation, as illustrated below: 
foreach ([1, 2, 3, 4, 5, 6, 9, 12] as $p) { 
 $i = pow(1024, $p); 
 printf("pow(1024, %d) > (%7s) %20s %38.0F", $p, gettype($i), $i, $i);
GoalKicker.com – PHP Notes for Professionals 36 
 echo " ", $i, "\n"; 
} 
// outputs: 
pow(1024, 1) integer 1024 1024 1024 pow(1024, 2) integer 1048576 1048576 1048576 pow(1024, 3) integer 1073741824 1073741824 1073741824 pow(1024, 4) double 1099511627776 1099511627776 1099511627776 pow(1024, 5) double 1.1258999068426E+15 1125899906842624 1.1258999068426E+15 
pow(1024, 6) double 1.1529215046068E+18 1152921504606846976 1.1529215046068E+18 
pow(1024, 9) double 1.2379400392854E+27 1237940039285380274899124224 1.2379400392854E+27 
pow(1024, 12) double 1.3292279957849E+36 1329227995784915872903807060280344576 1.3292279957849E+36 
Note: watch out for float precision, which is not infinite! 
While this looks nice, in this contrived example the numbers can all be represented as a binary number since they are all powers of 1024 (and thus 2). See for example: 
$n = pow(10, 27); 
printf("%s %.0F\n", $n, $n); 
// 1.0E+27 1000000000000000013287555072 
Section 5.6: Output a Multidimensional Array with index and value and print into the table 
Array 
( 
 [0] => Array 
 ( 
 [id] => 13 
 [category_id] => 7 
 [name] => Leaving Of Liverpool 
 [description] => Leaving Of Liverpool 
 [price] => 1.00 
 [virtual] => 1 
 [active] => 1 
 [sort_order] => 13 
 [created] => 2007-06-24 14:08:03 
 [modified] => 2007-06-24 14:08:03 
 [image] => NONE 
 ) 
 [1] => Array 
 ( 
 [id] => 16 
 [category_id] => 7 
 [name] => Yellow Submarine 
 [description] => Yellow Submarine 
 [price] => 1.00 
 [virtual] => 1 
 [active] => 1 
 [sort_order] => 16 
 [created] => 2007-06-24 14:10:02 
 [modified] => 2007-06-24 14:10:02
GoalKicker.com – PHP Notes for Professionals 37 
 [image] => NONE 
 ) 
)  
Output Multidimensional Array with index and value in table 
 $value) {  foreach ($value as $k => $v) { 
 echo ""; 
 echo ""; // Get index.  echo ""; // Get value.  echo ""; 
 } 
} 
?> 
 
$k
$v
GoalKicker.com – PHP Notes for Professionals 38 
Chapter 6: Constants 
Section 6.1: Defining constants 
Constants are created using the const statement or the define function. The convention is to use UPPERCASE letters for constant names. 
Define constant using explicit values 
const PI = 3.14; // float 
define("EARTH_IS_FLAT", false); // boolean 
const "UNKNOWN" = null; // null 
define("APP_ENV", "dev"); // string 
const MAX_SESSION_TIME = 60 * 60; // integer, using (scalar) expressions is ok const APP_LANGUAGES = ["de", "en"]; // arrays 
define("BETTER_APP_LANGUAGES", ["lu", "de"]); // arrays 
Define constant using another constant 
if you have one constant you can define another one based on it: 
const TAU = PI * 2; 
define("EARTH_IS_ROUND", !EARTH_IS_FLAT); 
define("MORE_UNKNOWN", UNKNOWN); 
define("APP_ENV_UPPERCASE", strtoupper(APP_ENV)); // string manipulation is ok too // the above example (a function call) does not work with const: 
// const TIME = time(); # fails with a fatal error! Not a constant scalar expression define("MAX_SESSION_TIME_IN_MINUTES", MAX_SESSION_TIME / 60); 
const APP_FUTURE_LANGUAGES = [-1 => "es"] + APP_LANGUAGES; // array manipulations 
define("APP_BETTER_FUTURE_LANGUAGES", array_merge(["fr"], APP_BETTER_LANGUAGES)); Reserved constants 
Some constant names are reserved by PHP and cannot be redefined. All these examples will fail: 
define("true", false); // internal constant 
define("false", true); // internal constant 
define("CURLOPT_AUTOREFERER", "something"); // will fail if curl extension is loaded And a Notice will be issued: 
Constant ... already defined in ... 
Conditional defines 
If you have several files where you may define the same variable (for example, your main config then your local config) then following syntax may help avoiding conflicts: 
defined("PI") || define("PI", 3.1415); // "define PI if it's not yet defined" const vs define 
define is a runtime expression while const a compile time one.
GoalKicker.com – PHP Notes for Professionals 39 
Thus define allows for dynamic values (i.e. function calls, variables etc.) and even dynamic names and conditional definition. It however is always defining relative to the root namespace. 
const is static (as in allows only operations with other constants, scalars or arrays, and only a restricted set of them, the so called constant scalar expressions, i.e. arithmetic, logical and comparison operators as well as array dereferencing), but are automatically namespace prefixed with the currently active namespace. 
const only supports other constants and scalars as values, and no operations. 
Section 6.2: Class Constants 
Constants can be defined inside classes using a const keyword. 
class Foo { 
 const BAR_TYPE = "bar"; 
 // reference from inside the class using self:: 
 public function myMethod() { 
 return self::BAR_TYPE; 
 } 
} 
// reference from outside the class using :: 
echo Foo::BAR_TYPE; 
This is useful to store types of items. 
log("Info"); // Using default value 
$logger->log("Warning", $logger::LEVEL_WARNING); // Using var 
$logger->log("Error", Logger::LEVEL_ERROR); // using class 
Section 6.3: Checking if constant is defined 
Simple check 
To check if constant is defined use the defined function. Note that this function doesn't care about constant's value, it only cares if the constant exists or not. Even if the value of the constant is null or false the function will still return true. 
 'hello', 
 'WORLD' => 'world', 
) 
*/ 
It's sometimes useful for debugging
GoalKicker.com – PHP Notes for Professionals 41 
Section 6.4: Using constants 
To use the constant simply use its name: 
if (EARTH_IS_FLAT) { 
 print "Earth is flat"; 
} 
print APP_ENV_UPPERCASE; 
or if you don't know the name of the constant in advance, use the constant function: 
// this code is equivalent to the above code 
$const1 = "EARTH_IS_FLAT"; 
$const2 = "APP_ENV_UPPERCASE"; 
if (constant($const1)) { 
 print "Earth is flat"; 
} 
print constant($const2); 
Section 6.5: Constant arrays 
Arrays can be used as plain constants and class constants from version PHP 5.6 onwards: 
Class constant example 
class Answer { 
 const C = [2,4]; 
} 
print Answer::C[1] . Answer::C[0]; // 42 
Plain constant example 
const ANSWER = [2,4]; 
print ANSWER[1] . ANSWER[0]; // 42 
Also from version PHP 7.0 this functionality was ported to the define function for plain constants. 
define('VALUES', [2, 3]); 
define('MY_ARRAY', [ 
 1, 
 VALUES, 
]); 
print MY_ARRAY[1][1]; // 3
GoalKicker.com – PHP Notes for Professionals 42 
Chapter 7: Magic Constants 
Section 7.1: Dierence between __FUNCTION__ and __METHOD__ 
__FUNCTION__ returns only the name of the function whereas __METHOD__ returns the name of the class along with the name of the function: 
doit(); // Outputs: doit 
$obj->doitagain(); // Outputs: trick::doitagain 
Section 7.2: Dierence between __CLASS__, get_class() and get_called_class() 
__CLASS__ magic constant returns the same result as get_class() function called without parameters and they both return the name of the class where it was defined (i.e. where you wrote the function call/constant name ). 
In contrast, get_class($this) and get_called_class() functions call, will both return the name of the actual class which was instantiated: 
say(); 
// Output: 
// __CLASS__ value: Definition_Class 
// get_called_class() value: Actual_Class 
// get_class($this) value: Actual_Class
GoalKicker.com – PHP Notes for Professionals 43 
// get_class() value: Definition_Class 
Section 7.3: File & Directory Constants 
Current file 
You can get the name of the current PHP file (with the absolute path) using the __FILE__ magic constant. This is most often used as a logging/debugging technique. 
echo "We are in the file:" , __FILE__ , "\n"; 
Current directory 
To get the absolute path to the directory where the current file is located use the __DIR__ magic constant. echo "Our script is located in the:" , __DIR__ , "\n"; 
To get the absolute path to the directory where the current file is located, use dirname(__FILE__). echo "Our script is located in the:" , dirname(__FILE__) , "\n"; 
Getting current directory is often used by PHP frameworks to set a base directory: 
// index.php of the framework 
define(BASEDIR, __DIR__); // using magic constant to define normal constant 
// somefile.php looks for views: 
$view = 'page'; 
$viewFile = BASEDIR . '/views/' . $view; 
Separators 
Windows system perfectly understands the / in paths so the DIRECTORY_SEPARATOR is used mainly when parsing paths. 
Besides magic constants PHP also adds some fixed constants for working with paths: 
DIRECTORY_SEPARATOR constant for separating directories in a path. Takes value / on *nix, and \ on Windows. The example with views can be rewritten with: 
$view = 'page'; 
$viewFile = BASEDIR . DIRECTORY_SEPARATOR .'views' . DIRECTORY_SEPARATOR . $view; 
Rarely used PATH_SEPARATOR constant for separating paths in the $PATH environment variable. It is ; on Windows, : otherwise
GoalKicker.com – PHP Notes for Professionals 44 
Chapter 8: Comments 
Section 8.1: Single Line Comments 
The single line comment begins with "//" or "#". When encountered, all text to the right will be ignored by the PHP interpreter. 
// This is a comment 
# This is also a comment 
echo "Hello World!"; // This is also a comment, beginning where we see "//" Section 8.2: Multi Line Comments 
The multi-line comment can be used to comment out large blocks of code. It begins with /* and ends with */. 
/* This is a multi-line comment. 
 It spans multiple lines. 
 This is still part of the comment. 
*/
GoalKicker.com – PHP Notes for Professionals 45 
Chapter 9: Types 
Section 9.1: Type Comparison 
There are two types of comparison: loose comparison with == and strict comparison with ===. Strict comparison ensures both the type and value of both sides of the operator are the same. 
// Loose comparisons 
var_dump(1 == 1); // true 
var_dump(1 == "1"); // true 
var_dump(1 == true); // true 
var_dump(0 == false); // true 
// Strict comparisons 
var_dump(1 === 1); // true 
var_dump(1 === "1"); // false 
var_dump(1 === true); // false 
var_dump(0 === false); // false 
// Notable exception: NAN — it never is equal to anything 
var_dump(NAN == NAN); // false 
var_dump(NAN === NAN); // false 
You can also use strong comparison to check if type and value don't match using !==. 
A typical example where the == operator is not enough, are functions that can return different types, like strpos, which returns false if the searchword is not found, and the match position (int) otherwise: 
if(strpos('text', 'searchword') == false) 
 // strpos returns false, so == comparison works as expected here, BUT: 
if(strpos('text bla', 'text') == false) 
 // strpos returns 0 (found match at position 0) and 0==false is true. 
 // This is probably not what you expect! 
if(strpos('text','text') === false) 
 // strpos returns 0, and 0===false is false, so this works as expected. 
Section 9.2: Boolean 
Boolean is a type, having two values, denoted as true or false. 
This code sets the value of $foo as true and $bar as false: 
$foo = true; 
$bar = false; 
true and false are not case sensitive, so TRUE and FALSE can be used as well, even FaLsE is possible. Using lower case is most common and recommended in most code style guides, e.g. PSR-2. 
Booleans can be used in if statements like this: 
if ($foo) { //same as evaluating if($foo == true) 
 echo "true"; 
} 
Due to the fact that PHP is weakly typed, if $foo above is other than true or false, it's automatically coerced to a boolean value.
GoalKicker.com – PHP Notes for Professionals 46 
The following values result in false: 
a zero value: 0 (integer), 0.0 (float), or '0' (string) 
an empty string '' or array [] 
null (the content of an unset variable, or assigned to a variable) 
Any other value results in true. 
To avoid this loose comparison, you can enforce strong comparison using ===, which compares value and type. See Type Comparison for details. 
To convert a type into boolean, you can use the (bool) or (boolean) cast before the type. var_dump((bool) "1"); //evaluates to true 
or call the boolval function: 
var_dump( boolval("1") ); //evaluates to true 
Boolean conversion to a string (note that false yields an empty string): 
var_dump( (string) true ); // string(1) "1" 
var_dump( (string) false ); // string(0) "" 
Boolean conversion to an integer: 
var_dump( (int) true ); // int(1) 
var_dump( (int) false ); // int(0) 
Note that the opposite is also possible: 
var_dump((bool) ""); // bool(false) 
var_dump((bool) 1); // bool(true) 
Also all non-zero will return true: 
var_dump((bool) -2); // bool(true) 
var_dump((bool) "foo"); // bool(true) 
var_dump((bool) 2.3e5); // bool(true) 
var_dump((bool) array(12)); // bool(true) 
var_dump((bool) array()); // bool(false) 
var_dump((bool) "false"); // bool(true) 
Section 9.3: Float 
$float = 0.123; 
For historical reasons "double" is returned by gettype() in case of a float, and not simply "float" 
Floats are floating point numbers, which allow more output precision than plain integers. Floats and integers can be used together due to PHP's loose casting of variable types:
GoalKicker.com – PHP Notes for Professionals 47 
$sum = 3 + 0.14; 
echo $sum; // 3.14 
php does not show float as float number like other languages, for example: 
$var = 1; 
echo ((float) $var); //returns 1 not 1.0 
Warning 
Floating point precision 
(From the PHP manual page) 
Floating point numbers have limited precision. Although it depends on the system, PHP typically give a maximum relative error due to rounding in the order of 1.11e-16. Non elementary arithmetic operations may give larger errors, and error propagation must be considered when several operations are compounded. 
Additionally, rational numbers that are exactly representable as floating point numbers in base 10, like 0.1 or 0.7, do not have an exact representation as floating point numbers in base 2 (binary), which is used internally, no matter the size of the mantissa. Hence, they cannot be converted into their internal binary counterparts without a small loss of precision. This can lead to confusing results: for example, floor((0.1+0.7)*10) will usually return 7 instead of the expected 8, since the internal representation will be something like 7.9999999999999991118.... 
So never trust floating number results to the last digit, and do not compare floating point numbers directly for equality. If higher precision is necessary, the arbitrary precision math functions and gmp functions are available. 
Section 9.4: Strings 
A string in PHP is a series of single-byte characters (i.e. there is no native Unicode support) that can be specified in four ways: 
Single Quoted 
Displays things almost completely "as is". Variables and most escape sequences will not be interpreted. The exception is that to display a literal single quote, one can escape it with a back slash ', and to display a back slash, one can escape it with another backslash \ 
$my_string = 'Nothing is parsed, except an escap\'d apostrophe or backslash. $foo\n'; var_dump($my_string); 
/* 
string(68) "Nothing is parsed, except an escap'd apostrophe or backslash. $foo\n" */ 
Double Quoted
GoalKicker.com – PHP Notes for Professionals 48 
Unlike a single-quoted string, simple variable names and escape sequences in the strings will be evaluated. Curly braces (as in the last example) can be used to isolate complex variable names. 
$variable1 = "Testing!"; 
$variable2 = [ "Testing?", [ "Failure", "Success" ] ]; 
$my_string = "Variables and escape characters are parsed:\n\n"; 
$my_string .= "$variable1\n\n$variable2[0]\n\n"; 
$my_string .= "There are limits: $variable2[1][0]"; 
$my_string .= "But we can get around them by wrapping the whole variable in braces: {$variable2[1][1]}"; 
var_dump($my_string); 
/* 
string(98) "Variables and escape characters are parsed: 
Testing! 
Testing? 
There are limits: Array[0]" 
But we can get around them by wrapping the whole variable in braces: Success 
*/ 
Heredoc 
In a heredoc string, variable names and escape sequences are parsed in a similar manner to double-quoted strings, though braces are not available for complex variable names. The start of the string is delimited by << 'y']; 
var_dump((object) $array); // object(stdClass)#1 (1) { ["x"]=> string(1) "y" } 
$object = new stdClass(); 
$object->x = 'y'; 
var_dump((array) $object); // array(1) { ["x"]=> string(1) "y" } 
$string = "asdf"; 
var_dump((unset)$string); // NULL 
But be careful: not all type casts work as one might expect: 
// below 3 statements hold for 32-bits systems (PHP_INT_MAX=2147483647) 
// an integer value bigger than PHP_INT_MAX is automatically converted to float: var_dump( 999888777666 ); // float(999888777666) 
// forcing to (int) gives overflow: 
var_dump((int) 999888777666 ); // int(-838602302) 
// but in a string it just returns PHP_INT_MAX 
var_dump((int) "999888777666"); // int(2147483647) 
var_dump((bool) []); // bool(false) (empty array) 
var_dump((bool) [false]); // bool(true) (non-empty array) 
Section 9.8: Type Juggling 
PHP is a weakly-typed language. It does not require explicit declaration of data types. The context in which the variable is used determines its data type; conversion is done automatically: 
$a = "2"; // string
GoalKicker.com – PHP Notes for Professionals 51 
$a = $a + 2; // integer (4) 
$a = $a + 0.5; // float (4.5) 
$a = 1 + "2 oranges"; // integer (3) 
Section 9.9: Null 
PHP represents "no value" with the null keyword. It's somewhat similar to the null pointer in C-language and to the NULL value in SQL. 
Setting the variable to null: 
$nullvar = null; // directly 
function doSomething() {} // this function does not return anything 
$nullvar = doSomething(); // so the null is assigned to $nullvar 
Checking if the variable was set to null: 
if (is_null($nullvar)) { /* variable is null */ } 
if ($nullvar === null) { /* variable is null */ } 
Null vs undefined variable 
If the variable was not defined or was unset then any tests against the null will be successful but they will also generate a Notice: Undefined variable: nullvar: 
$nullvar = null; 
unset($nullvar); 
if ($nullvar === null) { /* true but also a Notice is printed */ } 
if (is_null($nullvar)) { /* true but also a Notice is printed */ } 
Therefore undefined values must be checked with isset: 
if (!isset($nullvar)) { /* variable is null or is not even defined */ } 
Section 9.10: Integers 
Integers in PHP can be natively specified in base 2 (binary), base 8 (octal), base 10 (decimal), or base 16 (hexadecimal.) 
$my_decimal = 42; 
$my_binary = 0b101010; 
$my_octal = 052; 
$my_hexadecimal = 0x2a; 
echo ($my_binary + $my_octal) / 2; 
// Output is always in decimal: 42 
Integers are 32 or 64 bits long, depending on the platform. The constant PHP_INT_SIZE holds integer size in bytes. PHP_INT_MAX and (since PHP 7.0) PHP_INT_MIN are also available. 
printf("Integers are %d bits long" . PHP_EOL, PHP_INT_SIZE * 8); 
printf("They go up to %d" . PHP_EOL, PHP_INT_MAX); 
Integer values are automatically created as needed from floats, booleans, and strings. If an explicit typecast is
GoalKicker.com – PHP Notes for Professionals 52 
needed, it can be done with the (int) or (integer) cast: 
$my_numeric_string = "123"; 
var_dump($my_numeric_string); 
// Output: string(3) "123" 
$my_integer = (int)$my_numeric_string; 
var_dump($my_integer); 
// Output: int(123) 
Integer overflow will be handled by conversion to a float: 
$too_big_integer = PHP_INT_MAX + 7; 
var_dump($too_big_integer); 
// Output: float(9.2233720368548E+18) 
There is no integer division operator in PHP, but it can be simulated using an implicit cast, which always 'rounds' by just discarding the float-part. As of PHP version 7, an integer division function was added. 
$not_an_integer = 25 / 4; 
var_dump($not_an_integer); 
// Output: float(6.25) 
var_dump((int) (25 / 4)); // (see note below) 
// Output: int(6) 
var_dump(intdiv(25 / 4)); // as of PHP7 
// Output: int(6) 
(Note that the extra parentheses around (25 / 4) are needed because the (int) cast has higher precedence than the division)
GoalKicker.com – PHP Notes for Professionals 53 
Chapter 10: Operators 
An operator is something that takes one or more values (or expressions, in programming jargon) and yields another value (so that the construction itself becomes an expression). 
Operators can be grouped according to the number of values they take. 
Section 10.1: Null Coalescing Operator (??) 
Null coalescing is a new operator introduced in PHP 7. This operator returns its first operand if it is set and not NULL. Otherwise it will return its second operand. 
The following example: 
$name = $_POST['name'] ?? 'nobody'; 
is equivalent to both: 
if (isset($_POST['name'])) { 
 $name = $_POST['name']; 
} else { 
 $name = 'nobody'; 
} 
and: 
$name = isset($_POST['name']) ? $_POST['name'] : 'nobody'; 
This operator can also be chained (with right-associative semantics): 
$name = $_GET['name'] ?? $_POST['name'] ?? 'nobody'; 
which is an equivalent to: 
if (isset($_GET['name'])) { 
 $name = $_GET['name']; 
} elseif (isset($_POST['name'])) { 
 $name = $_POST['name']; 
} else { 
 $name = 'nobody'; 
} 
Note: 
When using coalescing operator on string concatenation don't forget to use parentheses () 
$firstName = "John"; 
$lastName = "Doe"; 
echo $firstName ?? "Unknown" . " " . $lastName ?? ""; 
This will output John only, and if its $firstName is null and $lastName is Doe it will output Unknown Doe. In order to output John Doe, we must use parentheses like this. 
$firstName = "John"; 
$lastName = "Doe";
GoalKicker.com – PHP Notes for Professionals 54 
echo ($firstName ?? "Unknown") . " " . ($lastName ?? ""); 
This will output John Doe instead of John only. 
Section 10.2: Spaceship Operator (<=>) 
PHP 7 introduces a new kind of operator, which can be used to compare expressions. This operator will return -1, 0 or 1 if the first expression is less than, equal to, or greater than the second expression. 
// Integers 
print (1 <=> 1); // 0 
print (1 <=> 2); // -1 
print (2 <=> 1); // 1 
// Floats 
print (1.5 <=> 1.5); // 0 
print (1.5 <=> 2.5); // -1 
print (2.5 <=> 1.5); // 1 
// Strings 
print ("a" <=> "a"); // 0 
print ("a" <=> "b"); // -1 
print ("b" <=> "a"); // 1 
Objects are not comparable, and so doing so will result in undefined behaviour. 
This operator is particularly useful when writing a user-defined comparison function using usort, uasort, or uksort. Given an array of objects to be sorted by their weight property, for example, an anonymous function can use <=> to return the value expected by the sorting functions. 
usort($list, function($a, $b) { return $a->weight <=> $b->weight; }); 
In PHP 5 this would have required a rather more elaborate expression. 
usort($list, function($a, $b) { 
 return $a->weight < $b->weight ? -1 : ($a->weight == $b->weight ? 0 : 1); }); 
Section 10.3: Execution Operator (``) 
The PHP execution operator consists of backticks (``) and is used to run shell commands. The output of the command will be returned, and may, therefore, be stored in a variable. 
// List files 
$output = `ls`; 
echo "
$output
"; 
Note that the execute operator and shell_exec() will give the same result. 
Section 10.4: Incrementing (++) and Decrementing Operators (--) 
Variables can be incremented or decremented by 1 with ++ or --, respectively. They can either precede or succeed variables and slightly vary semantically, as shown below.
GoalKicker.com – PHP Notes for Professionals 55 
$i = 1; 
echo $i; // Prints 1 
// Pre-increment operator increments $i by one, then returns $i 
echo ++$i; // Prints 2 
// Pre-decrement operator decrements $i by one, then returns $i 
echo --$i; // Prints 1 
// Post-increment operator returns $i, then increments $i by one 
echo $i++; // Prints 1 (but $i value is now 2) 
// Post-decrement operator returns $i, then decrements $i by one 
echo $i--; // Prints 2 (but $i value is now 1) 
More information about incrementing and decrementing operators can be found in the official documentation. Section 10.5: Ternary Operator (?:) 
The ternary operator can be thought of as an inline if statement. It consists of three parts. The operator, and two outcomes. The syntax is as follows: 
$value =  ?  :  
If the operator is evaluated as true, the value in the first block will be returned (), else the value in the second block will be returned (). Since we are setting $value to the result of our ternary operator it will store the returned value. 
Example: 
$action = empty($_POST['action']) ? 'default' : $_POST['action']; 
$action would contain the string 'default' if empty($_POST['action']) evaluates to true. Otherwise it would contain the value of $_POST['action']. 
The expression (expr1) ? (expr2) : (expr3) evaluates to expr2 if expr1evaluates to true, and expr3 if expr1 evaluates to false. 
It is possible to leave out the middle part of the ternary operator. Expression expr1 ?: expr3 returns expr1 if expr1 evaluates to TRUE, and expr3 otherwise. ?: is often referred to as Elvis operator. 
This behaves like the Null Coalescing operator ??, except that ?? requires the left operand to be exactly null while ?: tries to resolve the left operand into a boolean and check if it resolves to boolean false. 
Example: 
function setWidth(int $width = 0){ 
 $_SESSION["width"] = $width ?: getDefaultWidth(); 
} 
In this example, setWidth accepts a width parameter, or default 0, to change the width session value. If $width is 0 (if $width is not provided), which will resolve to boolean false, the value of getDefaultWidth() is used instead. The getDefaultWidth() function will not be called if $width did not resolve to boolean false. 
Refer to Types for more information about conversion of variables to boolean.
GoalKicker.com – PHP Notes for Professionals 56 
Section 10.6: Logical Operators (&&/AND and ||/OR) In PHP, there are two versions of logical AND and OR operators. 
Operator True if 
$a and $b Both $a and $b are true 
$a && $b Both $a and $b are true 
$a or $b Either $a or $b is true 
$a || $b Either $a or $b is true 
Note that the && and || opererators have higher precedence than and and or. See table below: 
Evaluation Result of $e Evaluated as 
$e = false || true True $e = (false || true) 
$e = false or true False ($e = false) or true 
Because of this it's safer to use && and || instead of and and or. 
Section 10.7: String Operators (. and .=) 
There are only two string operators: 
Concatenation of two strings (dot): 
$a = "a"; 
$b = "b"; 
$c = $a . $b; // $c => "ab" 
Concatenating assignment (dot=): 
$a = "a"; 
$a .= "b"; // $a => "ab" 
Section 10.8: Object and Class Operators 
Members of objects or classes can be accessed using the object operator (->) and the class operator (::). 
class MyClass { 
 public $a = 1; 
 public static $b = 2; 
 const C = 3; 
 public function d() { return 4; } 
 public static function e() { return 5; } 
} 
$object = new MyClass(); 
var_dump($object->a); // int(1) 
var_dump($object::$b); // int(2) 
var_dump($object::C); // int(3) 
var_dump(MyClass::$b); // int(2) 
var_dump(MyClass::C); // int(3) 
var_dump($object->d()); // int(4) 
var_dump($object::d()); // int(4) 
var_dump(MyClass::e()); // int(5) 
$classname = "MyClass";
GoalKicker.com – PHP Notes for Professionals 57 
var_dump($classname::e()); // also works! int(5) 
Note that after the object operator, the $ should not be written ($object->a instead of $object->$a). For the class operator, this is not the case and the $ is necessary. For a constant defined in the class, the $ is never used. 
Also note that var_dump(MyClass::d()); is only allowed if the function d() does not reference the object: 
class MyClass { 
 private $a = 1; 
 public function d() { 
 return $this->a; 
 } 
} 
$object = new MyClass(); 
var_dump(MyClass::d()); // Error! 
This causes a 'PHP Fatal error: Uncaught Error: Using $this when not in object context' 
These operators have left associativity, which can be used for 'chaining': 
class MyClass { 
 private $a = 1; 
  
 public function add(int $a) { 
 $this->a += $a; 
 return $this; 
 } 
  
 public function get() { 
 return $this->a; 
 } 
} 
$object = new MyClass(); 
var_dump($object->add(4)->get()); // int(5) 
These operators have the highest precedence (they are not even mentioned in the manual), even higher that clone. Thus: 
class MyClass { 
 private $a = 0; 
 public function add(int $a) { 
 $this->a += $a; 
 return $this; 
 } 
 public function get() { 
 return $this->a; 
 } 
} 
$o1 = new MyClass(); 
$o2 = clone $o1->add(2); 
var_dump($o1->get()); // int(2) 
var_dump($o2->get()); // int(2) 
The value of $o1 is added to before the object is cloned! 
Note that using parentheses to influence precedence did not work in PHP version 5 and older (it does in PHP 7):
GoalKicker.com – PHP Notes for Professionals 58 
// using the class MyClass from the previous code 
$o1 = new MyClass(); 
$o2 = (clone $o1)->add(2); // Error in PHP 5 and before, fine in PHP 7 
var_dump($o1->get()); // int(0) in PHP 7 
var_dump($o2->get()); // int(2) in PHP 7 
Section 10.9: Combined Assignment (+= etc) 
The combined assignment operators are a shortcut for an operation on some variable and subsequently assigning this new value to that variable. 
Arithmetic: 
$a = 1; // basic assignment 
$a += 2; // read as '$a = $a + 2'; $a now is (1 + 2) => 3 
$a -= 1; // $a now is (3 - 1) => 2 
$a *= 2; // $a now is (2 * 2) => 4 
$a /= 2; // $a now is (16 / 2) => 8 
$a %= 5; // $a now is (8 % 5) => 3 (modulus or remainder) 
// array + 
$arrOne = array(1); 
$arrTwo = array(2); 
$arrOne += $arrTwo; 
Processing Multiple Arrays Together 
$a **= 2; // $a now is (4 ** 2) => 16 (4 raised to the power of 2) 
Combined concatenation and assignment of a string: 
$a = "a"; 
$a .= "b"; // $a => "ab" 
Combined binary bitwise assignment operators: 
$a = 0b00101010; // $a now is 42 
$a &= 0b00001111; // $a now is (00101010 & 00001111) => 00001010 (bitwise and) $a |= 0b00100010; // $a now is (00001010 | 00100010) => 00101010 (bitwise or) $a ^= 0b10000010; // $a now is (00101010 ^ 10000010) => 10101000 (bitwise xor) $a >>= 3; // $a now is (10101000 >> 3) => 00010101 (shift right by 3) $a <<= 1; // $a now is (00010101 << 1) => 00101010 (shift left by 1) 
Section 10.10: Altering operator precedence (with parentheses) 
The order in which operators are evaluated is determined by the operator precedence (see also the Remarks section). 
In 
$a = 2 * 3 + 4; 
$a gets a value of 10 because 2 * 3 is evaluated first (multiplication has a higher precedence than addition) yielding a sub-result of 6 + 4, which equals to 10.
GoalKicker.com – PHP Notes for Professionals 59 
The precedence can be altered using parentheses: in 
$a = 2 * (3 + 4); 
$a gets a value of 14 because (3 + 4) is evaluated first. 
Section 10.11: Basic Assignment (=) 
$a = "some string"; 
results in $a having the value some string. 
The result of an assignment expression is the value being assigned. Note that a single equal sign = is NOT for comparison! 
$a = 3; 
$b = ($a = 5); 
does the following: 
1. Line 1 assigns 3 to $a. 
2. Line 2 assigns 5 to $a. This expression yields value 5 as well. 
3. Line 2 then assigns the result of the expression in parentheses (5) to $b. 
Thus: both $a and $b now have value 5. 
Section 10.12: Association 
Left association 
If the preceedence of two operators is equal, the associativity determines the grouping (see also the Remarks section): 
$a = 5 * 3 % 2; // $a now is (5 * 3) % 2 => (15 % 2) => 1 
* and % have equal precedence and left associativity. Because the multiplication occurs first (left), it is grouped. $a = 5 % 3 * 2; // $a now is (5 % 3) * 2 => (2 * 2) => 4 
Now, the modulus operator occurs first (left) and is thus grouped. 
Right association 
$a = 1; 
$b = 1; 
$a = $b += 1; 
Both $a and $b now have value 2 because $b += 1 is grouped and then the result ($b is 2) is assigned to $a. Section 10.13: Comparison Operators 
Equality 
For basic equality testing, the equal operator == is used. For more comprehensive checks, use the identical operator ===.
GoalKicker.com – PHP Notes for Professionals 60 
The identical operator works the same as the equal operator, requiring its operands have the same value, but also requires them to have the same data type. 
For example, the sample below will display 'a and b are equal', but not 'a and b are identical'. 
$a = 4; 
$b = '4'; 
if ($a == $b) { 
 echo 'a and b are equal'; // this will be printed 
} 
if ($a === $b) { 
 echo 'a and b are identical'; // this won't be printed 
} 
When using the equal operator, numeric strings are cast to integers. 
Comparison of objects 
=== compares two objects by checking if they are exactly the same instance. This means that new stdClass() === new stdClass() resolves to false, even if they are created in the same way (and have the exactly same values). 
== compares two objects by recursively checking if they are equal (deep equals). That means, for $a == $b, if $a and $b are: 
1. of the same class 
2. have the same properties set, including dynamic properties 
3. for each property $property set, $a->property == $b->property is true (hence recursively checked). Other commonly used operators 
They include: 
1. Greater Than (>) 
2. Lesser Than (<) 
3. Greater Than Or Equal To (>=) 
4. Lesser Than Or Equal To (<=) 
5. Not Equal To (!=) 
6. Not Identically Equal To (!==) 
1. Greater Than: $a > $b, returns true if $a's value is greater than of $b, otherwise returns false. Example: 
var_dump(5 > 2); // prints bool(true) 
var_dump(2 > 7); // prints bool(false) 
2. Lesser Than: $a < $b, returns true if $a's value is smaller that of $b, otherwise returns false. Example: 
var_dump(5 < 2); // prints bool(false) 
var_dump(1 < 10); // prints bool(true) 
3. Greater Than Or Equal To: $a >= $b, returns true if $a's value is either greater than of $b or equal to $b, otherwise returns false. 
Example:
GoalKicker.com – PHP Notes for Professionals 61 
var_dump(2 >= 2); // prints bool(true) 
var_dump(6 >= 1); // prints bool(true) 
var_dump(1 >= 7); // prints bool(false) 
4. Smaller Than Or Equal To: $a <= $b, returns true if $a's value is either smaller than of $b or equal to $b, otherwise returns false. 
Example: 
var_dump(5 <= 5); // prints bool(true) 
var_dump(5 <= 8); // prints bool(true) 
var_dump(9 <= 1); // prints bool(false) 
5/6. Not Equal/Identical To: To rehash the earlier example on equality, the sample below will display 'a and b are not identical', but not 'a and b are not equal'. 
$a = 4; 
$b = '4'; 
if ($a != $b) { 
 echo 'a and b are not equal'; // this won't be printed 
} 
if ($a !== $b) { 
 echo 'a and b are not identical'; // this will be printed 
} 
Section 10.14: Bitwise Operators 
Prefix bitwise operators 
Bitwise operators are like logical operators but executed per bit rather than per boolean value. 
// bitwise NOT ~: sets all unset bits and unsets all set bits 
printf("%'06b", ~0b110110); // 001001 
Bitmask-bitmask operators 
Bitwise AND &: a bit is set only if it is set in both operands 
printf("%'06b", 0b110101 & 0b011001); // 010001 
Bitwise OR |: a bit is set if it is set in either or both operands 
printf("%'06b", 0b110101 | 0b011001); // 111101 
Bitwise XOR ^: a bit is set if it is set in one operand and not set in another operand, i.e. only if that bit is in different state in the two operands 
printf("%'06b", 0b110101 ^ 0b011001); // 101100 
Example uses of bitmasks 
These operators can be used to manipulate bitmasks. For example: 
file_put_contents("file.log", LOCK_EX | FILE_APPEND); 
Here, the | operator is used to combine the two bitmasks. Although + has the same effect, | emphasizes that you
GoalKicker.com – PHP Notes for Professionals 62 
are combining bitmasks, not adding two normal scalar integers. 
class Foo{ 
 const OPTION_A = 1; 
 const OPTION_B = 2; 
 const OPTION_C = 4; 
 const OPTION_A = 8; 
 private $options = self::OPTION_A | self::OPTION_C; 
 public function toggleOption(int $option){ 
 $this->options ^= $option; 
 } 
 public function enable(int $option){ 
 $this->options |= $option; // enable $option regardless of its original state  } 
 public function disable(int $option){ 
 $this->options &= ~$option; // disable $option regardless of its original state,  // without affecting other bits 
 } 
 /** returns whether at least one of the options is enabled */ 
 public function isOneEnabled(int $options) : bool{ 
 return $this->options & $option !== 0; 
 // Use !== rather than >, because 
 // if $options is about a high bit, we may be handling a negative integer  } 
 /** returns whether all of the options are enabled */ 
 public function areAllEnabled(int $options) : bool{ 
 return ($this->options & $options) === $options; 
 // note the parentheses; beware the operator precedence 
 } 
} 
This example (assuming $option always only contain one bit) uses: 
the ^ operator to conveniently toggle bitmasks. 
the | operator to set a bit neglecting its original state or other bits 
the ~ operator to convert an integer with only one bit set into an integer with only one bit not set the & operator to unset a bit, using these properties of &: 
Since &= with a set bit will not do anything ((1 & 1) === 1, (0 & 1) === 0), doing &= with an integer with only one bit not set will only unset that bit, not affecting other bits. 
&= with an unset bit will unset that bit ((1 & 0) === 0, (0 & 0) === 0) 
Using the & operator with another bitmask will filter away all other bits not set in that bitmask. If the output has any bits set, it means that any one of the options are enabled. 
If the output has all bits of the bitmask set, it means that all of the options in the bitmask are enabled. 
Bear in mind that these comparison operators: (< > <= >= == === != !== <> <=>) have higher precedence than these bitmask-bitmask operators: (| ^ &). As bitwise results are often compared using these comparison operators, this is a common pitfall to be aware of. 
Bit-shifting operators 
Bitwise left shift <<: shift all bits to the left (more significant) by the given number of steps and discard the bits exceeding the int size
GoalKicker.com – PHP Notes for Professionals 63 
<< $x is equivalent to unsetting the highest $x bits and multiplying by the $xth power of 2 
printf("%'08b", 0b00001011<< 2); // 00101100 
assert(PHP_INT_SIZE === 4); // a 32-bit system 
printf("%x, %x", 0x5FFFFFFF << 2, 0x1FFFFFFF << 4); // 7FFFFFFC, FFFFFFFF 
Bitwise right shift >>: discard the lowest shift and shift the remaining bits to the right (less significant) >> $x is equivalent to dividing by the $xth power of 2 and discard the non-integer part 
printf("%x", 0xFFFFFFFF >> 3); // 1FFFFFFF 
Example uses of bit shifting: 
Fast division by 16 (better performance than /= 16) 
$x >>= 4; 
On 32-bit systems, this discards all bits in the integer, setting the value to 0. On 64-bit systems, this unsets the most significant 32 bits and keep the least 
$x = $x << 32 >> 32; 
significant 32 bits, equivalent to $x & 0xFFFFFFFF 
Note: In this example, printf("%'06b") is used. It outputs the value in 6 binary digits. 
Section 10.15: instanceof (type operator) 
For checking whether some object is of a certain class, the (binary) instanceof operator can be used since PHP version 5. 
The first (left) parameter is the object to test. If this variable is not an object, instanceof always returns false. If a constant expression is used, an error is thrown. 
The second (right) parameter is the class to compare with. The class can be provided as the class name itself, a string variable containing the class name (not a string constant!) or an object of that class. 
class MyClass { 
} 
$o1 = new MyClass(); 
$o2 = new MyClass(); 
$name = 'MyClass'; 
// in the cases below, $a gets boolean value true 
$a = $o1 instanceof MyClass; 
$a = $o1 instanceof $name; 
$a = $o1 instanceof $o2; 
// counter examples: 
$b = 'b'; 
$a = $o1 instanceof 'MyClass'; // parse error: constant not allowed 
$a = false instanceof MyClass; // fatal error: constant not allowed 
$a = $b instanceof MyClass; // false ($b is not an object)
GoalKicker.com – PHP Notes for Professionals 64 
instanceof can also be used to check whether an object is of some class which extends another class or implements some interface: 
interface MyInterface { 
} 
class MySuperClass implements MyInterface { 
} 
class MySubClass extends MySuperClass { 
} 
$o = new MySubClass(); 
// in the cases below, $a gets boolean value true  
$a = $o instanceof MySubClass; 
$a = $o instanceof MySuperClass; 
$a = $o instanceof MyInterface; 
To check whether an object is not of some class, the not operator (!) can be used: 
class MyClass { 
} 
class OtherClass { 
} 
$o = new MyClass(); 
$a = !$o instanceof OtherClass; // true 
Note that parentheses around $o instanceof MyClass are not needed because instanceof has higher precedence than !, although it may make the code better readable with parentheses. 
Caveats 
If a class does not exist, the registered autoload functions are called to try to define the class (this is a topic outside the scope of this part of the Documentation!). In PHP versions before 5.1.0, the instanceof operator would also trigger these calls, thus actually defining the class (and if the class could not be defined, a fatal error would occur). To avoid this, use a string: 
// only PHP versions before 5.1.0! 
class MyClass { 
} 
$o = new MyClass(); 
$a = $o instanceof OtherClass; // OtherClass is not defined! 
// if OtherClass can be defined in a registered autoloader, it is actually 
// loaded and $a gets boolean value false ($o is not a OtherClass) 
// if OtherClass can not be defined in a registered autoloader, a fatal 
// error occurs. 
$name = 'YetAnotherClass'; 
$a = $o instanceof $name; // YetAnotherClass is not defined! 
// $a simply gets boolean value false, YetAnotherClass remains undefined. 
As of PHP version 5.1.0, the registered autoloaders are not called anymore in these situations. Older versions of PHP (before 5.0)
GoalKicker.com – PHP Notes for Professionals 65 
In older versions of PHP (before 5.0), the is_a function can be used to determine wether an object is of some class. This function was deprecated in PHP version 5 and undeprecated in PHP version 5.3.0.
GoalKicker.com – PHP Notes for Professionals 66 
Chapter 11: References 
Section 11.1: Assign by Reference 
This is the first phase of referencing. Essentially when you assign by reference, you're allowing two variables to share the same value as such. 
$foo = &$bar; 
$foo and $bar are equal here. They do not point to one another. They point to the same place (the "value"). 
You can also assign by reference within the array() language construct. While not strictly being an assignment by reference. 
$foo = 'hi'; 
$bar = array(1, 2); 
$array = array(&$foo, &$bar[0]); 
Note, however, that references inside arrays are potentially dangerous. Doing a normal (not by reference) assignment with a reference on the right side does not turn the left side into a reference, but references inside arrays are preserved in these normal assignments. This also applies to function calls where the array is passed by value. 
Assigning by reference is not only limited to variables and arrays, they are also present for functions and all "pass by-reference" associations. 
function incrementArray(&$arr) { 
 foreach ($arr as &$val) { 
 $val++; 
 } 
} 
function &getArray() { 
 static $arr = [1, 2, 3]; 
 return $arr; 
} 
incrementArray(getArray()); 
var_dump(getArray()); // prints an array [2, 3, 4] 
Assignment is key within the function definition as above. You can not pass an expression by reference, only a value/variable. Hence the instantiation of $a in bar(). 
Section 11.2: Return by Reference 
Occasionally there comes time for you to implicitly return-by-reference. 
Returning by reference is useful when you want to use a function to find to which variable a reference should be bound. Do not use return-by-reference to increase performance. The engine will automatically optimize this on its own. Only return references when you have a valid technical reason to do so.
GoalKicker.com – PHP Notes for Professionals 67