PHP Quick Reference Summary

Code Structure

Reusing Code

Nomenclature Rules

Visibility & Scope

Data Types

Operators

Constants

Variable Management

Arrays

Date & Time

File System

Math Functions

Output & Formatting

Strings

Conditional Execution

Exception Handling

Looping

User Functions

Superglobals

Miscellanea

PHP: Constructs and Variables

PHP: Constructs and Variables

Introduction

This document describes:

Brief Overview of Variables

The syntax for PHP variables is similar to C and most other programming languages. There are three primary differences:

Fundamental Variable Types

Variable Dumping

PHP has a useful function named var_dump() that prints the current type and value for one or more variables. Arrays and objects are printed recursively with their values indented to show structure.


<?php
$a = 35;
$b = "Programming is fun!";
$c = array(1, 1, 2, 3);
var_dump($a, $b, $c);
?>

Output:


int(35)
string(19) "Programming is fun!"
array(4) {
  [0]=>
  int(1)
  [1]=>
  int(1)
  [2]=>
  int(2)
  [3]=>
  int(3)
}

Control Structures

The control structures – conditionals and loops – for PHP are nearly identical to C. The following list identifies how PHP’s control structure syntax differs from other languages:


foreach $val (@array) ...

In PHP, you would write:


foreach ($array as $val) ...

Mixed-Mode Processing

When the PHP interpreter encounters code islands, it switches into parsing mode. This feature is significant for two reasons: you can retain variable scope, and you can distinguish PHP code from markup. Here are two examples that demonstrate these concepts:


<?php
  $username = "dknuth";     // Defining a variable in the first code island
?>
...
<h1>Hello World</h1>
<p>Welcome,
<?php
  print "$username";        // Using a variable defined in a previous code island
?>. Enjoy your stay!</p>

Even though there is HTML markup between the two code islands, the variable $username retains its value. The technical reason for this capability is that the variable $username is within the current file’s scope.

The following example demonstrates how to have specific HTML markup displayed if a given condition is true:


<?php
  if ($is_logged_in == true) {
?>
<p>Welcome, member. (<a href="logout.php">Log out</a>)</p>
<p>Check out our new member features below.</p>
<?php
  } else {
?>
<p><a href="register.php">Register for an account</a></p>
<p>You must be a member to view anything on this site, sorry!</p>
<?php
  }
?>

The same result could be achieved by using multiple print statements within the condition blocks to output the HTML markup.

Including Other Scripts

As with most programming languages, initialization, function definitions, and common code can be placed in separate files. In the case of PHP, these separate scripts typically contain common/shared functions, object definitions, and page layout code.

To include other scripts, use the include statement.


include 'somefile.php';

The PHP interpreter essentially “inserts” the contents of the specified file name into the current location. If you try to include a file that does not exist, a warning message will be displayed in the browser.

Suppose you want to define the heading for each page on your site in the file pageheader.php:


<?php
  print "<div class=\"pageheader\">Programming is Fun!</div>\n";
  print "<div class=\"commonlinks\">some links would go here</div>\n";
  print "<p>Motto: <i>If programming isn't fun, you're doing it wrong.</i></p>\n";
?>

This script can be included by other PHP files. For example, the index page – index.php – may look like this:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="content-type" content="text/html; charset=utf-8" />
    <title>Programming is Fun!</title>
  </head>
  <body>
    <?php
      include 'pageheader.php';
      // More code here
    ?>
  </body>
</html>

Potentially each page of your site would use the page header so that (a) you don’t have to copy and paste the same header markup into every PHP file that displays HTML content, and (b) if you decide to change the page header content, you only need to modify pageheader.php.

The inclusion of other scripts can also be based on a condition. Suppose you want to display additional content if the current user is an administrator:


<?php
  if ($is_admin == true)
    include 'admincontent.php';
?>

If there are external scripts that contain code that is mandatory for the current script, use the require statement:


require 'somefile.php';

If a required file does not exist, an error message will be displayed in the browser, and the PHP interpreter will exit (i.e., a fatal error).

If you want to prevent multiple includes or requires, use the include_once or require_once statements. If you attempt to use include_once (or require_once) on a file that has already been included or required using the “once” functions, that statement will be ignored.

Functions

To define a function, use the function keyword. For example, function foo() below takes no arguments and simply returns the integer 1 (one).


<?php
function foo() {
  return 1;
}
?>

Arguments are passed by specifying the names within the parentheses of the function definition. Because PHP uses dynamic typing, no data type is necessary.


