it-swarm-es.tech

Como PHP ¿los operadores de comparación de igualdad (== doble igual) e identidad (=== triple igual) difieren?

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

  • ¿Cómo funciona exactamente la comparación ==?
  • ¿Cómo funciona exactamente la estricta comparación ===?

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

463
nickf

Diferencia entre == y ===

La diferencia entre el operador igual == y el operador idéntico === estricto se explica exactamente en el manual :

Operadores de comparación

 ┌──────────┬───────────┬───────────────────── ──────────────────────────────────────┐ 
 │ Ejemplo │ Nombre │ Resultado │ 
 ├──────────┼───────────┼──────────────────── ───────────────────────────────────────┤ 
 │ $ a == $ b │ Igual │ VERDADERO si $ a es igual a $ b después del tipo de malabarismo. │ 
 │ $ a === $ b │ Idéntico │ VERDADERO si $ a es igual a $ b, y son del mismo tipo. │ 
 └──────────┴───────────┴──────────────────── ───────────────────────────────────────┘ 

Sin comparación == igual comparación

Si está utilizando el operador ==, o cualquier otro operador de comparación que use una comparación flexible como !=, <> o ==, siempre debe mirar el context para ver qué, dónde y por qué se convierte algo. Entender lo que está pasando.

Reglas de conversión

Tabla de comparación de tipos

Como referencia y ejemplo, puede ver la tabla de comparación en manual :

Comparaciones sueltas con ==

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐ 
 │ │ VERDADERO │ FALSO │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ matriz NULL () │ "php" │ "" │ 
 ├─────────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼───────┼───────── . 
 │ VERDADERO VERDADERO FALSO VERDADERO │ FALSO VERDADERO │ VERDADERO │ FALSO VERDADERO │ FALSO │ FALSO VERDADERO │ FALSO │ 
 │ FALSO │ FALSO │ VERDADERO │ FALS E │ VERDADERO FALSO │ FALSO VERDADERO │ FALSO VERDADERO │ VERDADERO │ FALSO │ VERDADERO │ 
 │ 1 │ VERDADERO │ FALSO FALSO FALSO FALSE │ FALSO FALSO FALSO FALSO FALSO FALSO FALSO FALSO. 
 │ 0 │ FALSO VERDADERO │ FALSO VERDADERO │ FALSO │ FALSO │ VERDADERO FALSO VERDADERO │ FALSO VERDADERO VERDADERO 
 │ -1 │ VERDADERO │ FALSO FALSO FALSE FALSE │ VERDADERO FALSO │ FALSO VERDADERO FALSO FALSO │ FALSO │ FALSO. 
 │ "1" │ VERDADERO │ FALSO FALSO FALSO FALSO FALSO FALSO │ FALSO FALSO FALSO FALSO FALSO FALSO VERDADERO . 
 │ "0" │ FALSO VERDADERO │ FALSO VERDADERO │ FALSO │ FALSO VERDADERO FALSO │ FALSO │ FALSO FALSO FALSO 
 │ "-1" │ VERDADERO FALSO FALSO │ FALSO VERDADERO │ FALSO │ FALSO VERDADERO │ FALSO │ FALSO │ FALSO │ FALSO. 
 │ NULO │ FALSO │ VERDADERO FALSO VERDADERO │ FALSO FALSO FALSO │ FALSO VERDADERO │ VERDADERO │ FALSO 
 │ array () FALSO ││AL│││ALALAL││││││││││││││ VERDADERO FALSO FALSO │ 
 │ "php" │ VERDADERO │ FALSO │ FALSO VERDADERO FALSO │ FALSO │ FALSO FALSO │ FALSO │ FALSO FALSO │ [". │ VERDADERO FALSO │ VERDADERO │ FALSO │ FALSO │ FALSO │ FALSO │ VERDADERO │ FALSO │ FALSO │ VERDADERO │ 
 └─────────┴───────┴─── ────┴───────┴───────┴───────┴───────┴───────┴───── ──┴───────┴─────────┴───────┴───────┘ 

Estricto === comparación idéntica

Si está utilizando el operador ===, o cualquier otro operador de comparación que use una comparación estricta como !== o ===, entonces siempre puede estar seguro de que los tipos no mágicamente cambiarán, porque no habrá conversión continuando Entonces, con una comparación estricta, el tipo y el valor deben ser iguales, no solo el valor.

Tabla de comparación de tipos

Como referencia y ejemplo, puede ver la tabla de comparación en manual :

Comparaciones estrictas con ===

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐ 
 │ │ VERDADERO │ FALSO │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ matriz NULL () │ "php" │ "" │ 
 ├─────────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼───────┼───────── . 
 │ VERDADERO VERDADERO FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO 
 │ FALSO │ FALSO │ VERDADERO │ FALS E │ FALSO FALSO FALSO FALSO │ FALSO │ FALSO FALSO │ FALSO │ FALSO. 
 │ 1 │ FALSO FALSO FALSO FALSO FALSO FALSO FALSO │ FALSO FALSO FALSO FALSO FALSO FALSO FALSO │ FALSO FALSO FALSO. 
 │ 0 │ FALSO FALSO │ FALSO │ VERDADERO │ FALSO │ FALSO FALSO │ FALSO FALSO FALSO FALSO FALSO FALSO │ VERDADERO FALSO │ FALSO FALSO FALSO │ FALSO │ FALSO │ FALSO. 
 │ "1" │ FALSO FALSO FALSO │ FALSO FALSO FALSO FALSO FALSO FALSO │SE││SE│││UEUEUEUEUEUEUEUEUEUE . 
 │ "0" │ FALSO FALSO │ FALSO │ FALSO │ FALSO │ FALSO VERDADERO FALSO │ FALSO FALSO FALSO │ FALSO FALSO 
 │ "-1" │ FALSO FALSO FALSO FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ VERDADERO │ FALSO │ FALSO │ FALSO │ FALSO. 
 │ NULO │ FALSO │ FALSO │ FALSO FALSO FALSO FALSO FALSO │ FALSO │ VERDADERO │ FALSO │ FALSO │ 
 FALSO) FALSO) FALSO FALSO FALSO │ FALSO │ FALSO FALSO FALSO FALSO FALSO FALSO FALSO FALSO FALSO │ FALSO │ FALSO FALSO VERDADERO FALSO FALSO. 
 │ "php" │ FALSO │ FALSO. FALSO FALSO │ FALSO │ FALSO FALSO FALSO │ FALSO │ FALSO FALSO "". │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ FALSO │ VERDADERO │ 
 └─────────┴───────┴─── ────┴───────┴───────┴───────┴───────┴───────┴───── ──┴───────┴─────────┴───────┴───────┘ 
