Last updated: Fri, 16 Jul 2004

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.

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

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

Since PHP (for historical reasons) supports indexing into strings via offsets using the same syntax as array indexing, the example above leads to a problem: should $a become an array with its first element being "f", or should "f" become the first character of the string $a?
The current versions of PHP interpret the second assignment as a string offset identification, so $a becomes "f", the result of this automatic conversion however should be considered undefined. PHP 4 introduced the new curly bracket syntax to access characters in string, use this syntax instead of the one presented above:

<?php $a = "abc"; // $a is a string $a{1} = "f"; // $a is now "afc" ?>
See the section titled String access by character for more information.

Type Casting

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


<?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
(array) - cast to array
(object) - cast to object

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


<?php

$foo = (int) $bar;

$foo = ( int ) $bar;

?>

Opomba: 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:

Variables

Pseudo-types used in this documentation

Last updated: Fri, 16 Jul 2004

add a note User Contributed Notes
Type Juggling

Jeffrey
09-Nov-2008 11:34


IMAGINATION REQUIRED...



We can be a witness to PHP's 'type-jugglin' in real-time with a simple implementation of a MemoryMap. For the sake our purposes, pretend that this is an empty MemoryMap.

+-------+------+------+-------+

| index | $var | type | value |

+-------+------+------+-------+

|     1 |  --- | NULL |  null |

|     2 |  --- | NULL |  null |

|     3 |  --- | NULL |  null |

|     4 |  --- | NULL |  null |

+-------+------+------+-------+



<?php

# create some variables...

$a = 10;

$b = "Hello";

$c = array(55.45, 98.65);

# Now look at map...

?>

+-------+-------+---------+--------+

| index |  $var |    type |  value |

+-------+-------+---------+--------+

|     1 |    $a | INTEGER |     10 |

|     2 |    $b |  STRING |  Hello |

|     3 | $c[0] |   FLOAT |  55.45 |

|     4 | $c[1] |   FLOAT |  98.65 |

+-------+-------+---------+--------+

<?php

# Now, change the variable types...

$a = "Bye";

$b = 2;

$c[0] = "Buy";

$c[1] = "Now!";

#Look at map...

?>

+-------+-------+---------+--------+

| index |  $var |    type |  value |

+-------+-------+---------+--------+

|     1 |    $a |  STRING |    Bye | <- used to be INTEGER

|     2 |    $b | INTEGER |      2 | <- used to be STRING

|     3 | $c[0] |  STRING |    Buy | <- used to be FLOAT

|     4 | $c[1] |  STRING |  Right | <- used to be FLOAT

+-------+-------+---------+--------+

hek at theeks dot net
04-Nov-2008 09:22


The behavior of comparisons between objects of different types is, in fact, already documented (though a cross-reference from this page might be handy for future readers):



http://www.php.net/manual/en/language.operators.comparison.php

hek at theeks dot net
17-Oct-2008 09:24


It would be useful to know the precedence (for lack of a better word) for type juggling.  This entry currently explains that "if either operand is a float, then both operands are evaluated as floats, and the result will be a float" but could (and I think should) provide a hierarchy that indicates, for instance, "between an int and a boolean, int wins; between a float and an int, float wins; between a string and a float, string wins" and so on (and don't count on my example accurately capturing the true hierarchy, as I haven't actually done the tests to figure it out).  Thanks!

wbcarts at juno dot com
07-Oct-2008 06:05


WHERE'S THE BEEF?



Looks like type-casting user-defined objects is a real pain, and ya gotta be nuttin' less than a brain jus ta cypher-it. But since PHP supports OOP, you can add the capabilities right now. Start with any simple class.

<?php

class Point {

  protected $x, $y;



  public function __construct($xVal = 0, $yVal = 0) {

    $this->x = $xVal;

    $this->y = $yVal;

  }

  public function getX() { return $this->x; }

  public function getY() { return $this->y; }

}



$p = new Point(25, 35);

echo $p->getX();      // 25

echo $p->getY();      // 35

?>

Ok, now we need extra powers. PHP gives us several options:

  A. We can tag on extra properties on-the-fly using everyday PHP syntax...

    $p->z = 45; // here, $p is still an object of type [Point] but gains no capability, and it's on a per-instance basis, blah.

  B. We can try type-casting it to a different type to access more functions...

    $p = (SuperDuperPoint) $p; // if this is even allowed, I doubt it. But even if PHP lets this slide, the small amount of data Point holds would probably not be enough for the extra functions to work anyway. And we still need the class def + all extra data. We should have just instantiated a [SuperDuperPoint] object to begin with... and just like above, this only works on a per-instance basis.

  C. Do it the right way using OOP - and just extend the Point class already.

