Controlla se l'oggetto esiste in JavaScript

Come posso verificare l'esistenza di un oggetto in JavaScript?

Le seguenti opere:

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

Ma questo genera un errore:

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

L'errore:

maybeObject non è definito.

È possibile utilizzare in sicurezza l' typeofoperatore su variabili non definite.

Se è stato assegnato un valore qualsiasi, incluso null, typeof restituirà qualcosa di diverso da non definito. typeof restituisce sempre una stringa.

Perciò

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

Ci sono molte mezze verità qui, quindi ho pensato di chiarire alcune cose.

In realtà non puoi dire con precisione se esiste una variabile (a meno che tu non voglia avvolgere ogni seconda riga in un blocco try-catch).

Il motivo è che Javascript ha questo famigerato valore di undefinedcui sorprendentemente non significa che la variabile non sia definita o che non esistaundefined !== not defined

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

Quindi sia una variabile che esiste che un'altra che non può segnalarti il undefined tipo.

Per quanto riguarda @ equivoco di Kevin, null == undefined. È dovuto alla coercizione del tipo, ed è il motivo principale per cui Crockford continua a dire a tutti coloro che non sono sicuri di questo tipo di cose di usare sempre un rigoroso operatore di uguaglianza ===per testare valori eventualmente falsi. null !== undefinedti dà quello che potresti aspettarti. Si noti inoltre che foo != nullpuò essere un modo efficace per verificare se una variabile non è né undefinedné né null. Naturalmente puoi essere esplicito, perché può aiutare la leggibilità.

Se si limita la domanda per verificare se esiste un oggetto, typeof o == "object"può essere una buona idea, tranne se non si considerano gli array array, poiché anche questo verrà segnalato come il tipo objectche potrebbe lasciarti un po 'confuso. Per non parlare del fatto che typeof nullti darà anche ciò objectche è semplicemente sbagliato.

L'area primordiale in cui si dovrebbe essere attenti typeof, undefined, null, unknowne altri misteri sono oggetti host. Non ci si può fidare di loro. Sono liberi di fare quasi ogni cosa sporca che vogliono. Quindi fai attenzione con loro, controlla la funzionalità se puoi, perché è l'unico modo sicuro di utilizzare una funzionalità che potrebbe anche non esistere.

Puoi usare:

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

Due strade.

typeof per variabili locali

Puoi testare un oggetto locale usando typeof:

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

finestra per variabili globali

È possibile verificare un oggetto globale (uno definito nell'ambito globale) ispezionando l'oggetto finestra:

if (window.FormData) {}

Se questo è un oggetto globale, puoi usare if (!window.maybeObject)

È possibile utilizzare "typeof".

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

Il thread è stato aperto molto tempo fa. Penso che nel frattempo l'uso di un operatore ternario sia l'opzione più semplice:

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

Facevo solo un if(maybeObject)controllo null nei miei javascript.

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

Quindi solo se maybeObject- è un oggetto, verrà mostrato l'avviso. Ho un esempio nel mio sito.

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

Ho appena testato il tipo di esempi dall'alto e nessuno ha funzionato per me, quindi invece ho usato questo:

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

Oltre a controllare l'esistenza dell'oggetto / variabile, potresti voler fornire un output "nel peggiore dei casi" o almeno intercettarlo in un avviso in modo che non passi inosservato.

Esempio di funzione che controlla, fornisce alternative e rileva errori.

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

L'ho creato anche perché l'oggetto a cui stavo passando potrebbe essere x, xm, xm [z] e il tipo di xm [z] fallirebbe con un errore se xm non esistesse.

Spero possa essere d'aiuto. (A proposito, sono alle prime armi con JS)

per me questo ha funzionato per un oggetto DOM:

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

Se ti interessa solo della sua esistenza (è stata dichiarata?), La risposta approvata è sufficiente:

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

Se ti interessa che abbia un valore effettivo, dovresti aggiungere:

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

Come typeof( null ) == "object"

per esempio bar = { x: 1, y: 2, z: null}

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

in questo modo si controlla che non sia né nullo undefined, e poiché typeofnon si verifica un errore se il valore non esiste più&& corto circuiti, si otterrà mai un errore di run-time.

Personalmente, suggerirei di aggiungere un assistente fn da qualche parte (e non fidiamoci 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!");

imposta il valore Casella di testo su un fotogramma per incorporare il riquadro utilizzando il pannello a schede div alignmnt. Quindi prima di tutto, prima di impostare il valore, è necessario controllare la cornice dei pannelli a schede selezionata disponibile o non utilizzare i seguenti codici:

Codice 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 null sono puntatori impliciti. Se non si esegue l'aritmetica, il confronto o la stampa di "0" sullo schermo, non è necessario digitarlo effettivamente. È implicito. Come implicito. Anche Typeof non è richiesto per lo stesso motivo. Orologio.

if (obj) console.log ("esiste");

Non ho visto la richiesta di un no o altrimenti lì perché non è incluso come. Per quanto adoro i contenuti extra che non rientrano nella domanda. Lascialo semplice.

Penso che sia più facile in questo modo

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

In alternativa, puoi iniziare a utilizzare il mio metodo esclusivo esiste () invece ed essere in grado di fare cose considerate impossibili. vale a dire:

Cose come: exists("blabla")o anche: exists("foreignObject.guessedProperty.guessNext.propertyNeeded")sono anche possibili ...