588
nickf

El operador == realiza el reparto entre dos tipos diferentes si son diferentes, mientras que el operador === realiza una "comparación segura". Eso significa que solo devolverá verdadero si ambos operandos tienen el mismo tipo y el 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 miembros equivalentes NO coinciden con el operador ===. Ejemplo:

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

Una imagen vale mas que mil palabras:

PHP doble es igual a == cuadro de igualdad:

 enter image description here

PHP Triple es igual a === cuadro de igualdad:

 enter image description here

Código fuente para crear estas imágenes:

https://github.com/sentientmachine/php_equality_charts

Meditación Gurú

Aquellos que deseen mantener su cordura, no sigan leyendo porque nada de esto tendrá ningún sentido, excepto para decir que así se diseñó el fractal de la locura de PHP.

  1. NAN != NAN pero NAN == true.
  2. == convertirá los operandos izquierdo y derecho en números si el izquierdo es un número. Entonces 123 == "123foo", pero "123" != "123foo"
  3. Una cadena hexadecimal entre comillas es ocasionalmente un flotador, y se lanzará por sorpresa para que flote en contra de su voluntad, causando un error de tiempo de ejecución.

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

  5. Las variables de PHP que aún no se han declarado son falsas, aunque PHP tiene una forma de representar variables no definidas, esa función está deshabilitada con ==.
  6. "6" == " 6", "4.2" == "4.20", y "133" == "0133" pero 133 != 0133. Pero "0x10" == "16" y "1e3" == "1000" exponiendo esa conversión de cadena sorpresa a octal ocurrirán ambas sin su instrucción o consentimiento, lo que causará un error de tiempo de ejecución.

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

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

  9. Una clase nueva es == a 1.

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

Esperanza:

Si está utilizando PHP, no deberá usar el operador de doble igual porque si usa el triple de iguales, los únicos casos de Edge de los que debe preocuparse son NAN y números tan cercanos al infinito que se convierten en infinitos. Con dobles iguales, cualquier cosa puede sorprender a == a cualquier cosa o, o puede ser sorprendida en contra de su voluntad y != a algo de lo que obviamente debería ser igual.

