Cómo hacer el PHP de igualdad (== el doble de iguala) y la identidad (=== triple es igual a) los operadores de comparación son diferentes?

Question

¿Cuál es la diferencia entre == y ===?

• ¿Cómo funciona exactamente la flojos == el trabajo de comparación?
• ¿Cómo funciona exactamente la estricta === el trabajo de comparación?

¿Cuáles serían algunos ejemplos útiles?

Answer 1

La diferencia entre == y ===

La diferencia entre el poco == la igualdad de operador y de la estricta === idéntico operador es exactamente explicó en el manual:

Los Operadores De Comparación

┌──────────┬───────────┬───────────────────────────────────────────────────────────┐
│ Example  │ Name      │ Result                                                    │
├──────────┼───────────┼───────────────────────────────────────────────────────────┤
│$a ==  $b │ Equal     │ TRUE if $a is equal to $b after type juggling.            │
│$a === $b │ Identical │ TRUE if $a is equal to $b, and they are of the same type. │
└──────────┴───────────┴───────────────────────────────────────────────────────────┘

---

Vagamente == igual comparación

Si usted está utilizando el == operador, o de cualquier otro operador de comparación que utiliza libremente comparación como !=, <> o ==, siempre hay que mirar el contexto para ver por qué, el dónde y el porqué de las cosas se convierte a entender lo que está pasando.

La conversión de las reglas de

• La conversión a boolean
• La conversión a entero
• La conversión a flotar
• La conversión a string
• La conversión de la matriz
• La conversión a objeto
• La conversión de los recursos
• La conversión a NULL

Tipo de tabla de comparación

Como una referencia y un ejemplo se puede ver la tabla de comparación en el manual:

Suelta las comparaciones con ==

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ 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  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

Estricto === idéntica comparación

Si usted está utilizando el === operador, o de cualquier otro operador de comparación que utiliza una comparación estricta, tales como !== o ===, entonces usted siempre puede estar seguro de que los tipos no por arte de magia el cambio, porque no habrá conversión pasando.Así que con la comparación estricta el tipo y el valor tiene que ser el mismo, no sólo el valor.

Tipo de tabla de comparación

Como una referencia y un ejemplo se puede ver la tabla de comparación en el manual:

Comparaciones estrictas con ===

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ 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  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

Answer 2

El operador == arroja entre dos tipos diferentes si son diferentes, mientras que el === operador realiza una 'typesafe comparación'.Eso significa que sólo devolverá true si ambos operandos tienen el mismo tipo y del mismo valor.

Ejemplos:

1 === 1: true
1 == 1: true
1 === "1": false // 1 is an integer, "1" is a string
1 == "1": true // "1" gets casted to an integer, which is 1
"foo" === "foo": true // both operands are strings and have the same value

Advertencia:dos instancias de la misma clase con los equivalentes de los miembros NO coinciden con la === operador.Ejemplo:

$a = new stdClass();
$a->foo = "bar";
$b = clone $a;
var_dump($a === $b); // bool(false)

Answer 3

Una imagen vale más que mil palabras:

PHP Doble es Igual a == la igualdad gráfico:

PHP Triple es Igual a === La igualdad gráfico:

Código fuente para crear estas imágenes:

https://github.com/sentientmachine/php_equality_charts

El Gurú De La Meditación

Aquellos que desean mantener su cordura, no siga leyendo porque nada de esto tendrá sentido alguno, excepto para decir que esta es la forma en la locura-fractal, de PHP fue diseñado.

1. NAN != NAN pero NAN == true.
2. == va a convertir operandos izquierdo y derecho a los números si la izquierda es un número.Así 123 == "123foo", pero "123" != "123foo"

3. Una cadena hexadecimal de comillas, en ocasiones, es un flotador, y se sorprenderá de fundición de flotar en contra de su voluntad, causando un error en tiempo de ejecución.

4. == no es transitiva porque "0"== 0, y 0 == "" pero "0" != ""