<?php

class Point3D extends Point {

  protected $z;                                // add extra properties...



  public function __construct($xVal = 0, $yVal = 0, $zVal = 0) {

    parent::__construct($xVal, $yVal);

    $this->z = $zVal;

  }

  public function getZ() { return $this->z; }  // add extra functions...

}



$p3d = new Point3D(25, 35, 45);  // more data, more functions, more everything...

echo $p3d->getX();               // 25

echo $p3d->getY();               // 35

echo $p3d->getZ();               // 45

?>

Once the new class definition is written, you can make as many Point3D objects as you want. Each of them will have more data and functions already built-in. This is much better than trying to beef-up any "single lesser object" on-the-fly, and it's way easier to do.

lucazd at gmail dot com
23-Sep-2008 09:20


@alexgr (20-Jun-2008)



Correct me if I'm wrong, but that is not a cast, it might be useful sometimes, but the IDE will not reflect what's really happening:



<?php

class MyObject {

    /**

     * @param MyObject $object

     * @return MyObject

     */

    static public function cast(MyObject $object) {

        return $object;

    }

    /** Does nothing */

    function f() {}

}



class X extends MyObject {

    /** Throws exception */

    function f() { throw new exception(); }

}



$x = MyObject::cast(new X);

$x->f(); // Your IDE tells 'f() Does nothing'

?>



However, when you run the script, you will get an exception.

r dot nox at bk dot ru
22-Sep-2008 12:04


$j = 1;

print('a' . $j+1);



Will print:



1

nullhilty at gmail dot com
09-Sep-2008 11:34


Just a little experiment on the (unset) type cast:



<?php

$var = 1;

$var_unset = (unset) $var;

$var_ref_unset &= (unset) $var;

var_dump($var);

var_dump($var_unset);

var_dump($var_ref_unset);

?>



output:

int(1)

NULL

int(0)

alexgr at gmail dot com
20-Jun-2008 03:43


For a Cast to a User Defined Object you can define a cast method:



class MyObject {

    /**

     * @param MyObject $object

     * @return MyObject

     */

    static public function cast(MyObject $object) {

        return $object;

    }

}



In your php page code you can:

$myObject = MyObject::cast($_SESSION["myObject"]);



Then, PHP will validate the value and your IDE will help you.

miracle at 1oo-percent dot de
20-Feb-2006 05:26


If you want to convert a string automatically to float or integer (e.g. "0.234" to float and "123" to int), simply add 0 to the string - PHP will do the rest.



e.g.



$val = 0 + "1.234";

(type of $val is float now)



$val = 0 + "123";

(type of $val is integer now)

22-Jun-2005 05:47


If you have a boolean, performing increments on it won't do anything despite it being 1.  This is a case where you have to use a cast.



<html>

<body> <!-- don't want w3.org to get mad... -->

<?php

$bar = TRUE;

?>

I have <?=$bar?> bar.

<?php

$bar++;

?>

I now have <?=$bar?> bar.

<?php

$bar = (int) $bar;

$bar++;

?>

I finally have <?=$bar?> bar.

</body>

</html>



That will print



I have 1 bar.

I now have 1 bar.

I finally have 2 bar.

toma at smartsemantics dot com
09-Mar-2005 06:24


In my much of my coding I have found it necessary to type-cast between objects of different class types.



More specifically, I often want to take information from a database, convert it into the class it was before it was inserted, then have the ability to call its class functions as well.



The following code is much shorter than some of the previous examples and seems to suit my purposes.  It also makes use of some regular expression matching rather than string position, replacing, etc.  It takes an object ($obj) of any type and casts it to an new type ($class_type).  Note that the new class type must exist:



function ClassTypeCast(&$obj,$class_type){

    if(class_exists($class_type,true)){

        $obj = unserialize(preg_replace"/^O:[0-9]+:\"[^\"]+\":/i", 

          "O:".strlen($class_type).":\"".$class_type."\":", serialize($obj)));

    }

}

Raja
10-Feb-2005 03:05


