learn php script

Control Structures

2009-01-08T19:26:00.000-08:00

Control Structures

????
if
else
elseif
Alternative syntax for control structures
while
do-while
for
foreach
break
continue
switch
declare
return
require()
include()
require_once()
include_once()

Any PHP script is built out of a series of statements. A statement can be an assignment, a function call, a loop, a conditional statement of even a statement that does nothing (an empty statement). Statements usually end with a semicolon. In addition, statements can be grouped into a statement-group by encapsulating a group of statements with curly braces. A statement-group is a statement by itself as well. The various statement types are described in this chapter.

`if`

The if construct is one of the most important features of many languages, PHP included. It allows for conditional execution of code fragments. PHP features an if structure that is similar to that of C:

if (expression)
   statement
?>

As described in the section about expressions, expr is evaluated to its Boolean value. If expr evaluates to TRUE, PHP will execute statement, and if it evaluates to FALSE - it'll ignore it. More information about what values evaluate to FALSE can be found in the 'Converting to boolean' section.

The following example would display a is bigger than b if $a is bigger than $b:

if  ($a >  $b)
    echo "a is  bigger than b";
?>

Often you'd want to have more than one statement to be executed conditionally. Of course, there's no need to wrap each statement with an if clause. Instead, you can group several statements into a statement group. For example, this code would display a is bigger than b if $a is bigger than $b, and would then assign the value of $a into $b:

if  ($a >  $b)  {
    echo "a is bigger than  b";
    $b = $a;
}
?>

If statements can be nested indefinitely within other if statements, which provides you with complete flexibility for conditional execution of the various parts of your program.

Type Operators

2009-01-08T17:28:00.004-08:00

Type Operators

PHP has a single type operator: instanceof. instanceof is used to determine whether a given object is of a specified object class.

The instanceof operator was introduced in PHP 5. Before this time is_a() was used but is_a() has since been deprecated in favor of instanceof.

class A { }
class B { }

$thing = new A;

if ($thing instanceof A) {
   echo 'A';
}
if ($thing instanceof B) {
   echo 'B';
}
?>

As $thing is an object of type A, but not B, only the block dependent on the A type will be executed:

See also get_class() and is_a().

Array Operators

2009-01-08T17:28:00.003-08:00

Array Operators

???? 15-8. Array Operators

Example	Name	Result
$a + $b	Union	Union of $a and $b.
$a == $b	Equality	`TRUE` if $a and $b have the same key/value pairs.
$a === $b	Identity	`TRUE` if $a and $b have the same key/value pairs in the same order and of the same types.
$a != $b	Inequality	`TRUE` if $a is not equal to $b.
$a <> $b	Inequality	`TRUE` if $a is not equal to $b.
$a !== $b	Non-identity	`TRUE` if $a is not identical to $b.

The + operator appends the right handed array to the left handed, whereas duplicated keys are NOT overwritten.

$a =  array("a" => "apple", "b" =>  "banana");
$b = array("a"  => "pear", "b" =>  "strawberry", "c" => "cherry");

$c  = $a  + $b; // Union of $a and $b
echo "Union of \$a  and \$b: \n";
var_dump($c);

$c  = $b  + $a; // Union of $b and $a
echo "Union of \$b  and \$a: \n";
var_dump($c);
?>

When executed, this script will print the following:

Union of $a and $b:
array(3)  {
  ["a"]=>
  string(5) "apple"
  ["b"]=>
  string(6)  "banana"
  ["c"]=>
  string(6) "cherry"
}
Union of $b and  $a:
array(3) {
  ["a"]=>
  string(4)  "pear"
  ["b"]=>
  string(10)  "strawberry"
  ["c"]=>
  string(6) "cherry"
}

Elements of arrays are equal for the comparison if they have the same key and value.

????? 15-5. Comparing arrays

$a =  array("apple", "banana");
$b = array(1  => "banana",  "0" => "apple");

var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>

See also the manual sections on the Array type and Array functions.

String Operators

2009-01-08T17:28:00.001-08:00

String Operators

There are two string operators. The first is the concatenation operator ('.'), which returns the concatenation of its right and left arguments. The second is the concatenating assignment operator ('.='), which appends the argument on the right side to the argument on the left side. Please read Assignment Operators for more information.

$a =  "Hello ";
$b = $a . "World!";  // now $b contains "Hello  World!"

$a = "Hello  ";
$a  .= "World!";     // now $a  contains "Hello World!"
?>

See also the manual sections on the String type and String functions.

Logical Operators

2009-01-08T17:27:00.004-08:00

Logical Operators

???? 15-7. Logical Operators

Example	Name	Result
$a and $b	And	`TRUE` if both $a and $b are `TRUE`.
$a or $b	Or	`TRUE` if either $a or $b is `TRUE`.
$a xor $b	Xor	`TRUE` if either $a or $b is `TRUE`, but not both.
! $a	Not	`TRUE` if $a is not `TRUE`.
$a && $b	And	`TRUE` if both $a and $b are `TRUE`.
$a \|\| $b	Or	`TRUE` if either $a or $b is `TRUE`.

The reason for the two different variations of "and" and "or" operators is that they operate at different precedences. (See Operator Precedence.)

Incrementing/Decrementing Operators

2009-01-08T17:27:00.003-08:00

Incrementing/Decrementing Operators

PHP supports C-style pre- and post-increment and decrement operators.

????: The increment/decrement operators do not affect boolean values. Decrementing NULL values has no effect too, but incrementing them results in 1.

???? 15-6. Increment/decrement Operators

Example	Name	Effect
++$a	Pre-increment	Increments $a by one, then returns $a.
$a++	Post-increment	Returns $a, then increments $a by one.
--$a	Pre-decrement	Decrements $a by one, then returns $a.
$a--	Post-decrement	Returns $a, then decrements $a by one.

Here's a simple example script:

echo  "Postincrement
";
$a = 5;
echo "Should be  5: " . $a++ . "
\n";
echo "Should be  6: " . $a . "
\n";

echo "Preincrement
";
$a = 5;
echo "Should be  6: " . ++$a . "
\n";
echo "Should be  6: " . $a . "
\n";

echo "Postdecrement
";
$a = 5;
echo "Should be  5: " . $a-- . "
\n";
echo "Should be  4: " . $a . "
\n";

echo "Predecrement
";
$a = 5;
echo "Should be  4: " . --$a . "
\n";
echo "Should be  4: " . $a . "
\n";
?>

PHP follows Perl's convention when dealing with arithmetic operations on character variables and not C's. For example, in Perl 'Z'+1 turns into 'AA', while in C 'Z'+1 turns into '[' ( ord('Z') == 90, ord('[') == 91 ). Note that character variables can be incremented but not decremented.

????? 15-4. Arithmetic Operations on Character Variables

$i =  'W';
for ($n=0; $n<6; $n++) {
    echo  ++$i .  "\n";
}
?>

The above example will output:

X
Y
Z
AA
AB
AC

Incrementing or decrementing booleans has no effect.

Execution Operators

2009-01-08T17:27:00.001-08:00

Execution Operators

