PHP 类型比较表

以下的表格显示了 PHP 类型和比较运算符在松散和严格比较时的作用。该补充材料还和类型戏法的相关章节内容有关。同时，大量的用户注释和 » BlueShoes 的工作也给该材料提供了帮助。

在使用这些表格之前，需要明白变量类型及它们的意义。例如，"42" 是一个字符串而 42 是一个整数。false 是一个布尔值而 "false" 是一个字符串。

Note:
HTML 表单并不传递整数、浮点数或者布尔值，它们只传递字符串。要想检测一个字符串是不是数字，可以使用 is_numeric() 函数。

Note:
在没有定义变量 $x 的时候，诸如 if ($x) 的用法会导致一个 E_NOTICE 级别的错误。所以，可以考虑用 empty() 或者 isset() 函数来初始化变量。

Note:
某些数值操作会导致一个特殊值，可以用常量 NAN 表示。无论是松散还是严格比较，这个值和其他任意值（包括它自身，但排除 true）比较时都会产生 false 的结果，例如 NAN != NAN 和 NAN !== NAN。导致 NAN 的操作例子包括 sqrt(-1)、asin(2)、 acosh(0)。

**使用 PHP 函数对变量 `$x` 进行比较**
表达式	gettype()	empty()	is_null()	isset()	boolean : `if($x)`
`$x = "";`	string	`true`	`false`	`true`	`false`
`$x = null;`	NULL	`true`	`true`	`false`	`false`
`var $x;`	NULL	`true`	`true`	`false`	`false`
`$x` is undefined	NULL	`true`	`true`	`false`	`false`
`$x = array();`	array	`true`	`false`	`true`	`false`
`$x = array('a', 'b');`	array	`false`	`false`	`true`	`true`
`$x = false;`	boolean	`true`	`false`	`true`	`false`
`$x = true;`	boolean	`false`	`false`	`true`	`true`
`$x = 1;`	integer	`false`	`false`	`true`	`true`
`$x = 42;`	integer	`false`	`false`	`true`	`true`
`$x = 0;`	integer	`true`	`false`	`true`	`false`
`$x = -1;`	integer	`false`	`false`	`true`	`true`
`$x = "1";`	string	`false`	`false`	`true`	`true`
`$x = "0";`	string	`true`	`false`	`true`	`false`
`$x = "-1";`	string	`false`	`false`	`true`	`true`
`$x = "php";`	string	`false`	`false`	`true`	`true`
`$x = "true";`	string	`false`	`false`	`true`	`true`
`$x = "false";`	string	`false`	`false`	`true`	`true`

**松散比较 `==`**
	`true`	`false`	`1`	`0`	`-1`	`"1"`	`"0"`	`"-1"`	`null`	`array()`	`"php"`	`""`
`true`	`true`	`false`	`true`	`false`	`true`	`true`	`false`	`true`	`false`	`false`	`true`	`false`
`false`	`false`	`true`	`false`	`true`	`false`	`false`	`true`	`false`	`true`	`true`	`false`	`true`
`1`	`true`	`false`	`true`	`false`	`false`	`true`	`false`	`false`	`false`	`false`	`false`	`false`
`0`	`false`	`true`	`false`	`true`	`false`	`false`	`true`	`false`	`true`	`false`	`true`	`true`
`-1`	`true`	`false`	`false`	`false`	`true`	`false`	`false`	`true`	`false`	`false`	`false`	`false`
`"1"`	`true`	`false`	`true`	`false`	`false`	`true`	`false`	`false`	`false`	`false`	`false`	`false`
`"0"`	`false`	`true`	`false`	`true`	`false`	`false`	`true`	`false`	`false`	`false`	`false`	`false`
`"-1"`	`true`	`false`	`false`	`false`	`true`	`false`	`false`	`true`	`false`	`false`	`false`	`false`
`null`	`false`	`true`	`false`	`true`	`false`	`false`	`false`	`false`	`true`	`true`	`false`	`true`
`array()`	`false`	`true`	`false`	`false`	`false`	`false`	`false`	`false`	`true`	`true`	`false`	`false`
`"php"`	`true`	`false`	`false`	`true`	`false`	`false`	`false`	`false`	`false`	`false`	`true`	`false`
`""`	`false`	`true`	`false`	`true`	`false`	`false`	`false`	`false`	`true`	`false`	`false`	`true`

**严格比较 `===`**
	`true`	`false`	`1`	`0`	`-1`	`"1"`	`"0"`	`"-1"`	`null`	`array()`	`"php"`	`""`
