Verifique se o objeto existe em JavaScript

Como verifico a existência de um objeto em JavaScript?

Os seguintes trabalhos:

if (!null)
   alert("GOT HERE");

Mas isso gera um erro:

if (!maybeObject)
   alert("GOT HERE");

O erro:

maybeObject não está definido.

Você pode usar o typeofoperador com segurança em variáveis ​​indefinidas.

Se tiver sido atribuído algum valor, incluindo nulo, typeof retornará algo diferente de indefinido. typeof sempre retorna uma string.

Portanto

if (typeof maybeObject != "undefined") {
   alert("GOT THERE");
}

Há muitas meias-verdades aqui, então pensei em deixar algumas coisas mais claras.

Na verdade, você não pode dizer com precisão se existe uma variável (a menos que queira agrupar cada segunda linha em um bloco try-catch).

O motivo é que o Javascript tem esse notório valor, o undefinedque surpreendentemente não significa que a variável não está definida ou que não existeundefined !== not defined

var a;
alert(typeof a); // undefined (declared without a value)
alert(typeof b); // undefined (not declared)

Portanto, tanto uma variável que existe como outra que não existe podem informar o undefined tipo.

Quanto @ equívoco de Kevin, null == undefined. Isso se deve à coerção de tipos, e é a principal razão pela qual Crockford continua dizendo a todos que não têm certeza desse tipo de coisa que sempre usem um operador de igualdade estrita ===para testar possíveis valores falsos. null !== undefineddá-lhe o que você poderia esperar. Observe também que essa foo != nullpode ser uma maneira eficaz de verificar se uma variável não é nem undefinednem null. Claro que você pode ser explícito, porque isso pode ajudar na legibilidade.

Se você restringir a pergunta para verificar se existe um objeto, typeof o == "object"pode ser uma boa idéia, exceto se você não considerar objetos de matrizes, pois isso também será relatado como o tipo objectque pode deixar você um pouco confuso. Sem mencionar que typeof nulltambém lhe dará o objectque está simplesmente errado.

A área primal onde você realmente deve ter cuidado com typeof, undefined, null, unknowne outros mistérios são objetos de acolhimento. Eles não podem ser confiáveis. Eles são livres para fazer quase qualquer coisa suja que quiserem. Portanto, tenha cuidado com eles, verifique a funcionalidade, se puder, porque é a única maneira segura de usar um recurso que talvez nem exista.

Você pode usar:

if (typeof objectName == 'object') {
    //do something
}

Dois caminhos.

typeof para variáveis ​​locais

Você pode testar um objeto local usando typeof:

if (typeof object !== "undefined") {}

janela para variáveis ​​globais

Você pode testar um objeto global (um definido no escopo global) inspecionando o objeto da janela:

if (window.FormData) {}

Se esse é um objeto global, você pode usar if (!window.maybeObject)

Você pode usar "typeof".

if(typeof maybeObject != "undefined")
    alert("GOT HERE");

O tópico foi aberto há algum tempo. Enquanto isso, o uso de um operador ternário é a opção mais simples:

maybeObject ? console.log(maybeObject.id) : ""

Eu costumava fazer uma if(maybeObject)verificação nula nos meus javascripts.

if(maybeObject){
    alert("GOT HERE");
}

Portanto, apenas se maybeObject- for um objeto, o alerta será mostrado. Eu tenho um exemplo no meu site.

https://sites.google.com/site/javaerrorsandsolutions/home/javascript-dynamic-checkboxes

Acabei de testar os exemplos typeOf de cima e nenhum funcionou para mim; portanto, usei isso:

    btnAdd = document.getElementById("elementNotLoadedYet");
    if (btnAdd) {
       btnAdd.textContent = "Some text here";
    } else {
      alert("not detected!");
    }

Além de verificar a existência do objeto / variável, você pode fornecer uma saída de "pior caso" ou, pelo menos, prendê-la em um alerta para que ela não seja despercebida.

