Php

Basic syntax
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.
<p>This is going to be ignored.</p>
<?php echo 'While this is going to be parsed.'; ?>
<p>This will also be ignored.</p>
You can also use more advanced structures:
Example 10.1. Advanced escaping
<?php
if ($expression) {
?>
<strong>This is true.</strong>
<?php
} else {
?>
<strong>This is false.</strong>
<?php
}
?>
This works as expected, because when PHP hits the ?> closing tags, it
simply starts outputting whatever it finds (except for an immediately
following newline - see instruction separation ) 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, <?php ?> and <script language="php">
</script>, 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.
Note: Also note that if you are embedding PHP within XML or XHTML
you will need to use the <?php ?> tags to remain compliant with
standards.
Example 10.2. PHP Opening and Closing Tags
1. <?php echo 'if you want to serve XHTML or XML documents, do
like this'; ?>
2. <script language="php">
echo 'some editors (like FrontPage) don't
like processing instructions';
</script>
3. <? echo 'this is the simplest, an SGML processing instructio
n'; ?>
<?= expression ?> 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.
Note: 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.
Note: Support for ASP tags was added in 3.0.4.
Note: 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.
Instruction separation
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.
<?php
echo 'This is a test';
?>
<?php echo 'This is a test' ?>
<?php echo 'We omitted the last closing tag';
Note: The closing tag of a PHP block at the end of a file is optional, and
in some cases omitting it is helpful when using include() or require(), so
unwanted whitespace will not occur at the end of files, and you will still
be able to add headers to the response later. It is also handy if you use
output buffering, and would not like to see added unwanted whitespace
at the end of the parts generated by the included files.
Comments

PHP supports 'C', 'C++' and Unix shell-style (Perl style) comments. For
example:
<?php
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 one-line 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 // ... ?> or # ... ?> WILL be printed: ?> breaks out of
PHP mode and returns to HTML mode, and // or # cannot influence that.
If the asp_tags configuration directive is enabled, it behaves the same
with // %> and # %>. However, the </script> tag doesn't break out of
PHP mode in a one-line comment.
<h1>This is an <?php # echo 'simple';?> example.</h1>
<p>The header above will say 'This is an example'.</p>
'C' style comments end at the first */ encountered. Make sure you don't
nest 'C' style comments. It is easy to make this mistake if you are trying
to comment out a large block of code.
<?php
/*
echo 'This is a test'; /* This comment will cause a problem
*/
*/
?>
Prev III. Language Reference Next

Chapter 11. Types
Table of Contents
Introduction
Booleans
Integers
Floating point numbers
Strings
Arrays
Objects
Resource
NULL
Pseudo-types and variables 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
And the pseudo-variable $....
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.
Note: 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:
<?php
$a_bool = TRUE; // a boolean
$a_str = "foo"; // a string
$a_str2 = 'foo'; // a string
$an_int = 12; // an integer
echo gettype($a_bool); // prints out: boolean
echo gettype($a_str); // prints out: string
// If this is an integer, increment it by four
if (is_int($an_int)) {
$an_int += 4;
}
// If $bool is a string, print it out
// (does not print out anything)
if (is_string($a_bool)) {

echo "String: $a_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.
Prev Up Next
Comments Home Booleans
Booleans
This is the easiest type. A boolean expresses a truth value. It can be
either TRUE or FALSE.
Note: 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.
<?php
$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.
<?php
// == 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 "<hr>n";
}
// ...because you can simply type
if ($show_separators) {
echo "<hr>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.
See also Type Juggling.
When converting to boolean, the following values are considered FALSE:
the boolean FALSE itself
the integer 0 (zero)
the float 0.0 (zero)
the empty string, and the string "0"
an array with zero elements
an object with zero member variables (PHP 4 only)
the special type NULL (including unset variables)
SimpleXML objects created from empty tags
Every other value is considered TRUE (including any resource).
Warning

-1 is considered TRUE, like any other non-zero (whether negative or
positive) number!
<?php
var_dump((bool) ""); // bool(false)
var_dump((bool) 1); // bool(true)
var_dump((bool) -2); // bool(true)
var_dump((bool) "foo"); // bool(true)
var_dump((bool) 2.3e5); // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array()); // bool(false)
var_dump((bool) "false"); // bool(true)
?>
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.
Example 11.1. Integer literals
<?php
$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. Integer size can be determined from PHP_INT_SIZE, maximum
value from PHP_INT_MAX since PHP 4.4.0 and PHP 5.0.5.
Warning
If an invalid digit is passed to octal integer (i.e. 8 or 9), the rest of the
number is ignored.
Example 11.2. Octal weirdness
<?php
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.

<?php
$large_number = 2147483647;
var_dump($large_number);
// output: int(2147483647)
$large_number = 2147483648;
// output: float(2147483648)
// it's true also for hexadecimal specified integers between 2^3
1 and 2^32-1:
var_dump( 0xffffffff );
// output: float(4294967295)
// this doesn't go for hexadecimal specified integers above 2^32
-1:
var_dump( 0x100000000 );
// output: int(2147483647)
$million = 1000000;
$large_number = 50000 * $million;
// output: float(50000000000)
?>
Warning
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.
<?php
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().
See also type-juggling.
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!
Warning
Never cast an unknown fraction to integer, as this can sometimes lead to
unexpected results.
<?php
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
Caution
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.
Floating point numbers
Floating point numbers (AKA "floats", "doubles" or "real numbers") can
be specified using any of the following syntaxes:
<?php
$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.
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.
Note: 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.
Note: In PHP 3, a warning will be issued at the E_NOTICE level when
this happens.
Note: Unlike the two other syntaxes, variables and escape sequences for
special characters will not be expanded when they occur in single quoted
strings.
<?php
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:
Table 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)
v vertical tab (VT or 0x0B (11) in ASCII) (since PHP 5.2.5)
f form feed (FF or 0x0C (12) in ASCII) (since PHP 5.2.5)
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! Before PHP 5.1.1, backslash in {$var} hasn't been printed.
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 (followed by new line) 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.
Warning
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. Closing delimiter (possibly followed by a
semicolon) must be followed by a newline too.
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.
Example 11.3. Invalid example