`true`	`true`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`
`false`	`false`	`true`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`
`1`	`false`	`false`	`true`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`
`0`	`false`	`false`	`false`	`true`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`
`-1`	`false`	`false`	`false`	`false`	`true`	`false`	`false`	`false`	`false`	`false`	`false`	`false`
`"1"`	`false`	`false`	`false`	`false`	`false`	`true`	`false`	`false`	`false`	`false`	`false`	`false`
`"0"`	`false`	`false`	`false`	`false`	`false`	`false`	`true`	`false`	`false`	`false`	`false`	`false`
`"-1"`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`true`	`false`	`false`	`false`	`false`
`null`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`true`	`false`	`false`	`false`
`array()`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`true`	`false`	`false`
`"php"`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`true`	`false`
`""`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`false`	`true`

User Contributed Notes

Anonymous 17-Nov-2020 02:24


I noticed that some "magic" also happens when comparing strings with leading zeros with only two equal signs:



<?php

var_dump('1' == '01');

var_dump('01' == '000001');

?>



Output:

bool(true)

bool(true)



If the string contains only numbers all leading zeroes seem to be ignored.

TrickyFoxy 02-Jan-2020 08:25


<?php

echo md5('240610708') == md5('QNKCDZO') ? "equal" : "not equal"; // prints equal!!!

php at ckls dot net 20-Aug-2018 02:50


regarding the editors note in php at richardneill dot org note:

