javascript - vacio - Detectar una propiedad de objeto indefinido

undefined javascript error (30)

¿Cuál es la mejor manera de verificar si una propiedad de objeto en JavaScript no está definida?

'' if (window.x) {} '' es seguro contra errores

Lo más probable es que desee if (window.x) . Esta comprobación es segura incluso si no se ha declarado var x; ( var x; ): el navegador no arroja un error.

Ejemplo: quiero saber si mi navegador es compatible con la API de historial

if (window.history) { history.call_some_function(); }

Cómo funciona esto:

window es un objeto que contiene todas las variables globales como miembros, y es legal intentar acceder a un miembro que no existe. Si x no se ha declarado o no se ha establecido, window.x devuelve undefined . indefinido lleva a falso cuando if () lo evalúa.

¿Qué significa esto: "propiedad de objeto indefinido" ?

En realidad, puede significar dos cosas muy diferentes! Primero, puede significar la propiedad que nunca se ha definido en el objeto y, segundo, puede significar la propiedad que tiene un valor indefinido . Veamos este código:

var o = { a: undefined }

¿Está o no definido? ¡Sí! Su valor es indefinido. Es ob indefinido? ¡Por supuesto! No hay ninguna propiedad ''b'' en absoluto! Bien, vea ahora cómo se comportan los diferentes enfoques en ambas situaciones:

typeof o.a == ''undefined'' // true typeof o.b == ''undefined'' // true o.a === undefined // true o.b === undefined // true ''a'' in o // true ''b'' in o // false

Podemos ver claramente que typeof obj.prop == ''undefined'' y obj.prop === undefined son equivalentes, y no distinguen esas diferentes situaciones. Y ''prop'' in obj puede detectar la situación cuando una propiedad no se ha definido en absoluto y no presta atención al valor de la propiedad que puede no estar definido.

¿Entonces lo que hay que hacer?

1) Desea saber si una propiedad no está definida por el primer o segundo significado (la situación más típica).

obj.prop === undefined // IMHO, see "final fight" below

2) Usted solo quiere saber si el objeto tiene alguna propiedad y no le importa su valor.

''prop'' in obj

Notas:

No puedes verificar un objeto y su propiedad al mismo tiempo. Por ejemplo, este xa === undefined o este tipo de typeof xa == ''undefined'' eleva ReferenceError: x is not defined si x no está definido.
Variable undefined es una variable global (por lo que en realidad es window.undefined en los navegadores). Se ha admitido desde ECMAScript 1st Edition y desde ECMAScript 5 es de solo lectura . Por lo tanto, en los navegadores modernos no se puede redefinir a verdad, ya que a muchos autores les encanta asustarnos, pero esto sigue siendo cierto para los navegadores más antiguos.

Lucha final: `obj.prop === undefined` vs `typeof obj.prop == ''undefined''`

Ventajas de obj.prop === undefined :

Es un poco más corto y se ve un poco más bonito.
El motor de JavaScript le dará un error si ha escrito incorrectamente undefined

Desventajas de obj.prop === undefined :

undefined se puede anular en navegadores antiguos

Ventajas de typeof obj.prop == ''undefined'' :

¡Es realmente universal! Funciona en navegadores nuevos y antiguos.

Desventajas de typeof obj.prop == ''undefined'' :

''undefned'' ( mal escrito ) aquí es solo una constante de cadena, por lo que el motor de JavaScript no puede ayudarlo si lo ha escrito incorrectamente como lo hice yo.

Actualización (para JavaScript del lado del servidor):

Node.js admite la variable global undefined como global.undefined (también se puede usar sin el prefijo ''global''). No sé sobre otras implementaciones de JavaScript del lado del servidor.

A pesar de ser recomendado vehementemente por muchas otras respuestas aquí, typeof es una mala elección . Nunca debe usarse para verificar si las variables tienen el valor undefined , ya que actúa como una verificación combinada del valor undefined y si existe una variable. En la gran mayoría de los casos, usted sabe cuándo existe una variable, y typeof solo presentará el potencial de una falla silenciosa si comete un error tipográfico en el nombre de la variable o en el literal de cadena ''undefined'' .