<?php
class foo {
public $bar = <<<EOT
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.
Example 11.4. Heredoc string quoting example
<?php
$str = <<<EOD
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 <<<EOT
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;
?>
Note: 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.
<?php
$beer = 'Heineken';
echo "$beer's taste is great"; // works, "'" is an invalid chara
cter for varnames
echo "He drank some $beers"; // won't work, 's' is a valid cha
racter 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.
<?php
// 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 "{$" to get a literal "{$"). Some examples to make
it clear:
<?php
$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}}";
?>
Note: Functions and method calls work since PHP 5.
Note: Parsing variables within strings uses more memory than string
concatenation. When writing a PHP script in which memory usage is a
concern, consider using the concatenation operator (.) rather than
variable parsing.
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 using
square array-brackets like $str[42] so think of a string as an array of
characters.
Note: They may also be accessed using braces like $str{42} for the same
purpose. However, using square array-brackets is preferred because the
{braces} style is deprecated as of PHP 6.
Example 11.5. Some string examples
<?php
// 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';
// Alternative method using {} is deprecated as of PHP 6
$third = $str{2};
?>
Note: Accessing by [] or {} to variables of other type silently returns
NULL.
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). Floating point numbers can be converted using
the exponential notation (4.1E+6).
Note: The decimal point character is defined in the script's locale
(category LC_NUMERIC). See setlocale().
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 in PHP 4 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.
<?php
$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:
<?php
echo "$foo==$foo; type is " . gettype ($foo) . "<br />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.
Prev 11. Types Next
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
<?php
$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.
<?php
$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.
<?php
// This array is the same as ...
array(5 => 43, 32, 56, "b" => 12);
// ...this array
array(5 => 43, 6 => 32, 7 => 56, "b" => 12);
?>
Warning
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.
<?php
$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
?>
Note: 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.
Warning
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:
<?php
// 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 y
ou
// 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.
Note: 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().
<?php
$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:
<?php
$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.
Note: 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.
<?php
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";
}
?>

Checking 0:
Notice: Undefined index: $i in /path/to/script.html on line 9
Bad:
Good: 1
Bad:
Good: 1
Checking 1:
Bad:
Good: 2
Bad:
Good: 2
More examples to demonstrate this fact:
<?php
$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 superglobals in strings as we
ll
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:
<?php
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.
<?php
$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 notic
e";
?>
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:
<?php
$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.
Note: 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 with a few notable exceptions: private variables
have the class name prepended to the variable name; protected variables
have a '*' prepended to the variable name. These prepended values have
null bytes on either side. This can result in some unexpected behaviour.
<?php
class A {
private $A; // This will become '0A0A'
}
class B extends A {
private $A; // This will become '0B0A'
public $AA; // This will become 'AA'
}
var_dump((array) new B());
?>
The above will appear to have two keys named 'AA', although one of them is
actually named '0A0A'.
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.
<?php
// 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')
?>
Example 11.6. Using array()
<?php
// 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 overwrit
ten by 12
);
// empty array
$empty = array();
?>
Example 11.7. Collection
<?php
$colors = array('red', 'blue', 'green', 'yellow');
foreach ($colors as $color) {
echo "Do you like $color?n";
}
?>
Do you like red?
Do you like blue?
Do you like green?
Do you like yellow?