5. Variables de PHP que aún no se han declarado son falsos, incluso a pesar de que PHP tiene una forma de representar las variables no definidas, que se desactivará la función con ==.

6. "6" == " 6", "4.2" == "4.20", y "133" == "0133" pero 133 != 0133.Pero "0x10" == "16" y "1e3" == "1000" exponiendo que la sorpresa de la cadena de conversión a octal se producirá tanto sin su instrucción o consentimiento, causando un error en tiempo de ejecución.

7. False == 0, "", [] y "0".

8. Cuando los números son lo suficientemente grandes como son == Infinito.

9. Un fresco de la clase es == a 1.

10. Falso, es el más peligroso de valor porque es False == para la mayoría de las otras variables, la mayoría de derrotar a su propósito.

Esperanza:

Si está usando PHP, no Has de utilizar el doble operador es igual, porque si usted utiliza triple es igual, el único margen de los casos que preocuparse se de NAN y números tan cerca de infinito que son emitidos hasta el infinito.Con doble es igual, cualquier cosa puede ser la sorpresa == para nada o, o puede ser la sorpresa de escayola en contra de su voluntad y != algo que, obviamente, deben ser iguales.

En cualquier lugar que usted use == en PHP es un código mal olor debido a los 85 errores en lo expuesto por la conversión implícita de las reglas que parecen diseñados por millones de programadores de programación por el movimiento browniano.

Answer 4

En lo que respecta a JavaScript:

El === operador funciona como el operador==, pero requiere que sus operandos no solo tienen el mismo valor, pero también el mismo tipo de datos.

Por ejemplo, el ejemplo siguiente se muestra 'x y y son iguales', pero no 'x y y son idénticos'.

var x = 4;
var y = '4';
if (x == y) {
    alert('x and y are equal');
}
if (x === y) {
    alert('x and y are identical');
}

Answer 5

Una adición a las otras respuestas sobre el objeto de la comparación:

== compara los objetos utilizando el nombre del objeto y sus valores.Si dos objetos son del mismo tipo y tienen los mismos valores de miembro, $a == $b los rendimientos de la verdad.

=== compara el objeto interno de identificación de los objetos.Incluso si los miembros son iguales, $a !== $b si no son exactamente el mismo objeto.

class TestClassA {
    public $a;
}

class TestClassB {
    public $a;
}

$a1 = new TestClassA();
$a2 = new TestClassA();
$b = new TestClassB();

$a1->a = 10;
$a2->a = 10;
$b->a = 10;

$a1 == $a1;
$a1 == $a2;  // Same members
$a1 != $b;   // Different classes

$a1 === $a1;
$a1 !== $a2; // Not the same object

Answer 6

En términos más simples:

== comprueba si equivalente (valor único)

=== comprueba si el mismo (valor && type)


Equivalente vsMismo:Una Analogía

1 + 1 = 2 + 0 (equivalente)

1 + 1 = 1 + 1 (lo mismo)


En PHP:

true == 1 (verdadero - equivalente en valor)

true === 1 (falso, no de la misma en valor && type)

• cierto es boolean
• 1 es int

Answer 7

Es todo acerca de los tipos de datos.Tomar una BOOL (verdadero o falso) por ejemplo:

true también es igual a 1 y false también es igual a 0

El == no le importa acerca de los tipos de datos cuando se comparan:Así que si tienes una variable que es de 1 (que también podría ser true):

$var=1;

Y luego compara con el ==:

if ($var == true)
{
    echo"var is true";
}

Pero $var en realidad no igual true, no?Tiene la int valor de 1 en su lugar, que a su vez, es igual a true.

Con ===, los tipos de datos se comprueban para asegurarse de que las dos variables/objetos/lo que sea, están utilizando el mismo tipo.

Así que si lo hice

if ($var === true)
{
    echo "var is true";
}

esa condición no sería verdad, como $var !== true sólo == true (si usted sabe a qué me refiero).

¿Por qué necesitas?

Simple - vamos a echar un vistazo a uno de PHP funciones: array_search():