En cualquier lugar que use == en PHP hay un mal olor de código debido a los 85 errores expuestos a él por las reglas de conversión implícitas que parecen diseñadas por millones de programadores programados por movimiento browniano.

65
Eric Leschinski

En lo que respecta a JavaScript:

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

Por ejemplo, la muestra de abajo mostrará 'x e y son iguales', pero no 'x e 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');
}
39
user1684

Una adición a las otras respuestas concernientes a la comparación de objetos:

== compara objetos usando el nombre del objeto y sus valores. Si dos objetos son del mismo tipo y tienen los mismos valores de miembro, $a == $b produce true.

=== compara el id de objeto interno 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
22
soulmerge

En los términos más simples:

== comprueba si equivalente (solo valor)

=== comprueba si same (value && type)


Equivalente vs. Mismo: una analogía

1 + 1 = 2 + 0 (equivalente)

1 + 1 = 1 + 1 (igual)


En PHP:

true == 1 (true - equivalente en valor)

verdadero === 1 (falso - no es lo mismo en valor y tipo)

  • verdadero es booleano
  • 1 es int
13
silver

Se trata de tipos de datos. Tome una BOOL (verdadero o falso) por ejemplo:

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

El == no se preocupa por los tipos de datos cuando se compara: Entonces, si tiene una variable que es 1 (que también podría ser true):

$var=1;

Y luego comparar con el ==:

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

Pero $var no es igual a true, ¿verdad? En su lugar, tiene el valor int de 1, que a su vez, es igual a verdadero.

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

Asi que si lo hice

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

esa condición no sería verdadera, ya que $var !== true solo lo == true (si sabes lo que quiero decir).

Por qué necesitarías esto?

Simple: echemos un vistazo a una de las funciones de PHP: array_search():

La función array_search() simplemente busca un valor en una matriz y devuelve la clave del elemento en el que se encontró el valor. Si no se pudo encontrar el valor en la matriz, devuelve falso. Pero, ¿qué pasaría si hiciera una array_search() en un valor que estaba almacenado en el primer elemento de la matriz (que tendría la clave de matriz de 0) .... la función array_search() devolvería 0 ... que es igual a falso ..

Así que si lo hiciste:

$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.
}

Entonces, ¿ves cómo esto podría ser un problema ahora?

La mayoría de las personas no usan == false cuando comprueban si una función devuelve false. En su lugar, utilizan el !. Pero en realidad, esto es exactamente lo mismo que usar ==false, así que si lo hiciste:

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

Así que para cosas como esas, usarías el === en su lugar, para que el tipo de datos sea verificado.

8
user849137

Un ejemplo es que un atributo de base de datos puede ser nulo 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
8
fico7489

Dado x = 5

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

6
Mannusanghi

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

PD.

== Compara solo el valor, no se preocupará por los tipos de datos

vs.

=== Compara los valores y tipos de datos

4
Mohit Tanwani

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

PHP le permite hacer comparaciones que realmente no tienen sentido. Ejemplo:

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

Si bien esto permite algunos "accesos directos" interesantes, debe tener cuidado ya que una función que devuelve algo que no debería (como "error" en lugar de un número) no se verá atrapada, y se quedará preguntándose qué sucedió.

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

Si observa el PHP manual, verá que muchas funciones devuelven "falso" si la función falla, pero podrían devolver 0 en un escenario exitoso, por lo que recomiendan hacer "si ( función ()! == falso) "para evitar errores.

3
Christian P.
$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

Pero ten cuidado. Aquí hay 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...
}
3
Seph

PHP es un lenguaje vagamente escrito. El uso del doble operador igual permite una comprobación suelta de una variable.

La comprobación de un valor sin apretar permitiría que algunos valores similares, pero no iguales, equivalgan a los mismos:

  • ''
  • nulo
  • false

Todos estos valores se igualarían a igual usando el operador doble igual.

2
Cory Collier

