ingles grados entre ejercicios ejemplos diferencia adjetivos adjetivo php comparison operators equality identity-operator

php - entre - grados del adjetivo ejercicios



¿En qué se diferencian los operadores de comparación de igualdad de PHP(== doble igual) e identidad(=== triple igual)? (20)

Diferencia entre == y ===

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

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. │ └──────────┴───────────┴───────────────────────────────────────────────────────────┘

Sin comparación == igual comparación

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

Reglas de conversión

Tabla de comparación de tipos

Como referencia y ejemplo puedes ver la tabla de comparación en el manual :

Comparaciones sueltas 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 === 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 cambiarán mágicamente , 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 puedes 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 │ └─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

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

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

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

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

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)

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 FALSO 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!''); }

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 a continuación 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''); }

En los términos más simples:

== comprueba si es equivalente (solo valor)

=== comprueba si es igual (value && type)


Equivalente contra lo mismo: una analogía

1 + 1 = 2 + 0 (equivalente)

1 + 1 = 1 + 1 (igual)


En PHP:

verdadero == 1 (verdadero - equivalente en valor)

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

  • cierto es booleano
  • 1 es int

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

PHP te 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 Y el tipo y devolverá falso si el tipo no es el mismo.

Si observa el manual de PHP, 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 "if (function ()! == falso) "para evitar errores.

Existen dos diferencias entre == y === en matrices de PHP 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 ordenación clave y otra matriz con una ordenación clave diferente, son estrictamente diferentes (es decir, utilizando === ). Eso puede causar si ordena una matriz por orden de claves 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";

Sugerencia : Puede ordenar una matriz por clave usando la función ksort() .

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

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

Nota : puede ser obvio, pero la comparación de dos matrices diferentes utilizando una comparación estricta siempre resulta false Sin embargo, dos matrices arbitrarias 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 claves en una matriz es un buen ejemplo de eso.

Objetos

Tenga en cuenta que dos objetos diferentes nunca son exactamente 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 : la asignación de un objeto a otra variable no crea una copia, sino que crea una referencia a la misma ubicación de memoria que el objeto. Vea 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.

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 ya que 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".

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
  • falso
  • 0

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

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

contra

=== Compara los valores y tipos de datos

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

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

Se trata de tipos de datos. Toma un 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 (lo 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 == 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 el valor no se pudo encontrar en la matriz, devuelve falso . Pero, ¿qué array_search() si hiciera un array_search() en un valor que se almacenó en el primer elemento del array (que tendría la clave de array de 0 ) ... la función array_search() devolvería 0 ... 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 falso. 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)

Entonces, para cosas como esas, === el === lugar, para que el tipo de datos sea verificado.

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 convertirse en un doble, su tipo se cambia "para siempre" aunque una operación posterior, o muchas operaciones, puedan devolverlo a un pequeño entero en valor. 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.

Entonces, en las respuestas anteriores hay algunas tablas agradables, 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.

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

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 traduce en verdadero.

=== 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

Una imagen vale mas que mil palabras:

PHP Double Equals == gráfico de igualdad:

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

Código fuente para crear estas imágenes:

Meditación Gurú

Aquellos que desean mantener su cordura, no sigan leyendo.

  1. ''=='' convierte los operandos izquierdo y derecho en números cuando es posible (123 == "123foo", pero "123"! = "123foo"
  2. Una cadena hexadecimal entre comillas es ocasionalmente un flotador y se lanzará a ella contra tu voluntad.
  3. == no es transitivo porque ("0" es == a 0, y 0 es == a "" pero "0"! = "")
  4. "6" == "6", "4.2" == "4.20" y "133" == "0133". Pero 133! = 0133, porque 0133 es octal. Pero "0x10" == "16" y "1e3" == "1000"

  5. Las variables de PHP que aún no han sido declaradas son falsas.

  6. False es igual a 0, blankstring y una matriz vacía y "0".

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

  8. NAN no se == en sí mismo, pero es cierto.

  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 dobles iguales, siempre use los iguales de triple.

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

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

contra

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

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