Comprobar si el objeto existe en JavaScript

¿Cómo verifico la existencia de un objeto en JavaScript?

Los siguientes trabajos:

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

Pero esto arroja un error:

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

El error:

maybeObject no está definido.

Puede usar el typeofoperador de forma segura en variables indefinidas.

Si se le ha asignado algún valor, incluido nulo, typeof devolverá algo distinto de indefinido. typeof siempre devuelve una cadena.

Por lo tanto

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

Aquí hay muchas medias verdades, así que pensé en aclarar algunas cosas.

En realidad, no puede saber con precisión si existe una variable (a menos que desee ajustar cada segunda línea en un bloque try-catch).

La razón es que Javascript tiene este notorio valor, lo undefinedque sorprendentemente no significa que la variable no esté definida o que no exista.undefined !== not defined

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

Entonces, tanto una variable que existe como otra que no puede informarle undefined tipo.

En cuanto a la idea errónea de Kevin @, null == undefined. Se debe a la coerción de tipo, y es la razón principal por la que Crockford sigue diciéndole a todos los que no están seguros de este tipo de cosas que siempre usen un operador de igualdad estricto ===para probar posibles valores falsos. null !== undefinedte da lo que podrías esperar. Tenga en cuenta también que foo != nullpuede ser una forma efectiva de verificar si una variable no es undefinedninull . Por supuesto, puede ser explícito, porque puede ayudar a la legibilidad.

Si restringe la pregunta para verificar si existe un objeto, typeof o == "object"puede ser una buena idea, excepto si no considera los objetos de matrices, ya que también se informará que ese tipo objectpuede confundirlo un poco. Sin mencionar que typeof nulltambién te daráobject que simplemente está mal.

La zona primaria donde realmente se debe tener cuidado con typeof, undefined, null, unknowny otros misterios son objetos de acogida. No se puede confiar en ellos. Son libres de hacer casi cualquier cosa sucia que quieran. Así que tenga cuidado con ellos, verifique la funcionalidad si puede, porque es la única forma segura de usar una función que puede no existir.

Puedes usar:

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

Dos caminos.

typeof para variables locales

Puede probar un objeto local usando typeof:

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

ventana para variables globales

Puede probar un objeto global (uno definido en el alcance global) inspeccionando el objeto de la ventana:

if (window.FormData) {}

Si ese es un objeto global, puede usar if (!window.maybeObject)

Podrías usar "typeof".

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

El hilo se abrió hace bastante tiempo. Mientras tanto, creo que el uso de un operador ternario es la opción más simple:

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

Solía ​​hacer un if(maybeObject)chequeo nulo en mis javascripts.

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

Entonces, solo si maybeObject- es un objeto, se mostrará la alerta. Tengo un ejemplo en mi sitio.

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

Acabo de probar los ejemplos typeOf de arriba y ninguno funcionó para mí, así que en su lugar he usado esto:

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

Además de verificar la existencia del objeto / variable, es posible que desee proporcionar una salida del "peor de los casos" o al menos atraparlo en una alerta para que no pase desapercibido.

Ejemplo de función que verifica, proporciona alternativas y detecta errores.

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

También creé esto porque el objeto que le estaba pasando podría ser x, xm, xm [z] y typeof xm [z] fallaría con un error si xm no existiera.

Espero que ayude. (Por cierto, soy novato con JS)

para mí esto funcionó para un objeto DOM:

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

Si solo le importa su existencia (¿se ha declarado?), La respuesta aprobada es suficiente:

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

Si le importa que tenga un valor real, debe agregar:

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

Como typeof( null ) == "object"

p.ej bar = { x: 1, y: 2, z: null}

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

de esta manera verifica que no sea ninguno nullo undefined, y dado typeofque no se produce un error si el valor no existe más&& los cortocircuitos, nunca obtendrá un error en tiempo de ejecución.

Personalmente, sugeriría agregar un ayudante fn en alguna parte (y no confiemos 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!");

establezca el valor del cuadro de texto en un cuadro en línea usando el panel con pestañas de alineación div. Entonces, antes que nada, antes de establecer el valor, debemos verificar que el marco de paneles con pestañas seleccionado esté disponible o no utilizando los siguientes 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>

cero y nulo son punteros implícitos. Si no está haciendo aritmética, comparando o imprimiendo '0' en la pantalla, no hay necesidad de escribirlo. Es implícito. Como en implícito. Typeof tampoco se requiere por la misma razón. Reloj.

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

No vi la solicitud de un no o de lo contrario no está incluido como. Por mucho que me encanta el contenido extra que no encaja en la pregunta. Vamos a mantenerlo simple.

Creo que es más fácil así

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

O bien, todos ustedes pueden comenzar a usar mi exclusivo existe () método lugar y ser capaces de hacer cosas consideradas imposibles. es decir:

Cosas como: exists("blabla")o incluso: exists("foreignObject.guessedProperty.guessNext.propertyNeeded")también son posibles ...