El array_search() función simplemente busca un valor en una matriz y devuelve la clave del elemento el valor se encuentra en.Si el valor no se encuentra en la matriz, devuelve falso.Pero, ¿qué pasa si usted hizo un array_search() en un valor que se almacena en el primer elemento de la matriz (el que tendría la clave del array de 0)....el array_search() la función devolvería 0...que es igual a false..

Así que si usted hizo:

$arr = array("name");
if (array_search("name", $arr) == false)
{
    // This would return 0 (the key of the element the val was found
    // in), but because we're using ==, we'll think the function
    // actually returned false...when it didn't.
}

Así que, ¿puedes ver cómo esto podría ser un problema ahora?

La mayoría de las personas no utilizan == false cuando la comprobación de si una función devuelve false.En su lugar, la utilización de los !.Pero en realidad, este es exactamente el mismo como el uso de ==false, así que si lo hizo:

$arr = array("name");
if (!array_search("name", $arr)) // This is the same as doing (array_search("name", $arr) == false)

Así, por cosas como esa, tendría que usar la === en su lugar, de modo que el tipo de datos está activada.

Answer 8

Un ejemplo es que una base de datos de atributo puede ser null o "":

$attributeFromArray = "";
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //true
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //false

$attributeFromArray = null;
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //false
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //true

Answer 9

Dado x = 5

1) Operador :== es "igual". x == 8 es falso
2) Operador :=== es "exactamente igual" (el valor y tipo) x === 5 es cierto, x === "5" es falso

Answer 10

Algunos de los ejemplos

var_dump(5 == 5);    // True
var_dump(5 == "5");  // True because == checks only same value not type
var_dump(5 === 5);   // True
var_dump(5 === "5"); // False because value are same but data type are different.

P. S.

== Compara el valor solo, no te preocupes de los tipos de datos

vs

=== Compara los valores y tipos de datos

Answer 11

$a = 5;   // 5 as an integer

var_dump($a == 5);       // compare value; return true
var_dump($a == '5');     // compare value (ignore type); return true
var_dump($a === 5);      // compare type/value (integer vs. integer); return true
var_dump($a === '5');    // compare type/value (integer vs. string); return false

Sin embargo, tenga cuidado.Aquí es un problema notorio.

// 'test' is found at position 0, which is interpreted as the boolean 'false'
if (strpos('testing', 'test')) {
    // code...
}

vs

// true, as strict comparison was made (0 !== false)
if (strpos('testing', 'test') !== false) {
    // code...
}

Answer 12

En resumen, === funciona de la misma manera que == no en la mayoría de los otros lenguajes de programación.

PHP permite hacer comparaciones que no tenga mucho sentido.Ejemplo:

$y = "wauv";
$x = false;
if ($x == $y)
    ...

Mientras esto permite que para algunos interesante "atajos" que usted debe tener cuidado, ya que una función que devuelve algo que no debería (como "error" en lugar de un número) no pillan, y se le dejó preguntándose qué pasó.

En PHP, == compara los valores y realiza la conversión de tipo, si es necesario (por ejemplo, la cadena "12343sdfjskfjds" se convertirá en "12343" en una comparación de enteros).=== comparará el valor Y el tipo y devolverá false si el tipo no es el mismo.

Si usted mira en el manual de PHP, usted verá que una gran cantidad de funciones de devolución "false" si la función falla, pero que podría devolver a 0 en un escenario de éxito, es por eso que se recomienda realizar un "si (function() !== false)" para evitar errores.

Answer 13

Utilizaría === para comprobar si una función o variable es falso en lugar de simplemente lo que equivale a false (cero o una cadena vacía).

$needle = 'a';
$haystack = 'abc';
$pos = strpos($haystack, $needle);
if ($pos === false) {
    echo $needle . ' was not found in ' . $haystack;
} else {
    echo $needle . ' was found in ' . $haystack . ' at location ' . $pos;
}

En este caso strpos volvería 0, lo que equivale a false en la prueba

if ($pos == false)

o