<?php
function display_name_and_age($name, $age) {
  print "It appears that $name is $age year(s) old.\n";
}
?>

You can also specify default values for function arguments.


<?php
function greet($name = "user") {
  print "Hello, $name!\n";
}
?>

The statement greet(); displays “Hello, user!”, whereas greet("Donald"); displays “Hello, Donald!”. If values are passed to the function – rather than being set to a default value – they are used from left to right. Consider the following function:


<?php
function greet2($daypart = "day", $name = "user") {
  print "Good $daypart, $name!\n";
}
?>

The statement greet2(); displays “Good day, user!”, greet2("evening","Donald"); displays “Good evening, Donald!”, and greet2("Donald"); displays “Good Donald, user!”.

Arguments that have default values should be placed at the end of the argument list. For example, the following is not recommended:


<?php
function greet_bad($daypart = "day", $name) {
  print "Good $daypart, $name!\n";
}
?>

The true intent of the statement greet_bad("Donald") cannot be inferred. Should the string “Donald” override the default value for $daypart, or be assigned to the variable $name, which does not have a default value? In this case, greet_bad("Donald"); displays “Good Donald, !” – where $daypart is assigned the value "Donald", and $name is undefined, which in the string context is the empty string.

Suppose you have the following function:


<?php
function foo($a, $b) { }
foo(10, 20, 30);  // $a = 10, $b = 20, $c = 30 ignored
?>

The statement foo(10, 20, 30); will assign 10 to $a and 20 to $b – the value 30 is effectively ignored. Because the PHP interpreter does not complain if you specify too many arguments, you can support multiple arguments using the func_num_args() and func_get_arg() functions. Here is an example function that prints out each of its arguments:


<?php
function display_arguments() {
  $n = func_num_args();
  for ($i = 0; $i < $n; $i++)
    echo "arg ", $i + 1, " = ", func_get_arg($i), "\n";
}
display_arguments(1, 2, 3); // arg 1 = 1
                            // arg 2 = 2
                            // arg 3 = 3
?>

Global Variables

Global variables are stored in a predefined associative array named $GLOBALS. To assign a value to a global variable, use the following syntax:


<?php
$GLOBALS['variablename'] = somevalue;
?>

To access a global variable, simply provide the variable name as the key to the $GLOBALS array. For example,


<?php
$GLOBALS['theuser'] = "dknuth";     // Assign the value
$curr_user = $GLOBALS['theuser'];   // Retrieve the value
?>

Alternatively, you can specify that a given variable is global within the current scope using the GLOBAL keyword. Suppose you have a global variable $bar that you want to be updated by function foo().


<?php
function foo() {
  GLOBAL $bar;
  $bar++;
}
?>

In the above example, any use of the variable $bar after the GLOBAL statement is equivalent to $GLOBALS['bar'].

Special Cases for Variable Types

Booleans

As previously mentioned, non-zero numbers are considered to be true, and zero-valued numbers (e.g., 0, 0.000) are false. Any string with a value is considered to be true, except for the empty string ("") and "0". WARNING: The string "0.0" is true.

Strings

