Porque el Operador === es más Rápido que el Operador == en PHP

Nube Colectiva

hace 4 años

En esta página:

En PHP como en otros Lenguajes de Programación, existen los operadores, que nos permiten manejar variables o datos, entre este tipo de operadores se encuentra los operadores de comparación que suelen ser varios, entre este grupo de operadores se encuentran los operadores === y == aunque ambos parecen realizar los mismo, hay ciertos detalles que los diferencian, como la velocidad para comparar 2 variables o datos y en este Post te explicaré más sobre ello.

Antes de continuar te invito a leer los siguientes artículos:

Asimismo, te invito a escuchar el Podcast: “5 Consejos para ser un Programador más Productivo” (No son los clásicos consejos técnicos de programación, si no de rutinas y buenos hábitos cotidianos):

Spotify:	Sound Cloud:

Bien ahora continuemos con el Post: Porque el Operador === es más Rápido que el Operador == en PHP.

En este Post no quiero afirmar que debes usar el operador === por ser más rápido que el operador ==, si no hacerte ver que puedes elegir usar el operador que más te convenga según la tarea que estés realizando, al final un operador no reemplaza al otro, sino que debemos saber cuando usarlos.

Según la documentación oficial de PHP el operador de comparación == devuelve TRUE si una variable es igual a otra variable, después de la manipulación de tipos de datos y el operador de comparación === devuelve TRUE si una variable es igual a otra variable, siempre y cuando sean el mismo tipo de dato.

Ambos operadores nos permiten comparar valores, al operador == se le conoce como operador vagamente igual y al operador === se le conoce como operador estrictamente idéntico.

Si utilizamos operandos con tipos de datos diferentes y hacemos comparaciones entre ellos con == y ===, los resultados que obtendremos serán diferentes.

Las velocidad de los operadores serán diferentes en este caso, ya que el operador == realiza la conversión de tipos y luego hace la comparación entre ellos, si los operandos son del mismo tipo de datos, tanto el operador == como el operador === producirán los mismo resultados, la velocidad de ambos operadores será idéntica en este caso, ya que ninguno de los operadores realiza conversión de tipo de datos.

Pero el operador de igualdad == convierte el tipo de dato temporalmente para ver si su valor es igual al otro operando, mientras que el operador de identidad === no necesita realizar ningún tipo de conversión de tipo de dato y por ende realiza menos trabajo, lo que lo hace más rápido que el operador ==, veamos a continuación un ejemplo para entender mejor esto.


<?php

    // Se realiza la conversión y luego se comprueba si es igual o no, todos darán 'true'
    var_dump(7 == "a");
    
    // 3 == 3 -> true
    var_dump("3" == "03");
    
    // 10 == 10 -> true
    var_dump("10" == "1e1");
    
    // 100 == 100 -> true
    var_dump(100 == "1e2");


    // En este caso la conversión no se realiza, por ende es más rápido 
    // igual o no
    var_dump(0 === "a");

    // "3" === "03" -> false
    var_dump("3" === "03");

    // "10" === "1e1" -> false
    var_dump("10" === "1e1");

    // 100 == "1e2" -> false
    var_dump(100 === "1e2");
   
?>

<?php

// Se realiza la conversión y luego se comprueba si es igual o no, todos darán 'true'

var_dump(7 == "a");

// 3 == 3 -> true

var_dump("3" == "03");

// 10 == 10 -> true

var_dump("10" == "1e1");

// 100 == 100 -> true

var_dump(100 == "1e2");

// En este caso la conversión no se realiza, por ende es más rápido

// igual o no

var_dump(0 === "a");

// "3" === "03" -> false

var_dump("3" === "03");

// "10" === "1e1" -> false

var_dump("10" === "1e1");

// 100 == "1e2" -> false

var_dump(100 === "1e2");

Si ejecutamos el código anterior obtenemos las siguientes salidas:


# Tras ejecutar el código anterior obtenemos los siguientes resultados 
bool(true)
bool(true)
bool(true)
bool(true)
bool(false)
bool(false)
bool(false)
bool(false)

# Tras ejecutar el código anterior obtenemos los siguientes resultados

bool(true)

bool(false)

Tal como mencione al inicio más arriba, en este Post no quiero afirmarte que debes usar el operador === en vez del operador == por ser más rápido, si no que por criterio debes darte cuenta como usarlos para lograr que el codigo se ejecute fluidamente y logres tu objetivo.

Conclusión

Hemos aprendido en este Post, porque el operador === es más rápido que el operador ==, conocer esto te ayudará a entender cuando es necesario utilizar alguno de ellos en el momento adecuado.

Nota (s)

No olvides que debemos utilizar la tecnología para hacer cosas buenas por el mundo.

Síguenos en las Redes Sociales para que no te pierdas nuestros próximos contenidos.