Detectar una propiedad de objeto indefinida

https://stackoverflow.com/questions/27509

09-06-2019
|

Pregunta

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

Solución

Usar:

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

Si una variable de objeto 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
}

Otros consejos

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

Código correcto

La forma más sólida 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á declarado.

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.

A pesar de ser recomendado con vehemencia por muchas otras respuestas aquí, typeof es una mala elección.Nunca debe utilizarse para comprobar si las variables tienen el valor undefined, porque actúa como una verificación combinada del valor undefined y si existe una variable.En la gran mayoría de los casos, sabes cuándo existe una variable y typeof solo introducirá la posibilidad 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!
}

Entonces, a menos que esté realizando una detección de funciones², donde existe incertidumbre sobre si un nombre determinado estará dentro del alcance (como verificar typeof module !== 'undefined' como un paso en el código específico de un entorno CommonJS), typeof es una elecció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:

que leer una variable “no inicializada” (var foo) o parámetro (function bar(foo) { … }, llamado bar()) fallará.Esto simplemente no es cierto: las variables sin inicialización explícita y los parámetros a los que no se les dieron valores siempre se vuelven undefined, y siempre están dentro del alcance.
eso undefined se puede sobrescribir.Hay mucho más en esto. undefined no es una palabra clave en JavaScript.En cambio, es una propiedad del objeto global con el valor Indefinido.Sin embargo, desde ES5, esta propiedad ha sido solo lectura y no configurable.Ningún navegador moderno permitirá la undefined La propiedad se cambiará y, a partir de 2017, este ha sido el caso durante mucho tiempo.La falta de modo estricto no afecta undefinedtampoco el comportamiento: simplemente hace declaraciones como undefined = 5 no hacer nada en lugar de tirar.Sin embargo, como no es una palabra clave, puedes declarar variables con el nombre undefined, y esas variables podrían cambiarse, creando este patrón que alguna vez fue 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 recurras a typeof. (void siempre ha sido un operador unario que evalúa el valor indefinido para cualquier operando).

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

Este:

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

es siempre exactamente equivalente a esto³:

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

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

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

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

En JavaScript hay nulo y ahí está indefinido.Tienen diferentes significados.

indefinido significa que el valor de la variable no ha sido 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 "JavaScript elocuente" (el énfasis es mío):

También existe un valor similar, nulo, cuyo significado es 'este valor está definido, pero no tiene valor'.La diferencia de significado entre indefinido y nulo es mayoritariamente académica y, por lo general, no es muy interesante. En los programas prácticos, a menudo es necesario comprobar si algo "tiene valor".En estos casos se puede utilizar la expresión algo == undefinido, porque, aunque no sean exactamente el mismo valor, null == undefinido producirá verdadero.

Entonces, supongo que la mejor manera de comprobar si algo no está definido sería:

if (something == undefined)

¡Espero que esto ayude!

Editar: 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

Qué quiere decir esto: "propiedad de objeto indefinido"?

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

var o = { a: undefined }

Es o.a ¿indefinido?¡Sí!Su valor no está definido.Es o.b ¿indefinido?¡Seguro!¡No existe ninguna propiedad 'b' en absoluto!Bien, veamos 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) Quiere 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) Solo desea saber si el objeto tiene alguna propiedad y no le importa su valor.

'prop' in obj

Notas:

No se puede comprobar un objeto y su propiedad al mismo tiempo.Por ejemplo, este x.a === undefined o esto typeof x.a == '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 navegadores).Ha sido compatible desde ECMAScript 1.ª edición y desde ECMAScript 5 es solo lectura.Entonces, en los navegadores modernos no puede ser redefinido a verdadero como 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 JavaScript te dará un error si has escrito mal 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 la ha escrito mal como acabo de hacer yo.

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

Node.js admite la variable global undefined como global.undefined (También se puede utilizar sin el prefijo 'global').No conozco otras implementaciones de JavaScript del lado del servidor.

La cuestión se reduce a tres casos:

El objeto tiene la propiedad y su valor no es undefined.
El objeto tiene la propiedad y su valor es undefined.
El objeto no tiene la propiedad.

Esto nos dice algo que considero importante:

Existe una diferencia entre un miembro indefinido y un miembro definido con un valor indefinido.

pero infelizmente 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 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á ahí que verificar si no está definida, y el único caso en el que esta verificación será diferente es el caso 2, el raro caso 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 varias comprobaciones para determinar si un objeto tenía una propiedad determinada.

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

Lo cual fue más claro cuando se escribió sin un cheque por indefinido.

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

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

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

Esto funcionó para mí mientras que los demás no.

