类型转换的判别

目录搜索

文字

PHP 在变量定义中不需要（或不支持）明确的类型定义；变量类型是根据使用该变量的上下文所决定的。也就是说，如果把一个 string 值赋给变量 $var ， $var 就成了一个 string 。如果又把一个 integer 赋给 $var ，那它就成了一个 integer 。

PHP 的自动类型转换的一个例子是加法运算符“+”。如果任何一个操作数是 float ，则所有的操作数都被当成 float ，结果也是 float 。否则操作数会被解释为 integer ，结果也是 integer 。注意这并没有改变这些操作数本身的类型；改变的仅是这些操作数如何被求值以及表达式本身的类型。

  <?php
$foo  =  "0" ;   // $foo 是字符串 (ASCII 48)
 $foo  +=  2 ;    // $foo 现在是一个整数 (2)
 $foo  =  $foo  +  1.3 ;   // $foo 现在是一个浮点数 (3.3)
 $foo  =  5  +  "10 Little Piggies" ;  // $foo 是整数 (15)
 $foo  =  5  +  "10 Small Pigs" ;      // $foo 是整数 (15)
 ?>

如果上面两个例子看上去古怪的话，参见字符串转换为数值。

如果要强制将一个变量当作某种类型来求值，参见类型强制转换一节。如果要改变一个变量的类型，参见 settype() 。

如果想要测试本节中任何例子的话，可以用 var_dump() 函数。

Note:

自动转换为数组的行为目前没有定义。

此外，由于 PHP 支持使用和数组下标同样的语法访问字符串下标，以下例子在所有 PHP 版本中都有效：

<?php $a = 'car' ; // $a is a string $a [ 0 ] = 'b' ; // $a is still a string echo $a ; // bar ?>

请参阅存取和修改字符串中的字符一节以获取更多信息。

类型强制转换

PHP 中的类型强制转换和 C 中的非常像：在要转换的变量之前加上用括号括起来的目标类型。

  <?php
$foo  =  10 ;    // $foo is an integer
 $bar  = (boolean)  $foo ;    // $bar is a boolean
 ?>

允许的强制转换有：

(int), (integer) - 转换为整形 integer
(bool), (boolean) - 转换为布尔类型 boolean
(float), (double), (real) - 转换为浮点型 float
(string) - 转换为字符串 string
(array) - 转换为数组 array
(object) - 转换为对象 object
(unset) - 转换为 NULL (PHP 5)

(binary) 转换和 b 前缀转换支持为 PHP 5.2.1 新增。

注意在括号内允许有空格和制表符，所以下面两个例子功能相同：

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

将字符串文字和变量转换为二进制字符串：

  <?php
$binary  = (binary) $string ;
 $binary  =  b"binary string" ;
 ?>

Note:

可以将变量放置在双引号中的方式来代替将变量转换成字符串：

<?php $foo = 10 ; // $foo 是一个整数 $str = " $foo " ; // $str 是一个字符串 $fst = (string) $foo ; // $fst 也是一个字符串 // 输出 "they are the same" if ( $fst === $str ) { echo "they are the same" ; } ?>

有时在类型之间强制转换时确切地会发生什么可能不是很明显。更多信息见如下小节：

转换为布尔型
转换为整型
转换为浮点型
转换为字符串
转换为数组
转换为对象
转换为资源
转换为 NULL
类型比较表

用户评论:

