Verificação de JavaScript se a variável existe (é definida / inicializada)

1767

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) {
Samuel Liew
fonte
5
se você quiser saber se fooestá declarado, typeof foo === 'undefined'outypeof foo === typeof undefined
1
As respostas altamente votadas não funcionam para variáveis ​​declaradas, mas têm o valor undefined. A resposta correta é esta: stackoverflow.com/a/36432729/772035
Paul
@Paulpro, a versão que usa hasOwnProperty('bar')não tem as mesmas deficiências que as outras, mas exigiria algum ajuste para o Node (substitua windowpor global).
oligofren
@Paulpro De fato, mas como eu pensava nisso antes de você responder, cheguei à conclusão de que não é realmente um problema prático. Quando você está lidando com variáveis ​​de escopo de bloco ou função, geralmente é o código que você possui ou tem acesso de gravação, para que você tenha um erro de tempo de execução em qualquer caso que seja corrigível. Enquanto o problema comum com variáveis ​​que não foram definidas (não existe) geralmente está no código fora do seu controle, você precisa de uma maneira de detectá-lo. Portanto, é a solução 80/20.
oligofren

Respostas:

3056

Você quer o typeofoperador . Especificamente:

if (typeof variable !== 'undefined') {
    // the variable is defined
}
Jim Puls
fonte
35
Parece uma boa solução, mas você pode explicar por que isso funciona?
Morgan Cheng
46
Na verdade, você deve verificar se o objeto é o que você precisa. De modo que seria if (typeof consola == 'objeto') {// variável é o que eu preciso que ele seja}
staticsan
59
@George IV: "just do` se (variável)" - hum, não, isso não para falso e 0.
Jason S
17
'if (variable)' também falha ao testar a existência de propriedades do objeto.
scotts
54
@ geowa4 Na verdade, isso gerará um erro se a variável for indefinida.
kevinji
857

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?

Samuel Liew
fonte
2
if (! variable_here) {// seu código aqui. }; não pode dizer se a variável é falsa ou indefinido
boh
5
if(! variable_here)irá quebrar em muitos casos. Se a variável for 0 ou falsa, ela falhará. Não é isso que você quer.
Cory Danielson
2
não pode decidir se deseja votar isso. A rigor typeof foo === "undefined", a resposta está correta e melhor que a resposta mais votada, mas as notas adicionais apenas tornam essa resposta confusa.
Alnitak
1
@StevenPenny Verifique a linha do tempo. A resposta principal foi mesclada de outra pergunta após a publicação desta resposta
Rob
1
Esta resposta não funciona. Esta é a única resposta aqui que as obras: stackoverflow.com/a/36432729/772035
Paul
222

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:

indefinido, nulo etc.

Alireza
fonte
2
@Alireza, nice! Sua resposta ajudará muitas pessoas por aí. Eu já memorizei esses valores falsos, a única coisa que eu não tinha certeza era sobre [].
Thiago Yoithi
13
Eu recebo um "ReferenceError: elem não está definido"
ropo 19/11/18
3
@ropo, é porque você ainda não definiu o elem para verificar o que é, se for o seu caso, você precisa verificá-lo com typeof (elem) === "string" que já é mencionado ...
Alireza
19
Então a resposta é enganosa quando diz que if(elem)verifica indefinidamente (enquanto retorna erro não definido), não é?
Fanky 14/05/19
1
Dê-me um caso de uso para verificar se uma variável é indefinida e se é definida com um valor indefinido? Alguns de vocês estão entendendo os canudos e tentando parecer brilhantes, mas se estão definindo um valor como indefinido e verificando esse valor, obviamente ele retornará falso ou você precisará alterar seu código, smh ... essa resposta está correta !! !!!
Almcaffee
210

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.

Brian Kelley
fonte
7
Isso verifica apenas se a variável foi declarada globalmente. Se você estiver codificando corretamente, estará limitando seus vars globais. Ele reportará false para vars locais: (function () {var sdfsfs = 10; console.log ("sdfsfs" na janela);}) () `
Eddie Monge Jr
2
Esta é a melhor resposta de f $ # ^% ing. Eu estava no fim disso tentando descobrir como explicar exatamente esse caso de canto. Brilhante. Não tinha ideia de que você poderia fazer isso.
temporary_user_name
1
Atenção
Para usuários angulares: Infelizmente, não parece ser permitido em uma instrução ng-if.
Qwertzguy
... modelo perfeito para verificações no escopo. você tem alguma indicação de desempenho, se "na janela" ou "(tipo de variável === 'indefinida' || variável === nula)". Na verdade, eu estou interessado em um teste dura realidade e não na lógica potencial argumentado (o que eu poderia fazer-me: segunda cláusula tem mais operações -> pior desempenho)
Mais rápido
119

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.

David Tang
fonte
17
Estou chocado que você possa substituir undefined. Eu nem acho que vale a pena mencionar na resposta. Provavelmente, o pior nome de variável aceitável em todo o Javascript.
Cory Danielson
2
Isso causa uma exceção e exige que você use window.antes da variável, se usada no contexto global ... essa não é a melhor maneira.
Alex W
4
Devido a esse problema primordial, você SEMPRE deve usar em void(0)vez de undefined.
Bartłomiej Zalewski
+1 desde esta resposta assinala que às vezes você pode realmente quer para identificar false, 0etc., como valores inválidos.
Rinogo 26/06
77

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.

Fred Gandt
fonte
1
Esta é uma alternativa incrível e deve estar no topo desta votação. Simplifique o título da resposta com um exemplo de trabalho que retorna true(por exemplo, window.hasOwnProperty('console')ou var hop = "p";window.hasOwnProperty('hop')).
CPHPython
2
Finalmente, algo que não gera um erro por acessar um membro que não existe ... Algo que todas as typeofrespostas simplesmente ignoram.
Zelphir Kaltstahl
1
Esta resposta está desatualizada - de acordo com o ECMAScript padrão, é possível definir variáveis ​​nas letquais essas variáveis ​​não estão disponíveis como propriedades do windowobjeto [ou qualquer outro objeto disponível]. hasOwnPropertytestes para presença de propriedades , não variáveis ​​e, portanto, não podem ser usados ​​para detectar variáveis ​​definidas por let.
quer
1
@amn A resposta permanece verdadeira em relação ao uso vare, nesse sentido, não está desatualizada. No entanto, adicionei uma nota descrevendo como o uso de lete constdifere do de var. Obrigado pela sua inspiração; juntos vamos subir :)
Fred Gandt
1
@amn Reescrevi a resposta (espero pela última vez) para deixar mais claro que hasOwnPropertysó pode ser usado da maneira prescrita para verificar a existência de varvariáveis. Está tudo bem para mim.
Fred Gandt
68

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.

John Slegers
fonte
41

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 : '';
RajeshKdev
fonte
a resposta, pois é totalmente errada. A variável typeof sempre retorna uma string, portanto nunca é falsa. por exemplo, se typeof(booooo)é "undefined"então typeof(typeof boooooo)é "string"e typeof boooooo && trueé sempre true. A resposta de John-Slegers é a mais abreviada possível com o typeof.
mpag 5/05
É uma resposta absolutamente correta . Aqui está um violino em funcionamento . E eu não sei de qual cenário você está falando. A questão é verificar a existência de variáveis.
RajeshKdev
@mpag Não diga nada errado. Prove . Encontrar um erro é bem fácil, em vez disso, você pode fornecer Boas respostas aqui !!!. Se a resposta estiver errada, 28 programadores não teriam votado sem verificar minha resposta. Uma vez que existem muitas respostas de renome aqui, eles poderiam ter votado positivamente nisso, e não isso.
RajeshKdev
Na verdade, o segundo trecho de código não é o mesmo da condição acima. Eu pensei que as pessoas entenderiam por essa linha If you wanted to check variable shouldn't be undefined or null.. Por esse comentário, é claramente indicado, não é necessário executar a verificação da declaração da variável. isso é para verificar o valor da variável.
RajeshKdev
1
seu segundo cheque falhará com o valor 0
Fareed Alnamrouti
32

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).

user2878850
fonte
esse é o "caminho canônico" que é portátil?
Jason
3
Isto está errado. window.bar=undefinedé definido e definido como um valor. Sua resposta falha ao detectar a diferença entre isso e se a variável não existe. Se você fez this.hasOwnProperty('bar')isso pode ter funcionado.
oligofren
esse código não funciona e você pode verificar isso usando qualquer console do navegador
ha9u63ar
1
Considere const x = 0; (() => console.log(x, this.hasOwnProperty('x')))();. A variável xé definida, mas falso é retornado ...
user2878850
29

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.

Alan Geleynse
fonte
12

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 ...

tempestade
fonte
1
O ponto é discutível, porque se varName for indefinido, varName !== undefinedcausará apenas um ReferenceError. A mutabilidade de undefinednão importa.
Wutaz 27/03
Atenção
1
Nas versões Javascript mais recentes, undefinedé uma propriedade somente leitura. No entanto, para ser à prova de balas, você pode usar typeof mvVar === typeof void 0. void 0retorna undefinedsempre.
precisa saber é o seguinte
11
if (typeof console != "undefined") {    
   ...
}

Ou melhor

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

Funciona em todos os navegadores

boslior
fonte
3
Por que o último é melhor na sua opinião?
skalee
3
@skalee Concordo que o último é melhor. Pelo simples motivo de verificar se os tipos são os desejados antes de usá-los.
Broxzier 10/07/2013
Atenção
9

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)
} 

de3
fonte
Não foi isso que o OP pediu. Se data.url for igual à ''sua solução, a considerará indefinida, quando na verdade é definida como contendo uma sequência vazia.
Demonblack 14/01
Concordo que não foi o que foi solicitado, e você está certo: a string vazia '' seria considerada indefinida. Mas publiquei isso porque achei que poderia ser útil no debate que foi criado entre diferentes respostas. E, no exemplo, assim como em muitos outros casos, você só deseja imprimir uma string se realmente houver conteúdo; portanto, é bom aproveitar o fato de o javascript considerar falsas as strings vazias e as indefinidas
de3
8

É 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);

Jith
fonte
1
Seria útil mostrar em linha a saída de cada alerta.
Demisx
@demisx Concordou, mas em vez de sugerir a edição, por que não fazê-la? A opção existe por um motivo. Alguns podem considerar isso rude; Eu o considero eficiente - então editei a resposta (revisão pendente).
Fred Gandt
1
@ Fred - Eu olhei para o histórico de edição e posso adivinhar por que suas edições foram rejeitadas ... em vez de apenas adicionar linhas para mostrar qual seria a saída, como sugeriu o demisx, você mudou significativamente o que Jith havia postado.
Stephen P
8

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
}
Razan Paul
fonte
7

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;
Zv_oDD
fonte
7

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.

Ravindra Miyani
fonte
1
Atenção
7

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");
}
Ferran Maylinch
fonte
O que você quer dizer com "extrair o código para uma função"?
Melab 26/01
7

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.

Bekim Bacaj
fonte
1
O inoperador testa apenas a existência de propriedades, e nem todas as variáveis ​​são propriedades - conste as letdeclarações não são (e constnem são, bem, variáveis ).
amn
1
conste letforam padronizados com o ECMAScript 2015, que foi publicado há mais de 3 anos e desde então tem sido adotado pelos suspeitos de sempre e é usado de maneira difundida hoje, ouso dizer - há mais de 2 milhões de ocorrências de "const" no Github em arquivos JS .
amn
Sim, "variável" - exatamente. É por isso que comentei sua resposta, salientando que você não pode usar o inoperador para geralmente testar se existe uma variável , porque "const e let não são [propriedades]" - embora, de constfato, possa-se dizer que introduz uma referência constante , como ao contrário de uma referência de variávellet , por outro lado, na verdade introduz uma referência de variável - é, em outras palavras, por qualquer medida, uma variável e sua resposta está incorreta ao sugerir que você pode testar se uma variável definida com letexiste usando o inoperador - você não pode.
quer
A especificação ECMAScript 6 define a linguagem JavaScript, não você nem um navegador da Web. É por isso que é chamado de especificação - especifica sem ambiguidade o idioma. Sua resposta está, na melhor das hipóteses, desatualizada, na pior das hipóteses, intencionalmente omite o que você considera irrelevante, embora seja muito relevante. Citando a especificação vinculada, "as declarações let e const definem variáveis". Essas construções não são acessíveis como propriedades do windowobjeto, não sei como deixar isso mais claro para você.
amn
A resposta não cobre todos os casos de variáveis. Especificamente, ele não cobre variáveis ​​definidas com a letpalavra - chave. Era tudo o que eu estava apontando.
amn
6

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.

skalee
fonte
Atenção
2
Falso. o último lança uma exceção no meu console.
john ktejik
6

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.

SoEzPz
fonte
5

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)

curtwphillips
fonte
Se você colocá-lo em uma função, é redundante. typeof (x) != 'undefined' && x != nullé equivalente a x != nullquando xé declarado.
Ry-
3

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"
jpsimons
fonte
3

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)

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

se (a == b)

Digite a descrição da imagem aqui

se (a === b)

Digite a descrição da imagem aqui

Kamil Kiełczewski
fonte
1
Para sua informação, (a == b) colocada na grade do Jogo da Vida não foi tão emocionante.
johnsnails
1

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!
Daniel
fonte
Isto está errado. window.bar=undefinedé definido e definido como um valor. Sua resposta falha ao detectar a diferença entre isso e se a variável não existe. Se você fez this.hasOwnProperty('bar')isso pode ter funcionado.
oligofren
0

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

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

GalaxyCat105
fonte