Changing values of the array directly is possible since PHP 5 by passing
them as reference. Prior versions need workaround:
Example 11.8. Collection
<?php
// PHP 5
foreach ($colors as &$color) {
$color = strtoupper($color);
}
unset($color); /* ensure that following writes to
$color will not modify the last array element */
// Workaround for older versions
foreach ($colors as $key => $color) {
$colors[$key] = strtoupper($color);
}
print_r($colors);
?>
Array
(
[0] => RED
[1] => BLUE
[2] => GREEN
[3] => YELLOW
)
This example creates a one-based array.
Example 11.9. One-based index

<?php
$firstquarter = array(1 => 'January', 'February', 'March');
print_r($firstquarter);
?>
Array
(
[1] => 'January'
[2] => 'February'
[3] => 'March'
)
Example 11.10. Filling an array
<?php
// 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.
Example 11.11. Sorting an array
<?php
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.
Example 11.12. Recursive and multi-dimensional arrays
<?php
$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. It also means that the internal array pointer used by current()
and similar functions is reset. You need to use the reference operator to
copy an array by reference.

<?php
$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
?>
Prev Up Next
Strings Home Objects
Objects
Object Initialization
To initialize an object, you use the new statement to instantiate the
object to a variable.
<?php
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.
Array converts to an object with properties named by array keys and
with corresponding values. For any other value, a member variable
named scalar will contain the value.
<?php
$obj = (object) 'ciao';
echo $obj->scalar; // outputs 'ciao'
?>
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.
Note: The resource type was introduced in PHP 4
See also get_resource_type().
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.
Note: Persistent database links are special, they are not destroyed by the
garbage collector. See also the section about persistent connections.
NULL
The special NULL value represents that a variable has no value. NULL is the
only possible value of type NULL.
Note: 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.
<?php
$var = NULL;
?>
See also is_null() and unset().
Pseudo-types and variables 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 built-in 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.
Apart from common user-defined function, create_function() can be
used to create an anonymous callback function.
Example 11.13. Callback function examples
<?php
// 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'));
?>
Note: In PHP4, you will have to use a reference to create a callback that
points to the actual object, and not a copy of it. For more details, see
References Explained.
void
void in return type means that the return value is useless. void in
parameters list means that the function doesn't accept any parameters.
...
$... in function prototypes means and so on. This variable name is used
when a function can take an endless number of arguments.
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.
<?php
$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.
Note: The behaviour of an automatic conversion to array is currently
undefined.
Also, because PHP supports indexing into strings via offsets using the
same syntax as array indexing, the following example holds true for all
PHP versions:
<?php
$a = 'car'; // $a is a string
$a[0] = 'b'; // $a is still a string

echo $a; // bar
?>
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.
<?php
$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
(binary) - cast to binary string (PHP 6)
(array) - cast to array
(object) - cast to object
(binary) casting and b prefix forward support was added in PHP 5.2.1
Note that tabs and spaces are allowed inside the parentheses, so the
following are functionally equivalent:
<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
?>
Casting a literal strings and variables to binary strings:
<?php
$binary = (binary)$string;
$binary = b"binary string";
?>

Note: Instead of casting a variable to string, you can also enclose the
variable in double quotes.
<?php
$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
Prev Up Next
Pseudo-types and variables
used in this
Chapter 12. Variables
Table of Contents
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]*'
Note: For our purposes here, a letter is a-z, A-Z, and the ASCII
characters from 127 through 255 (0x7f-0xff).
Note: $this is a special variable that can't be assigned.
Tip
You may also want to take a look at the Appendix T, Userland Naming
Guide.
For information on variable related functions, see the Variable Functions
Reference.
<?php
$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.
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:
<?php
$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.
<?php
$foo = 25;
$bar = &$foo; // This is a valid assignment.
$bar = &(24 * 7); // Invalid; references an unnamed expression.
function test()
{
return 25;
}
$bar = &test(); // Invalid.
?>
It is not necessary to initialize variables in PHP however it is a very
good practice. Uninitialized variables have a default value of their type -
FALSE, zero, empty string or an empty array.

