typeof explícito == "undefined" check vs simplemente comprobando su existencia?

Question

suponiendo que x es un objeto ... ¿Hay alguna ventaja de hacer:

if (typeof x.foo != "undefined") 

hacer frente a

if (x.foo) 

?

Esta pregunta surgió cuando estaba leyendo esta entrada del blog: http://www.nczonline.net/blog/2010/03/09/custom-events-in-javascript/

En su ejemplo, lo hace:

function EventTarget(){ 
    this._listeners = {}; 
} 

EventTarget.prototype = { 

    constructor: EventTarget, 

    addListener: function(type, listener){ 
    if (typeof this._listeners[type] == "undefined"){ 
     this._listeners[type] = []; 
    } 

    this._listeners[type].push(listener); 

En este caso this._listeners [tipo] nunca serán nada excepto una matriz-- entonces ¿no es verdad que sería más limpio en este caso simplemente hacer

addListener: function(type, listener){ 
    if (!this._listeners[type]){ 
     this._listeners[type] = []; 
    } 

    this._listeners[type].push(listener); 

?

También, como una cuestión lado, no entiendo por qué está haciendo:

EventTarget.prototype = { 

    constructor: EventTarget 

no es el constructor por defecto ya está ajustada en EventTarget ('esto') cuando se llama a nueva EventTarget() ?

Answer 1

Tenga cuidado con truthy values.

if (x.foo) no se ejecutará si es x.foo

• falsa
• nula
• indefinido
• ""
• NaN

Donde como if (typeof x.foo !== "undefined") { sólo comprueba si el valor es undefined

cheques alternativa sería

if (x.foo !== undefined) { y if (x.foo !== void 0) {

Haz tener cuidado de que undefined se pueden sobrescribir como una variable local

undefined = true es una declaración válida y romperá todo tu código. Por supuesto, nunca verá este código en producción, por lo que no tendrá que protegerse contra él, es algo de lo que debe desconfiar.

personalmente tienden a usar

if (x.foo != null) { 
    ... 
} 

mucho que comprueba tanto null y undefined.

[[Editar]]

En el ejemplo específico es o bien un Array o undefined por lo !foo es seguro. Personalmente, prefiero verificar específicamente el undefined para que los usuarios sepan que solo espero que se ejecute cuando no esté definido en lugar de cuando es null o false o "". Esto hace que el código sea más explícito/auto documentado.

En cuanto a

EventTarget.prototype = { 

    constructor: EventTarget 

Si sobrescribe EventTarget.prototype con un nuevo objeto entonces la propiedad EventTarget.prototype.constructor se pierde y necesita ser ajustado de nuevo.

No necesita configurar .constructor nuevamente si solo extiende el prototipo llamando al EventTarget.prototype.method = ....

Answer 2

La primera comprueba explícitamente que x.foo es undefined, mientras que if (x.foo) está comprobando si x.foo es verdad.

http://11heavens.com/falsy-and-truthy-in-javascript