Comprobación de JavaScript si existe una variable (está definida / inicializada)

1767

¿Qué método para verificar si una variable se ha inicializado es mejor / correcto? (Suponiendo que la variable pueda contener cualquier cosa (cadena, int, objeto, función, etc.))

if (elem) { // or !elem

o

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

o

if (elem != null) {
Samuel Liew
fuente
55
si desea saber si foose declara, typeof foo === 'undefined'o bientypeof foo === typeof undefined
1
Las respuestas altamente votadas no funcionan para las variables que se declaran pero tienen el valor undefined. La respuesta correcta es esta: stackoverflow.com/a/36432729/772035
Paul
@Paulpro, la versión que usa hasOwnProperty('bar')no tiene las mismas deficiencias que las otras, pero requeriría algún ajuste para Node (reemplazar windowcon global).
oligofren
@Paulpro De hecho, pero mientras reflexionaba sobre eso antes de responder, llegué a la conclusión de que no es realmente un problema práctico. Cuando se trata de variables de ámbito de bloque o función, generalmente es código que posee o tiene acceso de escritura, por lo que en cualquier caso tendrá un error de tiempo de ejecución que se puede corregir. Mientras que el problema habitual con las variables que no se ha definido (no existe) suele estar en el código fuera de su control, por lo que necesita una forma de detectarlo. Entonces es la solución 80/20.
oligofren

Respuestas:

3056

Tú quieres el typeofoperador . Específicamente:

if (typeof variable !== 'undefined') {
    // the variable is defined
}
Jim Puls
fuente
35
Esta parece una buena solución, pero ¿puedes explicar por qué funciona?
Morgan Cheng
46
En realidad, debe verificar que el objeto es lo que necesita que sea. Entonces eso sería si (typeof console == 'object') {// variable es lo que necesito que sea}
staticsan
59
@George IV: "just do` if (variable) "- um, no, eso falla por falso y 0.
Jason S
17
'if (variable)' también falla al probar la existencia de propiedades de objeto.
scotts
54
@ geowa4 En realidad, arrojará un error si la variable no está definida.
kevinji
857

El typeofoperador verificará si la variable está realmente indefinida.

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

El typeofoperador, a diferencia de los otros operadores, no lanza una excepción ReferenceError cuando se usa con una variable no declarada.

Sin embargo, tenga en cuenta que typeof nullvolverá "object". Tenemos que tener cuidado para evitar el error de inicializar una variable null. Para estar seguros, esto es lo que podríamos usar en su lugar:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

Para obtener más información sobre el uso de la comparación estricta en ===lugar de la igualdad simple ==, consulte:
¿Qué operador igual (== vs ===) debe usarse en las comparaciones de JavaScript?

Samuel Liew
fuente
2
if (! variable_here) {// su código aquí. }; no se sabe si la variable es falsa o indefinida
boh
55
if(! variable_here)se romperá en muchos casos. Si la variable es 0 o falsa, fallará. Eso no es lo que quieres.
Cory Danielson
2
No puedo decidir si votar arriba. Estrictamente hablando, typeof foo === "undefined"es correcto y mejor que la respuesta más votada, pero las notas adicionales solo hacen que esta respuesta sea confusa.
Alnitak
1
@StevenPenny Verifique la línea de tiempo. La respuesta principal se fusionó con otra pregunta después de que esta respuesta fue publicada
Rob
1
Esta respuesta no funciona. Esta es la única respuesta aquí que funciona: stackoverflow.com/a/36432729/772035
Paul
222

En muchos casos, usando:

if (elem) { // or !elem

¡hará el trabajo por usted! ... esto verificará los siguientes casos:

  1. indefinido : si el valor no está definido y esundefined
  2. nulo : si es nulo, por ejemplo, si no existe un elemento DOM ...
  3. cadena vacía :''
  4. 0 : número cero
  5. NaN : no es un número
  6. falso

Por lo tanto, cubrirá todos los casos, pero siempre hay casos extraños que también nos gustaría cubrir, por ejemplo, una cadena con espacios, como este ' ', esto se definirá en JavaScript ya que tiene espacios dentro de la cadena ... por ejemplo, en este caso, agrega un cheque más usando trim (), como:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

Además, estas comprobaciones son solo para valores , ya que los objetos y las matrices funcionan de manera diferente en Javascript, la matriz []vacía y el objeto vacío {}siempre son verdaderos .

Creo la imagen a continuación para mostrar un breve resumen de la respuesta:

indefinido, nulo, etc.

Alireza
fuente
2
@Alireza, ¡bien! Su respuesta ayudará a mucha gente por ahí. Ya memoricé estos valores falsos, de lo único que no estaba seguro era de [].
Thiago Yoithi
13
Me sale un "ReferenceError: elem no está definido"
ropo
3
@ropo, es porque incluso no definiste el elemento para verificar qué es, si es tu caso, debes verificarlo con typeof (elem) === "string" que ya se mencionó ...
Alireza
19
Entonces, la respuesta es engañosa cuando dice if(elem)verificaciones indefinidas (aunque devuelve un error no definido), ¿no?
Fanky
1
¿Me da un caso de uso para verificar si una variable no está definida y si está definida con un valor indefinido? Algunos de ustedes se están aferrando a las pajitas e intentan lucir brillantes, pero si configuran un valor como indefinido y buscan ese valor, obviamente devolverá falso o necesitarán cambiar su código, smh ... ¡¡esta respuesta es correcta !! !!!
almcaffee
210

En JavaScript, se puede definir una variable, pero mantener el valor undefined, por lo que la respuesta más común no es técnicamente correcta, y en su lugar realiza lo siguiente:

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
}

Eso puede ser suficiente para sus propósitos. La siguiente prueba tiene una semántica más simple, lo que hace que sea más fácil describir con precisión el comportamiento de su código y comprenderlo usted mismo (si le importan tales cosas):

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

Esto, por supuesto, supone que se está ejecutando en un navegador (donde windowes un nombre para el objeto global). Pero si estás jugando con globals como este, probablemente estés en un navegador. Subjetivamente, usar 'name' in windowes estilísticamente consistente con usar window.namepara referirse a los globales. El acceso a los globales como propiedades de las windowvariables, en lugar de hacerlo como variables, le permite minimizar el número de variables no declaradas a las que hace referencia en su código (en beneficio de la alineación), y evita la posibilidad de que su variable global sea sombreada por una variable local. Además, si los glóbulos hacen que su piel se erice, es posible que se sienta más cómodo al tocarlos solo con este palo relativamente largo.

Brian Kelley
fuente
77
Esto solo verifica si la variable se declaró globalmente. Si está codificando correctamente, está limitando sus variables globales. Informará falso para vars locales: (function () {var sdfsfs = 10; console.log ("sdfsfs" en la ventana);}) () `
Eddie Monge Jr
2
Esta es la mejor respuesta de f $ # ^% ing. Estaba al final de esto tratando de descubrir cómo explicar exactamente este caso de esquina. Brillante. No tenía idea de que pudieras hacer esto.
temporary_user_name
1
Atención
Para usuarios angulares: Desafortunadamente, no parece estar permitido en una declaración ng-if.
qwertzguy
... plano perfecto para controles a lo largo del alcance. ¿tiene alguna indicación de rendimiento, si está "en la ventana" o "(typeof variable === 'undefined' || variable === null)". En realidad, estoy interesado en una prueba de hechos duros y no en una justificación potencial argumentada (que podría hacer yo mismo: la segunda cláusula tiene más operaciones -> peor rendimiento)
rápido el
119

En la mayoría de los casos usaría:

elem != null

A diferencia de un simple if (elem), que permite 0, false, NaNy '', pero rechaza nullo undefined, lo que es una buena, prueba general para la presencia de un argumento, o la propiedad de un objeto.


Las otras verificaciones tampoco son incorrectas, solo tienen diferentes usos:

  • if (elem): Se puede utilizar si elemse garantiza que sea un objeto, o si false, 0, etc. se consideran valores "por defecto" (por lo tanto equivalente a undefinedo null).

  • typeof elem == 'undefined'se puede usar en casos donde un especificado nulltiene un significado distinto para una variable o propiedad no inicializada.

    • Esta es la única comprobación que no arrojará un error si elemno se declara (es decir var, no hay una declaración, no es una propiedad windowo no es un argumento de función). Esto es, en mi opinión, bastante peligroso ya que permite que los errores tipográficos pasen desapercibidos. Para evitar esto, vea el siguiente método.

También es útil una comparación estricta contra undefined:

if (elem === undefined) ...

Sin embargo, debido a que el global undefinedse puede anular con otro valor, es mejor declarar la variable undefineden el alcance actual antes de usarlo:

var undefined; // really undefined
if (elem === undefined) ...

O:

(function (undefined) {
    if (elem === undefined) ...
})();

Una ventaja secundaria de este método es que los minificadores JS pueden reducir la undefinedvariable a un solo carácter, ahorrándole unos pocos bytes cada vez.

David Tang
fuente
17
Estoy sorprendido de que puedas anularlo undefined. Ni siquiera creo que valga la pena mencionarlo en la respuesta. Probablemente el peor nombre de variable aceptable en todo Javascript.
Cory Danielson
2
Esto causa una excepción y requiere que use window.antes de la variable si se usa en el contexto global ... esta no es la mejor manera.
Alex W
44
Debido a este problema primordial, SIEMPRE debe usar en void(0)lugar de undefined.
Bartłomiej Zalewski
1 ya esta respuesta señala que a veces puede que en realidad quiere identificar false, 0, etc., como valores no válidos.
rinogo
77

Comprueba si window. hasOwnProperty( " varname" )

Una alternativa a la gran cantidad de typeofrespuestas;

Variables globales declaradas con una var varname = value;declaración en el alcance global

Se puede acceder como propiedades del objeto de ventana.

Como tal, el hasOwnProperty()método, que

devuelve un valor booleano que indica si el objeto tiene la propiedad especificada como su propia propiedad (en lugar de heredarla)

puede usarse para determinar si

a varde "varname" ha sido declarado globalmente, es decir, es una propiedad de 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
] );

Lo bueno de esto hasOwnProperty()es que al llamarlo, no usamos una variable que aún no esté declarada, lo que, por supuesto, es la mitad del problema en primer lugar.

Aunque no siempre es la solución perfecta o ideal , en ciertas circunstancias, ¡es solo el trabajo!

Notas

Lo anterior es cierto cuando se usa varpara definir una variable , en oposición a la letcual:

declara una variable local de ámbito de bloque, opcionalmente inicializándola en un valor.

es diferente a la varpalabra clave, que define una variable globalmente o localmente para una función completa, independientemente del alcance del bloque.

En el nivel superior de programas y funciones, a letdiferencia de esto var, no crea una propiedad en el objeto global.

Para completar: las const constantes, por definición, no son realmente variables (aunque su contenido puede serlo); más relevante:

Las constantes globales no se convierten en propiedades del objeto de ventana, a diferencia de las varvariables. Se requiere un inicializador para una constante; es decir, debe especificar su valor en la misma declaración en la que se declara.

El valor de una constante no puede cambiar mediante la reasignación, y no se puede volver a declarar.

La declaración const crea una referencia de solo lectura a un valor. No significa que el valor que posee es inmutable, solo que el identificador de variable no se puede reasignar.

Dado que las letvariables o constconstantes nunca son propiedades de ningún objeto que haya heredado el hasOwnProperty()método, no se puede usar para verificar su existencia.

En cuanto a la disponibilidad y uso de hasOwnProperty():

Cada objeto que desciende de Object hereda el hasOwnProperty()método. [...] a diferencia del inoperador, este método no verifica la cadena prototipo del objeto.

Fred Gandt
fuente
1
Esta es una alternativa increíble y debería estar en la parte superior de esta pregunta. Simplifique el título de la respuesta con un ejemplo de trabajo que devuelve true(por ejemplo, window.hasOwnProperty('console')o var hop = "p";window.hasOwnProperty('hop')).
CPHPython
2
Finalmente, algo que no arroja un error por acceder a un miembro que no existe ... Algo que todas las typeofrespuestas simplemente pasan por alto.
Zelphir Kaltstahl
1
Esta respuesta está desactualizada: según ECMAScript estándar, puede definir variables con las letque estas variables no están disponibles como propiedades del objeto window[o cualquier otro disponible]. hasOwnPropertyprueba la presencia de propiedades , no variables y, por lo tanto, no puede utilizarse para detectar variables definidas por let.
amn
1
@amn La respuesta sigue siendo cierta con respecto al uso vary, en ese sentido, no está desactualizada. Sin embargo, he agregado una nota que describe cómo el uso de lety constdifiere del de var. Gracias por tu inspiracion; juntos nos levantamos :)
Fred Gandt
1
@amn He reescrito la respuesta (con suerte por última vez) para dejar más claro que hasOwnPropertysolo se puede usar de la manera prescrita para verificar la existencia de varvariables. Se lee bien para mí.
Fred Gandt
68

Cómo verificar si existe una variable

Esta es una solución bastante a prueba de balas para probar si existe una variable y se ha inicializado:

var setOrNot = typeof variable !== typeof undefined;

Se usa más comúnmente en combinación con un operador ternario para establecer un valor predeterminado en caso de que una determinada variable no se haya inicializado:

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

Problemas con la encapsulación

Desafortunadamente, no puede simplemente encapsular su cheque en una función.

Puede pensar en hacer algo como esto:

function isset(variable) {
    return typeof variable !== typeof undefined;
}

Sin embargo, esto producirá un error de referencia si está llamando, por ejemplo. isset(foo)y la variable foono se ha definido, porque no puede pasar una variable no existente a una función:

Error de referencia no capturado: foo no está definido


Prueba de si los parámetros de la función no están definidos

Si bien nuestra issetfunción no se puede usar para probar si una variable existe o no (por las razones explicadas anteriormente), nos permite probar si los parámetros de una función no están definidos:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

Aunque no yse transfiere ningún valor a la función test, nuestra issetfunción funciona perfectamente en este contexto, porque yse conoce en la función testcomo un undefinedvalor.

John Slegers
fuente
41

Hay otra forma abreviada de verificar esto, cuando realiza tareas simples y verificaciones relacionadas. Simplemente use el operador condicional (ternario).

var values = typeof variable !== 'undefined' ? variable : '';

Esto también será útil cuando intente declarar la variable Global con asignación de instancia de la variable de referencia.

Si desea verificar la variable no debe ser undefinedonull . Luego realice la verificación a continuación.

Cuando se declara la variable, y si desea verificar el valor, esto es incluso Simple: y se realizaría undefinedy nullverificaría en conjunto.

var values = variable ? variable : '';
RajeshKdev
fuente
la respuesta ya que es completamente incorrecta. La variable typeof siempre devuelve una cadena, por lo que nunca es falsa. por ejemplo, si typeof(booooo)es "undefined"entonces typeof(typeof boooooo)es "string"y typeof boooooo && truees siempre true. La respuesta de @ John-Slegers es tan abreviada como se puede obtener con typeof.
mpag
Es la respuesta absolutamente correcta . Aquí hay un violín que funciona . Y no sé de qué escenario estás hablando. La pregunta es sobre verificar la existencia variable.
RajeshKdev
@mpag No digas mal por completo. Probarlo . Encontrar un error es realmente fácil, en su lugar, puede proporcionar buenas respuestas aquí. Si la respuesta es totalmente errónea, 28 programadores no habrían votado sin comprobar mi respuesta. Dado que aquí hay muchas respuestas reputadas, podrían haber votado a favor, no esto.
RajeshKdev
En realidad, la segunda parte del código no es verificar lo mismo que la condición anterior. Pensé que la gente entendería por esta línea If you wanted to check variable shouldn't be undefined or null., por este comentario, está indicando claramente, no realizar la verificación de declaración de variables. eso es para verificar el valor variable.
RajeshKdev
1
su segundo cheque fallará con valor 0
Fareed Alnamrouti
31

La forma corta de probar una variable no se declara (no está indefinida) es

if (typeof variable === "undefined") {
  ...
}

Lo encontré útil para detectar secuencias de comandos que se ejecutan fuera de un navegador (sin haber declarado la windowvariable).

usuario2878850
fuente
¿Es esta la "forma canónica" que es portátil?
Jason
3
Esto está mal. window.bar=undefinedse define y se establece en un valor. Su respuesta no detecta la diferencia entre esto y si la variable no existe. Si lo hicieras this.hasOwnProperty('bar'), podría haber funcionado.
oligofren
este código no funciona y puede verificarlo utilizando cualquier consola del navegador
ha9u63ar
1
Considere const x = 0; (() => console.log(x, this.hasOwnProperty('x')))();. La variable xse define pero se devuelve falso ...
user2878850
29

Depende si solo le importa que la variable se haya definido o si desea que tenga un valor significativo.

Al verificar si el tipo no está definido, se verificará si la variable ya se ha definido.

=== nullo !== nullsolo verificará si el valor de la variable es exactamentenull .

== nullo != nullcomprobará si el valor es undefinedonull .

if(value)comprobará si la variable es undefined, null, 0, o una cadena vacía.

Alan Geleynse
fuente
12

La respuesta más alta es correcta, use typeof.

Sin embargo, lo que quería señalar era que en JavaScript undefinedes mutable (por alguna razón impía). Por lo tanto, simplemente hacer una verificación de varName !== undefinedtiene el potencial de no siempre regresar como lo espera, porque otras bibliotecas podrían haber cambiado indefinidamente. Algunas respuestas (@ skalee, por ejemplo), parecen preferir no usartypeof , y eso podría en problemas.

La forma "antigua" de manejar esto era declarar indefinido como var para compensar cualquier posible silenciamiento / anulación undefined. Sin embargo, la mejor manera es usarlo typeofporque ignorará cualquier anulación de undefinedotro código. Especialmente si está escribiendo código para usar en la naturaleza donde quién sabe qué más podría estar ejecutándose en la página ...

sombra de la tormenta
fuente
1
El punto es discutible, porque si varName no está definido varName !== undefined, solo causará un ReferenceError. La mutabilidad de undefinedno importará.
Wutaz
Atención
1
En las versiones más recientes de Javascript undefinedes una propiedad de solo lectura. Sin embargo, para ser a prueba de balas, puede usar typeof mvVar === typeof void 0. void 0vuelve undefinedsiempre.
kwarnke
11
if (typeof console != "undefined") {    
   ...
}

O mejor

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

Funciona en todos los navegadores.

boslior
fuente
3
¿Por qué este último es mejor en tu opinión?
skalee
3
@skalee Estoy de acuerdo, este último es mejor. Esto por la simple razón de que verifica si los tipos son los que desea antes de usarlos.
Broxzier
Atención
9

Para contribuir al debate, si sé que la variable debe ser una cadena o un objeto que siempre prefiero if (!variable), compruebe si es falsa. Esto puede llevar a un código más limpio para que, por ejemplo:

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

.. podría reducirse a:

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

de3
fuente
Esto no es lo que pidió el OP. Si data.url es igual a ''su solución, lo consideraría indefinido, cuando de hecho se define como que contiene una cadena vacía.
Demonblack
Estoy de acuerdo en que no es lo que se ha pedido, y tiene razón: la cadena vacía '' se consideraría indefinida. Pero publiqué esto porque pensé que podría ser útil en el debate que se ha creado entre diferentes respuestas. Y en el ejemplo, así como en muchos otros casos, solo desea imprimir una cadena si realmente hay contenido, por lo que está bien aprovechar el hecho de que JavaScript considera falsa tanto la cadena vacía como la indefinida
de3
8

Es difícil distinguir entre indefinido y nulo. Nulo es un valor que puede asignar a una variable cuando desea indicar que la variable no tiene un valor particular. Indefinido es un valor especial que será el valor predeterminado de las variables no asignadas.


var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

Jith
fuente
1
Sería útil mostrar en línea el resultado de cada alerta.
retiro el
@demisx De acuerdo, pero en lugar de sugerir la edición, ¿por qué no simplemente hacerlo? La opción está ahí por una razón. Algunos pueden considerarlo grosero; Lo considero eficiente, así que edité la respuesta yo mismo (pendiente de revisión).
Fred Gandt
1
@Fred: miré el historial de edición y puedo adivinar por qué se rechazaron tus ediciones ... en lugar de solo agregar líneas para mostrar cuál sería el resultado, como sugirió Demisx, cambiaste significativamente lo que Jith había publicado.
Stephen P
8

Nulo es un valor en JavaScript y typeof nulldevuelve"object"

Por lo tanto, la respuesta aceptada no funcionará si pasa valores nulos. Si pasa valores nulos, debe agregar una verificación adicional para los valores nulos:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}
Razan Paul
fuente
7

La verificación más robusta "está definido" es con typeof

if (typeof elem === 'undefined')

Si solo está buscando una variable definida para asignar un valor predeterminado, para una línea fácil de leer, a menudo puede hacer esto:

elem = elem || defaultElem;

A menudo está bien usar, ver: forma idiomática de establecer el valor predeterminado en javascript

También existe este forro con la palabra clave typeof :

elem = (typeof elem === 'undefined') ? defaultElem : elem;
Zv_oDD
fuente
7

puedes usar el typeof operador.

Por ejemplo,

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

El fragmento de código anterior devolverá la salida como

conjunto de datos variable es: indefinido.

Ravindra Miyani
fuente
1
Atención
7

Para verificar si una variable ha sido declarada / establecida, hice este truco sucio.

No he encontrado una manera de extraer el código a una función, incluso con 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
fuente
¿Qué quiere decir con "extraer el código a una función"?
Melab
7

Estas respuestas (aparte de la solución de Fred Gandt) son incorrectas o están incompletas.

Supongamos que necesito variableName;que lleve un undefinedvalor y, por lo tanto, se ha declarado de una manera tal var variableName;que significa que ya está inicializado ; - ¿Cómo verifico si ya está declarado?

O incluso mejor: ¿cómo verifico de inmediato si "Book1.chapter22.paragraph37" existe con una sola llamada, pero no surge un error de referencia?

Lo hacemos utilizando el operador JasvaScript más poderoso, el operador in .:

"[variable||property]" in [context||root] 
>> true||false

En tiempos de máxima popularidad de AJAX, he escrito un método (más tarde llamado) isNS () que es capaz de determinar si el espacio de nombres existe, incluyendo pruebas profundas para nombres de propiedades como "Book1.chapter22.paragraph37" y mucho más.

Pero dado que se ha publicado anteriormente y, debido a su gran importancia, merece ser publicado en un hilo separado, no lo publicaré aquí, pero proporcionaré palabras clave ( javascript + isNS ) que lo ayudarán a localizar el código fuente, respaldado con todos los explicaciones necesarias

Bekim Bacaj
fuente
1
El inoperador solo prueba la existencia de propiedades, y no todas las variables son propiedades, consty las letdeclaraciones no lo son (y constni siquiera son, bueno, variables ).
amn
1
consty letse estandarizaron con ECMAScript 2015, que se publicó hace más de 3 años y desde entonces ha sido visto por los sospechosos habituales, y hoy en día se usa de manera bastante generalizada, me atrevo a decir: hay más de 2 millones de casos de "const" en Github en archivos JS .
amn
Sí, "variable" - exactamente. Es por eso que comenté tu respuesta, señalando que no puedes usar el inoperador para probar si una variable existe, porque "const y let no son [propiedades]", mientras constque se puede decir que introduce una referencia constante , como opuesto a una referencia de variablelet , por otro lado, en realidad introduce una referencia de variable ; en otras palabras, es, por cualquier medida, una variable y su respuesta es incorrecta al implicar que puede probar si letexiste una variable definida con utilizando el inoperador, no puedes.
amn
La especificación ECMAScript 6 define el lenguaje JavaScript, no usted ni un navegador web. Es por eso que se llama una especificación : especifica inequívocamente el idioma. Su respuesta es, en el mejor de los casos, obsoleta, en el peor de los casos, omite intencionalmente lo que considera irrelevante, mientras que es muy relevante. Citando la especificación vinculada, "las declaraciones let y const definen variables". Estas construcciones no son accesibles como propiedades del windowobjeto, no sé cómo aclararlo.
amn
La respuesta no cubre todos los casos de variables. Específicamente, no cubre las variables definidas con la letpalabra clave. Eso es todo lo que estaba señalando.
amn
6

En la situación particular descrita en la pregunta,

typeof window.console === "undefined"

es idéntico a

window.console === undefined

Prefiero el último ya que es más corto.

Tenga en cuenta que solo buscamos consoleen el ámbito global (que es un windowobjeto en todos los navegadores). En esta situación particular es deseable. No queremosconsole definirse en otra parte.

@BrianKelley en su gran respuesta explica los detalles técnicos. Solo he agregado falta de conclusión y lo digerí en algo más fácil de leer.

skalee
fuente
Atención
2
Falso. este último arroja una excepción en mi consola.
John Ktejik
6

Yo uso dos formas diferentes dependiendo del objeto.

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

A veces no quiero evaluar una cadena vacía como falsey, entonces uso este caso

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

Si necesita lo contrario, en primera instancia, ¡variable se convierte en variable, y en la función no válida === se convierte! = Y los nombres de las funciones cambian a notInvalid.

SoEzPz
fuente
5

Mi preferencia es typeof(elem) != 'undefined' && elem != null.

Sin importar cómo elija, considere poner el cheque en una función como esta

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

Si no sabe que la variable está declarada, continúe con typeof (x) != 'undefined' && x != null;

Cuando sepa que la variable está declarada pero puede no existir, puede usar

existy(elem) && doSomething(elem);

La variable que está comprobando puede ser una propiedad anidada a veces. Puedes usar prop || {} para ir más abajo comprobando la existencia de la propiedad en cuestión:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

Después de cada propiedad use (... '|| {}'). NextProp para que una propiedad faltante no arroje un error.

O podrías usar existy como existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Curtwphillips
fuente
Si lo pones en una función, es redundante. typeof (x) != 'undefined' && x != nulles equivalente a x != nullcuando xse declara.
Ry-
3

Depende de la situación. Si está buscando algo que puede o no haberse definido globalmente fuera de su código (tal vez jQuery quizás) desea:

if (typeof(jQuery) != "undefined")

(No hay necesidad de igualdad estricta allí, typeof siempre devuelve una cadena). Pero si tiene argumentos para una función que puede o no haberse pasado, siempre se definirán, pero serán nulos si se omiten.

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"
jpsimons
fuente
3

Trata de atraparlo

Si la variable no se definió en absoluto, puede verificar esto sin la ejecución del código de interrupción usando el bloque try-catch de la siguiente manera (no necesita use strictmodo)

BONIFICACIÓN: (refiriéndose a otras respuestas) ¿Por qué ===es más claro que ==( fuente )

si (a == b)

Ingrese la descripción de la imagen aquí

si (a === b)

Ingrese la descripción de la imagen aquí

Kamil Kiełczewski
fuente
1
Para su información, (a == b) colocado en la cuadrícula Game of Life no fue tan emocionante.
johnsnails
1

Me sorprende que esto no haya sido mencionado todavía ...

Aquí hay un par de variaciones adicionales usando this['var_name']

El beneficio de usar este método es que puede usarse antes de definir una variable.

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
fuente
Esto está mal. window.bar=undefinedse define y se establece en un valor. Su respuesta no detecta la diferencia entre esto y si la variable no existe. Si lo hicieras this.hasOwnProperty('bar'), podría haber funcionado.
oligofren
0

Podrías usar un try ... catch block como el siguiente:

Una desventaja es que no puede ponerlo en una función, ya que arrojaría un ReferenceError

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))

GalaxyCat105
fuente