Example 12.1. Default values of uninitialized variables
<?php
echo ($unset_bool ? "true" : "false"); // false
$unset_int += 25; // 0 + 25 => 25
echo $unset_string . "abc"; // "" . "abc" => "abc"
$unset_array[3] = "def"; // array() + array(3 => "def") => array
(3 => "def")
?>
Relying on the default value of an uninitialized variable is problematic
in the case of including one file into another which uses the same
variable name. It is also a major security risk with register_globals
turned on. E_NOTICE level error is issued in case of working with
uninitialized variables, however not in the case of appending elements to
the uninitialized array. isset() language construct can be used to detect if
a variable has been already initialized.
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.
Warning
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 "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.
Note: 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().
Caution
Since PHP 4.3.0, FILE information from $_FILES does not exist in
$_REQUEST.
Note: 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.
Prev Up Next
12. Variables Home Variable scope
Prev 12. Variables Next
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:
<?php
$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:
<?php
$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:
Example 12.2. Using global
<?php
$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:
Example 12.3. Using $GLOBALS instead of global
<?php
$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:
Example 12.4. Example demonstrating superglobals and scope
<?php
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:
Example 12.5. Example demonstrating need for static variables
<?php
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:
Example 12.6. Example use of static variables

<?php
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:
Example 12.7. Static variables with recursive functions
<?php
function Test()
{
static $count = 0;
$count++;
echo $count;
if ($count < 10) {
Test();
}
$count--;
}
?>
Note: 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.
Example 12.8. Declaring static variables

<?php
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:
<?php
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:
<?php
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.
Prev Up Next
Predefined variables Home Variable variables
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:
<?php
$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.
<?php
$$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:
<?php
echo "$a ${$a}";
?>
produces the exact same output as:

<?php
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.
Warning
Please note that variable variables cannot be used with PHP's
Superglobal arrays within functions or class methods. The variable $this
is also a special variable that cannot be referenced dynamically.
Prev 12. Variables Next
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:
Example 12.9. A simple HTML form
<form action="foo.php" method="post">
Name: <input type="text" name="username" /><br />
Email: <input type="text" name="email" /><br />
<input type="submit" name="submit" value="Submit me!" />

</form>
Depending on your particular setup and personal preferences, there are
many ways to access data from your HTML forms. Some examples are:
Example 12.10. Accessing data from a simple POST HTML form
<?php
// 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().

Note: 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.
Note: 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:
Example 12.11. More complex form variables
<?php
if ($_POST) {
echo '<pre>';
echo htmlspecialchars(print_r($_POST, true));
echo '</pre>';
}
?>
<form action="" method="post">
Name: <input type="text" name="personal[name]" /><br />
Email: <input type="text" name="personal[email]" /><br />
Beer: <br />
<select multiple name="beer[]">
<option value="warthog">Warthog</option>
<option value="guinness">Guinness</option>
<option value="stuttgarter">Stuttgarter Schwabenbräu</op
tion>
</select><br />
<input type="submit" value="submit me!" />
</form>

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:
<input type="image" src="image.gif" name="sub" />
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:

<?php
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.
Example 12.12. A setcookie() example
<?php
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: <?php
$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.
Prev Up Next
Variable variables Home 13. Constants
Chapter 13. Constants
Table of Contents
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]*
Tip
Guide.
Example 13.1. Valid and invalid constant names
<?php
// 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");
?>
Note: 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. Do not define resource 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.
Note: 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.
Example 13.2. Defining Constants
<?php
define("CONSTANT", "Hello world.");
echo CONSTANT; // outputs "Hello world."
echo Constant; // outputs "Constant" and issues a notice.
?>

See also Class Constants.
Prev Up Next
Variables from outside PHP Home Magic constants
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:
Table 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.

Name Description
__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().
Chapter 17. Functions
Table of Contents
User-defined functions
Function arguments
Returning values
Variable functions
Internal (built-in) functions
User-defined functions
A function may be defined using syntax such as the following:
Example 17.1. Pseudo code to demonstrate function uses
<?php
function foo($arg_1, $arg_2, /* ..., */ $arg_n)
{
echo "Example function.n";
return $retval;
}
?>

