Diferencia

Veamos con este ejemplo la diferencia entre los operadores ‘==’ y ‘===’:

var a = [1,2,3,4]; 
var b = [1,2,3,4];  
var c = { x: 1, y: 2, z: 3 }; 
var d = { x: 1, y: 2, z: 3 };  
var e = "hello"; 
var f = "he" + "llo";  

alert((a == b));           // false

alert((a === b));           // false  


alert((c == d));            // false 

alert((c === d));           // false  


alert((e == f));            // true 

alert((e === f));           // true


alert((true == 1)); //true

alert(("2" == 2)); //true


alert((true === 1)); //false 

alert(("2" === 2)); // false

Javascript tiene dos operadores de igualdad ‘===’ y ‘==’. El operador ‘===’ retornará true si los dos operandos son del mismo tipo Y tienen el mismo valor.
En cambio, el operador ‘==’ intenta forzar una conversión si los operandos son de distinto tipo para luego comparar los valores.
Veamos otro ejemplo:

var a = [1,2,3,4]; 
var b = [1,2,3,4]; 
var c = a;  
var ab_igualdad = (a === b); // false 

var ac_igualdad = (a === c); // true

En realidad el operador ‘===’ verifica que ambos operandos apunten al mismo objeto o en el caso de tipo de datos de valor que ambos operandos tengan el mismo valor.
Veamos un ejemplo de esto con strings:

alert(("fernetjs" == new String("fernetjs")));    // true 

alert(("fernetjs" === new String("fernetjs")));   // false

Acá vemos que con ‘===’ da false porque hablamos de distintos objetos.

Performance

Se corrió lo siguiente 6 veces con cada operador de igualdad y los resultados arrojaron una mejor performace con el operador ‘===’.

console.time("testEquality"); 
var n = 0; 
while(true) {     
    n++;     
    if(n==100000) break; 
        
        } 
console.timeEnd("testEquality"); 

    
console.time("testTypeEquality"); 
var n = 0; 
while(true) {     
n++;     
if(n===100000) break; 
} 
console.timeEnd("testTypeEquality"); 

//16.83 en promedio con '=='

//16.5 en promedio con '==='

Usen la implementación de console.time and console.timeEnd en caso de que prueben
con explorer 8:

if(window.console && typeof(window.console.time) == "undefined") {
    console.time = function(name, reset){
        if(!name) { return; }
        var time = new Date().getTime();
        if(!console.timeCounters) { console.timeCounters = {} };
        var key = "KEY" + name.toString();
        if(!reset && console.timeCounters[key]) { return; }
            console.timeCounters[key] = time;
        };

    console.timeEnd = function(name){
        var time = new Date().getTime();
        if(!console.timeCounters) { return; }
        var key = "KEY" + name.toString();
        var timeCounter = console.timeCounters[key];
        if(timeCounter) {
            var diff = time - timeCounter;
            var label = name + ": " + diff + "ms";
            console.info(label);
            delete console.timeCounters[key];
        }
        return diff;
    };
}

Conclusión: aunque la diferencia no es grande (dependiendo del caso), vemos que con ‘===’ obtuvimos un mejor tiempo.

Las buenas prácticas nos dicen que siempre debemos usar ‘===’ para evitar errores lógicos y de performance a menos que tengamos en claro que usamos ‘==’ por alguna razón.