Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg



PHP : Language Reference : Types : Type Juggling

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.

copy to clipboard
<?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:

copy to clipboard
<?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.

copy to clipboard
<?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:

copy to clipboard
<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
?>

Casting a literal strings and variables to binary strings:

copy to clipboard
<?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.

copy to clipboard
<?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:

Code Examples / Notes » language.types.type_juggling

raja
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

philip_snyder
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. ;)

29-aug-2002 06: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!

yury
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"

toma
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)));
}
}

post_at_henribeige_dot_de
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

miracle
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)

23-jun-2005 01: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.

tom5025_
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
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;
}
}
?>

Change Language


Follow Navioo On Twitter
Introduction
Booleans
Integers
Floating point numbers
Strings
Arrays
Objects
Resource
NULL
Pseudo-types and variables used in this documentation
Type Juggling
Terms of Service Privacy Policy Sitemap

©2024 -EPSILONSYS SOFTWARE inc

Other EPSILONSYS SOFTWARE Web Sites : Programming Resources | News Headline | Free local classifieds

eXTReMe Tracker