PHP type comparison tables

The following tables demonstrate behaviors of PHP types and comparison operators, for both loose and strict comparisons. This supplemental is also related to the manual section on type juggling. Inspiration was provided by various user comments and by the work over at » BlueShoes.

Before utilizing these tables, it's important to understand types and their meanings. For example, "42" is a string while 42 is an integer . FALSE is a boolean while "false" is a string .

Note: HTML Forms do not pass integers, floats, or booleans; they pass strings. To find out if a string is numeric, you may use is_numeric().

Note: Simply doing if ($x) while $x is undefined will generate an error of level E_NOTICE. Instead, consider using empty() or isset() and/or initialize your variables.

**Comparisons of `$x` with PHP functions**
Expression	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 = 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`

**Loose comparisons with ==**
	`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`

Strict comparisons with *===*
	`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`

Unix Domain: Unix and UDG

List of Parser Tokens

Appendices

PHP Manual

User Contributed Notes
PHP type comparison tables

php at benizi dot com
15-Feb-2010 06: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 02: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);

                }

                
 ?>

rich
08-May-2008 02:20

The note about object comparison should be corrected. Cloning objects does not imply instances are the same, so === would return FALSE.

                

                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); //false
 ?>

gernovich at ya dot ru
08-May-2008 07:48

Universal comparison test.

                

                <?php

                

                $tests = array();
 $tests['==']  = create_function('$a, $b', 'return $a==$b;');
 $tests['==='] = create_function('$a, $b', 'return $a===$b;');
 $tests['!='] = create_function('$a, $b', 'return $a!=$b;');
 $tests['<>'] = create_function('$a, $b', 'return $a<>$b;');
 $tests['!=='] = create_function('$a, $b', 'return $a!==$b;');
 $tests['<']   = create_function('$a, $b', 'return $a<$b;');
 $tests['>']   = create_function('$a, $b', 'return $a>$b;');
 $tests['<=']  = create_function('$a, $b', 'return $a<=$b;');
 $tests['>=']  = create_function('$a, $b', 'return $a>=$b;');

                
 $comparison = array();
 $comparison['TRUE'] = true;
 $comparison['FALSE'] = false;
 $comparison['1'] = 1;
 $comparison['0'] = 0;
 $comparison['-1'] = -1;
 $comparison['3,14'] = pi();
 $comparison['"1"'] = '1';
 $comparison['"0"'] = '0';
 $comparison['"-1"'] = '-1';
 $comparison['NULL'] = null;
 $comparison['array()'] = array();
 $comparison['"php"'] = 'php';

                       

                print '<h1>PHP version '.PHP_VERSION.' type comparison tables</h1>';

                       

                foreach ($tests as $test=>$function) {

                    print "<h2>Comparisons with $test</h2>";

                    print "<table border='1'>";

                    print "<tr>";

                    print "<th>&nbsp;</th>";

                    foreach (array_keys($comparison) as $name) {

                        print "<th>$name</th>";

                    }

                    print "</tr>";

                    foreach ($comparison as $arg_1_name => $arg_1_value) {

                        print '<tr>';

                        print "<th>$arg_1_name</th>";

                        foreach ($comparison as $arg_2_value) {

                            print '<td>';

                            print $function($arg_1_value, $arg_2_value)==true ?

                                        '<span style="color:#00F;">TRUE</span>' : '<span style="color:#F00;">FALSE</span>';

                            print '</td>';

                        }

                        print "</tr>";

                    }

                    print "</table>";

                }

                
 ?>

info at shaelf dot ru
06-Jan-2008 09: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 10: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...).

15-Mar-2007 10:06

Re: omit's comment

                

                The note omit quotes is referring to the VALUE returned, not its name. If you put 42 into a text field, the corresponding array value will be the string "42". The note makes no comment on the array's keys.

omit
23-Aug-2006 06:32

the manual said "HTML Forms do not pass integers, floats, or booleans; they pass strings"

                

                while this is true, php will sometimes change the type to either type array, or possibly type integer(no, not a numeric string) if it was used as an array key. php seems to do this when it parses the request data into the predefined variable arrays.

                

                example:

                

                <input type="text" name="foo[5]">

                <input type="text" name="foo[7]">

                

                now obviously the browser will send those names as a string. but php will change thier type.

                

                <?php

                
 // $_POST['foo'] is an array
 var_dump($_POST['foo']);

                

                foreach ($_POST['foo'] as $key => $val) {

                    // the keys 5 and 7 will be type integer

                    var_dump($key);

                }

                
 ?>


                because of this, its also a good idea to check the types of your variables.

Jan
29-Dec-2005 07: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 08: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 09: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 03: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.