if (!$pos)

que no es lo que usted quiere aquí.

Answer 14

Como para cuando el uso de uno sobre el otro, por ejemplo, tomar la fwrite() función en PHP.

Esta función escribe el contenido de un archivo de secuencia.De acuerdo con PHP "fwrite() devuelve el número de bytes escritos, o FALSE en caso de error.".Si desea probar si la llamada a la función fue un éxito, este método es erróneo:

if (!fwrite(stuff))
{
    log('error!');
}

Se puede devolver cero (y se considera un éxito), y su condición aún se activa.La forma correcta sería:

if (fwrite(stuff) === FALSE)
{
    log('error!');
}

Answer 15

PHP es un lenguaje escrito indirectamente.El uso de la doble igualdad de operador permite una suelta de comprobación de una variable.

Vagamente la comprobación de un valor permitiría algunos similares, pero no iguales, los valores de equiparar como la misma:

• ''
• null
• falso
• 0

Todos estos valores se podría equiparar como la igualdad de doble operador igual.

Answer 16

php == es un operador de comparación que compara el valor de las variables.Pero === compara el valor y el tipo de datos.

Por ejemplo,

<?php 
  $var1 = 10;
  $var2 = '10';

  if($var1 == $var2) {
    echo 'Variables are equal';
  } else {
    echo 'Variables are not equal';
  }
?>

En este caso, la salida será "Variables son iguales', aunque sus tipos de datos son diferentes.

Pero si usamos === en lugar de ==, el resultado será 'Variables no son iguales'.El php primero se compara el valor de la variable y el tipo de datos.Aquí los valores son los mismos, pero los tipos de datos son diferentes.

Answer 17

Las Variables tienen un tipo y un valor.

• $var = "prueba" es una cadena que contiene "prueba"
• $var2 = 24 es un número entero vhose valor es de 24.

Cuando se utilizan estas variables (en PHP), a veces no tienen el buen tipo.Por ejemplo, si usted

if ($var == 1) {... do something ...}

PHP tiene que convertir ("lanzar") $var a entero.En este caso, "$var == 1" es cierto porque cualquier cadena no vacía es convertir a 1.

Cuando se utiliza ===, compruebe que el valor Y EL TIPO son iguales, por lo que "$var === 1" es falsa.

Esto es útil, por ejemplo, cuando tiene una función que puede devolver false (por error) y 0 (el resultado) :

if(myFunction() == false) { ... error on myFunction ... }

Este código es incorrecto, como si myFunction() devuelve 0, es convertir a false y parece que tienes un error.El código correcto es :

if(myFunction() === false) { ... error on myFunction ... }

porque la prueba es que el valor de retorno "es un valor booleano y es falso" y que no "se puede convertir en falso".

Answer 18

El === el operador se supone que para comparar exacto el contenido de la igualdad, mientras que el == operador de comparación semántica de la igualdad.En particular, se coaccionar a las cadenas a números.

La igualdad es un gran tema.Ver el artículo de la Wikipedia sobre la igualdad.

Answer 19

