vazia - Como verificar se há "indefinido" em JavaScript?




verificar tipo de variavel javascript (11)

Qual é a maneira mais apropriada de testar se uma variável é indefinida em JavaScript? Eu vi várias maneiras possíveis:

if (window.myVariable)

Ou

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

Ou

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

Atualização 2018-07-25

Já se passaram quase cinco anos desde que este post foi criado, e o JavaScript já percorreu um longo caminho. Ao repetir os testes no post original, não encontrei nenhuma diferença consistente entre os seguintes métodos de teste:

  • abc === undefined
  • abc === void 0
  • typeof abc == 'undefined'
  • typeof abc === 'undefined'

Mesmo quando eu modifiquei os testes para evitar que o Chrome os otimizasse, as diferenças foram insignificantes. Como tal, eu recomendaria agora abc === undefined para maior clareza.

Conteúdo relevante do chrome://version :

  • Google Chrome: 67.0.3396.99 (compilação oficial) (64 bits) (coorte: estável)
  • Revisão: a337fbf3c2ab8ebc6b64b0bfdce73a20e2e2252b-refs / branch-heads / 3396 @ {# 790}
  • SO: Windows
  • JavaScript: V8 6.7.288.46
  • User Agent: Mozilla / 5.0 (Windows NT 10.0; Win64; x64) AppleWebKit / 537.36 (KHTML, como o Gecko) Chrome / 67.0.3396.99 Safari / 537.36

Postagem original 2013-11-01

No Google Chrome, o seguinte foi sempre um pouco mais rápido do que um teste de tipo:

if (abc === void 0) {
    // Undefined
}

A diferença foi insignificante. No entanto, esse código é mais conciso e mais claro para quem sabe o que significa void 0 . Note, no entanto, que abc ainda deve ser declarado.

Ambos typeof e void foram significativamente mais rápidos do que comparando diretamente com undefined . Usei o seguinte formato de teste no console do desenvolvedor do Google Chrome:

var abc;
start = +new Date();
for (var i = 0; i < 10000000; i++) {
    if (TEST) {
        void 1;
    }
}
end = +new Date();
end - start;

Os resultados foram os seguintes:

Test: | abc === undefined      abc === void 0      typeof abc == 'undefined'
------+---------------------------------------------------------------------
x10M  |     13678 ms               9854 ms                 9888 ms
  x1  |    1367.8 ns              985.4 ns                988.8 ns

Observe que a primeira linha está em mili segundos, enquanto a segunda linha está em nano segundos. Uma diferença de 3,4 nanossegundos não é nada. Os tempos foram bastante consistentes nos testes subsequentes.


A maneira mais confiável que eu sei de verificar se há undefined é usar void 0 .

Isso é compatível com navegadores mais novos e antigos, e não pode ser sobrescrito como window.undefined pode, em alguns casos.

if( myVar === void 0){
    //yup it's undefined
}

Ao contrário da resposta do @Thomas Eding:

Se eu esquecer de declarar myVar no meu código, então eu vou pegar myVar is not defined .

Vamos dar um exemplo real:

Eu tenho um nome de variável, mas não tenho certeza se ele está declarado em algum lugar ou não.

Então a resposta do @ Anurag ajudará:

var myVariableToCheck = 'myVar';
if (window[myVariableToCheck] === undefined)
    console.log("Not declared or declared, but undefined.");

// Or you can check it directly 
if (window['myVar'] === undefined) 
    console.log("Not declared or declared, but undefined.");

Como nenhuma das outras respostas me ajudou, sugiro fazer isso. Funcionou para mim no Internet Explorer 8:

if (typeof variable_name.value === 'undefined') {
    // variable_name is undefined
}

Eu uso isso como um parâmetro de função e o excluo na execução da função dessa forma eu obtenho o "real" indefinido. Embora exija que você coloque seu código dentro de uma função. Eu encontrei isso ao ler a fonte jQuery.

undefined = 2;

(function (undefined) {
   console.log(undefined); // prints out undefined
   // and for comparison:
   if (undeclaredvar === undefined) console.log("it works!")
})()

Claro que você poderia apenas usar typeof embora. Mas todo o meu código é geralmente dentro de uma função de contenção de qualquer maneira, então usar este método provavelmente me salva alguns bytes aqui e ali.


Pessoalmente, eu sempre uso o seguinte:

var x;
if( x === undefined) {
    //Do something here
}
else {
   //Do something else here
}

A propriedade window.undefined é não-gravável em todos os navegadores modernos (JavaScript 1.8.5 ou posterior). Da documentação da Mozilla: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined , eu vejo isto: Uma razão para usar typeof () é que ele não lança um erro se a variável não foi definida.

Eu prefiro ter a abordagem de usar

x === undefined 

porque falha e explode na minha cara, em vez de passar / falhar silenciosamente, se x não foi declarado antes. Isso me alerta que x não está declarado. Eu acredito que todas as variáveis ​​usadas no JavaScript devem ser declaradas.


Se você estiver interessado em descobrir se uma variável foi declarada, independentemente de seu valor, usar o operador in é a maneira mais segura de ir. Considere este exemplo.

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

Mas isso pode não ser o resultado pretendido para alguns casos, uma vez que a variável ou propriedade foi declarada, mas não inicializada. Use o operador in para uma verificação mais robusta.

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

Se você estiver interessado em saber se a variável não foi declarada ou tem o valor undefined , use o operador typeof .

if (typeof myVar != 'undefined')

O operador typeof tem garantia de retornar uma string. Comparações diretas contra undefined são problemáticas, pois undefined pode ser sobrescrito.

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

Como apontado pelo @CMS, isso foi corrigido no ECMAScript 5th ed., E o undefined é não-gravável.

if (window.myVar) também incluirá esses valores falsos, por isso não é muito robusto:

false
0
""
NaN
null
undefined

Obrigado ao @CMS por apontar que seu terceiro caso - if (myVariable) também pode gerar um erro em dois casos. O primeiro é quando a variável não foi definida, o que gera um ReferenceError .

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

O outro caso é quando a variável foi definida, mas tem uma função getter que gera um erro quando invocada. Por exemplo,

// 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?
}

Usar typeof é minha preferência. Ele funcionará quando a variável nunca foi declarada, diferente de qualquer comparação com os operadores == ou === ou coerção de tipo usando if . ( undefined , ao contrário de null , também pode ser redefinido em ambientes ECMAScript 3, tornando-o não confiável para comparação, embora quase todos os ambientes comuns agora estejam em conformidade com o ECMAScript 5 ou superior).

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

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

Neste artigo eu li que frameworks como Underscore.js usam esta função:

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

// x has not been defined before
if (typeof x === 'undefined') { // Evaluates to true without errors.
   // These statements execute.
}

if (x === undefined) { // Throws a ReferenceError

}

    var x;
    if (x === undefined) {
        alert ("I am declared, but not defined.")
    };
    if (typeof y === "undefined") {
        alert ("I am not even declared.")
    };

    /* One more thing to understand: typeof ==='undefined' also checks 
       for if a variable is declared, but no value is assigned. In other 
       words, the variable is declared, but not defined. */

    // Will repeat above logic of x for typeof === 'undefined'
    if (x === undefined) {
        alert ("I am declared, but not defined.")
    };
    /* So typeof === 'undefined' works for both, but x === undefined 
       only works for a variable which is at least declared. */

    /* Say if I try using typeof === undefined (not in quotes) for 
       a variable which is not even declared, we will get run a 
       time error. */

    if (z === undefined) {
        alert ("I am neither declared nor defined.")
    };
    // I got this error for z ReferenceError: z is not defined 




undefined