PHP provides four primitive data types: integers, floating point numbers, strings, and booleans. In addition, there are two compound data types: arrays and objects.
Integers are whole numbers. The range of integers in PHP is equivalent to the range of the long data type in C. On 32-bit platforms, integer values range from -2,147,483,648 to +2,147,483,647. PHP automatically converts larger values to floating point numbers if you happen to overflow the range. An integer can be expressed in decimal (base-10), hexadecimal (base-16), or octal (base-8). For example:
$decimal=16;$hex=0x10;$octal=020;
Floating point numbers represent decimal values. The range of floating point numbers in PHP is equivalent to the range of the double type in C. On most platforms, a double can be between 1.7E-308 to 1.7E+308. A double may be expressed either as a regular number with a decimal point or in scientific notation. For example:
$var=0.017;$var=17.0E-3
PHP also has two sets of functions that let you manipulate numbers with arbitrary precision. These two sets are known as the BC and the GMP functions. See http://www.php.net/bc and http://www.php.net/gmp for more information.
A string is a sequence of characters. A string can be delimited by single quotes or double quotes:
'PHP is cool'"Hello, World!"
Double-quoted strings are subject to variable substitution and escape sequence handling, while single quotes are not. For example:
$a="World";echo "Hello\t$a\n";
This displays "Hello" followed by a tab and then "World" followed by a newline. In other words, variable substitution is performed on the variable $a and the escape sequences are converted to their corresponding characters. Contrast that with:
echo 'Hello\t$a\n';
In this case, the output is exactly "Hello\t$a\n". There is no variable substitution or handling of escape sequences.
Another way to assign a string is to use what is known as the heredoc syntax. The advantage with this approach is that you do not need to escape quotes. It looks like this:
$foo = <<<EOD This is a "multiline" string assigned using the 'heredoc' syntax.EOD;
The following table shows the escape sequences understood by PHP inside double-quoted strings.
|
Meaning |
|
|
\n |
Linefeed (LF or 0x0A (10) in ASCII) |
|
\r |
Carriage return (CR or 0x0D (13) in ASCII) |
|
\t |
Horizontal tab (HT or 0x09 (9) in ASCII) |
|
\\ |
Backslash |
|
\$ |
Dollar sign |
|
\" |
Double quote |
|
\123 |
Octal notation representation of a character |
|
\x12 |
Hexadecimal notation representation of a character |
The boolean type only has two states: true and false. For example:
$flag = true;
Boolean values are most commonly used when the == or === operators perform a comparison and return the result.
An array is a compound data type that can contain multiple data values, indexed either numerically or with strings. For example, an array of strings can be written like this:
$var[0]="Hello";
$var[1]="World";
Note that when you assign array elements like this, you do not have to use consecutive numbers to index the elements.
As a shortcut, PHP allows you to add an element onto the end of an array without specifying an index. For example:
$var[ ] ="Test";
PHP picks the next logical numerical index. In this case, the "Test" element is given the index 2 in our $var array: if the array has nonconsecutive elements, PHP selects the index value that is one greater than the current highest index value. This autoindexing feature is most useful when dealing with multiple-choice HTML <select> form elements, as we'll see in a later example.
Although we have called strings a primitive data type, it is actually possible to treat a string as a compound data type, where each character in the string can be accessed separately. In other words, you can think of a string as an array of characters, where the first character is at index 0. Thus, you can pick the third character out of a string with:
$string[2]
To solve an ambiguity problem between strings and arrays, a new syntax has been introduced to dereference individual characters from strings:
$string{2}
This syntax is equivalent to $string[2], and is preferable.
Arrays can also be indexed using strings; these kinds of arrays are called associative arrays:
$var["January"]=1;
$var["February"]=2;
You can use a mix of numerical and string indices with a single array because PHP treats all arrays as hash tables internally, and the hash, or index, can be whatever you want.
All arrays in PHP can be traversed safely with the following mechanism:
foreach($array as $key=>$value) {echo "array[$key]=$value<br>\n";
}
This is the most common way to loop through each element of an array, whether it is a linear or an associative array. PHP provides a number of array manipulation functions; these are detailed later in the "Function Reference."
An object is a compound data type that can contain any number of variables and functions. PHP's support for objects is somewhat limited in Version 4. PHP Version 5 will improve the object-oriented capabilities of PHP. In PHP 4, the object-oriented support is designed to make it easy to encapsulate data structures and functions in order to package them into reusable classes. Here's a simple example:
class test {var $str = "Hello World";
function init($str) {$this->str = $str;
}
}
$class = new test;
echo $class->str;
$class->init("Hello");echo $class->str;
This code creates a test object using the new operator. Then it sets a variable called str within the object. In object-speak, a variable in an object is known as a property of that object. The test object also defines a function, known as a method, called init(). This method uses the special-purpose $this variable to change the value of the str property within that object.
Inheritance is supported by using the extends keyword in the class definition. We can extend the previous test class like this:
class more extends test { function more( ) {echo "Constructor called";
}}
This means that the more class inherits from the test class and it also introduces the concept of a constructor. If a method inside a class has the same name as the class, it becomes the constructor function for that class. A constructor is called automatically when the class is instantiated.
Much more information is available at http://www.php.net/oop.
As I already mentioned, you do not need to specify a type when you create a variable, but that doesn't mean the variables do not have types associated with them. You can explicitly set the type, known as type casting, by using the C-style syntax in which you put the type you want in brackets before the variable or expression. For example:
$var = (int)"123abc";
Without the (int) in this example, PHP creates a string variable. With the explicit cast, however, we have created an integer variable with a value of 123. The following table shows the available cast operators in PHP.
|
Function |
|
|
(int), (integer) |
Cast to an integer |
|
(real), (double), (float) |
Cash to a floating point number |
|
(string) |
Cast to a string |
|
(array) |
Cast to an array |
|
(object) |
Cast to an object |
|
(bool), (boolean) |
Cast to a boolean |
|
(unset) |
Cast to NULL; the same as calling unset( ) on the value |
Although they are not usually needed, PHP does provide the following built-in functions to check variable types in your program: gettype(), is_bool(), is_long(), is_float(), is_string(), is_array(), and is_object().