No estoy seguro de dónde está el origen del uso. === con typeof vino, y como convención veo que se usa en muchas bibliotecas, pero el operador typeof devuelve un literal de cadena, y lo sabemos desde el principio, entonces, ¿por qué querrías escribirlo 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

Publicación cruzada de mi respuesta de una pregunta relacionada ¿Cómo comprobar si hay "indefinido" en JavaScript?

Específico para esta pregunta, consulte 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 las pruebas marcan la diferencia cuando están en un contenedor con alcance)

Código de referencia:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.log(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

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

Si lo haces

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

fallará cuando la variable myvar no existe porque myvar no está definido, por lo que el script no funciona y la prueba no tiene ningún efecto.

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

Por ejemplo:

var myvar = 'test';

La variable global mivar es lo mismo que ventana.myvar o ventana['myvar']

Para evitar errores al probar cuando existe una variable global, es mejor utilizar:

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

La pregunta de si una variable realmente existe no importa, su valor es incorrecto.De lo contrario, es una tontería 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, puede simplemente verificar su tipo o confiar en !window.myvar para comprobar si tiene un valor adecuado/válido.Entonces, incluso cuando la variable no está definida, entonces !window.myvar es lo mismo para myvar = undefined o myvar = false o myvar = 0.

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

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 se salta las siguientes pruebas.

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

(y)

No vi (espero no perdémelo) a nadie revisando el objeto antes que la propiedad.Entonces, este es el más breve y efectivo (aunque no necesariamente el más claro):

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

Si obj u obj.prop no está definido, es nulo o "falso", la instrucción if no ejecutará el bloque de código.Esto es generalmente el comportamiento deseado en la mayoría de las declaraciones de bloques de código (en JavaScript).

En el artículo Explorando el abismo de lo nulo y lo indefinido en JavaScript Leí que marcos como Subrayado.js utilizar esta función:

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

'si (ventana.x) { }' es seguro contra errores

Lo más probable es que quieras if (window.x).Esta verificación es segura incluso si x no ha sido declarado (var x;) - el navegador no arroja ningún error.

Ejemplo:Quiero saber si mi navegador admite History API

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

Cómo funciona esto:

ventana es un objeto que contiene todas las variables globales como miembros, y es legal intentar acceder a un miembro no existente.Si X no ha sido declarado o no ha sido configurado entonces window.x devoluciones indefinido. indefinido lleva a FALSO cuando si() lo evalúa.

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

Al leer esto, me sorprende no haber visto esto.Encontré varios algoritmos que funcionarían para esto.

Nunca definido

Si el valor de un objeto nunca fue definido, esto impedirá que regrese true si se define como null o undefined.Esto es útil si desea que se devuelva verdadero para los valores establecidos como undefined

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

Definido como indefinido o nunca definido

Si quieres que resulte como true para valores definidos con el valor de undefined, o nunca definido, simplemente puedes usar === undefined

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

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

Comúnmente, la gente me ha pedido un algoritmo para determinar si un valor es falso, undefined, o null.Lo siguiente funciona.

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

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

 function getAllUndefined(object) {

        function convertPath(arr, key) {
            var path = "";
            for (var i = 1; i < arr.length; i++) {

                path += arr[i] + "->";
            }
            path += key;
            return path;
        }


        var stack = [];
        var saveUndefined= [];
        function getUndefiend(obj, key) {

            var t = typeof obj;
            switch (t) {
                case "object":
                    if (t === null) {
                        return false;
                    }
                    break;
                case "string":
                case "number":
                case "boolean":
                case "null":
                    return false;
                default:
                    return true;
            }
            stack.push(key);
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    v = getUndefiend(obj[k], k);
                    if (v) {
                        saveUndefined.push(convertPath(stack, k));
                    }
                }
            }
            stack.pop();

        }

        getUndefiend({
            "": object
        }, "");
        return saveUndefined;
    }

jsFiddle enlace

Simplemente cualquier cosa que no esté definida en JavaScript, es indefinido, no importa si es una propiedad dentro de un Objeto/Matriz o simplemente como una simple variable...

JavaScript tiene typeof lo que hace que sea muy fácil detectar una variable indefinida.

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

Así funcionan los famosos isUndefined() en AngularJs v.1x está escrito:

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

Entonces, como ve, la función recibe un valor, si ese valor está definido, devolverá false, de lo contrario, para valores no definidos, devuelve true.

Entonces, echemos un vistazo a cuáles serán los resultados cuando pasemos valores, incluidas las propiedades del objeto como se muestra a continuación, esta es la lista de variables que tenemos:

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

