Para las variables no declaradas, typeof foo devolverá el literal de cadena "undefined" , mientras que la verificación de identidad foo === undefined desencadenaría el error "foo no está definido" .

Para las variables locales (que sabe que están declaradas en alguna parte), no ocurriría tal error, de ahí la verificación de identidad.

Me limitaría a usar typeof foo === "undefined" en todas partes. Eso nunca puede salir mal.

Me imagino que la razón por la que jQuery recomienda los dos métodos diferentes es que definen su propia variable undefined dentro de la función en la que vive el código jQuery, por lo que dentro de esa función undefined está a salvo de manipulaciones desde el exterior. También me imagino que alguien en algún lugar ha evaluado los dos enfoques diferentes y descubrió que foo === undefined es más rápido y, por lo tanto, decidió que es el camino a seguir. [ACTUALIZACIÓN: como se señaló en los comentarios, la comparación con undefined también es un poco más corta, lo que podría ser una consideración.] Sin embargo, la ganancia en situaciones prácticas será completamente insignificante: esta verificación nunca será ningún tipo de cuello de botella, y lo que pierde es significativo: evaluar una propiedad de un objeto host para comparar puede arrojar un error, mientras que un typeof de verificación nunca lo hará.

Por ejemplo, lo siguiente se usa en IE para analizar XML:

 var x = new ActiveXObject("Microsoft.XMLDOM");

Para verificar si tiene un método loadXML de forma segura:

 typeof x.loadXML === "undefined"; // Returns false

Por otro lado:

 x.loadXML === undefined; // Throws an error

ACTUALIZAR

Otra ventaja de la comprobación typeof que olvidé mencionar es que también funciona con variables no declaradas, lo que no ocurre con la comprobación foo === undefined y, de hecho, arroja un ReferenceError . Gracias a @LinusKleen por recordármelo. Por ejemplo:

 typeof someUndeclaredVariable; // "undefined" someUndeclaredVariable === undefined; // throws a ReferenceError

En pocas palabras: utilice siempre el typeof de cheque.

Otra razón más para usar typeof-variant: undefined se puede redefinir.

 undefined = "foo"; var variable = "foo"; if (variable === undefined) console.log("eh, what?!");

El resultado de typeof variable no puede.

Actualización : tenga en cuenta que este no es el caso en ES5, donde el undefined global es una propiedad no configurable y no escribible:

15.1.1 Propiedades de valor del objeto global
[...]
15.1.1.3 indefinido
El valor de undefined es indefinido (ver 8.1). Esta propiedad tiene los atributos
{ [[Escribible]]: falso, [[Enumerable]]: falso, [[Configurable]]: falso }.

Pero aún puede ser sombreado por una variable local:

 (function() { var undefined = "foo"; var variable = "foo"; if (variable === undefined) console.log("eh, what?!"); })()

o parámetro:

 (function(undefined) { var variable = "foo"; if (variable === undefined) console.log("eh, what?!"); })("foo")