Таблица сравнения типов в PHP

Следующие таблицы демонстрируют работу PHP с типами переменных и операторами сравнения, как в случае свободного, так и в случае строгого сравнения. Также эта информация относится к разделу документации по приведению типов. Вдохновением на создание этого раздела мы обязаны различным комментариям пользователей и работе над » BlueShoes.

До осмотра таблиц, важно знать и понимать типы переменных и их значения. К примеру, "42" - string, в то время как 42 - integer. FALSE - boolean, а "false" - string.

Замечание:
HTML-формы не передают целые, дробные числа или булевые переменные: они всегда передают строки. Для проверки является ли строка числом, используйте функцию is_numeric().

Замечание:
Использование if ($x), если $x не определена, сгенерирует ошибку уровня E_NOTICE. Вместо этого используйте функцию empty() или isset() и/или инициализируйте переменную.

Замечание:
Некоторые арифметические операции могут вернуть значение, представленное константой NAN (Not A Number, не-число). Любое строгое или нестрогое сравнение этого значения с каким-либо другим, включая его самого, вернет FALSE (т.е. NAN != NAN и NAN !== NAN). Примерами операций, возвращающих NAN, являются sqrt(-1), asin(2) и asinh(0).

**Сравнение типов `$x` и результатов функций PHP, связанных с типами**
Выражение	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` не определена	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`

**Гибкое сравнение с помощью ==**
	`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`

Коментарии

Jan 24

Автор: aidan at php dot net


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.

2005-01-24 09:00:06

http://php5.kiev.ua/manual/ru/types.comparisons.html

Jun 17

Автор: tom


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

2005-06-17 05:27:52

http://php5.kiev.ua/manual/ru/types.comparisons.html

Jul 26

Автор: jerryschwartz at comfortable dot com


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

2005-07-26 16:04:32

http://php5.kiev.ua/manual/ru/types.comparisons.html

Dec 29

Автор: Jan


Note that php comparison is not transitive:



"php" == 0 => true

0 == null => true

null == "php" => false

2005-12-29 13:23:21

http://php5.kiev.ua/manual/ru/types.comparisons.html

Aug 14

Автор: frank


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

2007-08-14 18:06:35

http://php5.kiev.ua/manual/ru/types.comparisons.html

Jan 06

Автор: info at shaelf dot ru


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

?>

2008-01-06 15:51:14

http://php5.kiev.ua/manual/ru/types.comparisons.html

Dec 15

Автор: edgar at goodforall dot eu


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

}



?>

2009-12-15 08:55:54

http://php5.kiev.ua/manual/ru/types.comparisons.html

Feb 15

Автор: php at benizi dot com


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

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

2010-02-15 12:31:09

http://php5.kiev.ua/manual/ru/types.comparisons.html

Jun 17

Автор: Jouriy LYSENKO


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

2011-06-17 05:18:19

http://php5.kiev.ua/manual/ru/types.comparisons.html

Apr 12

Автор: php at richardneill dot org


[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]

2012-04-12 22:45:28

http://php5.kiev.ua/manual/ru/types.comparisons.html

Dec 14

Автор: crazy888s at hotmail dot com


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.

2012-12-14 20:14:32

http://php5.kiev.ua/manual/ru/types.comparisons.html

Nov 21

Автор: Anonymous


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

2013-11-21 15:43:02

http://php5.kiev.ua/manual/ru/types.comparisons.html

Sep 07

Автор: blue dot hirano at gmail dot com


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

2014-09-07 05:29:39

http://php5.kiev.ua/manual/ru/types.comparisons.html

Oct 16

Автор: Anonymous


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.

2014-10-16 21:19:03

http://php5.kiev.ua/manual/ru/types.comparisons.html

Apr 22

Автор: aravind dot a dot padmanabhan at gmail dot com


please note that

 

$x = 0.0 ;

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



$x = "0.0";

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

2015-04-22 17:31:24

http://php5.kiev.ua/manual/ru/types.comparisons.html

Apr 25

Автор: trexx68


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.

2015-04-25 20:11:30

http://php5.kiev.ua/manual/ru/types.comparisons.html

Feb 07

Автор: engineer dot morozov at gmail dot com


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

2016-02-07 05:23:56

http://php5.kiev.ua/manual/ru/types.comparisons.html

Aug 12

Автор: biziclop at vipmail dot hu


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

}

2017-08-12 23:57:03

http://php5.kiev.ua/manual/ru/types.comparisons.html

Mar 10

Автор: alt dot jl-3gi8b7l at binich dot com


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

?>

2018-03-10 17:41:01

http://php5.kiev.ua/manual/ru/types.comparisons.html

Mar 29

Автор: mark at theanti dot social


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

2018-03-29 23:59:47

http://php5.kiev.ua/manual/ru/types.comparisons.html

Aug 20

Автор: php at ckls dot net


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.

2018-08-20 17:50:34

http://php5.kiev.ua/manual/ru/types.comparisons.html

Jan 02

Автор: TrickyFoxy


<?php

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

2020-01-02 22:25:18

http://php5.kiev.ua/manual/ru/types.comparisons.html

Unix-сокеты: UNIX и UDG

Список меток (tokens) парсера

Appendices

PHP Manual

PHP5

Для web разработчика

Apr 02
Таблица сравнения типов в PHP

Таблица сравнения типов в PHP

Коментарии

PHP5

Для web разработчика

Apr 02Таблица сравнения типов в PHP

Таблица сравнения типов в PHP

Коментарии

Apr 02
Таблица сравнения типов в PHP