Pregunta ¿Cómo verificar "indefinido" en JavaScript? [duplicar]


Esta pregunta ya tiene una respuesta aquí:

¿Cuál es la forma más adecuada de comprobar si una variable no está definida en JavaScript? He visto varias formas posibles:

if (window.myVariable)

O

if (typeof(myVariable) != "undefined")

O

if (myVariable) //This throws an error if undefined. Should this be in Try/Catch?

1872
2017-08-02 17:53


origen


Respuestas:


Si está interesado en saber si una variable ha sido declarada independientemente de su valor, entonces use la in el operador es la forma más segura de hacerlo. Considera este ejemplo.

// global scope
var theFu; // theFu has been declared, but its value is undefined
typeof theFu; // "undefined"

Pero este puede no ser el resultado esperado para algunos casos, ya que la variable o propiedad se declaró pero no se inicializó. Utilizar el in operador para un control más robusto.

"theFu" in window; // true
"theFoo" in window; // false

Si le interesa saber si la variable no ha sido declarada o si tiene el valor undefined, luego usa el typeof operador.

if (typeof myVar != 'undefined')

los typeof el operador está garantizado para devolver una cadena. Comparaciones directas contra undefined son problemáticos como undefined puede ser sobrescrito

window.undefined = "omg";
"omg" == undefined // true

Como @CMS señaló, esto ha sido parcheado en ECMAScript 5th ed., Y undefined no es escribible

if (window.myVar) también incluirá estos valores falsy, por lo que no es muy robusto:

falso
0
""
Yaya
nulo
indefinido

Gracias a @CMS por señalar que su tercer caso: if (myVariable) también puede arrojar un error en dos casos. El primero es cuando la variable no se ha definido, lo que arroja un ReferenceError.

// abc was never declared.
if (abc) {
    // ReferenceError: abc is not defined
} 

El otro caso es cuando la variable ha sido definida, pero tiene una función getter que arroja un error cuando se invoca. Por ejemplo,

// or it's a property that can throw an error
Object.defineProperty(window, "myVariable", { 
    get: function() { throw new Error("W00t?"); }, 
    set: undefined 
});
if (myVariable) {
    // Error: W00t?
}

2156
2017-08-02 17:58



Yo personalmente uso

myVar === undefined

Advertencia: tenga en cuenta que === se usa sobre == y eso myVar ha sido previamente declarado (no definido)


No me gusta typeof myVar === "undefined". Creo que es largo e innecesario. (Puedo hacer lo mismo en menos código).

Ahora algunas personas se doblarán de dolor cuando lean esto, gritando: "¡Esperen! ¡¡¡WAAITTT !!! undefined puede ser redefinido! "

Guay. Yo se esto. Por otra parte, la mayoría de las variables en Javascript se pueden redefinir. ¿Nunca debería usar un identificador incorporado que pueda redefinirse?

Si sigues esta regla, es bueno para ti: no eres un hipócrita.

La cuestión es que para hacer mucho trabajo real en JS, los desarrolladores necesitan confiar en identificadores redefinibles para ser lo que son. No escucho a la gente diciéndome que no debería usar setTimeout porque alguien puede

window.setTimeout = function () {
    alert("Got you now!");
};

En pocas palabras, el argumento "se puede redefinir" para no usar una === undefined es falso

(Si todavía tienes miedo de undefined al ser redefinido, ¿por qué estás integrando ciegamente el código de la biblioteca sin probar en tu base de código? O incluso más simple: una herramienta de pelusa).


Además, como el typeof enfoque, esta técnica puede "detectar" las variables no declaradas:

if (window.someVar === undefined) {
    doSomething();
}

Pero ambas técnicas se filtran en su abstracción. Te insto a que no uses esto o incluso

if (typeof myVar !== "undefined") {
    doSomething();
}

Considerar:

var iAmUndefined;

Para saber si esa variable está declarada o no, es posible que deba recurrir a la in operador. (En muchos casos, simplemente puede leer el código O_o).

if ("myVar" in window) {
    doSomething();
}

¡Pero espera! ¡Hay más! ¿Qué pasa si algo de magia de cadena prototipo está sucediendo ...? Ahora incluso el superior in operador no es suficiente. (De acuerdo, ya terminé aquí sobre esta parte excepto para decir eso el 99% del tiempo, === undefined (y **** tos **** typeof) funciona bien. Si realmente te importa, puedes leer sobre este tema por su cuenta).


888
2017-08-02 18:26



Utilizando typeof es mi preferencia Funcionará cuando la variable nunca se haya declarado, a diferencia de cualquier comparación con el == o === operadores o tipo de coerción usando if. (undefined, diferente a null, también se puede redefinir en entornos ECMAScript 3, por lo que no es confiable para la comparación, aunque casi todos los entornos comunes ahora son compatibles con ECMAScript 5 o superior).

if (typeof someUndeclaredVariable == "undefined") {
    // Works
}

if (someUndeclaredVariable === undefined) { 
    // Throws an error
}

149
2017-08-02 18:05



Tienes que usar typeof .

if (typeof something != "undefined") {
    // ...
}

51
2018-06-06 20:22



Si no está definido, no será igual a una cadena que contenga los caracteres "undefined", ya que la cadena no está indefinida.

Puede verificar el tipo de la variable:

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

Algunas veces ni siquiera tiene que verificar el tipo. Si el valor de la variable no se puede evaluar como falso cuando se establece (por ejemplo, si se trata de una función), entonces simplemente puede evaluar la variable. Ejemplo:

if (something) {
  something(param);
}

20
2018-06-06 20:23



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

(Tenga en cuenta que el uso de var para in las pruebas marcan la diferencia cuando se encuentran en un contenedor delimitado)

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

17
2018-01-13 15:39



if (typeof foo == 'undefined') {
 // Do something
};

Tenga en cuenta que la comparación estricta (!==) no es necesario en este caso, ya que typeof siempre devolverá una cadena.


16
2018-06-06 20:26



En Este artículo Leo esos marcos como Underscore.js usa esta función:

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

15
2017-12-19 10:42