Strings can be denoted by single (') or double (") quotation marks. The ability to use either type of quotation mark is useful if a string contains one of these marks. As with C, you can use the \' and \" escape codes to explicitly produce the desired quotation mark. The single and double quotation mark delimiters for strings have the same effect as they do in Perl: Characters within single quotation marks are treated as literals, and characters within double quotation marks are interpolated. Interpolation means that values will be substituted for variable names, and escape codes will be replaced with the appropriate characters within the string.

NOTE: To display a dollar sign, use \$; otherwise, PHP will try to resolve the character sequence as a variable name.


<?php
$greeting = 'Hello';
$message1 = "$greeting, world!\n";  // Double quotation marks
$message2 = '$greeting, world!\n';  // Single quotation marks
print "1: $message1\n";
print "2: $message2\n";
?>

This is how the output appears before being sent to the browser:


1: Hello, world!
2: $greeting, world!\n

As in Perl, the concatenation character is the dot (.) operator:


<?php
$a = "Hello, world" . 35 . "!\n";
print $a;
?>

This is how the output appears before being sent to the browser:


Hello, world35!

To handle cases where you need to have text adjacent to a variable name within an interpolated string, use curly-braces to distinguish between variable and text.


<?php
$person_type = "student";
$count = 20;
print "There are $count $person_types.";      // Looks for variable named $person_types
print "There are $count $person_type" . "s";  // Correct, but awkward to read
print "There are $count ${person_type}s";
print "There are $count {$person_type}s";     // Also correct
?>

To access individual characters within a string, use the {x} notation, where x is a zero-based index. As with Perl, you can specify a positive index that is beyond the current length of the string.


<?php
$foo = "Gleetings";
$foo{1} = "r";
$foo{20} = "!";
print "$foo\n";  // Displays "Greetings           !"
?>

Type Conversion

PHP is loosely typed, meaning that you can use variables of different types in the same statement. For example, strings that contain valid numeric values can be used in arithmetic expressions.


<?php
$a = "100";
$b = "324.75";
$sum = $a + $b;
print "$a + $b = $sum";
?>

This is how the output may appear in the browser:


100 + 324.75 = 424.75

With numeric expressions, the following conditions hold:

Unfortunately, PHP does not perform type conversion for arrays (i.e., array-to-string). In other words, if you tried to display the values in the array $myarray using print $myarray;, the output would be Array. Displaying boolean values can cause unexpected results as well.


<?php
$cake_exists = false;
print "The statement, 'The cake is a lie,' is $cake_exists.\n";
?>

The above code produces the output, "The statement, 'The cake is a lie,' is .". In the boolean-to-string context, false is interpreted as the empty string. If $cake_exists were set to true, the output would be "The statement, 'The cake is a lie,' is 1.".

PHP also supports type casting, using more or less the same syntax as C. Type casting is used to force a particular type, provide extra security, or ensure that a specific type is always used. The following example demonstrates how a floating-point value is truncated when cast as an integer.


<?php
$a = 100;
$b = 324.75;
$sum = $a + (int) $b;
print "$a + $b = $sum";
?>

This is how the output may appear in the browser:


100 + 324.75 = 424

To address the previous example where boolean values are displayed, consider the following revised code:


<?php
$cake_exists = false;
print "The statement, 'The cake is a lie,' is " . (int) $cake_exists . ".\n";
?>

The above code produces the output, "The statement, 'The cake is a lie,' is 0.".

Undefined Variables

Undefined variables have a default value of NULL. The NULL value is interpreted differently depending on the context in which the undefined variable is used (i.e., string, number, etc.). Depending on the configuration of the PHP interpreter, you may or may not see a warning when using an undefined variable. To determine if a variable has been defined, use the isset() function.


<?php
$foo = 10;
if (isset($foo) == true)
  print "foo is $foo\n";
else
  print "foo is undefined\n";
if (isset($bar) == true)
  print "bar is $bar\n";
else
  print "bar is undefined\n";
?>

The code above will produce the following output:


foo is 10
bar is undefined

Variable Variables

Variable variables allow you to access a variable without using that variable directly. Essentially the first variable contains a string whose value is the name of the second variable (without the dollar sign). The second variable is accessed indirectly by prefixing the first variable with an extra dollar sign. This PHP construct is best described with an example:


<?php
$val1 = 30;
$val2 = 60;
$foo = "val2";
$bar = $$foo;     // $bar's value is 60 after this statement
?>

Superglobals

Superglobals are global variables that are predefined by PHP because they have special uses. The variables themselves are associative arrays. The following table lists the superglobals and their corresponding descriptions:

Superglobal Description
$_GET Variables sent via an HTTP GET request.
$_POST Variables sent via an HTTP POST request.
$_FILES Data for HTTP POST file uploads.
$_COOKIE Values corresponding to cookies.
$_REQUEST The combination of $_GET, $_POST, and $_COOKIE.
$_SESSION Variables stored in a user’s session (server-side data store).
$_SERVER Variables set by the Web server.
$_ENV Environment variables for PHP’s host system.
$GLOBALS Global variables (including $GLOBALS).

$_SERVER Superglobal

The $_SERVER superglobal has several useful variables:

Variable Description
HTTP_REFERER The previous URL (if any).
HTTP_USER_AGENT Browser name.
PATH_INFO All characters in the URL after the script name.
PHP_SELF Current script’s file name.
REQUEST_METHOD Either GET or POST.
QUERY_STRING All characters after the ? in a GET-based URL.

Constants

Constants in PHP are distinct from other variables because there is no dollar-sign prefix. Constants are also global within the script’s scope. To define a constant, use the define() function:


<?php
define("constname", somevalue);
?>

The constant's value can be accessed using its name. However, constants cause a problem for variable variables. To get around this, use the constant() function:


<?php
define("foo", 10);
$bar = "foo";
$baz = constant($bar);
?>

PHP has some useful predefined constants:

Constant Description
__FILE__ Current file name and line of code.
__LINE__ Current line number.
__FUNCTION__ Current function name.
__CLASS__ Current class name.
PHP_EOL The newline character for the server’s operating system.
PHP_VERSION Current version of PHP.
DEFAULT_INCLUDE_PATH File paths used if a file is included/required and is not in the current directory.

There are also several mathematical constants, such as M_PI for the floating-point value for pi.

Arrays

PHP has essentially one type of array – the associative array (i.e., hash table). Each element in the array has a key and a corresponding value. Standard arrays (i.e., indexed arrays) can be used in PHP as well; they are simply associative arrays with integer-indexed keys. We’ll begin with indexed arrays to introduce some basic syntax and manipulation functions.

Array Basics

There are three ways to populate an array. The first method is to use the array() function:


<?php
$proglangs = array("C", "C++", "Perl", "Java");
$primes    = array(1, 2, 3, 5, 7, 11);
$mixedbag  = array("PHP", 42.8, true);
$emptylist = array();
?>

The second method is to access the elements directly using the array operator []:


<?php
for ($i = 0; $i < 10; $i++)
  $nums[$i] = $i + 1;
?>

The third method is to use the array operator with no key provided:


<?php
for ($i = 0; $i < 10; $i++)
  $nums[] = $i + 1;
?>

As with Perl, arrays are heterogeneous, meaning that the data stored in the array does not need to be of the same type. For example, $mixedbag contains a string, floating-point value, and a boolean value. To get the number of elements in an array, use the count() function.


<?php
$proglangs = array("C", "C++", "Perl", "Java");
echo "I know ", count($proglangs), " language(s).";   // Displays "I know 4 language(s)."
?>

To display the contents of an array, the print() function will simply display “Array”. The print_r() function performs a recursive output of the given array.


<?php
$proglangs = array("C", "C++", "Perl", "Java");
print_r($proglangs);
?>

Here’s the output from the above code:


Array
(
[0] => C
[1] => C++
[2] => Perl
[3] => Java
)

PHP also has a function, var_export(), that displays information about an array in PHP syntax.


<?php
$proglangs = array("C", "C++", "Perl", "Java");
var_export($proglangs);
?>

Here’s the output from the above code:


array (
       0 => 'C',
       1 => 'C++',
       2 => 'Perl',
       3 => 'Java',
)

Associative Arrays

Associative arrays work much like their indexed counterparts, except that associative arrays can have non-numeric keys (e.g., strings). The same three methods for populating indexed arrays apply, except for the array() function:


<?php
$file_ext = array(".c" => "C",
                  ".cpp" => "C++",
                  ".pl" => "Perl",
                  ".java" => "Java");
?>

The value to the left of the => operator is the key, and the content after it is the corresponding value.

Returning Arrays from Functions

A common task for functions is to initialize various data structures. Consider the following function (and its call):


<?php
function init_params() {
    $params["username"] = "dknuth";
    $params["realname"] = "Donald Knuth";
    return $params;
}
...
$params = init_params();
?>

The init_params() function creates an associative array with two keys, then returns the newly-created array. Suppose the “user name” and “real name” values had to be retrieved from a database, and one or more of the values could not be retrieved. The only way to ensure that the array was correctly populated is to see if the desired keys are defined (i.e., not NULL). Now consider the following revision:


<?php
function init_params(&$params) {
    // Perform a database query here, then populate $params...

    if (query was successful)
        return true;
    return false;
}
...
if (!init_params($params))
    // Display some useful error message here...
?>

The syntax becomes slightly more complex because the array is passed by reference (denoted by the & operator in the function argument list). However, the function can now return a success/failure indicator while populating the array (assuming the query was successful).

Multidimensional Arrays

Multidimensional arrays in PHP can be indexed or associative, and are heterogeneous. Consider the following code which constructs a multidimensional array.


<?php
$proglangs['scripted'] = array("Perl", "Python", "PHP");
$proglangs['compiled'] = array("C", "Java", "FORTRAN");
$proglangs['fun'] = array("PHP" => "Web programming", "Java" => "Nice for object-oriented code.");
?>

The variable $proglangs is a multidimensional associative array. The first two statements create indexed arrays of strings, and the last statement creates another associative array. A simple way to view the contents of a multidimensional array is with the var_dump() function. Here is the output of var_dump($proglangs):


array(3) {
  ["scripted"]=>
  array(3) {
    [0]=>
    string(4) "Perl"
    [1]=>
    string(6) "Python"
    [2]=>
    string(3) "PHP"
  }
  ["compiled"]=>
  array(3) {
    [0]=>
    string(1) "C"
    [1]=>
    string(4) "Java"
    [2]=>
    string(7) "FORTRAN"
  }
  ["fun"]=>
  array(2) {
    ["PHP"]=>
    string(15) "Web programming"
    ["Java"]=>
    string(30) "Nice for object-oriented code."
  }
}

Common Array Functions

This section lists common PHP functions that manipulate arrays. For more information as well as examples of these functions, use the PHP online reference by visiting http://www.php.net/function, where function is the name of the PHP function of interest.

Function Description
array_diff($arr1, $arr2) Returns an array containing all the values of array $arr1 that do not exist in array $arr2 (i.e., set difference).
array_filter($arr, funcname) Returns an array containing all the values of array $arr that pass a filter condition implemented in a boolean function funcname.
array_flip($arr) Returns an array where the keys are $arr’s values, and the values are $arr’s keys.
array_intersect($arr1, $arr2) Returns an array containing all the values in $arr1 that exist in $arr2 (i.e., set intersection).
array_keys($arr) Returns an array of keys in $arr1.
array_merge($arr1, $arr2) Returns an array where the contents of $arr1 have been combined with the contents of $arr2. If duplicate keys exist, numerical indices will be renumbered and string indices will be overwritten. NOTE: The + operator in PHP is overloaded to perform the same operation as array_merge(). However, if a key exists in $arr1 and $arr2, the instance in $arr2 will be ignored rather than renumbered or overwritten.
array_pop($arr) Returns the value from the end of array $arr while also removing that value from the array.
array_push($arr, $var) Appends the value $var to the end of array $arr.
array_rand($arr) Selects one random element from array $arr. Other useful attributes of this function:
  • A key is returned. In the case of numerical indices, the key will be a positive integer. For string indices, the key will be a string – meaning that the value can be obtained by using the returned key.
  • An optional second argument allows you to specify how many random elements should be returned. If this value is greater than one, this function will not return duplicate elements.
array_shift($arr) Returns the value from the front of array $arr while also removing that value from the array.
array_unique($arr) Returns an array where duplicates in array $arr have been removed (i.e., every value is unique).
array_unshift($arr, $var) Prepends the value $var to the front of array $arr.
array_values($arr) Returns an array of all the values in array $arr.
arsort($arr) Reverse-sorts array $arr by its values while preserving the keys. Some useful notes about this function:
  • The array is modified (i.e., arsort() does not return a sorted array).
  • By default, the sort functions do so numerically. In other words 5 comes before 15. To sort lexicographically, see the documentation for additional options.
explode($sep, $str) Converts the string $str into an array, tokenizing by $sep as a separator value. (The explode() function is similar to split() in Perl.)
extract($arr) Converts elements in array $arr into variables, where the variable names are the keys and the contents are the corresponding values.
implode($arr) Converts the array $arr into a string by inserting the string $sep between each element. (The implode() function is like join() in Perl.)
in_array($val, $arr) Returns true if the array $arr contains the value $val.
krsort($arr) Reverse-sorts only the keys in the array $arr.
ksort($arr) Sorts only the keys in the array $arr.
range($start, $end) Creates an array of numbers between $start and $end (inclusive).
shuffle($arr) Randomizes the positions of the elements within the array $arr. The array is modified (i.e., shuffle() does not return the shuffled array).

Common Number Functions

This section lists common PHP functions that manipulate numbers. For more information as well as examples of these functions, use the PHP online reference by visiting http://www.php.net/function, where function is the name of the PHP function of interest.

Function Description
abs($val) Computes the absolute value of $val.
base_convert($val, $from, $to) Converts the number $val from base $from to base $to, where $from and $to are integers (e.g., 10, 2).
ceil($val) Rounds the number $val to the nearest integer above its current value.
cos($val) Computes the cosine of $val (in radians).
deg2rad($val) Converts $val degrees into radians.
floor($val) Rounds the number $val to the nearest integer below its current value.
mt_rand() Returns a random integer between zero and getrandmax(). Uses the Mersenne Twister algorithm to generate “better” random numbers than rand().
pow($base, $exp) Computes $base raised to the power of $exp.
rad2deg($val) Converts $val radians into degrees.
rand() Returns a random integer between zero and getrandmax().
round($val) Rounds a floating-point number $val to the nearest integer.
sin($val) Computes the sine of $val (in radians).
sqrt($val) Computes the square root of $val.
tan($num) Computes the tangent of $val (in radians).
time() Returns the number of seconds since January 1, 1970.

Common String Functions