jeudi 8 janvier 2009

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

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

???? 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

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

???? 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

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

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

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

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

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

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

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

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

????
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

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

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

????
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

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

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

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.

learn php script Headline Animator

jeudi 8 janvier 2009

Postincrement

Preincrement

Postdecrement

Predecrement

the Google Friend Connect

PHP Manual

Archives

pub

Register Free

pub

Subscribe