[Editor's note: As of PHP 5.4.4 this is no longer true. Integral strings that overflow into floating point numbers will no longer be considered equal.]



While this is true, there is still the following behaviour:

<?php

$x = "1";

$y = "+1";

var_dump($x == $x);

?>

outputs "bool(true)".  

So still be wary of string-comparison where both strings might be interpreted as numbers.

mark at theanti dot social 29-Mar-2018 08:59


There is also 0.0 which is not identical to 0.



  $x = 0.0; 

  gettype($x); // double

  empty($x); // true

  is_null($x); //false

  isset($x); // true

  is_numeric($x); // true

  $x ? true : false; // false

  $x == 0; // true

  $x == "0"; // true

  $x == "0.0"; // true

  $x == false; // true

  $x == null; // true

  $x === 0; // false

  $x === false; // false

  $x === null; // false

  $x === "0"; // false

  $x === "0.0"; // false

alt dot jl-3gi8b7l at binich dot com 10-Mar-2018 03:41


Here's how PHP handles loose and strict comparisons of default parameters in functions:



Very unintuitive:



<?php

function f($x='surprise')

    {

    if ($x == 'surprise')

        return $x; // returns 0 !!

    }

    

echo f(0);

?>



Here some further tests:



<?php

function f($x='surprise')

    {

    if ($x == 'surprise')

        return 'A:'.$x;

    if ($x === 'surprise')

        return 'B:'.$x;

    return 'C:'.$x;

    }

    

echo "\n".f(0); // A:0 !!

echo "\n".f(0.0); // A:0 !!

echo "\n".f(NULL); // C: !!

echo "\n".f(FALSE); // C:

echo "\n".f(); // A:surprise

echo "\n".f(''); // C:

echo "\n".f((integer)0); // A:0

echo "\n".f((string)0); // C:0

echo "\n".f('0'); // C:0

echo "\n".f(0.1); // C:0.1

echo "\n".f(array()); // C:Array

echo "\n".f('surprise'); // A:surprise

?>

biziclop at vipmail dot hu 12-Aug-2017 08:57


Want to strictly compare integers that may or may not be converted to floats (via PHPExcel import/export, etc.)? You are out of luck:



var_dump(   (int)1 ===   (int)1 ); // bool(true)

var_dump( (float)1 === (float)1 ); // bool(true)

var_dump( (float)1 ===   (int)1 ); // bool(false)

var_dump(   (int)1 === (float)1 ); // bool(false)



This slightly complicated function might help you:



function equal_numbers( $a, $b ){

  if( $a === $b )  return true;

  if(   is_int( $a ) && is_float( $b ))  return (float)$a === $b && $a ===   (int)$b;

  if( is_float( $a ) &&   is_int( $b ))  return   (int)$a === $b && $a === (float)$b;

  return false;

}



Here are some tests:



test(100, 100.0 ); // int(100) float(100) bool(true) 

test(  0,  -0   ); // int(0)   int(0)     bool(true) 

test( -0,  -0.0 ); // int(0)   float(-0)  bool(true)

test(  0, 1/0   ); // int(0)   float(INF) bool(false)

test(  0, acos(2));// int(0)   float(NAN) bool(false)

test(       PHP_INT_MAX * 10, 0 );             //float(92233720368547758080) int(0) bool(false)

test((float)PHP_INT_MAX,     PHP_INT_MAX     );//float(9223372036854775808)  int(9223372036854775807) bool(false)

test((float)PHP_INT_MAX / 2, PHP_INT_MAX / 2 );//float(4611686018427387904)  float(4611686018427387904) bool(true)



function test( $a, $b ){

  var_dump( $a, $b, equal_numbers( $a, $b ));

}

engineer dot morozov at gmail dot com 07-Feb-2016 03:23


If you want to calculate how much more/less items by the criterion



Example:



in loop:

$counter += intval($item->isValid()) <=> 0.5;



if $counter >= 0 - valid items are more then invalid on $counter

if $counter  < 0 - valid items are less then invalid on $counter

trexx68 25-Apr-2015 05:11


If you want to view the truth tables colorized, just:



1. Save a local copy of this page as an .html file,

2. View the page source with any text editor.

3. Replace the opening <head> tag so it will include this: 



<head> 

  <script src="https://code.jquery.com/jquery-1.10.2.js"></script>



4. Replace the closing </body> tag with this: 



  <script>

    $( "td:contains('FALSE')" ).css("color", "red");

    $( "td:contains('TRUE')" ).css("color", "green");

  </script>

</body>



5. Save the file, and view it on your browser.  Enjoy.

aravind dot a dot padmanabhan at gmail dot com 22-Apr-2015 02:31


please note that

 

$x = 0.0 ;

print empty($x); // returns 1 (true) 



$x = "0.0";

print empty($x); // returns blank (false);

Anonymous 16-Oct-2014 06:19


The loose comparison chart is missing a few things.



array(1)==true returns true.



also:



(int)array(1) === 1 returns true



This is symmetric:



array(1) === (array)1 returns true



but the loose comparison



array(1)==1 still returns false.

blue dot hirano at gmail dot com 07-Sep-2014 02:29


The truth tables really ought to be colorized; they're very hard to read as they are right now (just big arrays of TRUE and FALSE).



Also, something to consider: clustering the values which compare similarly (like is done on qntm.org/equality) would make the table easier to read as well. (This can be done simply by hand by rearranging the order of headings to bring related values closer together).

Anonymous 21-Nov-2013 01:43


I'm running PHP 5.5.3.



This is a correction to one of the previous posts.



<?php

$o = new stdClass();

$o->we = 12;



$o2 = new stdClass();

$o2->we = 12;



$o3 = clone $o2;

var_dump($o == $o2); //true

var_dump($o === $o2); //false

var_dump($o3 === $o2); //false

?>



Output is:



true, false, false

crazy888s at hotmail dot com 14-Dec-2012 06:14


PHP's loose comparisons can be a huge convenience when used properly! It's extremely helpful to just remember the following are always FALSE:



null, false, "", 0, "0", array()



If your application never depends on a particular "empty/false/null/0/not set" value type, you won't have to worry about 99% of the other weird cases listed here. You won't need empty() or isset(). And ALL variable types will always work as expected for statements like:



if(boolean && !string){...}

if(array){...}

if(!null || int){...}



Consider the same when working with your database values.

php at richardneill dot org 12-Apr-2012 07:45


[Editor's note: As of PHP 5.4.4 this is no longer true. Integral strings that overflow into floating point numbers will no longer be considered equal.]





Be wary of string-comparison where both strings might be interpreted as numbers.  Eg:





$x="123456789012345678901234567890"; $y="123456789012345678900000000000";


echo  ($x==$y)?"equal":"not_equal";   #Prints equal !!





Both strings are getting converted to floats, then losing precision, then becoming equal :-(





Using "===" or making either of the strings non-numeric will prevent this.


[This is on a 32-bit machine, on a 64-bit, you will have to make the strings longer to see the effect]

Jouriy LYSENKO 17-Jun-2011 02:18


If $var not declared.



In php 5.2 :

<?php if($var) ?> - work



in php 5.3 :

<?php if($var) ?> - dont work and generate error E_NOTICE

php at benizi dot com 15-Feb-2010 10:31


It's interesting to note that 'empty()' and 'boolean : if($x)'

are paired as logical opposites, as are 'is_null()' and 'isset()'.

edgar at goodforall dot eu 15-Dec-2009 06:55


Some function to write out your own comparisson table in tsv format. Can be easily modified to add more testcases and/or binary functions. It will test all comparables against each other with all functions. 



<?php

$funcs = array(

        /* Testing equality */

        'eq' => '==',

        'ne' => '!=',

        'gt' => '>',

        'lt' => '<',

        'ne2' => '<>',

        'lte' => '<=',

        'gte' => '>=',

        /* Testing identity */

        'id' => '===',

        'nid' => '!=='

);

class Test {

        protected $a;

        public $b;

        public function __construct($a,$b){

                $this->a = $a;

                $this->b = $b;

        }

        public function getab(){

                return $this->a.",". $this->b;

        }



}

$tst1 = new Test(1,2);

$tst2 = new Test(1,2);

$tst3 = new Test(2,2);

$tst4 = new Test(1,1);



$arr1 = array(1,2,3);

$arr2 = array(2,3,4);

$arr3 = array('a','b','c','d');

$arr4 = array('a','b','c');

$arr5 = array();



$comp1 = array(

        'ints' => array(-1,0,1,2),

        'floats' => array(-1.1,0.0,1.1,2.0),

        'string' => array('str', 'str1', '', '1'),

        'bools' => array(true, false),

        'null' => array(null),

        'objects' => array($tst1,$tst2,$tst3,$tst4),

        'arrays' => array($arr1, $arr2, $arr3, $arr4, $arr5)

);

$fbody = array();



foreach($funcs as $name => $op){

        $fbody[$name] = create_function('$a,$b', 'return $a ' . $op . ' $b;');

}



$table = array(array('function', 'comp1', 'comp2', 'f comp1 comp2', 'type'));

/* Do comparisons */

$comp2  = array();

foreach($comp1 as $type => $val){

        $comp2[$type] = $val;

}



foreach($comp1 as $key1 => $val1){

        foreach($comp2 as $key2 => $val2){

                addTableEntry($key1, $key2, $val1, $val2);

        }

}

$out = '';

foreach($table as $row){

        $out .= sprintf("%-20s\t%-20s\t%-20s\t%-20s\t%-20s\n", $row[0], $row[1], $row[2], $row[3], $row[4]);

}



print $out;

exit;



function addTableEntry($n1, $n2, $comp1, $comp2){

        global $table, $fbody;

        foreach($fbody as $fname => $func){

                        foreach($comp1 as $val1){

  foreach($comp2 as $val2){

                                        $val = $func($val1,$val2);

                                                $table[] = array($fname, gettype($val1) . ' => ' . sprintval($val1), gettype($val2) .' => ' . sprintval($val2), gettype($val) . ' => ' . sprintval($val), gettype($val1) . "-" . gettype($val2) . '-' . $fname);

                                        }

                        }

        }

}



function sprintval($val){

        if(is_object($val)){

                return 'object-' . $val->getab();

        }

        if(is_array($val)){

                return implode(',', $val);

        }

        if(is_bool($val)){

                if($val){

                        return 'true';

                }

                return 'false';

        }

        return strval($val);

}



?>

info at shaelf dot ru 06-Jan-2008 01:51


Compare object

<?php

$o = new stdClass();

$o->we = 12;



$o2 = new stdClass();

$o2->we = 12;



$o3 = clone $o2;

var_dump($o == $o2); //true

var_dump($o === $o2); //false

var_dump($o3 === $o2); //true

?>

frank 14-Aug-2007 03:06


A comparison table for <=,<,=>,> would be nice...

Following are TRUE (tested PHP4&5):

NULL <= -1

NULL <= 0

NULL <= 1

!(NULL >= -1)

NULL >= 0

!(NULL >= 1)

That was a surprise for me (and it is not like SQL, I would like to have the option to have SQL semantics with NULL...).

Jan 29-Dec-2005 11:23


Note that php comparison is not transitive:



"php" == 0 => true

0 == null => true

null == "php" => false

jerryschwartz at comfortable dot com 26-Jul-2005 01:04


In some languages, a boolean is promoted to an integer (with a value of 1 or -1, typically) if used in an expression with an integer. I found that PHP has it both ways:



If you add a boolean with a value of true to an integer with a value of 3, the result will be 4 (because the boolean is cast as an integer).



On the other hand, if you test a boolean with a value of true for equality with an integer with a value of three, the result will be true (because the integer is cast as a boolean).



Surprisingly, at first glance, if you use either < or > as the comparison operator the result is always false (again, because the integer as cast as a boolean, and true is neither greater nor less than true).

tom 17-Jun-2005 02:27


<?php


if (strlen($_POST['var']) > 0) {


    // form value is ok


}


?>





When working with HTML forms this a good way to:





(A) let "0" post values through like select or radio values that correspond to array keys or checkbox booleans that would return FALSE with empty(), and;


(B) screen out $x = "" values, that would return TRUE with isset()!





Because HTML forms post values as strings, this is a good way to test variables!





[[Editor Note: This will create a PHP Error of level E_NOTICE if the checked variable (in this case $_POST['var']) is undefined. It may be used after (in conjuection with) isset() to prevent this.]]

aidan at php dot net 24-Jan-2005 07:00


The way PHP handles comparisons when multiple types are concerned is quite confusing.



For example:

"php" == 0



This is true, because the string is casted interally to an integer. Any string (that does not start with a number), when casted to an integer, will be 0.