<?php

    /**
     * Comparison of two PHP objects                         ==     ===
     * Checks for
     * 1. References                                         yes    yes
     * 2. Instances with matching attributes and its values  yes    no
     * 3. Instances with different attributes                yes    no
     **/

    // There is no need to worry about comparing visibility of property or
    // method, because it will be the same whenever an object instance is
    // created, however visibility of an object can be modified during run
    // time using ReflectionClass()
    // http://php.net/manual/en/reflectionproperty.setaccessible.php
    //
    class Foo
    {
        public $foobar = 1;

        public function createNewProperty($name, $value)
        {
            $this->{$name} = $value;
        }
    }

    class Bar
    {
    }
    // 1. Object handles or references
    // Is an object a reference to itself or a clone or totally a different object?
    //
    //   ==  true   Name of two objects are same, for example, Foo() and Foo()
    //   ==  false  Name of two objects are different, for example, Foo() and Bar()
    //   === true   ID of two objects are same, for example, 1 and 1
    //   === false  ID of two objects are different, for example, 1 and 2

    echo "1. Object handles or references (both == and    ===) <br />";

    $bar = new Foo();    // New object Foo() created
    $bar2 = new Foo();   // New object Foo() created
    $baz = clone $bar;   // Object Foo() cloned
    $qux = $bar;         // Object Foo() referenced
    $norf = new Bar();   // New object Bar() created
    echo "bar";
    var_dump($bar);
    echo "baz";
    var_dump($baz);
    echo "qux";
    var_dump($qux);
    echo "bar2";
    var_dump($bar2);
    echo "norf";
    var_dump($norf);

    // Clone: == true and === false
    echo '$bar == $bar2';
    var_dump($bar == $bar2); // true

    echo '$bar === $bar2';
    var_dump($bar === $bar2); // false

    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    echo '$bar === $baz';
    var_dump($bar === $baz); // false

    // Object reference: == true and === true
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    echo '$bar === $qux';
    var_dump($bar === $qux); // true

    // Two different objects: == false and === false
    echo '$bar == $norf';
    var_dump($bar == $norf); // false

    echo '$bar === $norf';
    var_dump($bar === $norf); // false

    // 2. Instances with matching attributes and its values (only ==).
    //    What happens when objects (even in cloned object) have same
    //    attributes but varying values?

    // $foobar value is different
    echo "2. Instances with matching attributes  and its values (only ==) <br />";

    $baz->foobar = 2;
    echo '$foobar' . " value is different <br />";
    echo '$bar->foobar = ' . $bar->foobar . "<br />";
    echo '$baz->foobar = ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false

    // $foobar's value is the same again
    $baz->foobar = 1;
    echo '$foobar' . " value is the same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    // Changing values of properties in $qux object will change the property
    // value of $bar and evaluates true always, because $qux = &$bar.
    $qux->foobar = 2;
    echo '$foobar value of both $qux and $bar is 2, because $qux = &$bar' . "<br />";
    echo '$qux->foobar is ' . $qux->foobar . "<br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    // 3. Instances with different attributes (only ==)
    //    What happens when objects have different attributes even though
    //    one of the attributes has same value?
    echo "3. Instances with different attributes (only ==) <br />";

    // Dynamically create a property with the name in $name and value
    // in $value for baz object
    $name = 'newproperty';
    $value = null;
    $baz->createNewProperty($name, $value);
    echo '$baz->newproperty is ' . $baz->{$name};
    var_dump($baz);

    $baz->foobar = 2;
    echo '$foobar' . " value is same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false
    var_dump($bar);
    var_dump($baz);
?>

Answer 20

Todas las respuestas hasta el momento se ignora un problema peligroso con ===.Se ha observado en pasar, pero no destacó, que integer y double son de tipos diferentes, por lo que el siguiente código:

$n = 1000;
$d = $n + 0.0e0;
echo '<br/>'. ( ($n ==  $d)?'equal' :'not equal' );
echo '<br/>'. ( ($n === $d)?'equal' :'not equal' );

da:

 equal
 not equal

Tenga en cuenta que este NO es un caso de un "error de redondeo".Los dos números son exactamente igual hasta el último pedazo, pero tienen diferentes tipos.

Este es un desagradable problema porque un programa usando === se puede ejecutar felizmente durante años si todos los números son lo suficientemente pequeños (donde "suficientemente pequeño" depende del hardware y el sistema operativo que se ejecuta en).Sin embargo, si por casualidad, un entero pasa a ser lo suficientemente grande como para ser convertido a un doble, su tipo de cambio "para siempre" aunque una operación posterior, o muchas operaciones, podría traer de vuelta a un entero pequeño en valor.Y se pone peor.Se puede propagar - doble-ness infección puede ser transmitida a cualquier cosa que toca, un cálculo a la vez.

