Estoy usando JSLint a ir a través de JavaScript, y es que regresan muchas sugerencias para reemplazar == (dos signos iguales) con === (tres iguales signos) cuando hacer las cosas como comparar idSele_UNVEHtype.value.length == 0 dentro de un if declaración.

Hay una ventaja de rendimiento a la sustitución de == con ===?

Cualquier mejora en el rendimiento sería recibido como muchos de los operadores de comparación existen.

Si no hay ningún tipo de conversión se lleva a cabo, habría una ganancia de rendimiento sobre ==?

Para quienes puedan estar interesados en el mismo tema === vs ==, pero en PHP, se puede leer aquí: stackoverflow.com/questions/2401478/why-is-faster-than-in-php/…
Sólo en caso de que alguien preguntaba en 2012: === es camino más rápido que ==. jsperf.com/comparison-of-comparisons
debe ser como el no hacer la conversión de tipo de
Dudo que alguien va a hacer su aplicación mucho más rápido mediante el uso de === más de ==. De hecho, el punto de referencia no muestran una gran diferencia entre ambos en los navegadores modernos. Personalmente, yo suelo usar == en todas partes, a menos que realmente necesito de igualdad estricta.
Aquí está la parte de Crockford JS Las Partes Buenas charla donde se discute la === y == operadores: youtube.com/… Si no juega, es en 15:20

OriginalEl autor bcasp | 2008-12-11

1 Comentario

  1. 6151

    La identidad (===) operador se comporta de forma idéntica a la igualdad (==) operador excepción de ningún tipo de conversión se realiza, y los tipos debe ser el mismo para ser considerados iguales.

    Referencia: Tutorial De Javascript: Operadores De Comparación

    La == operador va a comparar a la igualdad después de hacer cualquier tipo de conversiones. El === operador no hacer la conversión, así que si los dos valores no son el mismo tipo de === simplemente volver false. Ambos son igual de rápido.

    Citar Douglas Crockford excelente JavaScript: Las Partes Buenas,

    JavaScript dispone de dos conjuntos de operadores de igualdad: === y !==, y sus gemelos malvados == y !=. El buen trabajo de la manera que usted espera. Si los dos operandos son del mismo tipo y tienen el mismo valor, entonces === produce true y !== produce false. Los gemelos malvados hacer lo correcto cuando los operandos son del mismo tipo, pero si son de diferentes tipos, en su intento de coaccionar a los valores. las reglas por las que lo hacen, que son complicadas y poco memorable. Estos son algunos de los casos interesantes:

    '' == '0'           //false
    0 == ''             //true
    0 == '0'            //true
    
    false == 'false'    //false
    false == '0'        //true
    
    false == undefined  //false
    false == null       //false
    null == undefined   //true
    
    ' \t\r\n ' == 0     //true

    La falta de transitividad es alarmante. Mi consejo es no utilizar nunca el mal de los gemelos. En su lugar, utilice siempre === y !==. Todas las comparaciones solo se muestra producir false con el === operador.


    Actualización:

    Un buen punto fue criado por @Casebash en los comentarios y en @Phillipe Laybaert del respuesta relativas a los tipos de referencia. Para los tipos de referencia == y === actuar de manera coherente con el uno al otro (excepto en un caso especial).

    var a = [1,2,3];
    var b = [1,2,3];
    
    var c = { x: 1, y: 2 };
    var d = { x: 1, y: 2 };
    
    var e = "text";
    var f = "te" + "xt";
    
    a == b            //false
    a === b           //false
    
    c == d            //false
    c === d           //false
    
    e == f            //true
    e === f           //true

    El caso especial es cuando comparamos un literal con un objeto que se evalúa en el mismo literal, debido a su toString o valueOf método. Por ejemplo, considere la posibilidad de la comparación de un literal de cadena, con una cadena de objetos creados por el String constructor.

    "abc" == new String("abc")    //true
    "abc" === new String("abc")   //false

    Aquí el == operador es la comprobación de los valores de los dos objetos y regresar true, pero la === es ver que ellos no son el mismo tipo y regresar false. Cuál es la correcta? Eso realmente depende de lo que usted está tratando de comparar. Mi consejo es eludir la pregunta por completo y simplemente no usar la String constructor para crear objetos string.

    Referencia

    http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

    === no es más rápido si los tipos son los mismos. Si los tipos no son lo mismo, === será más rápido porque no va a tratar de hacer la conversión.
    === nunca será más lento que el de ==. Ambos hacen la comprobación de tipos, por lo que === no hacer nada más en comparación con ==, pero el tipo de verificación puede permitir === para salir de la tarde cuando los tipos no son los mismos.
    La sustitución de todos los = = o!= con = = = o!== aumenta el tamaño del archivo js, tomará entonces más tiempo para cargar. 🙂
    «…las reglas por las que lo hacen, que son complicadas y inmemorables…» Ahora estas declaraciones hacen sentir tan segura cuando la programación…
    A veces, JavaScript tipo de sistema me hace querer huir gritando.

    OriginalEl autor Bill the Lizard

Dejar respuesta

Please enter your comment!
Please enter your name here