PHP Manual
Prev | Chapter 7. Types | Next

# Type Juggling

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

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

    $foo = "0";  // $foo is string (ASCII 48)

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

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

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.

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

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

> For this reason, as of PHP 3.0.12 and PHP 4.0b3-RC4, the result of this automatic conversion is considered to be undefined. Fixes are, however, being discussed.

## Type Casting

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

    $foo = 10;   // $foo is an integer
    $bar = (float) $foo;   // $bar is a float

The casts allowed are:

- (int), (integer) - cast to integer

- (bool), (boolean) - cast to boolean

- (float), (double), (real) - cast to float

- (string) - cast to string

- (array) - cast to array

- (object) - cast to object

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

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

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

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

When casting or forcing a conversion from array to string, the result will be the word `Array`. When casting or forcing a conversion from object to string, the result will be the word `Object`.

When casting from a scalar or a string variable to an array, the variable will become the first element of the array:

    $var = 'ciao';
    $arr = (array) $var;
    echo $arr[0];  // outputs 'ciao'

When casting from a scalar or a string variable to an object, the variable will become an attribute of the object; the attribute name will be 'scalar':

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

Prev | Home | Next
Pseudo-types used in this documentation | Up | Variables