JavaScript verifica se a variável existe (está definida / inicializada)

Qual método de verificar se uma variável foi inicializada é melhor / correto? (Assumindo que a variável poderia conter qualquer coisa (string, int, object, function, etc.))

if (elem) { // or !elem 

ou

 if (typeof(elem) !== 'undefined') { 

ou

 if (elem != null) { 

   

Você quer o operador typeof . Especificamente:

 if (typeof variable !== 'undefined') { // the variable is defined } 

O operador typeof irá verificar se a variável está realmente indefinida.

 if (typeof variable === 'undefined') { // variable is undefined } 

O operador typeof , diferentemente dos outros operadores, não lança uma exceção ReferenceError quando usado com uma variável não declarada.

No entanto, note que typeof null irá retornar "object" . Temos que ter cuidado para evitar o erro de inicializar uma variável como null . Para estar seguro, isso é o que poderíamos usar em vez disso:

 if (typeof variable === 'undefined' || variable === null) { // variable is undefined or null } 

Para mais informações sobre como usar comparação estrita === vez de igualdade simples == , consulte:
Qual operador de igual (== vs ===) deve ser usado em comparações de JavaScript?

Em JavaScript, uma variável pode ser definida, mas mantenha o valor undefined , portanto, a resposta mais comum não é tecnicamente correta e, em vez disso, executa o seguinte:

 if (typeof v === "undefined") { // no variable "v" is defined in the current scope // *or* some variable v exists and has been assigned the value undefined } else { // some variable (global or local) "v" is defined in the current scope // *and* it contains a value other than undefined } 

Isso pode ser suficiente para seus propósitos. O teste a seguir tem uma semântica mais simples, o que facilita descrever com precisão o comportamento do seu código e entendê-lo por conta própria (se você se importa com essas coisas):

 if ("v" in window) { // global variable v is defined } else { // global variable v is not defined } 

Isso, obviamente, pressupõe que você esteja executando em um navegador (onde window é um nome para o object global). Mas se você está mexendo com globals como este, provavelmente você está em um navegador. Subjetivamente, usar 'name' in window é estilisticamente consistente com o uso de window.name para se referir a globals. Acessar globais como propriedades da window e não como variables, permite minimizar o número de variables ​​não declaradas que você referencia em seu código (para o benefício do linting) e evita a possibilidade de seu global ser sombreado por uma variável local. Além disso, se os globals fizerem sua pele se rastejar, você pode se sentir mais confortável em tocá-los apenas com este stick relativamente longo.

Na maioria dos casos, você usaria:

 elem != null 

Ao contrário de um simples if (elem) , ele permite 0 , false , NaN e '' , mas rejeita null ou undefined , tornando-se um bom teste geral para a presença de um argumento ou propriedade de um object.


As outras verificações também não estão incorretas, elas só têm usos diferentes:

  • if (elem) : pode ser usado se elem for garantido como um object, ou se false , 0 , etc. forem considerados valores “default” (portanto, equivalentes a undefined ou null ).

  • typeof elem == 'undefined' pode ser usado em casos em que um null especificado possui um significado distinto para uma variável ou propriedade não inicializada.

    • Esta é a única verificação que não lançará um erro se o elem não for declarado (ou seja, nenhuma declaração var , não uma propriedade da window ou não um argumento de function). Isto é, na minha opinião, bastante perigoso, pois permite que erros de digitação passem despercebidos. Para evitar isso, veja o método abaixo.

Também é útil uma comparação estrita contra o undefined :

 if (elem === undefined) ... 

No entanto, como o undefined global pode ser substituído por outro valor, é melhor declarar a variável undefined no escopo atual antes de usá-lo:

 var undefined; // really undefined if (elem === undefined) ... 

Ou:

 (function (undefined) { if (elem === undefined) ... })(); 

Uma vantagem secundária desse método é que os minificadores JS podem reduzir a variável undefined para um único caractere, economizando alguns bytes de cada vez.

Em muitos casos, usando:

 if (elem) { // or !elem 

vai fazer o trabalho para você! … isso irá verificar estes casos abaixo:

  1. undefined : se o valor não está definido e é undefined
  2. null : se for null, por exemplo, se um elemento DOM não existir …
  3. string vazia : ''
  4. 0 : número zero
  5. NaN : não é um número
  6. falso

Por isso vai cobrir o tipo de todos os casos, mas há sempre casos estranhos que gostaríamos de abordar também, por exemplo, uma string com espaços, como este ' ' um será definido em javascript, pois tem espaços dentro da string … por exemplo, neste caso, você adiciona mais uma verificação usando trim (), como:

 if(elem) { if(typeof elem === 'string' && elem.trim()) { /// 

Além disso, essas verificações são apenas para valores , como objects e matrizes funcionam de forma diferente em JavaScript, array vazio [] e object vazio {} são sempre verdadeiros .

Eu crio a imagem abaixo para mostrar um breve resumo da resposta:

indefinido, nulo, etc

Como verificar se existe uma variável

Esta é uma solução bastante à prova de balas para testar se uma variável existe e foi inicializada:

 var setOrNot = typeof variable !== typeof undefined; 

É mais comumente usado em combinação com um operador ternário para definir um padrão no caso de uma determinada variável não ter sido inicializada:

 var dark = typeof darkColor !== typeof undefined ? darkColor : "black"; 

Problemas com encapsulamento

Infelizmente, você não pode simplesmente encapsular seu cheque em uma function.

Você pode pensar em fazer algo assim:

 function isset(variable) { return typeof variable !== typeof undefined; } 

No entanto, isso produzirá um erro de referência se você estiver ligando, por exemplo. isset(foo) e a variável foo não foram definidos, porque você não pode passar uma variável não existente para uma function:

Incapaz ReferenceError: foo não está definido


Testando se os parâmetros da function são indefinidos

Embora nossa function isset não possa ser usada para testar se uma variável existe ou não (por razões explicadas acima), ela nos permite testar se os parâmetros de uma function são indefinidos:

 var a = '5'; var test = function(x, y) { console.log(isset(x)); console.log(isset(y)); }; test(a); // OUTPUT : // ------------ // TRUE // FALSE 

Mesmo que nenhum valor para y seja passado para o test function, nossa function isset funciona perfeitamente neste contexto, porque y é conhecido no test function como um valor undefined .

Verificar se um object hasOwnProperty()

Uma alternativa para a multiplicidade de respostas, é o uso de hasOwnProperty() que, claro, verifica se um object (praticamente tudo em JS) tem uma propriedade, ou seja, uma variável (entre outras coisas).

O método hasOwnProperty() retorna um booleano indicando se o object possui a propriedade especificada como propriedade própria (não herdada).

Cada object descendente de Object herda o método hasOwnProperty() . Esse método pode ser usado para determinar se um object tem a propriedade especificada como uma propriedade direta desse object; Ao contrário do operador in , esse método não faz check-down da cadeia de protótipos do object.

 // Globally established (therefore) properties of window var foo = "whatever", // string bar = false, // bool baz; // undefined // window.qux does not exist console.log( [ window.hasOwnProperty( "foo" ), // true window.hasOwnProperty( "bar" ), // true window.hasOwnProperty( "baz" ), // true window.hasOwnProperty( "qux" ), // false { foo: [], bar: 0 }.hasOwnProperty( "bar" ) // true ] ); 

Há outra maneira breve de verificar isso, quando você executa tarefas simples e verificações relacionadas. Simplesmente use o operador condicional (ternário).

 var values = typeof variable !== 'undefined' ? variable : ''; 

Isso também será útil quando você tentar declarar a variável Global com a atribuição de instância da variável de referência.

Se você quisesse verificar a variável, ela não deveria ser undefined ou null . Em seguida, execute abaixo do cheque.

Quando a variável é declarada, e se você quiser verificar o valor, isso é até Simples: e executaria verificações undefined e null juntas.

 var values = variable ? variable : ''; 

indefinido, booleano, string, número, function

 if (tipo de foo! == 'indefinido') { 

 } 

Objeto, matriz

 if( foo instanceof Array ) { } 

Depende se você apenas se importa que a variável foi definida ou se você quer que ela tenha um valor significativo.

Verificar se o tipo é indefinido irá verificar se a variável foi definida ainda.

=== null ou !== null irá somente verificar se o valor da variável é exatamente null .

== null ou != null irá verificar se o valor é undefined ou null .

if(value) verificará se a variável é undefined , null , 0 ou uma string vazia.

A resposta mais alta está correta, use typeof.

No entanto, o que eu queria salientar era que em JavaScript undefined é mutável (por algum motivo ímpio). Portanto, simplesmente fazer uma verificação de varName !== undefined tem o potencial de nem sempre retornar como esperado, porque outras bibliotecas podem ter sido alteradas indefinidamente. Algumas respostas (@ skalee’s, por exemplo), parecem preferir não usar typeof , e isso pode causar problemas.

A maneira “antiga” de lidar com isso era declarar indefinida como um var para compensar qualquer potencial muting / over-riding de undefined . No entanto, a melhor maneira ainda é usar typeof porque ele irá ignorar qualquer substituição de undefined de outro código. Especialmente se você está escrevendo código para uso na natureza, onde quem sabe o que mais poderia estar sendo executado na página …

 if (typeof console != "undefined") { ... } 

Ou melhor

 if ((typeof console == "object") && (typeof console.profile == "function")) { console.profile(f.constructor); } 

Funciona em todos os navegadores

Para contribuir com o debate, se eu sei que a variável deve ser uma string ou um object eu sempre prefiro if (!variable) , então checando se é falsy. Isso pode trazer mais código limpo para que, por exemplo:

 if (typeof data !== "undefined" && typeof data.url === "undefined") { var message = 'Error receiving response'; if (typeof data.error !== "undefined") { message = data.error; } else if (typeof data.message !== "undefined") { message = data.message; } alert(message); } 

É difícil distinguir entre indefinido e nulo. Nulo é um valor que você pode atribuir a uma variável quando deseja indicar que a variável não possui um valor específico. Indefinido é um valor especial que será o valor padrão de variables ​​não atribuídas.

var _undefined; var _null = null; alert(_undefined); alert(_null); alert(_undefined == _null); alert(_undefined === _null);
var _undefined; var _null = null; alert(_undefined); alert(_null); alert(_undefined == _null); alert(_undefined === _null); 

Nulo é um valor em JavaScript e typeof null retornos typeof null "object"

Portanto, a resposta aceita não funcionará se você passar valores nulos. Se você passar valores nulos, precisará adicionar uma verificação extra para valores nulos:

 if ((typeof variable !== "undefined") && (variable !== null)) { // the variable is defined and not null } 

Essas respostas (além da solução de Fred Gandt) estão todas incorretas ou incompletas.

Suponha que eu precise do meu variableName; carregar um valor undefined e, portanto, ele foi declarado de uma maneira como var variableName; o que significa que já está inicializado ; Como posso verificar se já está declarado?

Ou ainda melhor – como faço para verificar imediatamente se “Book1.chapter22.paragraph37” existe com uma única chamada, mas não sobe um erro de referência?

Fazemos isso usando o operador mais poderoso do JasvaScript, o operador in . :

 "[variable||property]" in [context||root] >> true||false 

Em tempos de picaking AJAX popularidade eu escrevi um método (mais tarde chamado) isNS (), que é capaz de determinar se o namespace existe, incluindo testes profundos para nomes de propriedade, como “Book1.chapter22.paragraph37” e muito mais.

Mas desde que foi publicado anteriormente e por causa de sua grande importância, ele merece ser publicado em um tópico separado. Eu não postarei aqui, mas fornecerá palavras-chave ( javascript + isNS ) que o ajudarão a localizar o código fonte, explicações necessárias.

A verificação mais robusta ‘é definida’ é com typeof

 if (typeof elem === 'undefined') 

Se você está apenas verificando uma variável definida para atribuir um padrão, para um fácil ler um liner, você pode fazer isso frequentemente:

 elem = elem || defaultElem; 

Muitas vezes é bom usar, veja: maneira idiomática de definir o valor padrão em javascript

Há também este forro usando a palavra-chave typeof :

 elem = (typeof elem === 'undefined') ? defaultElem : elem; 

você pode usar o operador typeof .

Por exemplo,

 var dataSet; alert("Variable dataSet is : " + typeof dataSet); 

O snippet de código acima retornará a saída como

O dataSet variável é: indefinido.

Na situação particular descrita na pergunta,

 typeof window.console === "undefined" 

é idêntico a

 window.console === undefined 

Eu prefiro o último desde que é mais curto.

Por favor, note que nós olhamos para o console apenas no escopo global (que é um object de window em todos os navegadores). Nesta situação particular é desejável. Nós não queremos console definido em outro lugar.

@BrianKelley, em sua ótima resposta, explica detalhes técnicos. Eu só adicionei falta de conclusão e digeri em algo mais fácil de ler.

Minha preferência é typeof(elem) != 'undefined' && elem != null .

Seja qual for a sua escolha, considere colocar o cheque em uma function assim

 function existy (x) { return typeof (x) != 'undefined' && x != null; } 

Se você não sabe que a variável está declarada então continue com typeof (x) != 'undefined' && x != null;

Onde você sabe que a variável está declarada, mas pode não existir, você pode usar

 existy(elem) && doSomething(elem); 

A variável que você está verificando pode ser uma propriedade aninhada às vezes. Você pode usar prop || {} para descer a linha verificando a existência para a propriedade em questão:

 var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4; 

Depois de cada propriedade use (… ‘|| {}’). NextProp para que uma propriedade ausente não lance um erro.

Ou você poderia usar existy como existy(o) && existy(op) && existy(opq) && doSomething(opq)

Se você quiser que o bloco definido faça alguma coisa, use este

 if (typeof variable !== 'undefined') { // the variable is defined } 

Se você quiser que o bloco indefinido faça alguma coisa ou atribua ou defina a variável, use este

 if (typeof variable === 'undefined') { // the variable is undefined } 

Eu uso duas maneiras diferentes, dependendo do object.

 if( !variable ){ // variable is either // 1. ''; // 2. 0; // 3. undefined; // 4. null; // 5. false; } 

Às vezes eu não quero avaliar uma string vazia como falsey, então eu uso este caso

 function invalid( item ){ return (item === undefined || item === null); } if( invalid( variable )){ // only here if null or undefined; } 

Se você precisar do oposto, então, na primeira instância! Variável torna-se !! variável, e na function inválida == = tornar-se! = E os nomes das funções mudam para notInvalid.

Depende da situação. Se você está verificando algo que pode ou não ter sido definido globalmente fora do seu código (como o jQuery, talvez), você deseja:

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

(Não há necessidade de igualdade estrita lá, typeof sempre retorna uma string.) Mas se você tiver argumentos para uma function que pode ou não ter sido passada, eles sempre serão definidos, mas null se omitidos.

 function sayHello(name) { if (name) return "Hello, " + name; else return "Hello unknown person"; } sayHello(); // => "Hello unknown person" 

Um pouco mais funcional e fácil de usar:

 function exist(obj) { return (typeof obj !== 'undefined'); } 

A function retornará true se existir, senão false se não existir.

Que tal um simples:

 if(!!variable){ //the variable is defined } 

Esteja ciente de que quando você verificar! == ou! = Contra “undefined” não vai funcionar

Testado no Firfox Quantom 60.0.1

use o teste como este, em vez de evitar conflitos

 if(!(typeof varibl['fl'] === 'undefined')) { console.log(varibl['fl']); console.log("Variable is Defined"); }else{ console.log(varibl['fl']); console.log("Variable is Un-Defined"); } 

Para verificar se uma variável foi declarada / definida, fiz este truque sujo.

Eu não encontrei uma maneira de extrair o código para uma function, mesmo com eval .

 "use strict"; // var someVar; var declared; try { someVar; declared = true; } catch(e) { declared = false; } if (declared) { console.log("someVar is declared; now has the value: " + someVar); } else { console.log("someVar is not declared"); } 

Não tenho certeza se isso vai ajudar, eu estava precisando verificar se um Var que estava definido na página estava sendo pego antes de executar os scripts relacionados e o seguinte funcionou bem para mim.

 if (window.myvar) { // run scripts here } 

É um pouco simples, mas bom para um offs ou os gostos.

Eu não posso ver isso nas respostas acima, então vou sugerir aqui, eu acho.

 function isDefined(x) { return !!x } if( isDefined(x) ) { //The variable is defined } 

! x retornará true se x for nulo ou indefinido , portanto !! x só retornará true se x não for indefinido nem nulo.

Eu percebo que isso também explica o caso nulo, mas aqui está um aviso justo sobre isso.