PHP supports one execution operator: backticks (``). Note that these are not single-quotes! PHP will attempt to execute the contents of the backticks as a shell command; the output will be returned (i.e., it won't simply be dumped to output; it can be assigned to a variable). Use of the backtick operator is identical to shell_exec().

$output =  `ls -al`;
echo "$output
";
?>

????: The backtick operator is disabled when safe mode is enabled or shell_exec() is disabled.

See also the manual section on Program Execution functions, popen() proc_open(), and Using PHP from the commandline.

Error Control Operators

2009-01-08T17:26:00.005-08:00

Error Control Operators

PHP supports one error control operator: the at sign (@). When prepended to an expression in PHP, any error messages that might be generated by that expression will be ignored.

If the track_errors feature is enabled, any error message generated by the expression will be saved in the variable $php_errormsg. This variable will be overwritten on each error, so check early if you want to use it.

/*  Intentional file error */
$my_file  = @file  ('non_existent_file')  or
    die ("Failed opening file: error  was '$php_errormsg'");

// this works for any expression, not just  functions:
$value = @$cache[$key];
// will not  issue a notice if the index $key doesn't exist.

?>

????: The @-operator works only on expressions. A simple rule of thumb is: if you can take the value of something, you can prepend the @ operator to it. For instance, you can prepend it to variables, function and include() calls, constants, and so forth. You cannot prepend it to function or class definitions, or conditional structures such as if and foreach, and so forth.

See also error_reporting() and the manual section for Error Handling and Logging functions.

?????

Currently the "@" error-control operator prefix will even disable error reporting for critical errors that will terminate script execution. Among other things, this means that if you use "@" to suppress errors from a certain function and either it isn't available or has been mistyped, the script will die right there with no indication as to why.

Comparison Operators

2009-01-08T17:26:00.003-08:00

Comparison Operators

Comparison operators, as their name implies, allow you to compare two values. You may also be interested in viewing the type comparison tables, as they show examples of various type related comparisons.

???? 15-4. Comparison Operators

Example	Name	Result
$a == $b	Equal	`TRUE` if $a is equal to $b.
$a === $b	Identical	`TRUE` if $a is equal to $b, and they are of the same type. (introduced in PHP 4)
$a != $b	Not equal	`TRUE` if $a is not equal to $b.
$a <> $b	Not equal	`TRUE` if $a is not equal to $b.
$a !== $b	Not identical	`TRUE` if $a is not equal to $b, or they are not of the same type. (introduced in PHP 4)
$a < $b	Less than	`TRUE` if $a is strictly less than $b.
$a > $b	Greater than	`TRUE` if $a is strictly greater than $b.
$a <= $b	Less than or equal to	`TRUE` if $a is less than or equal to $b.
$a >= $b	Greater than or equal to	`TRUE` if $a is greater than or equal to $b.

If you compare an integer with a string, the string is converted to a number. If you compare two numerical strings, they are compared as integers. These rules also apply to the switch statement.

var_dump(0 == "a"); // 0 == 0 ->  true
var_dump("1" == "01"); // 1 == 1 ->  true

switch ("a") {
case  0:
    echo "0";
    break;
case "a": // never reached because "a" is already matched with  0
    echo "a";
    break;
}
?>

If types of operands differ, comparison is done according to the following table (in order).

???? 15-5. Comparison with Different Types

Type of Operand 1	Type of Operand 2	Result
null or string	string	Convert `NULL` to "", numerical or lexical comparison
bool or null	anything	Convert to bool, `FALSE` < `TRUE`
object	object	Built-in classes can define its own comparison, different classes are uncomparable, same class - compare properties the same way as arrays (PHP 4), PHP 5 has its own explanation
string, resource or number	string, resource or number	Translate strings and resources to numbers, usual math
array	array	Array with fewer members is smaller, if key from operand 1 is not found in operand 2 then arrays are uncomparable, otherwise - compare value by value (see following example)
array	anything	array is always greater
object	anything	object is always greater

????? 15-2. Transcription of standard array comparison

// Arrays  are compared like this with standard comparison operators
function standard_array_compare($op1, $op2)
{
    if (count($op1) <  count($op2)) {
        return -1; // $op1 < $op2
    } elseif (count($op1) >  count($op2)) {
        return 1; // $op1 > $op2
    }
    foreach ($op1 as $key =>  $val)  {
        if (!array_key_exists($key, $op2)) {
            return null; // uncomparable
        } elseif ($val  < $op2[$key])  {
            return -1;
        } elseif ($val >  $op2[$key]) {
            return 1;
        }
    }
    return 0; // $op1 == $op2
}
?>

See also strcasecmp(), strcmp(), Array operators, and the manual section on Types.

Ternary Operator

Another conditional operator is the "?:" (or ternary) operator.

????? 15-3. Assigning a default value

//  Example usage for: Ternary Operator
$action =  (empty($_POST['action'])) ? 'default'  : $_POST['action'];

// The  above is identical to this if/else statement
if (empty($_POST['action']))  {
     $action = 'default';
} else  {
     $action = $_POST['action'];
}

?>

The expression (expr1) ? (expr2) : (expr3) evaluates to expr2 if expr1 evaluates to TRUE, and expr3 if expr1 evaluates to FALSE.

????: Please note that the ternary operator is a statement, and that it doesn't evaluate to a variable, but to the result of a statement. This is important to know if you want to return a variable by reference. The statement return $var == 42 ? $a : $b; in a return-by-reference function will therefore not work and a warning is issued in later PHP versions.

Bitwise Operators

2009-01-08T17:26:00.001-08:00

Bitwise Operators

Bitwise operators allow you to turn specific bits within an integer on or off. If both the left- and right-hand parameters are strings, the bitwise operator will operate on the characters' ASCII values.

echo  12 ^  9;  // Outputs '5'

echo "12"  ^ "9"; // Outputs the Backspace character (ascii  8)
                 // ('1' (ascii 49)) ^ ('9' (ascii 57)) =  #8

echo "hallo" ^  "hello";  // Outputs the ascii values #0 #4 #0 #0  #0
                        // 'a' ^ 'e' = #4
?>

???? 15-3. Bitwise Operators

Example	Name	Result
$a & $b	And	Bits that are set in both $a and $b are set.
$a \| $b	Or	Bits that are set in either $a or $b are set.
$a ^ $b	Xor	Bits that are set in $a or $b but not both are set.
~ $a	Not	Bits that are set in $a are not set, and vice versa.
$a << $b	Shift left	Shift the bits of $a $b steps to the left (each step means "multiply by two")
$a >> $b	Shift right	Shift the bits of $a $b steps to the right (each step means "divide by two")

?????

Don't right shift for more than 32 bits on 32 bits systems. Don't left shift in case it results to number longer than 32 bits.

Assignment Operators

2009-01-08T17:25:00.004-08:00

Assignment Operators

The basic assignment operator is "=". Your first inclination might be to think of this as "equal to". Don't. It really means that the left operand gets set to the value of the expression on the rights (that is, "gets set to").

The value of an assignment expression is the value assigned. That is, the value of "$a = 3" is 3. This allows you to do some tricky things:


$a =  ($b =  4) +  5;  // $a is equal to 9 now, and $b has been set  to 4.

?>

In addition to the basic assignment operator, there are "combined operators" for all of the binary arithmetic and string operators that allow you to use a value in an expression and then set its value to the result of that expression. For example:


$a =  3;
$a += 5; // sets $a to 8, as  if we had said: $a = $a + 5;
$b  = "Hello  ";
$b  .= "There!";  // sets $b to "Hello There!", just like $b =  $b . "There!";

?>

Note that the assignment copies the original variable to the new one (assignment by value), so changes to one will not affect the other. This may also have relevance if you need to copy something like a large array inside a tight loop. Since PHP 4, assignment by reference has been supported, using the $var = &$othervar; syntax, but this is not possible in PHP 3. 'Assignment by reference' means that both variables end up pointing at the same data, and nothing is copied anywhere. To learn more about references, please read References explained.

Arithmetic Operators

2009-01-08T17:25:00.003-08:00

Arithmetic Operators

Remember basic arithmetic from school? These work just like those.

???? 15-2. Arithmetic Operators

Example	Name	Result
-$a	Negation	Opposite of $a.
$a + $b	Addition	Sum of $a and $b.
$a - $b	Subtraction	Difference of $a and $b.
$a * $b	Multiplication	Product of $a and $b.
$a / $b	Division	Quotient of $a and $b.
$a % $b	Modulus	Remainder of $a divided by $b.

The division operator ("/") returns a float value anytime, even if the two operands are integers (or strings that get converted to integers).

????: Remainder $a % $b is negative for negative $a.

See also the manual page on Math functions.

Arithmetic Operators

2009-01-08T17:25:00.001-08:00

Arithmetic Operators

Remember basic arithmetic from school? These work just like those.

???? 15-2. Arithmetic Operators

Example	Name	Result
-$a	Negation	Opposite of $a.
$a + $b	Addition	Sum of $a and $b.
$a - $b	Subtraction	Difference of $a and $b.
$a * $b	Multiplication	Product of $a and $b.
$a / $b	Division	Quotient of $a and $b.
$a % $b	Modulus	Remainder of $a divided by $b.

The division operator ("/") returns a float value anytime, even if the two operands are integers (or strings that get converted to integers).

????: Remainder $a % $b is negative for negative $a.

See also the manual page on Math functions.

Operators

2009-01-08T17:24:00.002-08:00

Operators

????
Operator Precedence
Arithmetic Operators
Assignment Operators
Bitwise Operators
Comparison Operators
Error Control Operators
Execution Operators
Incrementing/Decrementing Operators
Logical Operators
String Operators
Array Operators
Type Operators

An operator is something that you feed with one or more values (or expressions, in programming jargon) which yields another value (so that the construction itself becomes an expression). So you can think of functions or constructions that return a value (like print) as operators and those that return nothing (like echo) as any other thing.

There are three types of operators. Firstly there is the unary operator which operates on only one value, for example ! (the negation operator) or ++ (the increment operator). The second group are termed binary operators; this group contains most of the operators that PHP supports, and a list follows below in the section Operator Precedence.

The third group is the ternary operator: ?:. It should be used to select between two expressions depending on a third one, rather than to select two sentences or paths of execution. Surrounding ternary expressions with parentheses is a very good idea.

Operator Precedence

The precedence of an operator specifies how "tightly" it binds two expressions together. For example, in the expression 1 + 5 * 3, the answer is 16 and not 18 because the multiplication ("*") operator has a higher precedence than the addition ("+") operator. Parentheses may be used to force precedence, if necessary. For instance: (1 + 5) * 3 evaluates to 18. If operator precedence is equal, left to right associativity is used.

The following table lists the precedence of operators with the highest-precedence operators listed at the top of the table. Operators on the same line have equal precedence, in which case their associativity decides which order to evaluate them in.

???? 15-1. Operator Precedence

Associativity	Operators	Additional Information
non-associative	new	new
right	[	array()
non-associative	++ --	increment/decrement
non-associative	! ~ - (int) (float) (string) (array) (object) @	types
left	* / %	arithmetic
left	+ - .	arithmetic and string
left	<< >>	bitwise
non-associative	< <= > >=	comparison
non-associative	== != === !==	comparison
left	&	bitwise and references
left	^	bitwise
left	\|	bitwise
left	&&	logical
left	\|\|	logical
left	? :	ternary
right	= += -= *= /= .= %= &= \|= ^= <<= >>=	assignment
left	and	logical
left	xor	logical
left	or	logical
left	,	many uses

Left associativity means that the expression is evaluated from left to right, right associativity means the opposite.

????? 15-1. Associativity

$a =  3 *  3 %  5;  // (3 * 3) % 5 = 4
$a = true ? 0 : true ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2

$a = 1;
$b = 2;
$a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5
?>

Use parentheses to increase readability of the code.

????: Although ! has a higher precedence than =, PHP will still allow expressions similar to the following: if (!$a = foo()), in which case the output from foo() is put into $a.

Expressions

2009-01-08T17:24:00.001-08:00

Expressions

Expressions are the most important building stones of PHP. In PHP, almost anything you write is an expression. The simplest yet most accurate way to define an expression is "anything that has a value".

The most basic forms of expressions are constants and variables. When you type "$a = 5", you're assigning '5' into $a. '5', obviously, has the value 5, or in other words '5' is an expression with the value of 5 (in this case, '5' is an integer constant).

After this assignment, you'd expect $a's value to be 5 as well, so if you wrote $b = $a, you'd expect it to behave just as if you wrote $b = 5. In other words, $a is an expression with the value of 5 as well. If everything works right, this is exactly what will happen.

Slightly more complex examples for expressions are functions. For instance, consider the following function:

function  foo ()
{
    return 5;
}
?>

Assuming you're familiar with the concept of functions (if you're not, take a look at the chapter about functions), you'd assume that typing $c = foo() is essentially just like writing $c = 5, and you're right. Functions are expressions with the value of their return value. Since foo() returns 5, the value of the expression 'foo()' is 5. Usually functions don't just return a static value but compute something.

Of course, values in PHP don't have to be integers, and very often they aren't. PHP supports four scalar value types: integer values, floating point values (float), string values and boolean values (scalar values are values that you can't 'break' into smaller pieces, unlike arrays, for instance). PHP also supports two composite (non-scalar) types: arrays and objects. Each of these value types can be assigned into variables or returned from functions.

PHP takes expressions much further, in the same way many other languages do. PHP is an expression-oriented language, in the sense that almost everything is an expression. Consider the example we've already dealt with, '$a = 5'. It's easy to see that there are two values involved here, the value of the integer constant '5', and the value of $a which is being updated to 5 as well. But the truth is that there's one additional value involved here, and that's the value of the assignment itself. The assignment itself evaluates to the assigned value, in this case 5. In practice, it means that '$a = 5', regardless of what it does, is an expression with the value 5. Thus, writing something like '$b = ($a = 5)' is like writing '$a = 5; $b = 5;' (a semicolon marks the end of a statement). Since assignments are parsed in a right to left order, you can also write '$b = $a = 5'.

Another good example of expression orientation is pre- and post-increment and decrement. Users of PHP and many other languages may be familiar with the notation of variable++ and variable--. These are increment and decrement operators. In PHP/FI 2, the statement '$a++' has no value (is not an expression), and thus you can't assign it or use it in any way. PHP enhances the increment/decrement capabilities by making these expressions as well, like in C. In PHP, like in C, there are two types of increment - pre-increment and post-increment. Both pre-increment and post-increment essentially increment the variable, and the effect on the variable is identical. The difference is with the value of the increment expression. Pre-increment, which is written '++$variable', evaluates to the incremented value (PHP increments the variable before reading its value, thus the name 'pre-increment'). Post-increment, which is written '$variable++' evaluates to the original value of $variable, before it was incremented (PHP increments the variable after reading its value, thus the name 'post-increment').

A very common type of expressions are comparison expressions. These expressions evaluate to either FALSE or TRUE. PHP supports > (bigger than), >= (bigger than or equal to), == (equal), != (not equal), < (smaller than) and <= (smaller than or equal to). The language also supports a set of strict equivalence operators: === (equal to and same type) and !== (not equal to or not same type). These expressions are most commonly used inside conditional execution, such as if statements.

The last example of expressions we'll deal with here is combined operator-assignment expressions. You already know that if you want to increment $a by 1, you can simply write '$a++' or '++$a'. But what if you want to add more than one to it, for instance 3? You could write '$a++' multiple times, but this is obviously not a very efficient or comfortable way. A much more common practice is to write '$a = $a + 3'. '$a + 3' evaluates to the value of $a plus 3, and is assigned back into $a, which results in incrementing $a by 3. In PHP, as in several other languages like C, you can write this in a shorter way, which with time would become clearer and quicker to understand as well. Adding 3 to the current value of $a can be written '$a += 3'. This means exactly "take the value of $a, add 3 to it, and assign it back into $a". In addition to being shorter and clearer, this also results in faster execution. The value of '$a += 3', like the value of a regular assignment, is the assigned value. Notice that it is NOT 3, but the combined value of $a plus 3 (this is the value that's assigned into $a). Any two-place operator can be used in this operator-assignment mode, for example '$a -= 5' (subtract 5 from the value of $a), '$b *= 7' (multiply the value of $b by 7), etc.

There is one more expression that may seem odd if you haven't seen it in other languages, the ternary conditional operator:

$first ?  $second : $third
?>

If the value of the first subexpression is TRUE (non-zero), then the second subexpression is evaluated, and that is the result of the conditional expression. Otherwise, the third subexpression is evaluated, and that is the value.

The following example should help you understand pre- and post-increment and expressions in general a bit better:

function  double($i)
{
    return $i*2;
}
$b  = $a  = 5;        /* assign  the value five into the variable $a and $b */
$c = $a++;          /*  post-increment, assign original value of $a
                       (5) to $c  */
$e = $d = ++$b;     /*  pre-increment, assign the incremented value of
                       $b (6)  to $d and $e */

/* at this point, both $d and $e are equal to 6  */

$f = double($d++);  /* assign twice  the value of $d before
                       the increment, 2*6 = 12 to $f  */
$g = double(++$e);  /* assign twice  the value of $e after
                       the increment, 2*7 = 14 to $g  */
$h = $g += 10;      /* first, $g  is incremented by 10 and ends with the
                       value of 24.  the value of the assignment (24) is
                       then assigned  into $h, and $h ends with the value
                       of 24 as well.  */
?>

Some expressions can be considered as statements. In this case, a statement has the form of 'expr' ';' that is, an expression followed by a semicolon. In '$b=$a=5;', $a=5 is a valid expression, but it's not a statement by itself. '$b=$a=5;' however is a valid statement.

One last thing worth mentioning is the truth value of expressions. In many events, mainly in conditional execution and loops, you're not interested in the specific value of the expression, but only care about whether it means TRUE or FALSE. The constants TRUE and FALSE (case-insensitive) are the two possible boolean values. When necessary, an expression is automatically converted to boolean. See the section about type-casting for details about how.

PHP provides a full and powerful implementation of expressions, and documenting it entirely goes beyond the scope of this manual. The above examples should give you a good idea about what expressions are and how you can construct useful expressions. Throughout the rest of this manual we'll write expr to indicate any valid PHP expression.

Magic constants

2009-01-08T17:23:00.002-08:00

Magic constants

PHP provides a large number of predefined constants to any script which it runs. Many of these constants, however, are created by various extensions, and will only be present when those extensions are available, either via dynamic loading or because they have been compiled in.

There are five magical constants that change depending on where they are used. For example, the value of __LINE__ depends on the line that it's used on in your script. These special constants are case-insensitive and are as follows:

???? 13-1. A few "magical" PHP constants

Name	Description
`__LINE__`	The current line number of the file.
`__FILE__`	The full path and filename of the file. If used inside an include, the name of the included file is returned. Since PHP 4.0.2, `__FILE__` always contains an absolute path whereas in older versions it contained relative path under some circumstances.
`__FUNCTION__`	The function name. (Added in PHP 4.3.0) As of PHP 5 this constant returns the function name as it was declared (case-sensitive). In PHP 4 its value is always lowercased.
`__CLASS__`	The class name. (Added in PHP 4.3.0) As of PHP 5 this constant returns the class name as it was declared (case-sensitive). In PHP 4 its value is always lowercased.
`__METHOD__`	The class method name. (Added in PHP 5.0.0) The method name is returned as it was declared (case-sensitive).

See also get_class(), get_object_vars(), file_exists() and function_exists().

Constants

2009-01-08T17:23:00.001-08:00

Constants

????
Syntax
Magic constants

A constant is an identifier (name) for a simple value. As the name suggests, that value cannot change during the execution of the script (except for magic constants, which aren't actually constants). A constant is case-sensitive by default. By convention, constant identifiers are always uppercase.

The name of a constant follows the same rules as any label in PHP. A valid constant name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. As a regular expression, it would be expressed thusly: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*

????? 13-1. Valid and invalid constant names


//  Valid constant names
define("FOO",     "something");
define("FOO2",    "something  else");
define("FOO_BAR",  "something more")

// Invalid  constant names
define("2FOO",    "something");

// This is  valid, but should be avoided:
// PHP may one day provide a magical  constant
// that will break your script
define("__FOO__",  "something");

?>

????: For our purposes here, a letter is a-z, A-Z, and the ASCII characters from 127 through 255 (0x7f-0xff).

Like superglobals, the scope of a constant is global. You can access constants anywhere in your script without regard to scope. For more information on scope, read the manual section on variable scope.

Syntax

You can define a constant by using the define()-function. Once a constant is defined, it can never be changed or undefined.

Only scalar data (boolean, integer, float and string) can be contained in constants.

You can get the value of a constant by simply specifying its name. Unlike with variables, you should not prepend a constant with a $. You can also use the function constant() to read a constant's value if you wish to obtain the constant's name dynamically. Use get_defined_constants() to get a list of all defined constants.

????: Constants and (global) variables are in a different namespace. This implies that for example TRUE and $TRUE are generally different.

If you use an undefined constant, PHP assumes that you mean the name of the constant itself, just as if you called it as a string (CONSTANT vs "CONSTANT"). An error of level E_NOTICE will be issued when this happens. See also the manual entry on why $foo[bar] is wrong (unless you first define() bar as a constant). If you simply want to check if a constant is set, use the defined() function.

These are the differences between constants and variables:

Constants do not have a dollar sign ($) before them;
Constants may only be defined using the define() function, not by simple assignment;
Constants may be defined and accessed anywhere without regard to variable scoping rules;
Constants may not be redefined or undefined once they have been set; and
Constants may only evaluate to scalar values.

????? 13-2. Defining Constants

define("CONSTANT",  "Hello world.");
echo CONSTANT;  // outputs "Hello world."
echo Constant;  // outputs "Constant" and issues a  notice.
?>

Variables from outside PHP

2009-01-08T17:22:00.004-08:00

Variables from outside PHP

HTML Forms (GET and POST)

When a form is submitted to a PHP script, the information from that form is automatically made available to the script. There are many ways to access this information, for example:

????? 12-8. A simple HTML form



   Name:  


   Email:

Depending on your particular setup and personal preferences, there are many ways to access data from your HTML forms. Some examples are:

????? 12-9. Accessing data from a simple POST HTML form

// Available since PHP 4.1.0



  echo $_POST['username'];

  echo $_REQUEST['username'];



  import_request_variables('p', 'p_');

  echo $p_username;



// Available since PHP 3. As of PHP 5.0.0, these long predefined

// variables can be disabled with the register_long_arrays directive.



  echo $HTTP_POST_VARS['username'];



// Available if the PHP directive register_globals = on. As of

// PHP 4.2.0 the default value of register_globals = off.

// Using/relying on this method is not preferred.



  echo $username;

?>

Using a GET form is similar except you'll use the appropriate GET predefined variable instead. GET also applies to the QUERY_STRING (the information after the '?' in a URL). So, for example, http://www.example.com/test.php?id=3 contains GET data which is accessible with $_GET['id']. See also $_REQUEST and import_request_variables().

????: Superglobal arrays, like $_POST and $_GET, became available in PHP 4.1.0

As shown, before PHP 4.2.0 the default value for register_globals was on. And, in PHP 3 it was always on. The PHP community is encouraging all to not rely on this directive as it's preferred to assume it's off and code accordingly.

????: The magic_quotes_gpc configuration directive affects Get, Post and Cookie values. If turned on, value (It's "PHP!") will automagically become (It\'s \"PHP!\"). Escaping is needed for DB insertion. See also addslashes(), stripslashes() and magic_quotes_sybase.

PHP also understands arrays in the context of form variables (see the related faq). You may, for example, group related variables together, or use this feature to retrieve values from a multiple select input. For example, let's post a form to itself and upon submission display the data:

????? 12-10. More complex form variables

if  (isset($_POST['action']) && $_POST['action'] ==  'submitted') {

    echo '';

    print_r($_POST);

    echo  '. $_SERVER['PHP_SELF']  .'">Please try  again';



    echo  '
';

} else {

?>

echo  $_SERVER['PHP_SELF'];  ?>"  method="post">

    Name:  


    Email: 


    Beer: 


    


    

    



}

?>

In PHP 3, the array form variable usage is limited to single-dimensional arrays. As of PHP 4, no such restriction applies.

IMAGE SUBMIT variable names

When submitting a form, it is possible to use an image instead of the standard submit button with a tag like:

When the user clicks somewhere on the image, the accompanying form will be transmitted to the server with two additional variables, sub_x and sub_y. These contain the coordinates of the user click within the image. The experienced may note that the actual variable names sent by the browser contains a period rather than an underscore, but PHP converts the period to an underscore automatically.

HTTP Cookies

PHP transparently supports HTTP cookies as defined by Netscape's Spec. Cookies are a mechanism for storing data in the remote browser and thus tracking or identifying return users. You can set cookies using the setcookie() function. Cookies are part of the HTTP header, so the SetCookie function must be called before any output is sent to the browser. This is the same restriction as for the header() function. Cookie data is then available in the appropriate cookie data arrays, such as $_COOKIE, $HTTP_COOKIE_VARS as well as in $_REQUEST. See the setcookie() manual page for more details and examples.

If you wish to assign multiple values to a single cookie variable, you may assign it as an array. For example:

  setcookie("MyCookie[foo]",  'Testing 1', time()+3600);

  setcookie("MyCookie[bar]",  'Testing 2', time()+3600);

?>

That will create two separate cookies although MyCookie will now be a single array in your script. If you want to set just one cookie with multiple values, consider using serialize() or explode() on the value first.

Note that a cookie will replace a previous cookie by the same name in your browser unless the path or domain is different. So, for a shopping cart application you may want to keep a counter and pass this along. i.e.

????? 12-11. A setcookie() example

if  (isset($_COOKIE['count'])) {

    $count  = $_COOKIE['count'] +  1;

}  else {

    $count = 1;

}

setcookie('count', $count, time()+3600);

setcookie("Cart[$count]",  $item,  time()+3600);

?>

Dots in incoming variable names

Typically, PHP does not alter the names of variables when they are passed into a script. However, it should be noted that the dot (period, full stop) is not a valid character in a PHP variable name. For the reason, look at it:

$varname.ext;  /* invalid  variable name */

?>

Now, what the parser sees is a variable named $varname, followed by the string concatenation operator, followed by the barestring (i.e. unquoted string which doesn't match any known key or reserved words) 'ext'. Obviously, this doesn't have the intended result.

For this reason, it is important to note that PHP will automatically replace any dots in incoming variable names with underscores.

Determining variable types

Because PHP determines the types of variables and converts them (generally) as needed, it is not always obvious what type a given variable is at any one time. PHP includes several functions which find out what type a variable is, such as: gettype(), is_array(), is_float(), is_int(), is_object(), and is_string(). See also the chapter on Types.

Variable variables

2009-01-08T17:22:00.003-08:00

Variable variables

Sometimes it is convenient to be able to have variable variable names. That is, a variable name which can be set and used dynamically. A normal variable is set with a statement such as:

$a =  'hello';
?>

A variable variable takes the value of a variable and treats that as the name of a variable. In the above example, hello, can be used as the name of a variable by using two dollar signs. i.e.

$$a = 'world';
?>

At this point two variables have been defined and stored in the PHP symbol tree: $a with contents "hello" and $hello with contents "world". Therefore, this statement:

echo  "$a ${$a}";
?>

produces the exact same output as:

echo  "$a $hello";
?>

i.e. they both produce: hello world.

In order to use variable variables with arrays, you have to resolve an ambiguity problem. That is, if you write $$a[1] then the parser needs to know if you meant to use $a[1] as a variable, or if you wanted $$a as the variable and then the [1] index from that variable. The syntax for resolving this ambiguity is: ${$a[1]} for the first case and ${$a}[1] for the second.

?????

Please note that variable variables cannot be used with PHP's Superglobal arrays within functions or class methods.

Variable scope

2009-01-08T17:22:00.001-08:00

Variable scope

The scope of a variable is the context within which it is defined. For the most part all PHP variables only have a single scope. This single scope spans included and required files as well. For example:

$a =  1;
include 'b.inc';
?>

Here the $a variable will be available within the included b.inc script. However, within user-defined functions a local function scope is introduced. Any variable used inside a function is by default limited to the local function scope. For example:

$a =  1;  /* global scope */

function Test()
{ 
    echo $a; /* reference to  local scope variable */
} 

Test();
?>

This script will not produce any output because the echo statement refers to a local version of the $a variable, and it has not been assigned a value within this scope. You may notice that this is a little bit different from the C language in that global variables in C are automatically available to functions unless specifically overridden by a local definition. This can cause some problems in that people may inadvertently change a global variable. In PHP global variables must be declared global inside a function if they are going to be used in that function.

The global keyword

First, an example use of global:

????? 12-1. Using global

$a =  1;
$b = 2;

function Sum()
{
    global $a, $b;

    $b  = $a  + $b;
} 

Sum();
echo $b;
?>

The above script will output "3". By declaring $a and $b global within the function, all references to either variable will refer to the global version. There is no limit to the number of global variables that can be manipulated by a function.

A second way to access variables from the global scope is to use the special PHP-defined $GLOBALS array. The previous example can be rewritten as:

????? 12-2. Using $GLOBALS instead of global

$a =  1;
$b = 2;

function Sum()
{
    $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
} 

Sum();
echo $b;
?>

The $GLOBALS array is an associative array with the name of the global variable being the key and the contents of that variable being the value of the array element. Notice how $GLOBALS exists in any scope, this is because $GLOBALS is a superglobal. Here's an example demonstrating the power of superglobals:

????? 12-3. Example demonstrating superglobals and scope

function  test_global()
{
    //  Most predefined variables aren't "super" and require
    // 'global' to be  available to the functions local scope.
    global $HTTP_POST_VARS;
   
    echo $HTTP_POST_VARS['name'];
   
    //  Superglobals are available in any scope and do
    // not require 'global'.  Superglobals are available
    // as of PHP 4.1.0, and HTTP_POST_VARS is  now
    // deemed deprecated.
    echo  $_POST['name'];
}
?>

Using static variables

Another important feature of variable scoping is the static variable. A static variable exists only in a local function scope, but it does not lose its value when program execution leaves this scope. Consider the following example:

????? 12-4. Example demonstrating need for static variables

function  Test()
{
    $a  = 0;
    echo  $a;
    $a++;
}
?>

This function is quite useless since every time it is called it sets $a to 0 and prints "0". The $a++ which increments the variable serves no purpose since as soon as the function exits the $a variable disappears. To make a useful counting function which will not lose track of the current count, the $a variable is declared static:

????? 12-5. Example use of static variables

function  Test()
{
    static $a = 0;
    echo  $a;
    $a++;
}
?>

Now, every time the Test() function is called it will print the value of $a and increment it.

Static variables also provide one way to deal with recursive functions. A recursive function is one which calls itself. Care must be taken when writing a recursive function because it is possible to make it recurse indefinitely. You must make sure you have an adequate way of terminating the recursion. The following simple function recursively counts to 10, using the static variable $count to know when to stop:

????? 12-6. Static variables with recursive functions

function  Test()
{
    static $count = 0;

    $count++;
    echo  $count;
    if ($count  < 10)  {
        Test();
    }
    $count--;
}
?>

????: Static variables may be declared as seen in the examples above. Trying to assign values to these variables which are the result of expressions will cause a parse error.

????? 12-7. Declaring static variables

function foo(){ static $int = 0; // correct static $int = 1+2; // wrong (as it is an expression) static $int = sqrt(121); // wrong (as it is an expression too) $int++; echo $int; } ?>

References with global and static variables

The Zend Engine 1, driving PHP 4, implements the static and global modifier for variables in terms of references. For example, a true global variable imported inside a function scope with the global statement actually creates a reference to the global variable. This can lead to unexpected behaviour which the following example addresses:

function  test_global_ref() {
    global $obj;
    $obj  = &new stdclass;
}

function test_global_noref()  {
    global $obj;
    $obj  = new stdclass;
}

test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>

Executing this example will result in the following output:

NULL
object(stdClass)(0) {
}

A similar behaviour applies to the static statement. References are not stored statically:

function  &get_instance_ref() {
    static $obj;

    echo  'Static object: ';
    var_dump($obj);
    if  (!isset($obj)) {
        //  Assign a reference to the static variable
        $obj = &new  stdclass;
    }
    $obj->property++;
    return $obj;
}

function &get_instance_noref()  {
    static $obj;

    echo 'Static object: ';
    var_dump($obj);
    if  (!isset($obj)) {
        //  Assign the object to the static variable
        $obj = new  stdclass;
    }
    $obj->property++;
    return $obj;
}

$obj1  = get_instance_ref();
$still_obj1  = get_instance_ref();
echo "\n";
$obj2 = get_instance_noref();
$still_obj2  = get_instance_noref();
?>

Executing this example will result in the following output:

Static object: NULL
Static object: NULL

Static object: NULL
Static object: object(stdClass)(1) {
 ["property"]=>
 int(1)
}

This example demonstrates that when assigning a reference to a static variable, it's not remembered when you call the &get_instance_ref() function a second time.

Predefined variables

2009-01-08T17:21:00.003-08:00

Predefined variables

PHP provides a large number of predefined variables to any script which it runs. Many of these variables, however, cannot be fully documented as they are dependent upon which server is running, the version and setup of the server, and other factors. Some of these variables will not be available when PHP is run on the command line. For a listing of these variables, please see the section on Reserved Predefined Variables.

?????

In PHP 4.2.0 and later, the default value for the PHP directive register_globals is off. This is a major change in PHP. Having register_globals off affects the set of predefined variables available in the global scope. For example, to get DOCUMENT_ROOT you'll use $_SERVER['DOCUMENT_ROOT'] instead of $DOCUMENT_ROOT, or $_GET['id'] from the URL http://www.example.com/test.php?id=3 instead of $id, or $_ENV['HOME'] instead of $HOME.

For related information on this change, read the configuration entry for register_globals, the security chapter on Using Register Globals , as well as the PHP 4.1.0 and 4.2.0 Release Announcements.

Using the available PHP Reserved Predefined Variables, like the superglobal arrays, is preferred.

From version 4.1.0 onward, PHP provides an additional set of predefined arrays containing variables from the web server (if applicable), the environment, and user input. These new arrays are rather special in that they are automatically global--i.e., automatically available in every scope. For this reason, they are often known as 'autoglobals' or 'superglobals'. (There is no mechanism in PHP for user-defined superglobals.) The superglobals are listed below; however, for a listing of their contents and further discussion on PHP predefined variables and their natures, please see the section Reserved Predefined Variables. Also, you'll notice how the older predefined variables ($HTTP_*_VARS) still exist. As of PHP 5.0.0, the long PHP predefined variable arrays may be disabled with the register_long_arrays directive.

Variable variables: Superglobals cannot be used as variable variables inside functions or class methods.

????: Even though both the superglobal and HTTP_*_VARS can exist at the same time; they are not identical, so modifying one will not change the other.

If certain variables in variables_order are not set, their appropriate PHP predefined arrays are also left empty.

PHP Superglobals

$GLOBALS

Contains a reference to every variable which is currently available within the global scope of the script. The keys of this array are the names of the global variables. $GLOBALS has existed since PHP 3.

$_SERVER

Variables set by the web server or otherwise directly related to the execution environment of the current script. Analogous to the old $HTTP_SERVER_VARS array (which is still available, but deprecated).

$_GET

Variables provided to the script via URL query string. Analogous to the old $HTTP_GET_VARS array (which is still available, but deprecated).

$_POST

Variables provided to the script via HTTP POST. Analogous to the old $HTTP_POST_VARS array (which is still available, but deprecated).

$_COOKIE

Variables provided to the script via HTTP cookies. Analogous to the old $HTTP_COOKIE_VARS array (which is still available, but deprecated).

$_FILES

Variables provided to the script via HTTP post file uploads. Analogous to the old $HTTP_POST_FILES array (which is still available, but deprecated). See POST method uploads for more information.

$_ENV

Variables provided to the script via the environment. Analogous to the old $HTTP_ENV_VARS array (which is still available, but deprecated).

$_REQUEST

Variables provided to the script via the GET, POST, and COOKIE input mechanisms, and which therefore cannot be trusted. The presence and order of variable inclusion in this array is defined according to the PHP variables_order configuration directive. This array has no direct analogue in versions of PHP prior to 4.1.0. See also import_request_variables().

?????

Since PHP 4.3.0, FILE information from $_FILES does not exist in $_REQUEST.

????: When running on the command line , this will not include the argv and argc entries; these are present in the $_SERVER array.

$_SESSION

Variables which are currently registered to a script's session. Analogous to the old $HTTP_SESSION_VARS array (which is still available, but deprecated). See the Session handling functions section for more information.

Variables

2009-01-08T17:21:00.001-08:00

Variables

????
Basics
Predefined variables
Variable scope
Variable variables
Variables from outside PHP

Basics

Variables in PHP are represented by a dollar sign followed by the name of the variable. The variable name is case-sensitive.

Variable names follow the same rules as other labels in PHP. A valid variable name starts with a letter or underscore, followed by any number of letters, numbers, or underscores. As a regular expression, it would be expressed thus: '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'

????: For our purposes here, a letter is a-z, A-Z, and the ASCII characters from 127 through 255 (0x7f-0xff).

For information on variable related functions, see the Variable Functions Reference.

$var =  'Bob';
$Var  = 'Joe';
echo  "$var, $Var";      // outputs  "Bob, Joe"

$4site = 'not yet';     // invalid;  starts with a number
$_4site = 'not  yet';    // valid; starts with an underscore
$täyte = 'mansikka';    // valid; 'ä' is  (Extended) ASCII 228.
?>

In PHP 3, variables are always assigned by value. That is to say, when you assign an expression to a variable, the entire value of the original expression is copied into the destination variable. This means, for instance, that after assigning one variable's value to another, changing one of those variables will have no effect on the other. For more information on this kind of assignment, see the chapter on Expressions.

As of PHP 4, PHP offers another way to assign values to variables: assign by reference. This means that the new variable simply references (in other words, "becomes an alias for" or "points to") the original variable. Changes to the new variable affect the original, and vice versa. This also means that no copying is performed; thus, the assignment happens more quickly. However, any speedup will likely be noticed only in tight loops or when assigning large arrays or objects.

To assign by reference, simply prepend an ampersand (&) to the beginning of the variable which is being assigned (the source variable). For instance, the following code snippet outputs 'My name is Bob' twice:

$foo =  'Bob';              //  Assign the value 'Bob' to $foo
$bar  = &$foo;              //  Reference $foo via $bar.
$bar  = "My  name is $bar";  // Alter $bar...
echo $bar;
echo $foo;                 //  $foo is altered too.
?>

One important thing to note is that only named variables may be assigned by reference.

$foo =  25;
$bar  = &$foo;      // This is a  valid assignment.
$bar = &(24  * 7);  // Invalid; references an unnamed  expression.

function test()
{
   return 25;
}

$bar  = &test();    //  Invalid.
?>

Type Juggling

2009-01-08T17:20:00.004-08:00

Type Juggling

PHP does not require (or support) explicit type definition in variable declaration; a variable's type is determined by the context in which that variable is used. That is to say, if you assign a string value to variable $var, $var becomes a string. If you then assign an integer value to $var, it becomes an integer.

An example of PHP's automatic type conversion is the addition operator '+'. If any of the operands is a float, then all operands are evaluated as floats, and the result will be a float. Otherwise, the operands will be interpreted as integers, and the result will also be an integer. Note that this does NOT change the types of the operands themselves; the only change is in how the operands are evaluated.

$foo =  "0";  // $foo is string  (ASCII 48)
$foo += 2;   // $foo is now an  integer (2)
$foo = $foo + 1.3;  // $foo is now a  float (3.3)
$foo = 5 + "10 Little  Piggies"; // $foo is integer (15)
$foo = 5 + "10 Small Pigs";     // $foo is  integer (15)
?>

If the last two examples above seem odd, see String conversion to numbers.

If you wish to force a variable to be evaluated as a certain type, see the section on Type casting. If you wish to change the type of a variable, see settype().

If you would like to test any of the examples in this section, you can use the var_dump() function.

????: The behaviour of an automatic conversion to array is currently undefined.

$a = "1"; // $a is a string $a[0] = "f"; // What about string offsets? What happens? ?>

Since PHP (for historical reasons) supports indexing into strings via offsets using the same syntax as array indexing, the example above leads to a problem: should $a become an array with its first element being "f", or should "f" become the first character of the string $a?

The current versions of PHP interpret the second assignment as a string offset identification, so $a becomes "f", the result of this automatic conversion however should be considered undefined. PHP 4 introduced the new curly bracket syntax to access characters in string, use this syntax instead of the one presented above:

$a = "abc"; // $a is a string $a{1} = "f"; // $a is now "afc" ?>

See the section titled String access by character for more information.

Type Casting

Type casting in PHP works much as it does in C: the name of the desired type is written in parentheses before the variable which is to be cast.

$foo =  10;   // $foo is an  integer
$bar = (boolean) $foo;   // $bar is a boolean
?>

The casts allowed are:

(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

Note that tabs and spaces are allowed inside the parentheses, so the following are functionally equivalent:

$foo =  (int) $bar;
$foo  = ( int ) $bar;
?>

????: Instead of casting a variable to string, you can also enclose the variable in double quotes.

$foo = 10; // $foo is an integer $str = "$foo"; // $str is a string $fst = (string) $foo; // $fst is also a string // This prints out that "they are the same" if ($fst === $str) { echo "they are the same"; } ?>

It may not be obvious exactly what will happen when casting between certain types. For more info, see these sections:

Converting to boolean
Converting to integer
Converting to float
Converting to string
Converting to array
Converting to object
Converting to resource
The type comparison tables

Pseudo-types used in this documentation

2009-01-08T17:20:00.003-08:00

Pseudo-types used in this documentation

mixed

mixed indicates that a parameter may accept multiple (but not necessarily all) types.

gettype() for example will accept all PHP types, while str_replace() will accept strings and arrays.

number

number indicates that a parameter can be either integer or float.

callback

Some functions like call_user_func() or usort() accept user defined callback functions as a parameter. Callback functions can not only be simple functions but also object methods including static class methods.

A PHP function is simply passed by its name as a string. You can pass any builtin or user defined function with the exception of array(), echo(), empty(), eval(), exit(), isset(), list(), print() and unset().

A method of an instantiated object is passed as an array containing an object as the element with index 0 and a method name as the element with index 1.

Static class methods can also be passed without instantiating an object of that class by passing the class name instead of an object as the element with index 0.

????? 11-13. Callback function examples

// An example callback  function
function my_callback_function() {
    echo 'hello world!';
}

// An  example callback method
class  MyClass {
    function myCallbackMethod()  {
        echo 'Hello World!';
    }
}

// Type 1: Simple callback
call_user_func('my_callback_function');

// Type 2:  Static class method call
call_user_func(array('MyClass',  'myCallbackMethod'));

// Type  3: Object method call
$obj = new MyClass();
call_user_func(array(&$obj, 'myCallbackMethod'));
?>

NULL

2009-01-08T17:20:00.001-08:00

NULL

The special NULL value represents that a variable has no value. NULL is the only possible value of type NULL.

????: The null type was introduced in PHP 4.

A variable is considered to be NULL if

it has been assigned the constant NULL.
it has not been set to any value yet.
it has been unset().

Syntax

There is only one value of type NULL, and that is the case-insensitive keyword NULL.

$var =  NULL;      
?>

Resource

2009-01-08T17:19:00.002-08:00

Resource

A resource is a special variable, holding a reference to an external resource. Resources are created and used by special functions. See the appendix for a listing of all these functions and the corresponding resource types.

????: The resource type was introduced in PHP 4

Converting to resource

As resource types hold special handlers to opened files, database connections, image canvas areas and the like, you cannot convert any value to a resource.

Freeing resources

Due to the reference-counting system introduced with PHP 4's Zend Engine, it is automatically detected when a resource is no longer referred to (just like Java). When this is the case, all resources that were in use for this resource are made free by the garbage collector. For this reason, it is rarely ever necessary to free the memory manually by using some free_result function.

????: Persistent database links are special, they are not destroyed by the garbage collector. See also the section about persistent connections.

Objects

2009-01-08T17:19:00.001-08:00

Objects

Object Initialization

To initialize an object, you use the new statement to instantiate the object to a variable.

class  foo
{
    function do_foo()
    {
        echo "Doing foo."; 
    }
}

$bar = new foo;
$bar->do_foo();
?>

For a full discussion, please read the section Classes and Objects.

Converting to object

If an object is converted to an object, it is not modified. If a value of any other type is converted to an object, a new instance of the stdClass built in class is created. If the value was null, the new instance will be empty. For any other value, a member variable named scalar will contain the value.

$obj =  (object) 'ciao';
echo $obj->scalar;  // outputs 'ciao'
?>

Arrays

2009-01-08T17:18:00.004-08:00

Arrays

An array in PHP is actually an ordered map. A map is a type that maps values to keys. This type is optimized in several ways, so you can use it as a real array, or a list (vector), hashtable (which is an implementation of a map), dictionary, collection, stack, queue and probably more. Because you can have another PHP array as a value, you can also quite easily simulate trees.

Explanation of those data structures is beyond the scope of this manual, but you'll find at least one example for each of them. For more information we refer you to external literature about this broad topic.

Syntax

Specifying with array()

An array can be created by the array() language-construct. It takes a certain number of comma-separated key => value pairs.

array( [key =>] value
    , ...
    )
// key may be an integer or string
// value may be any value

$arr =  array("foo" => "bar", 12 => true);

echo  $arr["foo"]; //  bar
echo $arr[12];    // 1
?>

A key may be either an integer or a string. If a key is the standard representation of an integer, it will be interpreted as such (i.e. "8" will be interpreted as 8, while "08" will be interpreted as "08"). Floats in key are truncated to integer. There are no different indexed and associative array types in PHP; there is only one array type, which can both contain integer and string indices.

A value can be of any PHP type.

$arr =  array("somearray" => array(6  => 5, 13 => 9, "a" =>  42));

echo $arr["somearray"][6];    //  5
echo $arr["somearray"][13];   //  9
echo $arr["somearray"]["a"];  //  42
?>

If you do not specify a key for a given value, then the maximum of the integer indices is taken, and the new key will be that maximum value + 1. If you specify a key that already has a value assigned to it, that value will be overwritten.

// This  array is the same as ...
array(5 => 43, 32, 56, "b" => 12);

// ...this  array
array(5 => 43, 6 => 32, 7 => 56, "b" =>  12);
?>

?????

As of PHP 4.3.0, the index generation behaviour described above has changed. Now, if you append to an array in which the current maximum key is negative, then the next key created will be zero (0). Before, the new index would have been set to the largest existing key + 1, the same as positive indices are.

Using TRUE as a key will evaluate to integer 1 as key. Using FALSE as a key will evaluate to integer 0 as key. Using NULL as a key will evaluate to the empty string. Using the empty string as key will create (or overwrite) a key with the empty string and its value; it is not the same as using empty brackets.

You cannot use arrays or objects as keys. Doing so will result in a warning: Illegal offset type.

Creating/modifying with square-bracket syntax

You can also modify an existing array by explicitly setting values in it.

This is done by assigning values to the array while specifying the key in brackets. You can also omit the key, add an empty pair of brackets ("[]") to the variable name in that case.

$arr[key] = value;
$arr[] = value;
// key may be an integer or string
// value may be any value

If $arr doesn't exist yet, it will be created. So this is also an alternative way to specify an array. To change a certain value, just assign a new value to an element specified with its key. If you want to remove a key/value pair, you need to unset() it.

$arr =  array(5 => 1, 12 => 2);

$arr[] = 56;    // This is the same as $arr[13] =  56;
                // at this point of the script

$arr["x"] = 42; // This adds a new element to
                // the  array with key "x"
               
unset($arr[5]); // This removes the element from the  array

unset($arr);    // This deletes  the whole array
?>

????: As mentioned above, if you provide the brackets with no key specified, then the maximum of the existing integer indices is taken, and the new key will be that maximum value + 1 . If no integer indices exist yet, the key will be 0 (zero). If you specify a key that already has a value assigned to it, that value will be overwritten.

?????

As of PHP 4.3.0, the index generation behaviour described above has changed. Now, if you append to an array in which the current maximum key is negative, then the next key created will be zero (0). Before, the new index would have been set to the largest existing key + 1, the same as positive indices are.

Note that the maximum integer key used for this need not currently exist in the array. It simply must have existed in the array at some time since the last time the array was re-indexed. The following example illustrates:
// Create a simple array. $array = array(1, 2, 3, 4, 5); print_r($array); // Now delete every item, but leave the array itself intact: foreach ($array as $i => $value) { unset($array[$i]); } print_r($array); // Append an item (note that the new key is 5, instead of 0 as you // might expect). $array[] = 6; print_r($array); // Re-index: $array = array_values($array); $array[] = 7; print_r($array); ?>

The above example will output:
Array
(
   [0] => 1
   [1] => 2
   [2] => 3
   [3] => 4
   [4] => 5
)
Array
(
)
Array
(
   [5] => 6
)
Array
(
   [0] => 6
   [1] => 7
)

Useful functions

There are quite a few useful functions for working with arrays. See the array functions section.

????: The unset() function allows unsetting keys of an array. Be aware that the array will NOT be reindexed. If you only use "usual integer indices" (starting from zero, increasing by one), you can achieve the reindex effect by using array_values().

$a = array(1 => 'one', 2 => 'two', 3 => 'three'); unset($a[2]); /* will produce an array that would have been defined as $a = array(1 => 'one', 3 => 'three'); and NOT $a = array(1 => 'one', 2 =>'three'); */ $b = array_values($a); // Now $b is array(0 => 'one', 1 =>'three') ?>

The foreach control structure exists specifically for arrays. It provides an easy way to traverse an array.

Array do's and don'ts

Why is `$foo[bar]` wrong?

You should always use quotes around a string literal array index. For example, use $foo['bar'] and not $foo[bar]. But why is $foo[bar] wrong? You might have seen the following syntax in old scripts:

$foo[bar] = 'enemy';
echo  $foo[bar];
//  etc
?>

This is wrong, but it works. Then, why is it wrong? The reason is that this code has an undefined constant (bar) rather than a string ('bar' - notice the quotes), and PHP may in future define constants which, unfortunately for your code, have the same name. It works because PHP automatically converts a bare string (an unquoted string which does not correspond to any known symbol) into a string which contains the bare string. For instance, if there is no defined constant named bar, then PHP will substitute in the string 'bar' and use that.

????: This does not mean to always quote the key. You do not want to quote keys which are constants or variables, as this will prevent PHP from interpreting them.

error_reporting(E_ALL); ini_set('display_errors', true); ini_set('html_errors', false); // Simple array: $array = array(1, 2); $count = count($array); for ($i = 0; $i < $count; $i++) { echo "\nChecking $i: \n"; echo "Bad: " . $array['$i'] . "\n"; echo "Good: " . $array[$i] . "\n"; echo "Bad: {$array['$i']}\n"; echo "Good: {$array[$i]}\n"; } ?>

????: The above example will output:
Checking 0:
Notice: Undefined index:  $i in /path/to/script.html on line 9
Bad:
Good: 1
Notice: Undefined index:  $i in /path/to/script.html on line 11
Bad:
Good: 1

Checking 1:
Notice: Undefined index:  $i in /path/to/script.html on line 9
Bad:
Good: 2
Notice: Undefined index:  $i in /path/to/script.html on line 11
Bad:
Good: 2

More examples to demonstrate this fact:

// Let's  show all errors
error_reporting(E_ALL);

$arr  = array('fruit' =>  'apple',  'veggie' => 'carrot');

//  Correct
print $arr['fruit'];  //  apple
print $arr['veggie'];  // carrot

// Incorrect.  This works  but also throws a PHP error of
// level E_NOTICE because of an undefined  constant named fruit
//
// Notice: Use of undefined constant fruit -  assumed 'fruit' in...
print $arr[fruit];    //  apple

// Let's define a constant to demonstrate what's going  on.  We
// will assign value 'veggie' to a constant named  fruit.
define('fruit', 'veggie');

// Notice  the difference now
print $arr['fruit'];  //  apple
print $arr[fruit];    //  carrot

// The following is okay as it's inside a string.  Constants are  not
// looked for within strings so no E_NOTICE error here
print "Hello  $arr[fruit]";      // Hello apple

// With one exception, braces  surrounding arrays within strings
// allows constants to be looked  for
print "Hello {$arr[fruit]}";    // Hello  carrot
print "Hello {$arr['fruit']}";  // Hello  apple

// This will not work, results in a parse error such as:
//  Parse error: parse error, expecting T_STRING' or T_VARIABLE' or  T_NUM_STRING'
// This of course applies to using autoglobals in strings as  well
print "Hello $arr['fruit']";
print "Hello  $_GET['foo']";

// Concatenation is another option
print "Hello "  . $arr['fruit'];  // Hello apple
?>

When you turn error_reporting() up to show E_NOTICE level errors (such as setting it to E_ALL) then you will see these errors. By default, error_reporting is turned down to not show them.

As stated in the syntax section, there must be an expression between the square brackets ('[' and ']'). That means that you can write things like this:

echo  $arr[somefunc($bar)];
?>

This is an example of using a function return value as the array index. PHP also knows about constants, as you may have seen the E_* ones before.

$error_descriptions[E_ERROR]   = "A fatal error  has occured";
$error_descriptions[E_WARNING] =  "PHP issued a warning";
$error_descriptions[E_NOTICE]  = "This is just an  informal notice";
?>

Note that E_ERROR is also a valid identifier, just like bar in the first example. But the last example is in fact the same as writing:

$error_descriptions[1] = "A fatal error  has occured";
$error_descriptions[2] = "PHP issued a  warning";
$error_descriptions[8] = "This is just an  informal notice";
?>

because E_ERROR equals 1, etc.

As we already explained in the above examples, $foo[bar] still works but is wrong. It works, because bar is due to its syntax expected to be a constant expression. However, in this case no constant with the name bar exists. PHP now assumes that you meant bar literally, as the string "bar", but that you forgot to write the quotes.

So why is it bad then?

At some point in the future, the PHP team might want to add another constant or keyword, or you may introduce another constant into your application, and then you get in trouble. For example, you already cannot use the words empty and default this way, since they are special reserved keywords.

????: To reiterate, inside a double-quoted string, it's valid to not surround array indexes with quotes so "$foo[bar]" is valid. See the above examples for details on why as well as the section on variable parsing in strings.

Converting to array

For any of the types: integer, float, string, boolean and resource, if you convert a value to an array, you get an array with one element (with index 0), which is the scalar value you started with.

If you convert an object to an array, you get the properties (member variables) of that object as the array's elements. The keys are the member variable names.

If you convert a NULL value to an array, you get an empty array.

Comparing

It is possible to compare arrays by array_diff() and by Array operators.

Examples

The array type in PHP is very versatile, so here will be some examples to show you the full power of arrays.

//  this
$a = array( 'color'  => 'red',
            'taste' =>  'sweet',
            'shape' =>  'round',
            'name'  =>  'apple',
                       4        // key will  be 0
          );

// is completely equivalent with
$a['color'] =  'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name']  = 'apple';
$a[]        = 4;        // key will  be 0

$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// will result  in the array array(0 => 'a' , 1 => 'b' , 2 => 'c'),
// or simply  array('a', 'b', 'c')
?>

????? 11-6. Using array()

// Array  as (property-)map
$map = array( 'version'    =>  4,
              'OS'         =>  'Linux',
              'lang'       =>  'english',
              'short_tags' =>  true
            );
           
// strictly numerical keys
$array = array(  7,
                8,
                0,
                156,
                -10
              );
// this is the  same as array(0 => 7, 1 => 8, ...)

$switching =  array(         10, // key =  0
                    5    =>  6,
                    3    =>  7,
                    'a'  =>  4,
                            11, // key = 6 (maximum of integer-indices was  5)
                    '8'  =>  2, // key = 8  (integer!)
                    '02'  => 77, // key = '02'
                    0    =>  12  //  the value 10 will be overwritten by 12
                  );
                 
// empty array
$empty =  array();        
?>

????? 11-7. Collection

$colors =  array('red', 'blue', 'green', 'yellow');

foreach ($colors as  $color)  {
    echo "Do you like  $color?\n";
}

?>

The above example will output:

Do you like red?
Do you like blue?
Do you like green?
Do you like yellow?

Note that it is currently not possible to change the values of the array directly in such a loop. A workaround is the following:

????? 11-8. Collection

foreach  ($colors as $key => $color)  {
    // won't work:
    //$color =  strtoupper($color);
   
    // works:
    $colors[$key] = strtoupper($color);
}
print_r($colors);
?>

The above example will output:

Array
(
   [0] => RED
   [1] => BLUE
   [2] => GREEN
   [3] => YELLOW
)

This example creates a one-based array.

????? 11-9. One-based index

$firstquarter  = array(1  => 'January',  'February', 'March');
print_r($firstquarter);
?>

The above example will output:

Array
(
   [1] => 'January'
   [2] => 'February'
   [3] => 'March'
)

????? 11-10. Filling an array

// fill  an array with all items from a directory
$handle =  opendir('.');
while (false  !== ($file = readdir($handle)))  {
    $files[] = $file;
}
closedir($handle); 
?>

Arrays are ordered. You can also change the order using various sorting functions. See the array functions section for more information. You can count the number of items in an array using the count() function.

????? 11-11. Sorting an array

sort($files);
print_r($files);
?>

Because the value of an array can be anything, it can also be another array. This way you can make recursive and multi-dimensional arrays.

????? 11-12. Recursive and multi-dimensional arrays

$fruits =  array ( "fruits"  => array ( "a"  => "orange",
                                       "b" =>  "banana",
                                       "c" =>  "apple"
                                     ),
                  "numbers" => array  ( 1,
                                       2,
                                       3,
                                       4,
                                       5,
                                       6
                                     ),
                  "holes"   => array  (      "first",
                                       5 => "second",
                                            "third"
                                     )
                );

// Some examples to address values in the array above 
echo $fruits["holes"][5];    // prints "second"
echo $fruits["fruits"]["a"]; // prints  "orange"
unset($fruits["holes"][0]);  // remove "first"

// Create a new  multi-dimensional array
$juices["apple"]["green"] =  "good"; 
?>

You should be aware that array assignment always involves value copying. You need to use the reference operator to copy an array by reference.

$arr1 =  array(2,  3);
$arr2  = $arr1;
$arr2[] =  4;  // $arr2 is changed,
             //  $arr1 is still array(2, 3)
            
$arr3 =  &$arr1;
$arr3[] =  4;  // now $arr1 and $arr3 are the  same
?>

Strings

2009-01-08T17:18:00.003-08:00

Strings

A string is series of characters. In PHP, a character is the same as a byte, that is, there are exactly 256 different characters possible. This also implies that PHP has no native support of Unicode. See utf8_encode() and utf8_decode() for some Unicode support.

????: It is no problem for a string to become very large. There is no practical bound to the size of strings imposed by PHP, so there is no reason at all to worry about long strings.

Syntax

A string literal can be specified in three different ways.

single quoted
double quoted
heredoc syntax

Single quoted

The easiest way to specify a simple string is to enclose it in single quotes (the character ').

To specify a literal single quote, you will need to escape it with a backslash (\), like in many other languages. If a backslash needs to occur before a single quote or at the end of the string, you need to double it. Note that if you try to escape any other character, the backslash will also be printed! So usually there is no need to escape the backslash itself.

????: In PHP 3, a warning will be issued at the E_NOTICE level when this happens.

????: Unlike the two other syntaxes, variables and escape sequences for special characters will not be expanded when they occur in single quoted strings.

echo  'this is a simple string';



echo 'You  can also have embedded newlines in

strings this way as it is

okay to  do';



// Outputs: Arnold once said: "I'll be  back"

echo 'Arnold once said: "I\'ll be back"';



// Outputs:  You deleted C:\*.*?

echo 'You deleted C:\\*.*?';



// Outputs:  You deleted C:\*.*?

echo 'You deleted C:\*.*?';



// Outputs:  This will not expand: \n a newline

echo  'This will not expand: \n a  newline';



// Outputs: Variables do not $expand  $either

echo 'Variables do not $expand $either';

?>

Double quoted

If the string is enclosed in double-quotes ("), PHP understands more escape sequences for special characters:

???? 11-1. Escaped characters

sequence	meaning
`\n`	linefeed (LF or 0x0A (10) in ASCII)
`\r`	carriage return (CR or 0x0D (13) in ASCII)
`\t`	horizontal tab (HT or 0x09 (9) in ASCII)
`\\`	backslash
`\$`	dollar sign
`\"`	double-quote
`\[0-7]{1,3}`	the sequence of characters matching the regular expression is a character in octal notation
`\x[0-9A-Fa-f]{1,2}`	the sequence of characters matching the regular expression is a character in hexadecimal notation

Again, if you try to escape any other character, the backslash will be printed too!

But the most important feature of double-quoted strings is the fact that variable names will be expanded. See string parsing for details.

Heredoc

Another way to delimit strings is by using heredoc syntax ("<<<"). One should provide an identifier after <<<, then the string, and then the same identifier to close the quotation.

The closing identifier must begin in the first column of the line. Also, the identifier used must follow the same naming rules as any other label in PHP: it must contain only alphanumeric characters and underscores, and must start with a non-digit character or underscore.

?????

It is very important to note that the line with the closing identifier contains no other characters, except possibly a semicolon (;). That means especially that the identifier may not be indented, and there may not be any spaces or tabs after or before the semicolon. It's also important to realize that the first character before the closing identifier must be a newline as defined by your operating system. This is \r on Macintosh for example.

If this rule is broken and the closing identifier is not "clean" then it's not considered to be a closing identifier and PHP will continue looking for one. If in this case a proper closing identifier is not found then a parse error will result with the line number being at the end of the script.

It is not allowed to use heredoc syntax in initializing class members. Use other string syntaxes instead.

????? 11-3. Invalid example

class  foo {

    public $bar  = <<bar

EOT;

}

?>

Heredoc text behaves just like a double-quoted string, without the double-quotes. This means that you do not need to escape quotes in your here docs, but you can still use the escape codes listed above. Variables are expanded, but the same care must be taken when expressing complex variables inside a heredoc as with strings.

????? 11-4. Heredoc string quoting example

$str =  <<Example of  string

spanning multiple lines

using heredoc syntax.

EOD;



/* More  complex example, with variables. */

class  foo

{

    var $foo;

    var  $bar;



    function foo()

    {

        $this->foo = 'Foo';

        $this->bar = array('Bar1', 'Bar2', 'Bar3');

    }

}



$foo = new  foo();

$name  = 'MyName';



echo  <<My name is "$name". I am  printing some $foo->foo.

Now, I am printing some {$foo->bar[1]}.

This should  print a capital 'A': \x41

EOT;

?>

????: Heredoc support was added in PHP 4.

Variable parsing

When a string is specified in double quotes or with heredoc, variables are parsed within it.

There are two types of syntax: a simple one and a complex one. The simple syntax is the most common and convenient. It provides a way to parse a variable, an array value, or an object property.

The complex syntax was introduced in PHP 4, and can be recognised by the curly braces surrounding the expression.

Simple syntax

If a dollar sign ($) is encountered, the parser will greedily take as many tokens as possible to form a valid variable name. Enclose the variable name in curly braces if you want to explicitly specify the end of the name.

$beer =  'Heineken';

echo "$beer's  taste is great"; // works, "'" is an invalid character for  varnames

echo "He drank some $beers";   // won't work,  's' is a valid character for varnames

echo "He drank some  ${beer}s"; // works

echo  "He drank some {$beer}s"; //  works

?>

Similarly, you can also have an array index or an object property parsed. With array indices, the closing square bracket (]) marks the end of the index. For object properties the same rules apply as to simple variables, though with object properties there doesn't exist a trick like the one with variables.

// These  examples are specific to using arrays inside of strings.

// When outside of a  string, always quote your array string keys

// and do not use {braces} when  outside of strings either.



// Let's show all errors

error_reporting(E_ALL);



$fruits  = array('strawberry' =>  'red',  'banana' => 'yellow');



// Works  but note that this works differently outside string-quotes

echo "A banana is  $fruits[banana].";



// Works

echo  "A banana is  {$fruits['banana']}.";



// Works but PHP looks for a constant named banana  first

// as described below.

echo  "A banana is {$fruits[banana]}.";



// Won't  work, use braces.  This results in a parse error.

echo "A banana is  $fruits['banana'].";



// Works

echo  "A banana is " . $fruits['banana'] . ".";



//  Works

echo "This square is $square->width meters  broad.";



// Won't work. For a solution, see the complex  syntax.

echo "This square is $square->width00 centimeters  broad.";

?>

For anything more complex, you should use the complex syntax.

Complex (curly) syntax

This isn't called complex because the syntax is complex, but because you can include complex expressions this way.

In fact, you can include any value that is in the namespace in strings with this syntax. You simply write the expression the same way as you would outside the string, and then include it in { and }. Since you can't escape '{', this syntax will only be recognised when the $ is immediately following the {. (Use "{\$" or "\{$" to get a literal "{$"). Some examples to make it clear:

// Let's  show all errors

error_reporting(E_ALL);



$great  = 'fantastic';



// Won't  work, outputs: This is { fantastic}

echo  "This is { $great}";



// Works,  outputs: This is fantastic

echo  "This is {$great}";

echo "This is  ${great}";



// Works

echo  "This square is {$square->width}00  centimeters broad.";



// Works

echo  "This works: {$arr[4][3]}";



// This is  wrong for the same reason as $foo[bar] is wrong

// outside a string.  In  other words, it will still work but

// because PHP first looks for a constant  named foo, it will

// throw an error of level E_NOTICE (undefined  constant).

echo "This is wrong: {$arr[foo][3]}";



//  Works.  When using multi-dimensional arrays, always use

// braces around  arrays when inside of strings

echo  "This works: {$arr['foo'][3]}";



//  Works.

echo "This works: " .  $arr['foo'][3];



echo "You  can even write {$obj->values[3]->name}";



echo "This  is the value of the var named $name: {${$name}}";

?>

String access and modification by character

Characters within strings may be accessed and modified by specifying the zero-based offset of the desired character after the string in curly braces.

????: For backwards compatibility, you can still use array-brackets for the same purpose. However, this syntax is deprecated as of PHP 4.

????? 11-5. Some string examples

// Get  the first character of a string

$str  = 'This  is a test.';

$first = $str{0};



// Get the  third character of a string

$third  = $str{2};



// Get the  last character of a string.

$str  = 'This  is still a test.';

$last = $str{strlen($str)-1}; 



// Modify the last character of a  string

$str = 'Look at the  sea';

$str{strlen($str)-1} = 'e';

         

?>

Useful functions and operators

Strings may be concatenated using the '.' (dot) operator. Note that the '+' (addition) operator will not work for this. Please see String operators for more information.

There are a lot of useful functions for string modification.

See the string functions section for general functions, the regular expression functions for advanced find&replacing (in two tastes: Perl and POSIX extended).

There are also functions for URL-strings, and functions to encrypt/decrypt strings (mcrypt and mhash).

Finally, if you still didn't find what you're looking for, see also the character type functions.

Converting to string

You can convert a value to a string using the (string) cast, or the strval() function. String conversion is automatically done in the scope of an expression for you where a string is needed. This happens when you use the echo() or print() functions, or when you compare a variable value to a string. Reading the manual sections on Types and Type Juggling will make the following clearer. See also settype().

A boolean TRUE value is converted to the string "1", the FALSE value is represented as "" (empty string). This way you can convert back and forth between boolean and string values.

An integer or a floating point number (float) is converted to a string representing the number with its digits (including the exponent part for floating point numbers).

Arrays are always converted to the string "Array", so you cannot dump out the contents of an array with echo() or print() to see what is inside them. To view one element, you'd do something like echo $arr['foo']. See below for tips on dumping/viewing the entire contents.

Objects are always converted to the string "Object". If you would like to print out the member variable values of an object for debugging reasons, read the paragraphs below. If you would like to find out the class name of which an object is an instance of, use get_class(). As of PHP 5, __toString() method is used if applicable.

Resources are always converted to strings with the structure "Resource id #1" where 1 is the unique number of the resource assigned by PHP during runtime. If you would like to get the type of the resource, use get_resource_type().

NULL is always converted to an empty string.

As you can see above, printing out the arrays, objects or resources does not provide you any useful information about the values themselves. Look at the functions print_r() and var_dump() for better ways to print out values for debugging.

You can also convert PHP values to strings to store them permanently. This method is called serialization, and can be done with the function serialize(). You can also serialize PHP values to XML structures, if you have WDDX support in your PHP setup.

String conversion to numbers

When a string is evaluated as a numeric value, the resulting value and type are determined as follows.

The string will evaluate as a float if it contains any of the characters '.', 'e', or 'E'. Otherwise, it will evaluate as an integer.

The value is given by the initial portion of the string. If the string starts with valid numeric data, this will be the value used. Otherwise, the value will be 0 (zero). Valid numeric data is an optional sign, followed by one or more digits (optionally containing a decimal point), followed by an optional exponent. The exponent is an 'e' or 'E' followed by one or more digits.

$foo =  1 +  "10.5";                //  $foo is float (11.5)

$foo = 1 + "-1.3e3";              //  $foo is float (-1299)

$foo = 1 + "bob-1.3e3";           // $foo  is integer (1)

$foo = 1 + "bob3";                //  $foo is integer (1)

$foo = 1 + "10 Small  Pigs";       // $foo is integer (11)

$foo = 4 + "10.2 Little Piggies"; // $foo is float  (14.2)

$foo = "10.0 pigs "  + 1;          // $foo is  float (11)

$foo = "10.0 pigs "  + 1.0;        // $foo is  float (11)    

?>

For more information on this conversion, see the Unix manual page for strtod(3).

If you would like to test any of the examples in this section, you can cut and paste the examples and insert the following line to see for yourself what's going on:

echo  "\$foo==$foo; type is " . gettype  ($foo) . "
\n";

?>

Do not expect to get the code of one character by converting it to integer (as you would do in C for example). Use the functions ord() and chr() to convert between charcodes and characters.

Floating point numbers

2009-01-08T17:18:00.001-08:00

Floating point numbers

Floating point numbers (AKA "floats", "doubles" or "real numbers") can be specified using any of the following syntaxes:

$a =  1.234; 
$b =  1.2e3; 
$c =  7E-10;
?>

Formally:

LNUM          [0-9]+
DNUM          ([0-9]*[\.]{LNUM})  | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM ( ({LNUM} | {DNUM}) [eE][+-]?  {LNUM})

The size of a float is platform-dependent, although a maximum of ~1.8e308 with a precision of roughly 14 decimal digits is a common value (that's 64 bit IEEE format).

Floating point precision

It is quite usual that simple decimal fractions like 0.1 or 0.7 cannot be converted into their internal binary counterparts without a little 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 as the result of the internal representation really being something like 7.9999999999....

This is related to the fact that it is impossible to exactly express some fractions in decimal notation with a finite number of digits. For instance, 1/3 in decimal form becomes 0.3333333. . ..

So never trust floating number results to the last digit and never compare floating point numbers for equality. If you really need higher precision, you should use the arbitrary precision math functions or gmp functions instead.

Converting to float

For information on when and how strings are converted to floats, see the section titled String conversion to numbers. For values of other types, the conversion is the same as if the value would have been converted to integer and then to float. See the Converting to integer section for more information. As of PHP 5, notice is thrown if you try to convert object to float.

Integers

2009-01-08T17:17:00.001-08:00

Integers

An integer is a number of the set Z = {..., -2, -1, 0, 1, 2, ...}.

See also: Arbitrary length integer / GMP, Floating point numbers, and Arbitrary precision / BCMath

Syntax

Integers can be specified in decimal (10-based), hexadecimal (16-based) or octal (8-based) notation, optionally preceded by a sign (- or +).

If you use the octal notation, you must precede the number with a 0 (zero), to use hexadecimal notation precede the number with 0x.

????? 11-1. Integer literals

$a =  1234;  // decimal number
$a = -123; // a negative number
$a = 0123; // octal number (equivalent to 83  decimal)
$a = 0x1A; // hexadecimal  number (equivalent to 26 decimal)
?>

Formally the possible structure for integer literals is:

decimal     : [1-9][0-9]*
           | 0

hexadecimal : 0[xX][0-9a-fA-F]+

octal       : 0[0-7]+

integer     : [+-]?decimal
           | [+-]?hexadecimal
           | [+-]?octal

The size of an integer is platform-dependent, although a maximum value of about two billion is the usual value (that's 32 bits signed). PHP does not support unsigned integers.

?????

If an invalid digit is passed to octal integer (i.e. 8 or 9), the rest of the number is ignored.

????? 11-2. Octal weirdness

var_dump(01090); // 010 octal = 8  decimal
?>

Integer overflow

If you specify a number beyond the bounds of the integer type, it will be interpreted as a float instead. Also, if you perform an operation that results in a number beyond the bounds of the integer type, a float will be returned instead.

$large_number =  2147483647;
var_dump($large_number);
// output:  int(2147483647)

$large_number  =  2147483648;
var_dump($large_number);
// output:  float(2147483648)

// this doesn't go for hexadecimal specified  integers:
var_dump( 0x100000000  );
//  output: int(2147483647)

$million  = 1000000;
$large_number  =  50000  * $million;
var_dump($large_number);
// output:  float(50000000000)
?>

?????

Unfortunately, there was a bug in PHP so that this does not always work correctly when there are negative numbers involved. For example: when you do -50000 * $million, the result will be -429496728. However, when both operands are positive there is no problem.

This is solved in PHP 4.1.0.

There is no integer division operator in PHP. 1/2 yields the float 0.5. You can cast the value to an integer to always round it downwards, or you can use the round() function.

var_dump(25/7);         //  float(3.5714285714286)
var_dump((int)  (25/7)); //  int(3)
var_dump(round(25/7));  // float(4) 
?>

Converting to integer

To explicitly convert a value to integer, use either the (int) or the (integer) cast. However, in most cases you do not need to use the cast, since a value will be automatically converted if an operator, function or control structure requires an integer argument. You can also convert a value to integer with the function intval().

From booleans

FALSE will yield 0 (zero), and TRUE will yield 1 (one).

From floating point numbers

When converting from float to integer, the number will be rounded towards zero.

If the float is beyond the boundaries of integer (usually +/- 2.15e+9 = 2^31), the result is undefined, since the float hasn't got enough precision to give an exact integer result. No warning, not even a notice will be issued in this case!

?????

Never cast an unknown fraction to integer, as this can sometimes lead to unexpected results.

echo  (int) ( (0.1+0.7) * 10 ); // echoes  7!
?>

See for more information the warning about float-precision.

From strings

See String conversion to numbers

From other types

?????

Behaviour of converting to integer is undefined for other types. Currently, the behaviour is the same as if the value was first converted to boolean. However, do not rely on this behaviour, as it can change without notice.

Booleans

2009-01-08T17:16:00.002-08:00

Booleans

This is the easiest type. A boolean expresses a truth value. It can be either TRUE or FALSE.

????: The boolean type was introduced in PHP 4.

Syntax

To specify a boolean literal, use either the keyword TRUE or FALSE. Both are case-insensitive.

$foo =  True;  // assign the value TRUE to  $foo
?>

Usually you use some kind of operator which returns a boolean value, and then pass it on to a control structure.

// == is  an operator which test
// equality and returns a boolean
if ($action  == "show_version")  {
    echo "The version is  1.23";
}

// this is not necessary...
if ($show_separators  == TRUE) {
    echo  "
\n";
}

//  ...because you can simply type
if  ($show_separators) {
    echo "
\n";
}
?>

Converting to boolean

To explicitly convert a value to boolean, use either the (bool) or the (boolean) cast. However, in most cases you do not need to use the cast, since a value will be automatically converted if an operator, function or control structure requires a boolean argument.

Types

2009-01-08T17:16:00.001-08:00

Types

????
Introduction
Booleans
Integers
Floating point numbers
Strings
Arrays
Objects
Resource
NULL
Pseudo-types used in this documentation
Type Juggling

Introduction

PHP supports eight primitive types.

Four scalar types:

boolean
integer
float (floating-point number, aka 'double')
string

Two compound types:

array
object

And finally two special types:

resource
NULL

This manual also introduces some pseudo-types for readability reasons:

mixed
number
callback

You may also find some references to the type "double". Consider double the same as float, the two names exist only for historic reasons.

The type of a variable is usually not set by the programmer; rather, it is decided at runtime by PHP depending on the context in which that variable is used.

????: If you want to check out the type and value of a certain expression, use var_dump().

????: If you simply want a human-readable representation of the type for debugging, use gettype(). To check for a certain type, do not use gettype(), but use the is_type functions. Some examples:

$bool = TRUE; // a boolean $str = "foo"; // a string $int = 12; // an integer echo gettype($bool); // prints out "boolean" echo gettype($str); // prints out "string" // If this is an integer, increment it by four if (is_int($int)) { $int += 4; } // If $bool is a string, print it out // (does not print out anything) if (is_string($bool)) { echo "String: $bool"; } ?>

If you would like to force a variable to be converted to a certain type, you may either cast the variable or use the settype() function on it.

Note that a variable may be evaluated with different values in certain situations, depending on what type it is at the time. For more information, see the section on Type Juggling. Also, you may be interested in viewing the type comparison tables, as they show examples of various type related comparisons.

Basic syntax

2009-01-08T17:11:00.000-08:00

Escaping from HTML

When
PHP parses a file, it looks for opening and closing tags, which tell
PHP to start and stop interpreting the code between them. Parsing in
this manner allows php to be embedded in all sorts of different
documents, as everything outside of a pair of opening and closing tags
is ignored by the PHP parser. Most of the time you will see php
embedded in HTML documents, as in this example.

This is going to be ignored.


echo 'While this is  going to be parsed.'; ?>

This will also be ignored.

You can also use more advanced structures:

????? 10-1. Advanced escaping

if  ($expression) {
    ?>
    This is  true.
    } else {
    ?>
    This is  false.
    }
?>

This
works as expected, because when PHP hits the ?> closing tags, it
simply starts outputting whatever it finds until it hits another
opening tag. The example given here is contrived, of course, but for
outputting large blocks of text, dropping out of PHP parsing mode is
generally more efficient than sending all of the text through echo() or print().

There are four different pairs of opening and closing tags which can be used in php. Two of those, and , are always available. The other two are short tags and ASP style tags, and can be turned on and off from the php.ini configuration file. As such, while some people find short tags and ASP style tags convenient, they are less portable, and generally not recommended.

????: Also
note that if you are embedding PHP within XML or XHTML you will need to
use the tags to remain compliant with standards.

????? 10-2. PHP Opening and Closing Tags

1.  echo 'if  you want to serve XHTML or XML documents, do like this'; ?>

2.  

3.  echo  'this is the simplest, an SGML processing  instruction'; ?>
     This is a shortcut for "echo  expression ?>"

4.  <%  echo 'You may optionally use ASP-style tags'; %>
    <%= $variable; #  This is a shortcut for "<% echo . . ." %>

While
the tags seen in examples one and two are both always available,
example one is the most commonly used, and recommended, of the two.

Short tags (example three) are only available when they are enabled via the short_open_tag php.ini configuration file directive, or if php was configured with the --enable-short-tags option.

????: If you are using PHP 3 you may also enable short tags via the short_tags() function. This is only available in PHP 3!

ASP style tags (example four) are only available when they are enabled via the asp_tags php.ini configuration file directive.

????: Support for ASP tags was added in 3.0.4.

????: Using
short tags should be avoided when developing applications or libraries
that are meant for redistribution, or deployment on PHP servers which
are not under your control, because short tags may not be supported on
the target server. For portable, redistributable code, be sure not to
use short tags.

As in C or
Perl, PHP requires instructions to be terminated with a semicolon at
the end of each statement. The closing tag of a block of PHP code
automatically implies a semicolon; you do not need to have a semicolon
terminating the last line of a PHP block. The closing tag for the block
will include the immediately trailing newline if one is present.

echo  'This is a test';
?>

echo 'This is a test' ?>

????: The
closing tag of a PHP block at the end of a file is optional, and in
some cases not using it is helpful when using output buffering and include() or require().

Comments

PHP supports 'C', 'C++' and Unix shell-style (Perl style) comments. For example:

echo 'This is a test'; // This is a one-line c++ style comment /* This is a multi line comment yet another line of comment */ echo 'This is yet another test'; echo 'One Final Test'; # This is a shell-style comment ?>

The
"one-line" comment styles only comment to the end of the line or the
current block of PHP code, whichever comes first. This means that HTML
code after // ?> WILL be printed: ?> skips out of the PHP mode and returns to HTML mode, and // cannot influence that. If asp_tags configuration directive is enabled, it behaves the same with // %>. However, tag doesn't escape PHP mode in one-line comment.

This is an # echo 'simple';?> example.
The header above will say 'This is an example'.

'C' style comments end by the first encountered */. You should be careful not to nest 'C' style comments, which can happen when commenting out large blocks.

/* echo 'This is a test'; /* This comment will cause a problem */ */ ?>

Language Reference

2009-01-08T17:10:00.004-08:00

Language Reference

????
10. Basic syntax
11. Types
12. Variables
13. Constants
14. Expressions
15. Operators
16. Control Structures
17. Functions
18. Classes and Objects (PHP 4)
19. Classes and Objects (PHP 5)
20. Exceptions
21. References Explained

Using old code with new versions of PHP

2009-01-08T17:10:00.003-08:00

Using old code with new versions of PHP

Now that PHP has grown to be a popular scripting language, there are a lot of public repositories and libraries containing code you can reuse. The PHP developers have largely tried to preserve backwards compatibility, so a script written for an older version will run (ideally) without changes in a newer version of PHP. In practice, some changes will usually be needed.

Two of the most important recent changes that affect old code are:

The deprecation of the old $HTTP_*_VARS arrays (which need to be indicated as global when used inside a function or method). The following autoglobal arrays were introduced in PHP 4.1.0. They are: $_GET, $_POST, $_COOKIE, $_SERVER, $_FILES, $_ENV, $_REQUEST, and $_SESSION. The older $HTTP_*_VARS arrays, such as $HTTP_POST_VARS, still exist as they have since PHP 3. As of PHP 5.0.0, the long PHP predefined variable arrays may be disabled with the register_long_arrays directive.
External variables are no longer registered in the global scope by default. In other words, as of PHP 4.2.0 the PHP directive register_globals is off by default in php.ini. The preferred method of accessing these values is via the autoglobal arrays mentioned above. Older scripts, books, and tutorials may rely on this directive being on. If it were on, for example, one could use $id from the URL http://www.example.com/foo.php?id=42. Whether on or off, $_GET['id'] is available.

For more details on these changes, see the section on predefined variables and links therein.

Dealing with Forms

2009-01-08T17:10:00.001-08:00

Dealing with Forms

One of the most powerful features of PHP is the way it handles HTML forms. The basic concept that is important to understand is that any form element will automatically be available to your PHP scripts. Please read the manual section on Variables from outside of PHP for more information and examples on using forms with PHP. Here is an example HTML form:

????? 2-6. A simple HTML form


Your name: 

Your age:

There is nothing special about this form. It is a straight HTML form with no special tags of any kind. When the user fills in this form and hits the submit button, the action.php page is called. In this file you would write something like this:

????? 2-7. Printing data from our form

Hi echo $_POST['name']; ?>.
You are echo  $_POST['age']; ?> years  old.

A sample output of this script may be:

Hi Joe. You are 22 years old.

It should be obvious what this does. There is nothing more to it. The $_POST['name'] and $_POST['age'] variables are automatically set for you by PHP. Earlier we used the $_SERVER autoglobal; above we just introduced the $_POST autoglobal which contains all POST data. Notice how the method of our form is POST. If we used the method GET then our form information would live in the $_GET autoglobal instead. You may also use the $_REQUEST autoglobal, if you do not care about the source of your request data. It contains the merged information of GET, POST and COOKIE data. Also see the import_request_variables() function.

You can also deal with XForms input in PHP, although you will find yourself comfortable with the well supported HTML forms for quite some time. While working with XForms is not for beginners, you might be interested in them. We also have a short introduction to handling data received from XForms in our features section.

5 . Something Useful

2009-01-08T17:09:00.001-08:00

Something Useful

Let us do something more useful now. We are going to check what sort of browser the visitor is using. For that, we check the user agent string the browser sends as part of the HTTP request. This information is stored in a variable. Variables always start with a dollar-sign in PHP. The variable we are interested in right now is $_SERVER['HTTP_USER_AGENT'].

????: $_SERVER is a special reserved PHP variable that contains all web server information. It is known as an autoglobal (or superglobal). See the related manual page on superglobals for more information. These special variables were introduced in PHP 4.1.0. Before this time, we used the older $HTTP_*_VARS arrays instead, such as $HTTP_SERVER_VARS. Although deprecated, these older variables still exist. (See also the note on old code.)

To display this variable, you can simply do:

????? 2-3. Printing a variable (Array element)

echo $_SERVER['HTTP_USER_AGENT']; ?>

A sample output of this script may be:

Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)

There are many types of variables available in PHP. In the above example we printed an Array element. Arrays can be very useful.

$_SERVER is just one variable that PHP automatically makes available to you. A list can be seen in the Reserved Variables section of the manual or you can get a complete list of them by looking at the output of the phpinfo() function used in the example in the previous section.

You can put multiple PHP statements inside a PHP tag and create little blocks of code that do more than just a single echo. For example, if you want to check for Internet Explorer you can do this:

????? 2-4. Example using control structures and functions

if  (strpos($_SERVER['HTTP_USER_AGENT'],  'MSIE')  !== FALSE) {
   echo 'You  are using Internet Explorer.
';
}
?>

A sample output of this script may be:

You are using Internet Explorer.

Here we introduce a couple of new concepts. We have an if statement. If you are familiar with the basic syntax used by the C language, this should look logical to you. Otherwise, you should probably pick up an introductory PHP book and read the first couple of chapters, or read the Language Reference part of the manual. You can find a list of PHP books at http://www.php.net/books.php.

The second concept we introduced was the strpos() function call. strpos() is a function built into PHP which searches a string for another string. In this case we are looking for 'MSIE' (so-called needle) inside $_SERVER['HTTP_USER_AGENT'] (so-called haystack). If the needle is found inside the haystack, the function returns the position of the needle relative to the start of the haystack. Otherwise, it returns FALSE. If it does not return FALSE, the if expression evaluates to TRUE and the code within its {braces} is executed. Otherwise, the code is not run. Feel free to create similar examples, with if, else, and other functions such as strtoupper() and strlen(). Each related manual page contains examples too. If you are unsure how to use functions, you will want to read both the manual page on how to read a function definition and the section about PHP functions.

We can take this a step further and show how you can jump in and out of PHP mode even in the middle of a PHP block:

????? 2-5. Mixing both HTML and PHP modes

if  (strpos($_SERVER['HTTP_USER_AGENT'],  'MSIE')  !== FALSE) {
?>
strpos() must have returned  non-false

You are using Internet  Explorer

} else {
?>
strpos() must have returned  false

You are not using Internet  Explorer

}
?>

A sample output of this script may be:

strpos() must have returned non-false

You are using Internet Explorer

Instead of using a PHP echo statement to output something, we jumped out of PHP mode and just sent straight HTML. The important and powerful point to note here is that the logical flow of the script remains intact. Only one of the HTML blocks will end up getting sent to the viewer depending on the result of strpos(). In other words, it depends on whether the string MSIE was found or not.

4.Your first PHP-enabled page

2009-01-08T17:07:00.001-08:00

Your first PHP-enabled page

Create a file named hello.php and put it in your web
server's root directory (DOCUMENT_ROOT) with the
following content:

????? 2-1. Our first PHP script: hello.php

<html>
<head>
  <title>PHP
Test</title>
</head>
<body>
<?php echo
'<p>Hello World</p>'; ?>
</body>
</html>

Use your browser to access the file with your web server's URL, ending with
the "/hello.php" file reference. When developing locally this URL will be
something like http://localhost/hello.php or http://127.0.0.1/hello.php but this depends on the web
server's configuration. If everything is configured correctly, this file will be
parsed by PHP and the following output will be sent to your browser:

<html>
<head>
 <title>PHP Test</title>
</head>
<body>
<p>Hello World</p>
</body>
</html>

This program is extremely simple and you really did not need to use PHP to
create a page like this. All it does is display: Hello World using the PHP echo() statement. Note that the file does not need to be executable or
special in any way. The server finds out that this file needs to be interpreted
by PHP because you used the ".php" extension, which the server is configured to
pass on to PHP. Think of this as a normal HTML file which happens to have a set
of special tags available to you that do a lot of interesting things.

If you tried this example and it did not output anything, it prompted for
download, or you see the whole file as text, chances are that the server you are
on does not have PHP enabled, or is not configured properly. Ask your
administrator to enable it for you using the Installation chapter of the manual. If you are
developing locally, also read the installation chapter to make sure everything
is configured properly. Make sure that you access the file via http with the
server providing you the output. If you just call up the file from your file
system, then it will not be parsed by PHP. If the problems persist anyway, do
not hesitate to use one of the many PHP support options.

The point of the example is to show the special PHP tag format. In this
example we used <?php to indicate the start of a PHP
tag. Then we put the PHP statement and left PHP mode by adding the closing tag,
?>. You may jump in and out of PHP mode in an HTML
file like this anywhere you want. For more details, read the manual section on
the basic PHP syntax.

A Note on Text Editors: There are many text editors and Integrated
Development Environments (IDEs) that you can use to create, edit and manage PHP
files. A partial list of these tools is maintained at PHP
Editors List. If you wish to recommend an editor, please visit the above
page and ask the page maintainer to add the editor to the list. Having an editor
with syntax highlighting can be helpful.
A Note on Word Processors: Word processors such as StarOffice Writer,
Microsoft Word and Abiword are not optimal for editing PHP files. If you wish to
use one for this test script, you must ensure that you save the file as plain text or PHP will not be able
to read and execute the script.
A Note on Windows Notepad: If you are writing your PHP scripts using
Windows Notepad, you will need to ensure that your files are saved with the .php
extension. (Notepad adds a .txt extension to files automatically unless you take
one of the following steps to prevent it.) When you save the file and are
prompted to provide a name for the file, place the filename in quotes (i.e. "hello.php"). Alternatively, you can click on the 'Text
Documents' drop-down menu in the 'Save' dialog box and change the setting to
"All Files". You can then enter your filename without quotes.

Now that you have successfully created a working PHP script, it is time to
create the most famous PHP script! Make a call to the phpinfo() function and
you will see a lot of useful information about your system and setup such as
available predefined variables,
loaded PHP modules, and configuration settings.
Take some time and review this important information.

????? 2-2. Get system information from PHP

<?php
phpinfo(); ?>

3. A simple tutorial

2009-01-08T17:04:00.000-08:00

Here we would like to show the very basics of PHP in a short, simple
tutorial. This text only deals with dynamic webpage creation with PHP, though
PHP is not only capable of creating webpages. See the section titled What can PHP do for more information.

PHP-enabled web pages are treated just like regular HTML pages and you can
create and edit them the same way you normally create regular HTML pages.

What do I need?

In this tutorial we assume that your server has activated support for PHP and
that all files ending in .php are handled by PHP. On
most servers, this is the default extension for PHP files, but ask your server
administrator to be sure. If your server supports PHP, then you do not need to
do anything. Just create your .php files, put them in
your web directory and the server will automatically parse them for you. There
is no need to compile anything nor do you need to install any extra tools. Think
of these PHP-enabled files as simple HTML files with a whole new family of
magical tags that let you do all sorts of things. Most web hosts offer PHP
support, but if your host does not, consider reading the PHP Links section for
resources on finding PHP enabled web hosts.

Let us say you want to save precious bandwidth and develop locally. In this
case, you will want to install a web server, such as Apache, and of course PHP. You will most
likely want to install a database as well, such as MySQL.

You can either install these individually or choose a simpler way. Our manual
has installation instructions for PHP (assuming you
already have some webserver set up). In case you have problems with installing
PHP yourself, we would suggest you ask your questions on our installation mailing
list. If you choose to go on the simpler route, then locate a pre-configured package for your operating system, which
automatically installs all of these with just a few mouse clicks. It is easy to
setup a web server with PHP support on any operating system, including MacOSX,
Linux and Windows. On Linux, you may find rpmfind and PBone helpful for locating RPMs. You may also want to visit apt-get to find packages for
Debian.

Getting Started -- 2.What can PHP do?

2009-01-08T16:58:00.000-08:00

What can PHP do?

Anything. PHP is mainly focused on server-side scripting, so you can do
anything any other CGI program can do, such as collect form data, generate
dynamic page content, or send and receive cookies. But PHP can do much more.

There are three main areas where PHP scripts are used.

Server-side scripting. This is the most traditional and main target field for
PHP. You need three things to make this work. The PHP parser (CGI or server
module), a webserver and a web browser. You need to run the webserver, with a
connected PHP installation. You can access the PHP program output with a web
browser, viewing the PHP page through the server. All these can run on your home
machine if you are just experimenting with PHP programming. See the installation instructions section for more information.
Command line scripting. You can make a PHP script to run it without any
server or browser. You only need the PHP parser to use it this way. This type of
usage is ideal for scripts regularly executed using cron (on *nix or Linux) or
Task Scheduler (on Windows). These scripts can also be used for simple text
processing tasks. See the section about Command line usage of PHP for more
information.
Writing desktop applications. PHP is probably not the very best language to
create a desktop application with a graphical user interface, but if you know
PHP very well, and would like to use some advanced PHP features in your
client-side applications you can also use PHP-GTK to write such programs. You
also have the ability to write cross-platform applications this way. PHP-GTK is
an extension to PHP, not available in the main distribution. If you are
interested in PHP-GTK, visit its own
website.

PHP can be used on all major operating systems, including Linux, many Unix
variants (including HP-UX, Solaris and OpenBSD), Microsoft Windows, Mac OS X,
RISC OS, and probably others. PHP has also support for most of the web servers
today. This includes Apache, Microsoft Internet Information Server, Personal Web
Server, Netscape and iPlanet servers, Oreilly Website Pro server, Caudium,
Xitami, OmniHTTPd, and many others. For the majority of the servers PHP has a
module, for the others supporting the CGI standard, PHP can work as a CGI
processor.

So with PHP, you have the freedom of choosing an operating system and a web
server. Furthermore, you also have the choice of using procedural programming or
object oriented programming, or a mixture of them. Although not every standard
OOP feature is implemented in PHP 4, many code libraries and large applications
(including the PEAR library) are written only using OOP code. PHP 5 fixes the
OOP related weaknesses of PHP 4, and introduces a complete object model.

With PHP you are not limited to output HTML. PHP's abilities includes
outputting images, PDF files and even Flash movies (using libswf and Ming)
generated on the fly. You can also output easily any text, such as XHTML and any
other XML file. PHP can autogenerate these files, and save them in the file
system, instead of printing it out, forming a server-side cache for your dynamic
content.

One of the strongest and most significant features in PHP is its support for
a wide range of databases. Writing a database-enabled web page is incredibly
simple. The following databases are currently supported:

Adabas D InterBase PostgreSQL
dBase FrontBase SQLite
Empress mSQL Solid
FilePro (read-only) Direct MS-SQL Sybase
Hyperwave MySQL Velocis
IBM DB2 ODBC Unix dbm
Informix Oracle (OCI7 and OCI8)
Ingres Ovrimos

We also have a DBX database abstraction extension allowing
you to transparently use any database supported by that extension. Additionally
PHP supports ODBC, the Open Database Connection standard, so you can connect to
any other database supporting this world standard.

PHP also has support for talking to other services using protocols such as
LDAP, IMAP, SNMP, NNTP, POP3, HTTP, COM (on Windows) and countless others. You
can also open raw network sockets and interact using any other protocol. PHP has
support for the WDDX complex data exchange between virtually all Web programming
languages. Talking about interconnection, PHP has support for instantiation of
Java objects and using them transparently as PHP objects. You can also use our
CORBA extension to access remote objects.

PHP has extremely useful text processing features, from the POSIX Extended or
Perl regular expressions to parsing XML documents. For parsing and accessing XML
documents, PHP 4 supports the SAX and DOM standards, and you can also use the
XSLT extension to transform XML documents. PHP 5 standardizes all the XML
extensions on the solid base of libxml2 and extends the feature set adding
SimpleXML and XMLReader support.

While using PHP in the e-commerce field, you'll find the Cybercash payment,
CyberMUT, VeriSign Payflow Pro and MCVE functions useful for your online payment
programs.

At last but not least, we have many other interesting extensions, the
mnoGoSearch search engine functions, the IRC Gateway functions, many compression
utilities (gzip, bz2), calendar conversion, translation...

As you can see this page is not enough to list all the features and benefits
PHP can offer. Read on in the sections about installing
PHP, and see the function reference part for
explanation of the extensions mentioned here.

Getting Started -- 1. Introduction

2009-01-08T16:51:00.000-08:00

What is PHP?

PHP (recursive acronym for "PHP: Hypertext
Preprocessor") is a widely-used Open Source general-purpose scripting language
that is especially suited for Web development and can be embedded into HTML.

Simple answer, but what does that mean? An example:

????? 1-1. An introductory example

<html>
    <head>
        <title>Example</title>
    </head>
    <body>

        <?php
        echo "Hi, I'm a PHP
script!";
        ?>

    </body>
</html>

Notice how this is different from a script written in other languages like
Perl or C -- instead of writing a program with lots of commands to output HTML,
you write an HTML script with some embedded code to do something (in this case,
output some text). The PHP code is enclosed in special start and end
tags that allow you to jump into and out of "PHP mode".

What distinguishes PHP from something like client-side JavaScript is that the
code is executed on the server. If you were to have a script similar to the
above on your server, the client would receive the results of running that
script, with no way of determining what the underlying code may be. You can even
configure your web server to process all your HTML files with PHP, and then
there's really no way that users can tell what you have up your sleeve.

The best things in using PHP are that it is extremely simple for a newcomer,
but offers many advanced features for a professional programmer. Don't be afraid
reading the long list of PHP's features. You can jump in, in a short time, and
start writing simple scripts in a few hours.

Although PHP's development is focused on server-side scripting, you can do
much more with it. Read on, and see more in the What can PHP do? section, or go right to the introductory tutorial if you are only interested in web
programming.

Adabas D	InterBase	PostgreSQL
dBase	FrontBase	SQLite
Empress	mSQL	Solid
FilePro (read-only)	Direct MS-SQL	Sybase
Hyperwave	MySQL	Velocis
IBM DB2	ODBC	Unix dbm
Informix	Oracle (OCI7 and OCI8)
Ingres	Ovrimos