Uneven division of an integer variable by another integer variable will result in a float by automatic conversion -- you do not have to cast the variables to floats in order to avoid integer truncation (as you would in C, for example):



$dividend = 2;

$divisor = 3;

$quotient = $dividend/$divisor;

print $quotient; // 0.66666666666667

tom5025_ at hotmail dot com
24-Aug-2004 01:27


function strhex($string)

{

   $hex="";

   for ($i=0;$i<strlen($string);$i++)

       $hex.=dechex(ord($string[$i]));

   return $hex;

}

function hexstr($hex)

{

   $string="";

   for ($i=0;$i<strlen($hex)-1;$i+=2)

       $string.=chr(hexdec($hex[$i].$hex[$i+1]));

   return $string;

}



to convert hex to str and vice versa

dimo dot vanchev at bianor dot com
10-Mar-2004 07:02


For some reason the code-fix posted by philip_snyder at hotmail dot com [27-Feb-2004 02:08]

didn't work for me neither with long_class_names nor with short_class_names. I'm using PHP v4.3.5 for Linux.

Anyway here's what I wrote to solve the long_named_classes problem:



<?php

function typecast($old_object, $new_classname) {

    if(class_exists($new_classname)) {

        $old_serialized_object = serialize($old_object);

        $old_object_name_length = strlen(get_class($old_object));

        $subtring_offset = $old_object_name_length + strlen($old_object_name_length) + 6;

        $new_serialized_object  = 'O:' . strlen($new_classname) . ':"' . $new_classname . '":';

        $new_serialized_object .= substr($old_serialized_object, $subtring_offset);

        return unserialize($new_serialized_object);

     } else {

         return false;

     }

}

?>

philip_snyder at hotmail dot com
27-Feb-2004 07:08


Re: the typecasting between classes post below... fantastic, but slightly flawed. Any class name longer than 9 characters becomes a problem... SO here's a simple fix:



function typecast($old_object, $new_classname) {

  if(class_exists($new_classname)) {

    // Example serialized object segment

    // O:5:"field":9:{s:5:...   <--- Class: Field

    $old_serialized_prefix  = "O:".strlen(get_class($old_object));

    $old_serialized_prefix .= ":\"".get_class($old_object)."\":";



    $old_serialized_object = serialize($old_object);

    $new_serialized_object = 'O:'.strlen($new_classname).':"'.$new_classname . '":';

    $new_serialized_object .= substr($old_serialized_object,strlen($old_serialized_prefix));

   return unserialize($new_serialized_object);

  }

  else

   return false;

}



Thanks for the previous code. Set me in the right direction to solving my typecasting problem. ;)

post_at_henribeige_dot_de
03-May-2003 09:37


If you want to do not only typecasting between basic data types but between classes, try this function. It converts any class into another. All variables that equal name in both classes will be copied.



function typecast($old_object, $new_classname) {

  if(class_exists($new_classname)) {

    $old_serialized_object = serialize($old_object);

    $new_serialized_object = 'O:' . strlen($new_classname) . ':"' . $new_classname . '":' . 

                             substr($old_serialized_object, $old_serialized_object[2] + 7);

    return unserialize($new_serialized_object);

  }

  else

    return false;

}



Example:



class A {

  var $secret;

  function A($secret) {$this->secret = $secret;}

  function output() {echo("Secret class A: " . $this->secret);}

}



class B extends A {

  var $secret;

  function output() {echo("Secret class B: " . strrev($this->secret));}

}



$a = new A("Paranoia");

$b = typecast($a, "B");



$a->output();

$b->output();

echo("Classname \$a: " . get_class($a) . "Classname \$b: " . get_class($b));



Output of the example code above:



Secret class A: Paranoia

Secret class B: aionaraP

Classname $a: a

Classname $b: b

yury at krasu dot ru
27-Nov-2002 01:24


incremental operator ("++") doesn't make type conversion from boolean to int, and if an variable is boolean and equals TRUE than after ++ operation it remains as TRUE, so:



$a = TRUE; 

echo ($a++).$a;  // prints "11"

28-Aug-2002 10:26


Printing or echoing a FALSE boolean value or a NULL value results in an empty string:

(string)TRUE //returns "1"

(string)FALSE //returns ""

echo TRUE; //prints "1"

echo FALSE; //prints nothing!

add a note

Variables

Pseudo-types used in this documentation

Last updated: Fri, 16 Jul 2004