var snapshot = …; if (typeof snaposhot === ''undefined'') { // ^ // misspelled¹ – this will never run, but it won’t throw an error! }

var foo = …; if (typeof foo === ''undefned'') { // ^ // misspelled – this will never run, but it won’t throw an error! }

Por lo tanto, a menos que esté haciendo detección de características², donde no está claro si un nombre dado estará dentro del alcance (como revisar el tipo de typeof module !== ''undefined'' como un paso en el código específico de un entorno CommonJS), typeof es una opción dañina cuando se usa en una variable, y la opción correcta es comparar el valor directamente:

var foo = …; if (foo === undefined) { ⋮ }

Algunos conceptos erróneos comunes sobre esto incluyen:

la lectura de una variable "no inicializada" ( var foo ) o un parámetro ( function bar(foo) { … } , llamada como bar() ) fallará. Esto simplemente no es cierto: las variables sin inicialización explícita y los parámetros a los que no se dieron valores siempre se vuelven undefined y siempre están dentro del alcance.
que undefined se puede sobrescribir. Hay mucho más para esto. undefined no es una palabra clave en JavaScript. En su lugar, es una propiedad en el objeto global con el valor no definido. Sin embargo, desde ES5, esta propiedad ha sido de solo lectura y no configurable . Ningún navegador moderno permitirá cambiar la propiedad undefined , y desde 2017 este ha sido el caso durante mucho tiempo. La falta de modo estricto tampoco afecta el comportamiento de undefined , solo hace que las declaraciones como undefined = 5 no hagan nada en lugar de lanzar. Sin embargo, como no es una palabra clave, puede declarar variables con el nombre undefined , y esas variables podrían cambiarse, haciendo este patrón una vez común:
(function (undefined) { // … })()
Más peligroso que usar el global undefined . Si tiene que ser compatible con ES3, reemplace undefined con void 0 , no recurra a typeof . ( void siempre ha sido un operador unario que se evalúa al valor indefinido de cualquier operando).

Con la forma en que las variables funcionan, es hora de abordar la pregunta real: las propiedades del objeto. No hay razón para usar typeof para las propiedades de los objetos. La excepción anterior con respecto a la detección de características no se aplica aquí: typeof solo tiene un comportamiento especial en las variables, y las expresiones que hacen referencia a las propiedades de los objetos no son variables.

Esta:

if (typeof foo.bar === ''undefined'') { ⋮ }

Siempre es exactamente equivalente a esto³:

if (foo.bar === undefined) { ⋮ }

y teniendo en cuenta los consejos anteriores, para evitar confundir a los lectores acerca de por qué está usando typeof , porque tiene más sentido usar === para verificar la igualdad, ya que podría ser refactorizado para verificar el valor de una variable más adelante, y porque simplemente se ve mejor, siempre debe usar === undefined ³ aquí también .

Otra cosa a considerar cuando se trata de las propiedades del objeto es si realmente desea verificar si no está undefined . Un nombre de propiedad dado puede estar ausente en un objeto (que produce el valor undefined cuando se lee), presente en el propio objeto con el valor undefined , presente en el prototipo del objeto con el valor undefined , o presente en cualquiera de los que tienen un no undefined valor. ''key'' in obj le dirá si una clave está en algún lugar de la cadena de prototipo de un objeto, y Object.prototype.hasOwnProperty.call(obj, ''key'') le dirá si está directamente en el objeto. Sin embargo, no voy a entrar en detalles en esta respuesta sobre los prototipos y el uso de objetos como mapas con cadenas de caracteres, ya que su objetivo principal es contrarrestar todos los consejos erróneos en otras respuestas, independientemente de las posibles interpretaciones de la pregunta original. ¡Lea sobre los prototipos de objetos en MDN para más!

_{Choice elección inusual de ejemplo nombre de variable?} _{Este es un código muerto real de la extensión NoScript para Firefox.}
_{² no asumas que no saber lo que está en el alcance está bien en general, sin embargo.} _{Vulnerabilidad adicional causada por el abuso de alcance dinámico: Proyecto Cero 1225}
_{³ una vez más, asumiendo un entorno ES5 + y que undefined refiere a la propiedad undefined del objeto global.} _{sustituye void 0 caso contrario.}

Al leer esto, me sorprende que no haya visto esto. He encontrado múltiples algoritmos que funcionarían para esto.

Nunca definido

Si el valor de un objeto nunca se definió, esto evitará que se devuelva true si se define como null o undefined . Esto es útil si desea que se devuelva true para los valores establecidos como undefined

if(obj.prop === void 0) console.log("The value has never been defined");

Definido como no definido o nunca definido

Si quiere que sea true para los valores definidos con el valor de undefined , o nunca definido, simplemente puede usar === undefined

if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");

Definido como un valor falso, no definido, nulo o nunca definido.

En general, las personas me han pedido un algoritmo para averiguar si un valor es falsy, undefined o null . Los siguientes trabajos.

if(obj.prop == false || obj.prop === null || obj.prop === undefined) { console.log("The value is falsy, null, or undefined"); }

Creo que hay una serie de respuestas incorrectas a este tema. Contrariamente a la creencia común, "indefinido" no es una palabra clave en JavaScript y, de hecho, puede tener un valor asignado.

Código correcto

La forma más robusta de realizar esta prueba es:

if (typeof myVar === "undefined")

Esto siempre devolverá el resultado correcto e incluso maneja la situación en la que myVar no está declarada.

Código degenerado. NO UTILICE.

var undefined = false; // Shockingly, this is completely legal! if (myVar === undefined) { alert("You have been misled. Run away!"); }

Además, myVar === undefined generará un error en la situación en la que myVar no está declarado.

Crossposting mi answer de la pregunta relacionada ¿ Cómo buscar "indefinido" en JavaScript?

Específico para esta pregunta, vea los casos de prueba con someObject.<whatever> .

Algunos escenarios que ilustran los resultados de las distintas respuestas: http://jsfiddle.net/drzaus/UVjM4/

(Tenga en cuenta que el uso de var para in pruebas hace una diferencia cuando se encuentra en una envoltura con alcance)

Código de referencia:

Y resultados:

definedButNotInitialized in window: true definedAndInitialized in window: false someObject.firstProp in window: false someObject.secondProp in window: false someObject.undefinedProp in window: true notDefined in window: Exception--ReferenceError: notDefined is not defined "definedButNotInitialized" in window: false "definedAndInitialized" in window: true "someObject.firstProp" in window: false "someObject.secondProp" in window: false "someObject.undefinedProp" in window: false "notDefined" in window: false typeof definedButNotInitialized == "undefined": true typeof definedButNotInitialized === typeof undefined: true definedButNotInitialized === undefined: true ! definedButNotInitialized: true !! definedButNotInitialized: false typeof definedAndInitialized == "undefined": false typeof definedAndInitialized === typeof undefined: false definedAndInitialized === undefined: false ! definedAndInitialized: false !! definedAndInitialized: true typeof someObject.firstProp == "undefined": false typeof someObject.firstProp === typeof undefined: false someObject.firstProp === undefined: false ! someObject.firstProp: false !! someObject.firstProp: true typeof someObject.secondProp == "undefined": false typeof someObject.secondProp === typeof undefined: false someObject.secondProp === undefined: false ! someObject.secondProp: true !! someObject.secondProp: false typeof someObject.undefinedProp == "undefined": true typeof someObject.undefinedProp === typeof undefined: true someObject.undefinedProp === undefined: true ! someObject.undefinedProp: true !! someObject.undefinedProp: false typeof notDefined == "undefined": true typeof notDefined === typeof undefined: true notDefined === undefined: Exception--ReferenceError: notDefined is not defined ! notDefined: Exception--ReferenceError: notDefined is not defined !! notDefined: Exception--ReferenceError: notDefined is not defined

El tema se reduce a tres casos:

El objeto tiene la propiedad y su valor no está undefined .
El objeto tiene la propiedad y su valor undefined está undefined .
El objeto no tiene la propiedad.

Esto nos dice algo que considero importante:

Hay una diferencia entre un miembro no definido y un miembro definido con un valor no definido.

Pero, desgraciadamente, typeof obj.foo no nos dice cuál de los tres casos tenemos. Sin embargo, podemos combinar esto con "foo" in obj para distinguir los casos.

| typeof obj.x === ''undefined'' | !("x" in obj) 1. { x:1 } | false | false 2. { x : (function(){})() } | true | false 3. {} | true | true

Vale la pena señalar que estas pruebas son las mismas para null entradas null también

| typeof obj.x === ''undefined'' | !("x" in obj) { x:null } | false | false

Yo diría que en algunos casos tiene más sentido (y es más claro) verificar si la propiedad está allí, que verificar si está indefinida, y el único caso en que esta verificación será diferente es el caso 2, el caso poco frecuente de una entrada real en el objeto con un valor indefinido.

Por ejemplo: acabo de refactorizar un montón de código que tenía un montón de controles si un objeto tenía una propiedad determinada.

if( typeof blob.x != ''undefined'' ) { fn(blob.x); }

Lo que fue más claro cuando se escribió sin un cheque para indefinido.

if( "x" in blob ) { fn(blob.x); }

Pero como se ha mencionado, estos no son exactamente iguales (pero son más que lo suficientemente buenos para mis necesidades).

En JavaScript hay nulo y hay indefinido . Tienen diferentes significados.

indefinido significa que el valor de la variable no se ha definido; No se sabe cuál es el valor.
nulo significa que el valor de la variable está definido y establecido en nulo (no tiene valor).

Marijn Haverbeke afirma, en su libro gratuito en línea " Eloquent JavaScript " (el énfasis es mío):

También hay un valor similar, nulo, cuyo significado es "este valor está definido, pero no tiene un valor". La diferencia de significado entre indefinido y nulo es principalmente académica, y generalmente no es muy interesante. En los programas prácticos, a menudo es necesario verificar si algo ''tiene un valor''. En estos casos, la expresión algo == indefinido puede usarse, porque, aunque no sean exactamente el mismo valor, nulo == indefinido producirá verdadero.

Entonces, supongo que la mejor manera de verificar si algo no estaba definido sería:

if (something == undefined)

¡Espero que esto ayude!

Edición: en respuesta a su edición, las propiedades del objeto deberían funcionar de la misma manera.

var person = { name: "John", age: 28, sex: "male" }; alert(person.name); // "John" alert(person.fakeVariable); // undefined

En el artículo Exploring the Abyss of Null and Undefined in JavaScript , leí que los marcos como Underscore.js usan esta función:

function isUndefined(obj){ return obj === void 0; }

No estoy seguro de dónde proviene el origen de usar === con typeof , y como una convención veo que se usa en muchas bibliotecas, pero el operador typeof devuelve una cadena literal, y lo sabemos desde el principio, ¿por qué lo haría? También quiere escribir comprobar también?

typeof x; // some string literal "string", "object", "undefined" if (typeof x === "string") { // === is redundant because we already know typeof returns a string literal if (typeof x == "string") { // sufficient

No vi (espero que no me lo perdiera) a nadie revisando el objeto antes de la propiedad. Entonces, este es el más corto y efectivo (aunque no necesariamente el más claro):

if (obj && obj.prop) { // Do something; }

Si el obj o el obj.prop es indefinido, nulo o "falsy", la instrucción if no ejecutará el bloque de código. Este suele ser el comportamiento deseado en la mayoría de las declaraciones de bloque de código (en JavaScript).

Si lo haces

if (myvar == undefined ) { alert(''var does not exists or is not initialized''); }

fallará cuando la variable myvar no exista, porque myvar no está definida, por lo que el script está roto y la prueba no tiene efecto.

Debido a que el objeto de la ventana tiene un alcance global (objeto predeterminado) fuera de una función, se ''adjuntará'' una declaración al objeto de la ventana.

Por ejemplo:

var myvar = ''test'';

La variable global myvar es la misma que window.myvar o window [''myvar'']

Para evitar errores para probar cuando existe una variable global, mejor use:

if(window.myvar == undefined ) { alert(''var does not exists or is not initialized''); }

La cuestión de si realmente existe una variable no importa, su valor es incorrecto. De lo contrario, es tonto inicializar variables con indefinido, y es mejor usar el valor falso para inicializar. Cuando sepa que todas las variables que declara se inicializan con falso, simplemente puede verificar su tipo o confiar en !window.myvar para verificar si tiene un valor adecuado / válido. Entonces, incluso cuando la variable no está definida, entonces !window.myvar es la misma para myvar = undefined o myvar = false o myvar = 0 .

Cuando espere un tipo específico, pruebe el tipo de la variable. Para acelerar la prueba de una condición que es mejor hacer:

if( !window.myvar || typeof window.myvar != ''string'' ) { alert(''var does not exists or is not type of string''); }

Cuando la primera y simple condición es verdadera, el intérprete omite las siguientes pruebas.

Siempre es mejor usar la instancia / objeto de la variable para verificar si obtuvo un valor válido. Es más estable y es una mejor manera de programar.

(y)

Utilizar:

Para comprobar si la propiedad no está definida:

if (typeof something === "undefined") { alert("undefined"); }

Para comprobar si la propiedad no está indefinida:

if (typeof something !== "undefined") { alert("not undefined"); }

Utilizar:

if (typeof something === "undefined") { alert("something is undefined"); }

Si una variable de objeto que tiene algunas propiedades puede usar lo mismo como esto:

if (typeof my_obj.someproperties === "undefined"){ console.log(''the property is not available...''); // print into console }

Aquí está mi situación:

Estoy usando el resultado de una llamada REST. El resultado debe analizarse desde JSON a un objeto JavaScript.

Hay un error que necesito defender. Si los argumentos para la llamada de reposo eran incorrectos en la medida en que el usuario especificó los argumentos incorrectos, la llamada de reposo regresará básicamente vacía.

Mientras utilizaba esta publicación para ayudarme a defenderme de esto, intenté esto.

if( typeof restResult.data[0] === "undefined" ) { throw "Some error"; }

Para mi situación, si restResult.data [0] === "objeto", entonces puedo comenzar a inspeccionar de manera segura al resto de los miembros. Si no está definido, arroje el error como se indica arriba.

Lo que estoy diciendo es que para mi situación, todas las sugerencias anteriores en esta publicación no funcionaron. No estoy diciendo que tengo razón y que todos están equivocados. No soy un maestro de JavaScript, pero espero que esto ayude a alguien.

Hay una forma agradable y elegante de asignar una propiedad definida a una nueva variable si está definida o asignarle un valor predeterminado como una alternativa si no está definida.

var a = obj.prop || defaultValue;

Es adecuado si tiene una función, que recibe una propiedad de configuración adicional:

var yourFunction = function(config){ this.config = config || {}; this.yourConfigValue = config.yourConfigValue || 1; console.log(this.yourConfigValue); }

Ahora ejecutando

yourFunction({yourConfigValue:2}); //=> 2 yourFunction(); //=> 1 yourFunction({otherProperty:5}); //=> 1

La solución es incorrecta. En JavaScript,

null == undefined

devolverá verdadero, porque ambos están "emitidos" a un valor booleano y son falsos. La forma correcta sería comprobar

if (something === undefined)

cual es el operador de identidad ...

Puede obtener una matriz sin definir con ruta utilizando el siguiente código.

jsFiddle link

Revisando los comentarios, para aquellos que quieran verificar ambos, no está definido o su valor es nulo:

//Just in JavaScript var s; // Undefined if (typeof s == "undefined" || s === null){ alert(''either it is undefined or value is null'') }

Si está utilizando jQuery Library, entonces jQuery.isEmptyObject()será suficiente para ambos casos,

var s; // Undefined jQuery.isEmptyObject(s); // Will return true; s = null; // Defined as null jQuery.isEmptyObject(s); // Will return true; //Usage if (jQuery.isEmptyObject(s)) { alert(''Either variable:s is undefined or its value is null''); } else { alert(''variable:s has value '' + s); } s = ''something''; // Defined with some value jQuery.isEmptyObject(s); // Will return false;

Si está utilizando Angular:

angular.isUndefined(obj) angular.isUndefined(obj.prop)

Underscore.js:

_.isUndefined(obj) _.isUndefined(obj.prop)

También las mismas cosas se pueden escribir más corto:

if (!variable){ //do it if variable is Undefined }

if (variable){ //do it if variable is Defined }

Comparar con void 0, para la terseness.

if (foo !== void 0)

No es tan detallado como if (typeof foo !== ''undefined'')

Me gustaría mostrarle algo que estoy usando para proteger la undefinedvariable:

Object.defineProperty(window, ''undefined'', {});

Esto prohíbe que alguien cambie el window.undefinedvalor, por lo tanto destruye el código basado en esa variable. Si se usa "use strict", cualquier cosa que intente cambiar su valor terminará en un error, de lo contrario se ignorará silenciosamente.

Me sorprende que no haya visto esta sugerencia todavía, pero se vuelve aún más específica que con las pruebas typeof. Úselo Object.getOwnPropertyDescriptor()si necesita saber si una propiedad de objeto se inicializó con undefinedo si nunca se inicializó:

// to test someObject.someProperty var descriptor = Object.getOwnPropertyDescriptor(someObject, ''someProperty''); if (typeof descriptor === ''undefined'') { // was never initialized } else if (typeof descriptor.value === ''undefined'') { if (descriptor.get || descriptor.set) { // is an accessor property, defined via getter and setter } else { // is initialized with `undefined` } } else { // is initialized with some other value }

Simplemente cualquier cosa no está definida en JavaScript, está indefinida , no importa si es una propiedad dentro de un Objeto / Array o simplemente como una simple variable ...

JavaScript tiene lo typeofque hace que sea muy fácil detectar una variable no definida.

Simplemente comprueba si typeof whatever === ''undefined''y te devolverá un booleano.

Así es como isUndefined()se escribe la función famosa en AngularJs v.1x:

function isUndefined(value) {return typeof value === ''undefined'';}

Entonces, a medida que vea que la función recibe un valor, si ese valor está definido, retornará false, de lo contrario, para valores no definidos, retornará true.

Así que echemos un vistazo a los resultados que obtendremos cuando pasemos valores, incluidas las propiedades de los objetos como a continuación, esta es la lista de variables que tenemos:

var = {}; .javascipt = ''javascript''; var today; var self = this; var num = 8; var list = [1, 2, 3, 4, 5]; var y = null;

y los verificamos a continuación, puedes ver los resultados delante de ellos como un comentario:

isUndefined(); //false isUndefined(.javascipt); //false isUndefined(today); //true isUndefined(self); //false isUndefined(num); //false isUndefined(list); //false isUndefined(y); //false isUndefined(.java); //true isUndefined(.php); //true isUndefined( && .css); //true

Como puede ver, podemos verificar cualquier cosa con el uso de algo así en nuestro código, como se mencionó, simplemente puede usar typeof en su código, pero si lo está utilizando una y otra vez, cree una función como la muestra angular que comparto y continúe reutilizando como el siguiente patrón de código DRY.

También una cosa más, para verificar la propiedad de un objeto en una aplicación real que no está seguro de que el objeto exista o no, verifique si el objeto existe primero.

Si verifica una propiedad en un objeto y el objeto no existe, generará un error y detendrá la ejecución de toda la aplicación.

isUndefined(x.css); VM808:2 Uncaught ReferenceError: x is not defined(…)

Tan simple que puedes envolver dentro de una declaración if como a continuación:

if(typeof x !== ''undefined'') { //do something }

Que también es igual a isDefined en Angular 1.x ...

function isDefined(value) {return typeof value !== ''undefined'';}

Además, otros marcos de javascript como el guión bajo tienen una comprobación de definición similar, pero te recomiendo que uses typeofsi ya no usas ningún marco.

También agrego esta sección de MDN que tiene información útil sobre typeof, undefined y void (0).

Igualdad estricta e indefinida
Puede usar los operadores no definidos y de igualdad estricta y desigualdad para determinar si una variable tiene un valor. En el siguiente código, la variable x no está definida y la sentencia if se evalúa como verdadera.

var x; if (x === undefined) { // these statements execute } else { // these statements do not execute }

Nota: el operador de igualdad estricta en lugar del operador de igualdad estándar debe usarse aquí, porque x == indefinido también verifica si x es nulo, mientras que la igualdad estricta no lo hace. null no es equivalente a undefined. Ver operadores de comparación para más detalles.

Typeof operator y undefined.
Alternativamente, typeof puede ser usado:

var x; if (typeof x === ''undefined'') { // these statements execute }

Una razón para usar typeof es que no arroja un error si la variable no ha sido declarada.

// x has not been declared before if (typeof x === ''undefined'') { // evaluates to true without errors // these statements execute } if (x === undefined) { // throws a ReferenceError }

Sin embargo, este tipo de técnica debe evitarse. JavaScript es un lenguaje de ámbito estático, por lo que saber si una variable está declarada se puede leer al ver si está declarada en un contexto adjunto. La única excepción es el alcance global, pero el alcance global está vinculado al objeto global, por lo que se puede verificar la existencia de una variable en el contexto global al verificar la existencia de una propiedad en el objeto global (usando el operador in, por ejemplo).

Operador nulo e indefinido
El operador del vacío es una tercera alternativa.

var x; if (x === void 0) { // these statements execute } // y has not been declared before if (y === void 0) { // throws a ReferenceError (in contrast to `typeof`) }

más> here

Todas las respuestas están incompletas. Esta es la forma correcta de saber que hay una propiedad ''definida como no definida'':

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){ return ((prop in obj) && (typeof obj[prop] == ''undefined'')) ; } ;

Ejemplo:

var a = { b : 1, e : null } ; a.c = a.d ; hasUndefinedProperty(a, ''b'') ; // false : b is defined as 1 hasUndefinedProperty(a, ''c'') ; // true : c is defined as undefined hasUndefinedProperty(a, ''d'') ; // false : d is undefined hasUndefinedProperty(a, ''e'') ; // false : e is defined as null // And now... delete a.c ; hasUndefinedProperty(a, ''c'') ; // false : c is undefined

Lástima que esta respuesta correcta haya sido enterrada en respuestas incorrectas> _ <

Entonces, para cualquier persona que pase, te daré undefineds gratis !!

var undefined ; undefined ; // undefined ({}).a ; // undefined [].a ; // undefined ''''.a ; // undefined (function(){}()) ; // undefined void(0) ; // undefined eval() ; // undefined 1..a ; // undefined /a/.a ; // undefined (true).a ; // undefined

Yo uso if (this.variable)para probar si está definido. Simple if (variable), recomendado arriba , falla por mi. Resulta que funciona solo cuando la variable es un campo de algún objeto, obj.someFieldpara verificar si está definido en el diccionario. Pero podemos usar thiso windowcomo objeto de diccionario, ya que cualquier variable es un campo en la ventana actual, tal como lo entiendo. Por lo tanto aquí hay una prueba.

if (this.abc) alert("defined"); else alert("undefined"); abc = "abc"; if (this.abc) alert("defined"); else alert("undefined");

Primero detecta que la variable abcno está definida y se define después de la inicialización.

"propertyName" in obj //-> true | false

function isUnset(inp) { return (typeof inp === ''undefined'') }

Devuelve falso si la variable está establecida, y verdadero si no está definido.

Luego use:

if (isUnset(var)) { // initialize variable here }

if ( typeof( something ) == "undefined")

Esto funcionó para mí mientras que los otros no lo hicieron.