març 10, 2021

== Vs === Per què no tot és igual (i menys en Javascript)

Si alguna vegada ho vas notar, en Javascript no tots els operadors d’igualtat són iguals;). En particular, estic parlant de == (doble igual) i de === (triple igual). De fet, encara que en aparença fan coses semblants, en molts casos es comporten de forma completament diferent. El bon maneig d’aquests dos operadors és essencial per a un un bon desenvolupament i per no incorporar errors no desitjats. Però bé, anem a veure què és tot això!

Doble Igual (==)

Quan al nostre codi volem comparar dues variables, podem usar aquest operador per revisar que aquestes dues variables siguin iguals, però … compte !, perquè si les dues variables que volem comparar són de diferent tipus, el comportament del nostre codi pot tornar-se “estrany”.

Per entendre una mica millor l’explicació, fixa’t meu post de Dynamic Typing.

Com sabràs (al menys després de llegir el post de Dynamic Typing), Javascript és dynamic typing i això comporta que el motor apliqui coerció per transformar una variable d’un tipus a un altre. Moltes vegades aquesta transformació no és la que esperem, estic es pot veure molt a l’usar l’operador “==”.

Bàsicament, l’operador == el que fa és comparar 2 valors PERÒ ho fa sense revisar el tipus de les variables.

Operador doble Igual (==): compara 2 valors PERÒ ho fa sense revisar el tipus de les variables

amb això vull dir el següent: si per exemple, tinc una variable que és numèrica i val 1 i tinc un variable string que val ‘1’, a l’comparar-les amb aquest operador, la resposta donarà TRUE:

var a = 1;var b = '1'if (a == b) { console.log('son iguales')} else { console.log('son diferentes')}

Això imprimeix en pantalla ‘són iguals’, sí, exacte, encara que siguin tipus diferents; com Javascript converteix les dues variables a el mateix tipus utilitzant coerció, aquestes dues variables acaben sent iguals.

Coerció: convertir el valor d’una variable d’un tipus a un altre, per exemple convertir el valor ‘1’ (de tipus string) a numèric, donaria com a resultat el valor 1 (de tipus numèric)

Però què passa si comparem el valor fals amb el número zero?

var a = false;var b = 0;if (a == b) { console.log('son iguales')} else { console.log('son diferentes')}

Això també imprimeix en pantalla ‘són iguals’. I per què? perquè quan Javascript converteix 0 (zero) a boolean, per al motor Javascript, 0 (zero) es converteix en fals, llavors es pregunta si FALS és igual a FALS i la condició retorna TRUE imprimint en pantalla ‘són iguals’.

Un cas més, que mostra en pantalla el següent?

var a = '';var b = 0;if (a == b) { console.log('son iguales')} else { console.log('son diferentes')}

Això també imprimeix ‘són iguals’ encara que el nombre 0 i el string buit “siguin molt diferents. Ja que, a la variable” a “el valor és un string buit, a l’convertir-lo a un valor numèric, aquest és igual a 0 (zero).

I com faig quan vull comparar tenint en compte TAMBÉ el tipus de la variable?

endevinar !, usant l’operador triple igual (===)

triple igual (===)

En resum, el triple igual comprova el contingut de la variable ia més, comprova que les dues variables siguin de el mateix tipus. és per això que es diu que és més segur que el == (doble igual).

Operador triple Igual (===): una revisió el contingut de la vari able ia més, comprova que les dues variables siguin de la mateixa mena.

Tornant a l’exemple anterior:

var a = 1;var b = '1';if (a === b) { console.log('son iguales')} else { console.log('son diferentes')}

en aquest cas, com “a” i “b” no són de la mateixa mena, s’imprimeix en consola ‘són diferents’.

Amb l’exemple:

var a = false;var b = 0;if (a === b) { console.log('son iguales')} else { console.log('son diferentes')}

També es mostra en consola ‘són diferents’ ja que” a “de l’tipus boolean i” b “de l’tipus numèric són de diferent tipus.

Finalment:

var a = '';var b = 0;if (a === b) { console.log('son iguales')} else { console.log('son diferentes')}

Com podeu suposar, també imprimeix en consola ‘són diferents’. a

Conclusió

Com podeu veure, hi ha una gran gran diferència entre usar == i ===, de fet, el seu mal ús pot ocasionar-bugs no desitjats. Per això, davant del dubte, usá sempre === i t’estalvies més d’un mal de cap.

Deixa un comentari

L'adreça electrònica no es publicarà. Els camps necessaris estan marcats amb *