¿Por qué es una mala idea permitir esto en JavaScript ==,! =, ++, -

Question

Estaba revisando JSLint, y algunas de las reglas despertaron mi interés. Particularmente esto:

No permitir == y =

No permitir ++ y -

¿Por qué es una mala idea para no permitir estos!? Entiendo la primera parte, básicamente quiere que haga === en lugar de ==. No entiendo por qué embargo. Entiendo la diferencia entre los dos, solo quiero saber por qué es una mala práctica. Algunas veces realmente quiero hacer == por ejemplo para que se evalúe verdadero para undefined == null

El segundo, bueno, no entiendo en absoluto. ¿Quiere que haga myInt + = 1 en lugar de myInt ++?

Gracias!

Answer 1

Douglas Crockford (el tipo que escribió JSLint) explica a sí mismo en este video:

http://www.youtube.com/watch?v=hQVTIJBZook#t=14m45s

pero en el fondo (como todos los demás han mencionado) que es debido a la coercian tipo.

Merece la pena ver quién es honesto, muy interesante y útil.

Answer 2

Doug Crockford tiene sus propias ideas sobre lo que es "bueno" y "malo" en Javascript. En consecuencia, JSLint implementa estos controles, pero los hace opcionales si no está completamente de acuerdo con él.

No permitir == le ayuda a evitar que cometa errores cuando realmente quiso decir ===. Por supuesto, esto supone que en realidad nunca desea utilizar ==.

No permitir ++ y -- es una cosa de estilo, algunas personas creen que son difíciles de leer que += 1 y -= 1.

Answer 3

El comportamiento de los operadores de igualdad estándar (== y! =) Depende de la versión de JavaScript. Esa es una razón para no usarlos.

Otra razón es que el comportamiento de la = tiende a ser muy vago.

Ver https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Operators/Comparison_Operators

Answer 4

Desde el instructions:

El == y = operadores lo escriba antes de comparar la coacción. Esto es malo porque hace que '\ t \ r \ n' == 0 sea verdadero. Esto puede enmascarar errores de tipo.

y

La ++ (incremento) y - (decremento) Los operadores han sido conocidos por contribuir al mal código mediante el fomento de astucia excesiva. Solo superan a la arquitectura defectuosa al permitir virus y otras amenazas de seguridad. Existe una opción plusplus que prohíbe el uso de estos operadores.

Answer 5

No estoy de acuerdo demasiado con esas reglas, en lugar de desalentar el uso de ==, recomendaría a aprender sobre el tipo de coacción.

La razón principal de por qué Crockford quiere evitar == es que las reglas de comparación en función de los tipos de los operandos pueden hacer que este operador no transitiva, por ejemplo, si:

A == B AND 
B == C 

Doesn' t garantiza que:

A == C 

Un ejemplo real:

'0' == 0; // true 
0 == ''; // true 
'0' == ''; // false 

La estricta === operador no es realmente necesario cuando se comparan los valores del mismo tipo, por ejemplo:

if (typeof foo == "function") { } 

Se compara el resultado del operador typeof, que es siempre una cadena, con una cadena literal ...

Otro ejemplo, cuando se compara algo en contra de null, == compara también contra undefined, por ejemplo:

if (something == null) {} 

VS

if (something === null || typeof something === "undefined") {} 

Las dos condiciones anteriores son equivalentes en el final, pero el primero mucho más legible, por supuesto, si usted sabe sobre el tipo de coacción y cómo se comporta ==.

Conocer cómo funciona el operador ==, lo ayudará a decidir qué usar.

artículos recomendados:

• ECMAScript. Equality operators (Grandes consejos para recordar cómo == obras)
• typeof, == and ===

Answer 6

entiendo ==. (Lo undefined == null es una excepción)

("0" == false) === true 
("0" === false) === false 

nunca he entendido lo ++ y -- sin embargo. No me gusta hacer i+=1 en todo mi código (es más lento que ++i).

Answer 7

Los operadores == y != hacen la conversión implícita de los operadores si es necesario, mientras que los operadores === y !== no lo hacen. La expresión 4 == '4' por ejemplo será verdadera, mientras que la expresión 4 === '4' será falsa.

Preferiblemente, debe conocer los tipos de datos con los que está tratando para poder hacer las comparaciones adecuadas en el código.

El ++ y -- operadores no causa ningún problema si se usan solos en un comunicado, pero a menudo se utilizan para hacer una declaración que hace más de una cosa de una manera no tan obvio, como:

arr[++idx] = 42; 

que sería más clara como:

idx += 1; 
arr[idx] = 42;