[#1] berniev [2015-09-15 23:23:41]

May be expected, but not stated ..
Casting to the existing (same) type has no effect.
$t = 'abc'; // string 'abc'
$u=(array) $t; // array 0 => string 'abc' <-- now an array
$v=(array) $u; // array 0 => string 'abc' <-- unchanged

[#2] davaakhuu at outlook dot com [2015-06-03 07:29:40]

Type Juggling 
 <?php $count = "2 cats"; ?>
 Type: <?php echo gettype($count); ?> 
 <?php $count += 3; ?>
 Type: <?php echo gettype($count); ?> 
 <?php $cats = "I have " . $count . "cats."; ?>
 Cats: <?php echo gettype($cats); ?> 
 
 Type Casting 
 <?php settype($count, "integer"); ?>
 count: <?php echo gettype($count); ?> 

 <?php $count2 = (string)$count; ?>
 count: <?php echo gettype($count); ?> 
 count2: <?php echo gettype($count2); ?> 

 <?php $test1 = 3; ?>
 <?php $test2 = 3; ?>
 <?php settype($test1, "string"); ?>
 <?php (string)$test2; ?>
 test1: <?php echo gettype($test1); ?> 
 test2: <?php echo gettype($test2); ?>

[#3] mbrowne83 (at GM) [2014-12-27 13:15:31]

The code listed in some of the comments here for supposedly "casting" from one class to another using unserialize/serialize does not actually change the class of the existing object; it creates a new object. So it's not the same as a cast.

[#4] Eric Lavoie [2014-10-02 21:24:52]

(array) null
array(null)

are not the same.

var_dump((array) null) =>
array (size=0)
empty

var_dump(array (null)) =>
array (size=1)
0 => null

[#5] kuzawinski dot marcin at NOSPAM dot gmail dot com [2014-07-14 21:40:57]

You REALLY must be aware what you are doing, when you cast a lot in your code. For example, you can accidentaly change FALSE to TRUE (probably not in one line, like here):

if(TRUE === (boolean) (array) (int) FALSE) {
kaboom();
}

[#6] fardelian [2013-04-13 15:23:14]

Casting objects to arrays is a pain. Example:

<?php class MyClass { private $priv = 'priv_value'; protected $prot = 'prot_value'; public $pub = 'pub_value'; public $MyClasspriv = 'second_pub_value'; } $test = new MyClass(); echo '<pre>'; print_r((array) $test); ?>

Yes, that looks like an array with two keys with the same name and it looks like the protected field was prepended with an asterisk. But that's not true:

<?php foreach ((array) $test as $key => $value) { $len = strlen($key); echo "{$key} ({$len}) => {$value} "; for ($i = 0; $i < $len; ++$i) { echo ord($key[$i]) . ' '; } echo '<hr />'; } ?>

The char codes show that the protected keys are prepended with '\0*\0' and private keys are prepended with '\0'.__CLASS__.'\0' so be careful when playing around with this.

[#7] ieee at REMOVE dot bk dot ru [2012-06-17 16:26:32]

There are some shorter and faster (at least on my machine) ways to perform a type cast.
<?php $string='12345.678'; $float=+$string; $integer=0|$string; $boolean=!!$string; ?>

[#8] Anonymous [2012-02-07 18:31:53]

namaroulis stated "I found it tricky to check if a posted value was an integer"; to test if a variable is a number or a numeric string (such as form input, which is always a string), you must use is_numeric():

<?php $_POST['a'] = "42"; is_numeric( $_POST['a'] ); // true ?>

[#9] hemi68 at hotmail dot com [2011-09-06 08:01:52]

Cast a string to binary using PHP < 5.2.1

$binary = unpack('c*', $string);

[#10] jphansen at uga dot edu [2011-04-21 10:53:02]

Type casting from string to int and vice versa is probably the most common conversation. PHP does this very simply through the +. and .= operators, removing any explicit casting:

<?php $x = 1; var_dump($x); // int(1) $x .= 1; var_dump($x); // string(2) "11"; also an empty string ("") would cast to string without changing $x $x = "1"; var_dump($x); // string(1) "1" $x += 1; var_dump($x); // int(2); also a zero value (0) would cast to int without changing $x ?>

[#11] Anonymous [2011-03-11 11:01:34]

Checking for strings to be integers?
How about if a string is a float?

<?php $isInt=preg_match('/^\s*([0-9]+)\s*$/', $myString, $myInt); echo 'Is Integer? ', ($isInt) ? 'Yes: '.$myInt[1] : 'No', "\n"; $isInt=preg_match('/^[0-9]+$/', $myString); echo 'Is Integer? ', ($isInt) ? 'Yes' : 'No', "\n"; $isFloat=preg_match('/^\s*([0-9]+(\.[0-9]+)?)\s*$/', $myString, $myNum); echo 'Is Number? ', ($isFloat) ? 'Yes: '.$myNum[1] : 'No', "\n"; $isInt=preg_match('/^[0-9]+(\.[0-9]+)?$/', $myString); echo 'Is Number? ', ($isFloat) ? 'Yes' : 'No', "\n"; ?>

[#12] namaroulis at gmail dot com [2011-03-02 13:47:57]

I found it tricky to check if a posted value was an integer.

<?php $_POST['a'] = "42"; is_int( $_POST['a'] ); //false is_int( intval( "anything" ) ); //always true ?>

A method I use for checking if a string represents an integer value.

<?php function check_int( $str ) { return is_numeric( $str ) && intval( $str ) - $str == 0; } ?>

[#13] rmirabelle [2010-10-17 10:18:39]

The object casting methods presented here do not take into account the class hierarchy of the class you're trying to cast your object into.

public static function cast($object, $class_name) {
if($object === false) return false;
if(class_exists($class_name)) {
$ser_object = serialize($object);
$obj_name_len = strlen(get_class($object));
$start = $obj_name_len + strlen($obj_name_len) + 6;
$new_object = 'O:' . strlen($class_name) . ':"' . $class_name . '":';
$new_object .= substr($ser_object, $start);
$new_object = unserialize($new_object);

$graph = new $class_name;
foreach($new_object as $prop => $val) {
$graph->$prop = $val;
}
return $graph;
} else {
throw new CoreException(false, "could not find class $class_name for casting in DB::cast");
return false;
}
}

[#14] martinscotta at gmail dot com [2010-09-21 20:44:15]

in response to bhsmither at gmail.com

It raises a warning because of the bad enquoted variable

<?php

error_reporting( E_ALL | E_STRICT );

$foo['ten'] = 10; // $foo['ten'] is an array holding an integer at key "ten"
$str = "{$foo['ten']}"; // works "10"
$str = "$foo[ten]"; // DO NOT work!

[#15] bhsmither at gmail.com [2010-03-19 15:41:15]

<?php $foo['ten'] = 10; // $foo['ten'] is an array holding an integer at key "ten" $str = "$foo['ten']"; // throws T_ENCAPSED_AND_WHITESPACE error $str = "$foo[ten]"; // works because constants are skipped in quotes $fst = (string) $foo['ten']; // works with clear intention ?>

[#16] edgar dot klerks at gmail dot com [2009-03-17 08:04:31]

It seems (unset) is pretty useless. But for people who like to make their code really compact (and probably unreadable). You can use it to use an variable and unset it on the same line:

Without cast:

<?php $hello = 'Hello world'; print $hello; unset($hello); ?>

With the unset cast:

<?php $hello = 'Hello world'; $hello = (unset) print $hello; ?>

Hoorah, we lost another line!

[#17] kajsunansis at that gmail [2008-12-03 11:18:59]

json_decode users consider this, when casting stdClass to array:
<?php $obj = new stdClass(); $obj->{"2"} = "id"; $arr = (array) $obj; $result = isset($arr["2"]) || array_key_exists(2, $arr); // false ?>
..though casting is at least 2x faster than foreach.

[#18] Jeffrey [2008-11-09 11:34:57]

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
+-------+-------+---------+--------+

[#19] hek at theeks dot net [2008-10-17 09:24:55]

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!

[#20] wbcarts at juno dot com [2008-10-07 18:05:42]

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.

[#21] lucazd at gmail dot com [2008-09-23 21:20:17]

@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 { static public function cast(MyObject $object) { return $object; } function f() {} } class X extends MyObject { 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.

[#22] nullhilty at gmail dot com [2008-09-09 11:34:11]

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)

[#23] alexgr at gmail dot com [2008-06-20 03:43:25]

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

class 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.

[#24] miracle at 1oo-percent dot de [2006-02-20 05:26:38]

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)

[#25] [2005-06-22 17:47:40]

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> 
<?php $bar = TRUE; ?>
I have <?php=$bar?> bar.
<?php $bar++; ?>
I now have <?php=$bar?> bar.
<?php $bar = (int) $bar; $bar++; ?>
I finally have <?php=$bar?> bar.
</body>
</html>

That will print

I have 1 bar.
I now have 1 bar.
I finally have 2 bar.

[#26] toma at smartsemantics dot com [2005-03-09 18:24:17]

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

[#27] Raja [2005-02-10 03:05:16]

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

[#28] tom5025_ at hotmail dot com [2004-08-24 13:27:46]

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

[#29] dimo dot vanchev at bianor dot com [2004-03-10 07:02:17]

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

[#30] philip_snyder at hotmail dot com [2004-02-27 07:08:06]

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

[#31] post_at_henribeige_dot_de [2003-05-03 09:37:47]

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

[#32] yury at krasu dot ru [2002-11-27 01:24:02]

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"

[#33] [2002-08-28 22:26:34]

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!