Usaría === para probar si una función o variable es falsa en lugar de simplemente igualar a falso (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 devolvería 0, lo que equivaldría a falso en la prueba

if ($pos == false)

o

if (!$pos)

que no es lo que quieres aquí.

2
Stacey Richards

En cuanto a cuándo usar uno sobre el otro, tome por ejemplo la función fwrite() en PHP.

Esta función escribe contenido en una secuencia de archivos. Según 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 exitosa, este método es defectuoso:

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

Puede devolver cero (y se considera exitoso), y su condición aún se activa. El camino correcto sería:

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

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á 'Las variables son iguales', aunque sus tipos de datos sean diferentes.

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

1
2rahulsk

Todas las respuestas hasta ahora ignoran un problema peligroso con ===. Se ha observado de pasada, pero sin subrayar, que entero y doble son 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 "error de redondeo". Los dos números son exactamente iguales al último bit, pero tienen diferentes tipos.

Este es un problema desagradable porque un programa que usa === puede ejecutarse felizmente durante años si todos los números son lo suficientemente pequeños (donde "lo suficientemente pequeño" depende del hardware y sistema operativo en el que esté ejecutándose). Sin embargo, si por casualidad, un entero es lo suficientemente grande como para convertirlo en un doble, su tipo se cambia "para siempre" aunque una operación posterior, o muchas operaciones, puedan devolverlo a un valor entero pequeño. Y, se pone peor. Puede propagarse: la infección doble puede transmitirse a cualquier cosa que toque, un cálculo a la vez.

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

Creo que esto es mucho peor que las conversiones entre cadenas y 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, pero seguir la pista de la cantidad de bits en un número me supera.

Por lo tanto, en las respuestas anteriores hay algunas tablas de Niza, pero no hay distinción entre 1 (como un entero) y 1 (doble sutil) y 1.0 (doble obvio). Además, los consejos que siempre debe usar === y nunca == no son muy buenos porque a veces === fallará donde == funciona correctamente. Además, JavaScript no es equivalente a este respecto porque tiene un solo tipo de número (internamente puede tener diferentes representaciones de bits, pero no causa problemas para ===).

Mi consejo - no uses ninguno. Necesitas escribir tu propia función de comparación para realmente arreglar este lío.

1
DavidWalley
<?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);
?>
1
Sathish

Las variables tienen un tipo y un valor.

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

Cuando usa estas variables (en PHP), a veces no tiene el tipo correcto. Por ejemplo, si lo haces

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

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

Cuando usa ===, verifica que el valor Y EL TIPO sean iguales, por lo que "$ var === 1" es falso.

Esto es útil, por ejemplo, cuando tiene una función que puede devolver falso (en caso de error) y 0 (resultado):

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

Este código es incorrecto como si myFunction() devuelve 0, se convierte en falso y parece que tiene 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 no "se puede convertir en falso".

1
ofaurax

Se supone que el operador === debe comparar exacto igualdad de contenido mientras que el operador == compararía la igualdad semántica. En particular, obligará a las cadenas a los números.

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

1
kmkaplan

Hay dos diferencias entre == y === en PHP matrices y objetos que creo que no mencioné aquí; Dos matrices con diferentes tipos de claves, y objetos.

Dos matrices con diferentes tipos de claves.

Si tiene una matriz con una clasificación de clave y otra matriz con una clasificación de clave diferente, son estrictamente diferentes (es decir, utilizando ===). Eso puede causar si ordena una matriz por orden e intenta comparar la matriz ordenada con la original.

Por ejemplo, considere una matriz vacía. Primero, intentamos insertar algunos índices nuevos en la matriz sin ninguna ordenación especial. Un buen ejemplo sería una matriz con cadenas como claves. Ahora profundizando en un ejemplo:

// Define an array
$arr = [];

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

Ahora, tenemos una matriz de claves no ordenadas (por ejemplo, 'he' vino después de 'you'). Considere la misma matriz, pero ordenamos sus claves alfabéticamente:

// Declare array
$alphabetArr = [];

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

Consejo : Puede ordenar una matriz por clave usando ksort () function.

Ahora tienes otra matriz con una ordenación de teclas diferente a la primera. Entonces, vamos a compararlos:

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

Nota : Puede ser obvio, pero al comparar dos matrices diferentes usando una comparación estricta siempre resulta false. Sin embargo, dos arreglos arbitrarios pueden ser iguales usando === o no.

Dirías: "Esta diferencia es despreciable". Entonces digo que es una diferencia y debería ser considerada y puede suceder en cualquier momento. Como se mencionó anteriormente, ordenar las claves en una matriz es un buen ejemplo de eso.

Objetos

Tenga en cuenta que dos objetos diferentes nunca son estrictamente iguales. Estos ejemplos ayudarían:

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

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

Nota : Asignar un objeto a otra variable no crea una copia, sino que crea una referencia a la misma ubicación de memoria que el objeto. Mira aquí .

Nota : A partir de PHP7, se agregaron clases anónimas . De los resultados, no hay diferencia entre new class {} y new stdClass() en las pruebas anteriores.

0
MAChitgarha