Any valid PHP code may appear inside a function, even other functions
and class definitions.
Function names follow the same rules as other labels in PHP. A valid
function 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]*.
Tip
Guide.
In PHP 3, functions must be defined before they are referenced. No such
requirement exists since PHP 4. Except when a function is conditionally
defined such as shown in the two examples below.
When a function is defined in a conditional manner such as the two
examples shown. Its definition must be processed prior to being called.
Example 17.2. Conditional functions
<?php
$makefoo = true;
/* We can't call foo() from here
since it doesn't exist yet,
but we can call bar() */
bar();
if ($makefoo) {
function foo()
{
echo "I don't exist until program execution reaches me.n";
}
}
/* Now we can safely call foo()
since $makefoo evaluated to true */

if ($makefoo) foo();
function bar()
{
echo "I exist immediately upon program start.n";
}
?>
Example 17.3. Functions within functions
<?php
function foo()
{
function bar()
{
echo "I don't exist until foo() is called.n";
}
}
/* We can't call bar() yet
since it doesn't exist. */
foo();
/* Now we can call bar(),
foo()'s processesing has
made it accessible. */
bar();
?>
All functions and classes in PHP have the global scope - they can be
called outside a function even if they were defined inside and vice versa.
PHP does not support function overloading, nor is it possible to undefine
or redefine previously-declared functions.
Note: Function names are case-insensitive, though it is usually good
form to call functions as they appear in their declaration.

PHP 3 does not support variable numbers of arguments to functions,
although default arguments are supported (see Default argument values
for more information). Both are supported, as of PHP 4: see Variable-
length argument lists and the function references for func_num_args(),
func_get_arg(), and func_get_args() for more information.
It is possible to call recursive functions in PHP. However avoid
recursive function/method calls with over 100-200 recursion levels as it
can smash the stack and cause a termination of the current script.
Example 17.4. Recursive functions
<?php
function recursion($a)
{
if ($a < 20) {
echo "$an";
recursion($a + 1);
}
}
?>
Prev Up Next
include_once Home Function arguments
Prev 17. Functions Next
Function arguments
Information may be passed to functions via the argument list, which is a
comma-delimited list of expressions.
PHP supports passing arguments by value (the default), passing by
reference, and default argument values. Variable-length argument lists
are supported only in PHP 4 and later; see Variable-length argument lists
and the function references for func_num_args(), func_get_arg(), and

func_get_args() for more information. A similar effect can be achieved
in PHP 3 by passing an array of arguments to a function:
Example 17.5. Passing arrays to functions
<?php
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>
Making arguments be passed by reference
By default, function arguments are passed by value (so that if you
change the value of the argument within the function, it does not get
changed outside of the function). If you wish to allow a function to
modify its arguments, you must pass them by reference.
If you want an argument to a function to always be passed by reference,
you can prepend an ampersand (&) to the argument name in the function
definition:
Example 17.6. Passing function parameters by reference
<?php
function add_some_extra(&$string)
{
$string .= 'and something extra.';
}
$str = 'This is a string, ';
add_some_extra($str);
echo $str; // outputs 'This is a string, and something extra.
'
?>
Default argument values

