[edit] Last updated: Mon, 01 Nov 2010

Apêndice P. Tabelas de comparação de tipo do PHP

As seguintes tabelas demonstram comportamentos no PHP de tipos e operadores de comparação, tanto para comparação solta e restrita. Esse suplemento também se relacionam a seção do manual de type juggling. Inspiração provem de comentários de vários usuários e pelo trabalho na BlueShoes.

Antes de utilizar essas tabelas, é importante entender tipos e seus significados. Por exemplo, "42" é uma string enquanto 42 é um inteiro. FALSE é um boolean enquanto "false" é uma string.

Nota: Formulários HTML não passam inteiros, floats ou booleans; Eles passam strings. Para descobrir se uma string é numérica, você pode usar is_numeric().

Nota: Simplesmente fazer if ($x) enquanto $x é indefinido causará um error de nível E_NOTICE. Ao invés, considere usar empty() ou isset() e/ou inicializar suas variáveis.

Tabela P-1. Comparações de $x com funções do PHP

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`

Tabela P-2. Comparações soltas com ==

	`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`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`TRUE`	`FALSE`
`1`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`0`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`TRUE`
`-1`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`
`"1"`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`"0"`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`"-1"`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`
`NULL`	`FALSE`	`TRUE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`TRUE`	`FALSE`
`array()`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`TRUE`	`FALSE`
`"php"`	`TRUE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`

Tabela P-3. Comparações restritas com ===

	`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`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`1`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`0`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`-1`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`"1"`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`"0"`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`
`"-1"`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`	`FALSE`
`NULL`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`	`FALSE`
`array()`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`	`FALSE`
`"php"`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`FALSE`	`TRUE`

Nota para o PHP 3.0: O valor string "0" era considerado não-vazio no PHP 3, esse comportamento mudou no PHP 4 onde ele é visto como vazio.

List of Parser Tokens

Domínio Unix: Unix e UDG

[edit] Last updated: Mon, 01 Nov 2010

add a note User Contributed Notes Tabelas de comparação de tipo do PHP

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


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

mauritsdajong at gmail dot com 18-Feb-2011 07:12


When we're doing loose comparisons (with double equals signs), the following fact is interesting.



false == array() evaluates to true

false == "" evaluates to true

array() == "" however, evaluates to false

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

}



?>

rich 08-May-2008 07: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 12: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 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...).

15-Mar-2007 02: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 11: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 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.

add a note