[edit] Last updated: Fri, 28 Jun 2013

Comparaison de types en PHP

La table suivante résume les différents comportements de PHP avec les types et opérateurs de comparaison, strictes ou larges. Cette table est aussi reliée au transtypage. Elle a été inspirée par différents commentaires d'utilisateurs, et par le travail fait chez » BlueShoes.

Avant d'utiliser ces tables, il est important de comprendre les types et leur signification. Par exemple, "42" est une chaîne de caractères, alors que 42 est un entier. FALSE est boolean alors que "false" est une chaîne de caractères.

Note:
Les formulaires HTML ne connaissent pas les entiers, nombres à virgules et autres booléens. Pour savoir si une structure est un entier, utilisez is_numeric().

Note:
La ligne if ($x) génère une erreur de niveau E_NOTICE lorsque $x est indéfini. Alternativement, utilisez plutôt les fonctions empty() ou isset(), ou encore, initialisez toutes vos variables.

Note:
Des opérations numériques peuvent donner une valeur représentée par la constante NAN. Toutes les comparaisons de cette valeur avec une autre valeur, y compris cette même valeur, aura comme résultat FALSE (i.e. NAN != NAN et NAN !== NAN). Exemples d'opérations qui produisent la valeur NAN : sqrt(-1), asin(2), et asinh(0).

**Comparaisons de `$x` avec des fonctions PHP**
Expression	gettype()	empty()	is_null()	isset()	boolean : if($x)
$x = "";	chaîne de caractères	`TRUE`	`FALSE`	`TRUE`	`FALSE`
$x = null	NULL	`TRUE`	`TRUE`	`FALSE`	`FALSE`
var $x;	NULL	`TRUE`	`TRUE`	`FALSE`	`FALSE`
`$x` est indéfini	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;	entier	`FALSE`	`FALSE`	`TRUE`	`TRUE`
$x = 42;	entier	`FALSE`	`FALSE`	`TRUE`	`TRUE`
$x = 0;	entier	`TRUE`	`FALSE`	`TRUE`	`FALSE`
$x = -1;	entier	`FALSE`	`FALSE`	`TRUE`	`TRUE`
$x = "1";	chaîne de caractères	`FALSE`	`FALSE`	`TRUE`	`TRUE`
$x = "0";	chaîne de caractères	`TRUE`	`FALSE`	`TRUE`	`FALSE`
$x = "-1";	chaîne de caractères	`FALSE`	`FALSE`	`TRUE`	`TRUE`
$x = "php";	chaîne de caractères	`FALSE`	`FALSE`	`TRUE`	`TRUE`
$x = "true";	chaîne de caractères	`FALSE`	`FALSE`	`TRUE`	`TRUE`
$x = "false";	string	`FALSE`	`FALSE`	`TRUE`	`TRUE`

**Comparaison large avec ==**
	`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`

Comparaison stricte avec *===*
	`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`

Liste des tokens de l'analyseur

Domaine Unix : UNIX et UDG

[edit] Last updated: Fri, 28 Jun 2013

add a note User Contributed Notes Comparaison de types en PHP - [16 notes]

down

jerryschwartz at comfortable dot com ¶

7 years ago


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

down

php at richardneill dot org ¶

1 year ago


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]

down

frank ¶

5 years ago


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

down

Jan ¶

7 years ago


Note that php comparison is not transitive:



"php" == 0 => true

0 == null => true

null == "php" => false

down

crazy888s at hotmail dot com ¶

6 months ago


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.

down

Jouriy LYSENKO ¶

2 years ago


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

down

edgar at goodforall dot eu ¶

3 years ago


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

}



?>

down

php at benizi dot com ¶

3 years ago


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

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

down

info at shaelf dot ru ¶

5 years ago


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

?>

down

tom ¶

8 years ago


<?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.]]

down

aidan at php dot net ¶

8 years ago


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.

down

-1

omit ¶

6 years ago


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.

down

-1

mauritsdajong at gmail dot com ¶

2 years ago


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

down

-2

gernovich at ya dot ru ¶

5 years ago


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

}



?>

down

-2

Anonymous ¶

6 years ago


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.

down

-4

rich ¶

5 years ago


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

?>

add a note