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




verificar se uma variavel é nula javascript (19)

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

if (elem) { // or !elem

ou

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

ou

if (elem != null) {

Verificar se um objeto hasOwnProperty()

Uma alternativa para a multiplicidade de respostas, é o uso de hasOwnProperty() que, claro, verifica se um objeto (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 objeto possui a propriedade especificada como propriedade própria (não herdada).

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

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

O que é ótimo sobre o hasOwnProperty() é que, ao chamá-lo, não usamos uma variável que ainda pode ser indefinida - o que, é claro, é metade do problema em primeiro lugar.

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


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 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 foo não foram definidos, porque você não pode passar uma variável não existente para uma função:

Incapaz ReferenceError: foo não está definido

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

Embora nossa função 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 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

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


A resposta mais alta está correta, use typeof.

No entanto, o que eu queria salientar era que, em JavaScript, o undefined é mutável (por alguma razão ímpia). Portanto, simplesmente fazer uma verificação de varName !== undefined tem o potencial de nem sempre retornar como você espera, 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 ...


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 fácil ler um liner, você pode fazer isso frequentemente:

elem = elem || defaultElem;

Muitas vezes é bom usar, consulte: Forma idiomática para definir o valor padrão em javascript

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

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

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.


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 torna mais fácil 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 objeto global). Mas se você está mexendo com globals como este, você provavelmente 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 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 linting) e evita a possibilidade de seu global ser sombreado por uma variável local. Além disso, se os globais fizerem sua pele se rastejar, você pode se sentir mais confortável tocando-os apenas com este bastão relativamente longo.


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á foi inicializado ; Como posso verificar se ele já está declarado?

Ou ainda melhor - como faço para verificar imediatamente se "Book1.chapter22.paragraph37" existe com uma única chamada, mas não aumenta 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 pico de popularidade AJAX 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.


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.


Há outra maneira breve 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 : '';

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 : '';

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

Seja qual for a sua escolha, considere colocar o cheque em uma função 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)


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 procuramos apenas pelo console no escopo global (que é um objeto 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 excelente resposta, explica detalhes técnicos. Eu só adicionei falta de conclusão e digeri em algo mais fácil de ler.


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
}

Para contribuir com o debate, se eu souber que a variável deve ser uma string ou um objeto 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); 
}

.. pode ser reduzido para:

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


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

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

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

Se você quiser bloco indefinido para fazer algo ou atribuir ou definir a variável, então use este

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

Um pouco mais funcional e fácil de usar:

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

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


indefinido, booleano, string, número, função

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

}

Objeto, matriz

if( foo instanceof Array ) { 

}

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.


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

Ou melhor

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

Funciona em todos os navegadores





undefined