A function may define C++-style default values for scalar arguments as
follows:
Example 17.7. Use of default parameters in functions
<?php
function makecoffee($type = "cappuccino")
{
return "Making a cup of $type.n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>
The output from the above snippet is:
Making a cup of cappuccino.
Making a cup of .
Making a cup of espresso.
Also PHP allows you to use arrays and special type NULL as default
values, for example:
Example 17.8. Using non-scalar types as default values
<?php
function makecoffee($types = array("cappuccino"), $coffeeMaker =
NULL)
{
$device = is_null($coffeeMaker) ? "hands" : $coffeeMaker;
return "Making a cup of ".join(", ", $types)." with $device.
n";
}
echo makecoffee();
echo makecoffee(array("cappuccino", "lavazza"), "teapot");
?>
The default value must be a constant expression, not (for example) a
variable, a class member or a function call.

Note that when using default arguments, any defaults should be on the
right side of any non-default arguments; otherwise, things will not work
as expected. Consider the following code snippet:
Example 17.9. Incorrect usage of default function arguments
<?php
function makeyogurt($type = "acidophilus", $flavour)
{
return "Making a bowl of $type $flavour.n";
}
echo makeyogurt("raspberry"); // won't work as expected
?>
The output of the above example is:
Warning: Missing argument 2 in call to makeyogurt() in
/usr/local/etc/httpd/htdocs/php3test/functest.html on line 41
Making a bowl of raspberry .
Now, compare the above with this:
Example 17.10. Correct usage of default function arguments
<?php
function makeyogurt($flavour, $type = "acidophilus")
{
return "Making a bowl of $type $flavour.n";
}
echo makeyogurt("raspberry"); // works as expected
?>
The output of this example is:
Making a bowl of acidophilus raspberry.
Note: As of PHP 5, default values may be passed by reference.

Variable-length argument lists
PHP 4 and above has support for variable-length argument lists in user-
defined functions. This is really quite easy, using the func_num_args(),
func_get_arg(), and func_get_args() functions.
No special syntax is required, and argument lists may still be explicitly
provided with function definitions and will behave as normal.
Prev Up Next
17. Functions Home Returning values
Returning values
Values are returned by using the optional return statement. Any type
may be returned, including lists and objects. This causes the function to
end its execution immediately and pass control back to the line from
which it was called. See return() for more information.
Example 17.11. Use of return()
<?php
function square($num)
{
return $num * $num;
}
echo square(4); // outputs '16'.
?>
You can't return multiple values from a function, but similar results can
be obtained by returning a list.
Example 17.12. Returning an array to get multiple values

<?php
function small_numbers()
{
return array (0, 1, 2);
}
list ($zero, $one, $two) = small_numbers();
?>
To return a reference from a function, you have to use the reference
operator & in both the function declaration and when assigning the
returned value to a variable:
Example 17.13. Returning a reference from a function
<?php
function &returns_reference()
{
return $someref;
}
$newref =& returns_reference();
?>
For more information on references, please check out References
Explained.
Prev Up Next
Function arguments Home Variable functions
Variable functions
PHP supports the concept of variable functions. This means that if a
variable name has parentheses appended to it, PHP will look for a
function with the same name as whatever the variable evaluates to, and

will attempt to execute it. Among other things, this can be used to
implement callbacks, function tables, and so forth.
Variable functions won't work with language constructs such as echo(),
print(), unset(), isset(), empty(), include(), require() and the like. You
need to use your own wrapper function to utilize any of these constructs
as variable functions.
Example 17.14. Variable function example
<?php
function foo() {
echo "In foo()<br />n";
}
function bar($arg = '')
{
echo "In bar(); argument was '$arg'.<br />n";
}
// This is a wrapper function around echo
function echoit($string)
{
echo $string;
}
$func = 'foo';
$func(); // This calls foo()
$func = 'bar';
$func('test'); // This calls bar()
$func = 'echoit';
$func('test'); // This calls echoit()
?>
You can also call an object's method by using the variable functions
feature.
Example 17.15. Variable method example

<?php
class Foo
{
function Variable()
{
$name = 'Bar';
$this->$name(); // This calls the Bar() method
}
function Bar()
{
echo "This is Bar";
}
}
$foo = new Foo();
$funcname = "Variable";
$foo->$funcname(); // This calls $foo->Variable()
?>
See also call_user_func(), variable variables and function_exists().
Prev Up Next
Returning values Home Internal (built-in) functions
Internal (built-in) functions
PHP comes standard with many functions and constructs. There are also
functions that require specific PHP extensions compiled in otherwise
you'll get fatal "undefined function" errors. For example, to use image
functions such as imagecreatetruecolor(), you'll need your PHP
compiled with GD support. Or, to use mysql_connect() you'll need your
PHP compiled in with MySQL support. There are many core functions
that are included in every version of PHP like the string and variable

functions. A call to phpinfo() or get_loaded_extensions() will show you
which extensions are loaded into your PHP. Also note that many
extensions are enabled by default and that the PHP manual is split up by
extension. See the configuration, installation, and individual extension
chapters, for information on how to setup your PHP.
Reading and understanding a function's prototype is explained within the
manual section titled how to read a function definition. It's important to
realize what a function returns or if a function works directly on a passed
in value. For example, str_replace() will return the modified string while
usort() works on the actual passed in variable itself. Each manual page
also has specific information for each function like information on
function parameters, behavior changes, return values for both success
and failure, and availability information. Knowing these important (yet
often subtle) differences is crucial for writing correct PHP code.
Note: If the parameters given to a function are not what it expects, such
as passing an array where a string is expected, the return value of the
function is undefined. In this case it will likely return NULL but this is just
a convention, and cannot be relied upon.
See also function_exists(), the function reference, get_extension_funcs(),
and dl().
Prev Up Next
Variable functions
Home
18. Classes and Objects
(PHP 4)

Php

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Php (20)

Recently uploaded (20)

Php