Exemplo de função que verifica, fornece alternativas e captura erros.

function fillForm(obj) {
  try {
    var output;
    output = (typeof obj !== 'undefined') ? obj : '';
    return (output);
  } 
  catch (err) {
    // If an error was thrown, sent it as an alert
    // to help with debugging any problems
    alert(err.toString());
    // If the obj doesn't exist or it's empty 
    // I want to fill the form with ""
    return ('');
  } // catch End
} // fillForm End

Eu criei isso também porque o objeto que eu estava passando para ele poderia ser x, xm, xm [z] e typeof xm [z] falharia com um erro se xm não existisse.

Espero que ajude. (BTW, eu sou iniciante com JS)

para mim isso funcionou para um objeto DOM:

if(document.getElementsById('IDname').length != 0 ){
   alert("object exist");
}

Se você se importa apenas com a sua existência (foi declarada?), A resposta aprovada é suficiente:

if (typeof maybeObject != "undefined") {
   alert("GOT THERE");
}

Se você se importa com o valor real, deve adicionar:

if (typeof maybeObject != "undefined" && maybeObject != null ) {
   alert("GOT THERE");
}

Como typeof( null ) == "object"

por exemplo bar = { x: 1, y: 2, z: null}

typeof( bar.z ) == "object" 
typeof( bar.not_present ) == "undefined" 

Dessa forma, você verifica se não é nem nullou undefined, e como typeofnão existe erro se o valor não existir mais um &&curto-circuito, você nunca receberá um erro em tempo de execução.

Pessoalmente, sugiro adicionar um auxiliar fn em algum lugar (e não vamos confiar typeof()):

function exists(data){
   data !== null && data !== undefined
}

if( exists( maybeObject ) ){
    alert("Got here!"); 
}

if (n === Object(n)) {
   // code
}

if (maybeObject !== undefined)
  alert("Got here!");

defina o valor da Caixa de texto como um quadro para o quadro embutido usando o painel com guias div alignmnt. Então, antes de tudo, antes de definir o valor, precisamos verificar a moldura dos painéis com guias disponíveis ou não usar os seguintes códigos:

Código Javascript:

/////////////////////////////////////////
<script>

function set_TextID()
            {
                try
                    {
                        if(!parent.frames["entry"])
                            {
                            alert("Frame object not found");    
                            }
                            else
                            {
                                var setText=document.getElementById("formx").value;
                                parent.frames["entry"].document.getElementById("form_id").value=setText;
                            }
                            if(!parent.frames["education"])
                            {
                            alert("Frame object not found");    

                            }
                            else
                            {
                                var setText=document.getElementById("formx").value;
                                parent.frames["education"].document.getElementById("form_id").value=setText;
                            }
                            if(!parent.frames["contact"])
                            {
                            alert("Frame object not found");    

                            }
                            else
                            {
                                var setText=document.getElementById("formx").value;
                                parent.frames["contact"].document.getElementById("form_id").value=setText;
                            }

                        }catch(exception){}
                }

</script>

zero e nulo são ponteiros implícitos. Se você não estiver fazendo aritmética, comparação ou impressão de '0' na tela, não há necessidade de digitá-la. Está implícito. Como está implícito. Typeof também não é necessário pelo mesmo motivo. Ver.

se (obj) console.log ("existe");

Eu não vi o pedido de um não ou então não está incluído como. Tanto quanto eu amo conteúdo extra que não se encaixa na pergunta. Vamos mantê-lo simples.

Acho que é mais fácil assim

if(myobject_or_myvar)
    alert('it exists');
else
   alert("what the hell you'll talking about");

Ou, você pode começar a usar o meu método existir () exclusivo e poder fazer coisas consideradas impossíveis. ou seja:

Coisas como:, exists("blabla")ou até: exists("foreignObject.guessedProperty.guessNext.propertyNeeded")também são possíveis ...