En el mundo real, esto es probable que sea un problema de los programas que manejan las fechas más allá del año 2038, por ejemplo.En este momento, UNIX marcas de tiempo (número de segundos desde 1970-01-01 00:00:00 UTC), se requieren más de 32-bits, por lo que su representación "mágicamente" interruptor doble en algunos sistemas.Por lo tanto, si se calcula la diferencia entre dos tiempos, usted podría terminar con un par de segundos, pero como un doble, más que el resultado entero que se produce en el año 2017.

Creo que esto es mucho peor que las conversiones entre las cuerdas y los números, porque es sutil.Me resulta fácil seguir la pista de lo que es una cadena y lo que es un número, sino mantener un registro del número de bits en un número está más allá de mí.

Así, en las respuestas anteriores hay algunas buenas tablas, pero no hay distinción entre el 1 (como un número entero) y 1 (sutil doble) y 1.0 (obvio doble).También, el asesoramiento que usted siempre debe usar === y nunca == no es grande por === se, a veces no se de donde == funciona correctamente.También, JavaScript no es equivalente en este sentido, ya que sólo tiene un tipo de número (internamente pueden tener diferentes bit a bit de las representaciones, pero no causa problemas para ===).

Mi consejo - el uso de ninguno de los dos.Usted necesita escribir su propia función de comparación para realmente solucionar este lío.

Answer 21

Hay dos diferencias entre == y === en PHP arrays y objetos que creo que no se mencionan aquí;dos matrices con distintas clases y objetos.

Dos matrices con clave diferente tipo

Si usted tiene una matriz con una clave de ordenación y otra matriz con una clave diferente tipo, están estrictamente diferentes (es decir,el uso de ===).Que puede causar si la clave de ordenación de un array, y tratar de comparar la matriz ordenada con el original.

Por ejemplo, considere una matriz vacía.En primer lugar, tratamos de empujar a algunos de los nuevos índices de la matriz sin ninguna clase especial.Un buen ejemplo sería el de una matriz de cadenas como claves.Ahora profundamente en un ejemplo:

// Define an array
$arr = [];

// Adding unsorted keys
$arr["I"] = "we";
$arr["you"] = "you";
$arr["he"] = "they";

Ahora, tenemos un no-ordenados-matriz de claves (por ejemplo, 'él', llegó después de 'usted').Considere la posibilidad de la misma matriz, pero nos ordenan sus teclas en orden alfabético:

// Declare array
$alphabetArr = [];

// Adding alphabetical-sorted keys
$alphabetArr["I"] = "we";
$alphabetArr["he"] = "they";
$alphabetArr["you"] = "you";

Punta:Usted puede ordenar una matriz por clave con ksort() la función.

Ahora tienes otra matriz con una clave diferente tipo de la primera.Así que, vamos a comparar:

$arr == $alphabetArr; // true
$arr === $alphabetArr; // false

Nota:Puede ser obvio, pero la comparación de dos diferentes las matrices mediante la comparación estricta siempre resultados false.Sin embargo, dos matrices arbitrarias pueden ser iguales utilizando === o no.

Usted diría que:"Esta diferencia es insignificante".Entonces yo digo que es una diferencia y debe ser considerado y puede suceder en cualquier momento.Como se mencionó anteriormente, la clasificación de las claves de una matriz es un buen ejemplo de eso.

Los objetos

Tenga en cuenta, dos diferentes objetos nunca son de la estricta igualdad de.Estos ejemplos podrían ayudar:

$stdClass1 = new stdClass();
$stdClass2 = new stdClass();
$clonedStdClass1 = clone $stdClass1;

// Comparing
$stdClass1 == $stdClass2; // true
$stdClass1 === $stdClass2; // false
$stdClass1 == $clonedStdClass1; // true
$stdClass1 === $clonedStdClass1; // false

Nota:La asignación de un objeto a otra variable no crear una copia de lugar, se crea una referencia a la misma ubicación de memoria como el objeto. Ver aquí.

Nota:Como de PHP7, las clases anónimas se ha añadido.A partir de los resultados, no hay ninguna diferencia entre new class {} y new stdClass() en las pruebas anteriores.