y los verificamos como se muestra a continuación, puede ver los resultados frente a ellos como un comentario:

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

Como puede ver, podemos verificar cualquier cosa usando algo como esto en nuestro código, como se mencionó, simplemente puede usar typeof en su código, pero si lo usa una y otra vez, cree una función como la muestra angular que comparto y siga reutilizándola siguiendo el patrón de código DRY.

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

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(…)

Es tan simple que puedes envolverlo dentro de una declaración if como la siguiente:

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

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

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

También otros marcos de JavaScript como el guión bajo tienen una verificación de definición similar, pero te recomiendo que uses typeof si ya no estás utilizando ningún marco.

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

Igualdad estricta e indefinida.
Puede usar operadores de igualdad y desigualdad sinfinidos y estrictos para determinar si una variable tiene un valor.En el siguiente código, la variable x no está definida, y la instrucción IF se evalúa a verdaderas.

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

Nota:El operador de igualdad estricto en lugar del operador de igualdad estándar debe usarse aquí, porque X == Undefined también verifica si X es nulo, mientras que la igualdad estricta no.NULL no es equivalente a indefinido.Consulte los operadores de comparación para obtener más detalles.

Operador tipo de e indefinido
Alternativamente, se puede utilizar typeof:

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

Una razón para usar tipoF es que no arroja un error si la variable no se ha declarado.

// 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 alcance estáticamente, por lo que saber si se declara una variable se puede leer al ver si se declara en un contexto adjunto.La única excepción es el alcance global, pero el alcance global está vinculado al objeto global, por lo que verificar la existencia de una variable en el contexto global se puede hacer verificación de la existencia de una propiedad en el objeto global (usando el operador en, por ejemplo).

Operador nulo e indefinido.

El operador nulo 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 > aquí

Comparar con void 0, por la concisión.

if (foo !== void 0)

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

La solución es incorrecta.En JavaScript,

null == undefined

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

if (something === undefined)

cual es el operador de identidad...

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 de la llamada rest eran incorrectos en la medida en que el usuario los especificó mal, la llamada rest vuelve básicamente vacía.

Mientras usaba esta publicación para ayudarme a defenderme contra esto, probé esto.

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

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

Lo que digo es que, en mi situación, todas las sugerencias anteriores en esta publicación no funcionaron.No digo que yo tenga razón y que todos estén equivocados.No soy un maestro de JavaScript en absoluto, pero espero que esto ayude a alguien.

Existe una manera agradable y elegante de asignar una propiedad definida a una nueva variable si está definida o asignarle un valor predeterminado como 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

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

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 esté sepultada entre respuestas incorrectas >_<

Entonces, para cualquiera que pase, ¡¡les 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

Revisando los comentarios, para aquellos que quieran comprobar si ambos son indefinidos 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 la biblioteca jQuery, 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ás usando Angular:

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

Subrayado.js:

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

yo suelo if (this.variable) para probar si está definido.Simple if (variable), recomendado arriba, falla para mí.Resulta que solo funciona cuando la variable es un campo de algún objeto, obj.someField para comprobar si está definido en el diccionario.Pero podemos usar this o window como objeto del diccionario ya que cualquier variable es un campo en la ventana actual, según tengo entendido.Por eso aquí tenéis una prueba.

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

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

Primero detecta esa variable. abc no está definido y se define después de la inicialización.

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

Devuelve falso si se establece la variable y verdadero si no está definida.

Luego usa:

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

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

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

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

Me gustaría mostrarles algo que estoy usando para proteger el undefined variable:

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

Esto prohíbe a cualquiera cambiar el window.undefined value, por lo tanto, destruye el código basado en esa variable.Si usa "use strict", cualquier intento de cambiar su valor terminará en error; de lo contrario, se ignorará silenciosamente.

De lodash.js.

var undefined;
function isUndefined(value) {
  return value === undefined;
}

Crea una variable LOCAL llamada undefined que se inicializa con el valor predeterminado: el real undefined, luego compara value con la variable undefined.

Aquí proporciono tres formas para aquellos que esperan respuestas extrañas:

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}
function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
    const defaultVal={};
    return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
    console.group(`test start :`+func.name);
    console.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

es indefinido1:

Intente obtener una propiedad del valor de entrada, verifique el mensaje de error si existe.Si el valor de entrada no está definido, el mensaje de error sería Error de tipo no detectado:No se puede leer la propiedad 'b' de indefinido

es indefinido2:

Convertir el valor de entrada en una cadena para compararlo "undefined" y asegúrese de que sea un valor negativo.

es indefinido3:

En js, el parámetro opcional funciona cuando el valor de entrada es exactamente undefined.

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow