Qual método de verificação se uma variável foi inicializada é melhor / correto? (Supondo que a variável possa conter qualquer coisa (string, int, objeto, função etc.))

if (elem) { // or !elem

ou

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

ou

if (elem != null) {

Você quer o typeofoperador . Especificamente:

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

O typeofoperador verificará se a variável está realmente indefinida.

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

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

No entanto, observe que typeof nullretornará "object". Temos que ter cuidado para evitar o erro de inicializar uma variável para null. Para estar seguro, é isso que poderíamos usar:

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

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

Em muitos casos, usando:

if (elem) { // or !elem

fará o trabalho para você! ... isso verificará os seguintes casos:

1. indefinido : se o valor não estiver definido e forundefined
2. null : se for nulo, 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

Portanto, ele cobre todos os casos, mas sempre há casos estranhos que gostaríamos de cobrir, por exemplo, uma string com espaços, como este ' ', que será definida em javascript, pois possui 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 , pois objetos e matrizes funcionam de maneira diferente em Javascript, matriz []vazia e objeto vazio {}sempre são verdadeiros .

Crio a imagem abaixo para mostrar um breve resumo da resposta:

Em JavaScript, uma variável pode ser definida, mas mantenha o valor undefined, para que a resposta mais comum não seja tecnicamente correta e, em vez disso, execute 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 possui semântica mais simples, o que facilita a descrição precisa do comportamento do seu código e a sua compreensão (se você se importa com essas coisas):

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

Obviamente, isso pressupõe que você esteja executando em um navegador (onde windowé um nome para o objeto global). Mas se você está mexendo com globals como esse, provavelmente está em um navegador. Subjetivamente, o uso 'name' in windowé estilisticamente consistente com o uso window.namepara se referir a globais. O acesso a globais como propriedades de windowe não como variáveis ​​permite minimizar o número de variáveis ​​não declaradas que você faz referência em seu código (para o benefício de aprender a usar fiapos) e evita a possibilidade de sua global ser sombreada por uma variável local. Além disso, se os globais fizerem a pele arrepiar, você poderá se sentir mais confortável tocando-os apenas com esse bastão relativamente longo.

Na maioria dos casos, você usaria:

elem != null

Ao contrário de um simples if (elem), permite 0, false, NaNe '', mas rejeita nullou undefined, tornando-se uma boa, teste geral para a presença de um argumento, ou propriedade de um objeto.

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

• if (elem): Pode ser utilizado se elemé garantida para ser um objecto, ou se false, 0, etc, são considerados como valores "padrão" (portanto, equivalente a undefinedou null).

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

  • Esta é a única verificação que não gera um erro se elemnão for declarada (ou seja, nenhuma vardeclaração, nem uma propriedade de window, nem um argumento de função). Isso é, na minha opinião, bastante perigoso, pois permite que erros de digitação passem despercebidos. Para evitar isso, consulte o método abaixo.

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

if (elem === undefined) ...

No entanto, como o global undefinedpode ser substituído por outro valor, é melhor declarar a variável undefinedno 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 undefinedvariável para um único caractere, economizando alguns bytes a cada vez.

Verifique se window. hasOwnProperty( " varname" )

Uma alternativa para a infinidade de typeofrespostas;

Variáveis globais declaradas com uma var varname = value;declaração no escopo global

pode ser acessado como propriedades do objeto window.

Como tal, o hasOwnProperty()método, que

retorna um booleano indicando se o objeto tem a propriedade especificada como sua própria propriedade (em vez de herdá-lo)

pode ser usado para determinar se

um varde "varname" foi declarado globalmente, isto é, uma propriedade do window.

// 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
] );

O que é ótimo hasOwnProperty()é que, ao chamá-lo, não usamos uma variável que ainda não foi declarada - o que, obviamente, é metade do problema.

Embora nem sempre seja a solução perfeita ou ideal , em certas circunstâncias, é apenas o trabalho!

Notas

O exposto acima é verdadeiro ao usar varpara definir uma variável , ao contrário da letqual:

declara uma variável local do escopo do bloco, inicializando-a opcionalmente como um valor.

é diferente da varpalavra - chave, que define uma variável globalmente ou localmente para uma função inteira, independentemente do escopo do bloco.

No nível superior de programas e funções, letao contrário var, não cria uma propriedade no objeto global.

Para completude: const constantes, por definição, não são realmente variáveis ​​(embora seu conteúdo possa ser); mais relevante:

As constantes globais não se tornam propriedades do objeto window, diferentemente das varvariáveis. É necessário um inicializador para uma constante; isto é, você deve especificar seu valor na mesma instrução em que é declarado.

O valor de uma constante não pode mudar através da reatribuição e não pode ser redeclarado.

A declaração const cria uma referência somente leitura para um valor. Isso não significa que o valor que ele possui seja imutável, apenas que o identificador da variável não pode ser reatribuído.

Como letvariáveis ​​ou constconstantes nunca são propriedades de nenhum objeto que herdou o hasOwnProperty()método, ele não pode ser usado para verificar sua existência.

Em relação à disponibilidade e uso de hasOwnProperty():

Todo objeto descendente de Object herda o hasOwnProperty()método. [...] diferentemente do inoperador, esse método não verifica a cadeia de protótipos do objeto.

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, caso uma determinada variável não tenha sido inicializada:

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

Problemas com o encapsulamento

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

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 variável foonão foi definida, porque você não pode passar uma variável inexistente para uma função:

Não detectado ReferenceError: foo não está definido

Testando se os parâmetros de função são indefinidos

Embora nossa issetfunção 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 função são indefinidos:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

Embora nenhum valor para yseja repassado para a função test, nossa issetfunção funciona perfeitamente nesse contexto, porque yé conhecida na função testcomo um undefinedvalor.

Existe outra maneira curta de verificar isso, quando você executa tarefas simples e verificações relacionadas. Basta usar o operador condicional (ternário).

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

Além disso, isso 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 não deveria ser undefinedou null. Em seguida, execute a verificação abaixo.

Quando a variável é declarada, e se você deseja verificar o valor, isso é até Simples: e seria executado undefinede nullverificado juntos.

var values = variable ? variable : '';

A maneira curta de testar uma variável não é declarada (não indefinida) é

if (typeof variable === "undefined") {
  ...
}

Eu achei útil para detectar scripts em execução fora de um navegador (não tendo declarado windowvariável).

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

Verificar se o tipo está indefinido verificará se a variável já foi definida.

=== nullou !== nullverificará apenas se o valor da variável é exatamente null.

== nullou != nullirá verificar se o valor é undefinedou null.

if(value)irá 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 ressaltar era que no JavaScript undefinedé mutável (por algum motivo ímpio). Portanto, simplesmente fazer uma verificação para varName !== undefinedtem o potencial de nem sempre retornar como você espera, porque outras bibliotecas podem ter mudado 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 foi declarar indefinida como uma var para compensar qualquer possível bloqueio / substituição undefined. No entanto, a melhor maneira ainda é usar, typeofporque ignorará qualquer substituição de undefinedoutro código. Especialmente se você estiver escrevendo um código para uso na natureza, onde quem sabe o que mais poderia estar em execução 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 objeto que eu sempre prefiro if (!variable), verifique se é falso. Isso pode levar a um código mais limpo, de modo 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); 
}

..pode ser reduzido para:

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

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

var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

Nulo é um valor em JavaScript e typeof nullretorna"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
}

A verificação mais robusta 'está definida' é com typeof

if (typeof elem === 'undefined')

Se você está apenas verificando uma variável definida para atribuir um padrão, para um liner de fácil leitura, é possível fazer isso:

elem = elem || defaultElem;

Geralmente é bom usar, veja: Maneira linguística de definir o valor padrão em javascript

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

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

você pode usar o typeof operador.

Por exemplo,

var dataSet;

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

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

A variável dataSet é: indefinida.

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

Eu não encontrei uma maneira de extrair o código para uma função, 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");
}

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

Suponha que eu precise que eu variableName;carregue um undefinedvalor e, portanto, ele foi declarado de uma maneira var variableName;que significa que já foi inicializado ; - Como verifico se já está declarado?

Ou melhor ainda - como verifico imediatamente se "Book1.chapter22.paragraph37" existe com uma única chamada, mas não gera um erro de referência?

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

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

Em tempos de grande popularidade do AJAX, escrevi um método (mais tarde denominado) isNS () que é capaz de determinar se o espaço para nome existe, incluindo testes profundos para nomes de propriedades como "Book1.chapter22.paragraph37" e muito mais.

Mas, como ele foi publicado anteriormente e, devido à sua grande importância, merece ser publicado em um tópico separado, não o publicarei aqui, mas fornecerá palavras-chave ( javascript + isNS ) que ajudarão a localizar o código-fonte, com todos os recursos explicações necessárias.

Na situação específica descrita na pergunta,

typeof window.console === "undefined"

é idêntico a

window.console === undefined

Eu prefiro o último, pois é mais curto.

Observe que procuramos consoleapenas no escopo global (que é um windowobjeto em todos os navegadores). Nesta situação em particular, é desejável. Nós não queremosconsole definidos em outro lugar.

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

Eu uso duas maneiras diferentes, dependendo do objeto.

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

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

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

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

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

Como você escolher, considere colocar o cheque em uma função como essa

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

Se você não sabe que a variável está declarada, 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 da propriedade em questão:

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

Após cada propriedade, use (... '|| {}'). NextProp para que uma propriedade ausente não gere um erro.

Ou você pode usar existy como existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Depende da situação. Se você está procurando 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 função que pode ou não ter sido passada, eles sempre serão definidos, mas nulos se omitidos.

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

Try-catch

Se a variável não foi definida, você pode verificar isso sem a execução do código de interrupção usando o bloco try-catch da seguinte maneira (você não precisa usar o use strictmodo)

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

BÔNUS: (referindo-se a outras respostas) Por que ===é mais claro que ==( fonte )

se (a == b)

se (a === b)

Estou surpreso que isso ainda não tenha sido mencionado ...

Aqui estão algumas variações adicionais usando this['var_name']

o benefício de usar esse método que ele pode ser usado antes que uma variável seja definida.

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

Você pode usar um bloco try ... catch como a seguir:

var status = 'Variable exists'

try {
	myVar
} catch (ReferenceError) {
	status = 'Variable does not exist'
}

console.log(status)

Uma desvantagem é que você não pode colocá-lo em uma função, pois geraria um ReferenceError

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))