¿Cómo puedo determinar si una variable es 'indefinida' o 'nula'?

¿Cómo determino si la variable es undefined or null?

Mi código es el siguiente:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};
<div id="esd-names">
  <div id="name"></div>
</div>

Pero si hago esto, el intérprete de JavaScript detiene la ejecución.

preguntado el 15 de abril de 10 a las 15:04

Utilice el operador coalescente Nullish incorporado (??) Ref; desarrollador.mozilla.org/en-US/docs/Web/JavaScript/Reference/… -

@DennisNolan Esta pregunta se hizo en 2010 -

30 Respuestas

Puede utilizar las cualidades del operador de igualdad abstracto para hacer esto:

if (variable == null){
    // your code here.
}

Porque null == undefined es cierto, el código anterior capturará tanto null y undefined.

Respondido 20 Jul 17, 21:07

Estoy tratando de probar si el evento es nulo en Firefox y un error bloquea la ejecución: "el evento no está definido" - Entretoizar

@MichaelFever ¿Cómo no funciona eso? Copia y pega esto en tu consola: const y = undefined; y == null; Debería volver true - Estarán

@ChrisStryczynski En el ejemplo de su comentario que declaró y constante, pero vas a comparar abc (¿No estás registrado como y). Cuando probé y vía console.log(y == null); en Chrome y Firefox tengo true como resultado. Si tiene un error, tal vez intentó usar el operador de asignación = en lugar de comparación == lo que tendría sentido devolver un error ya que const no se puede reasignar. - pshemo

podría ser complicado: undefined !== null -> verdadero undefined == null -> cierto - d.popov

ejemplo vivo de comparaciones relevantes. lgtm. - ryan haining

La forma estándar de atrapar null y undefined simultáneamente es esto:

if (variable == null) {
     // do something 
}

- que es 100% equivalente al más explícito pero menos conciso:

if (variable === undefined || variable === null) {
     // do something 
}

Al escribir JS profesional, se da por sentado que la igualdad de tipos y el comportamiento de == vs === está entendido. Por lo tanto usamos == y solo comparar con null.


Editar de nuevo

Los comentarios que sugieren el uso de typeof son simplemente equivocada. Sí, mi solución anterior causará un ReferenceError si la variable no existe. Ésto es una cosa buena. Este ReferenceError es deseable: lo ayudará a encontrar sus errores y corregirlos antes de enviar su código, tal como lo harían los errores del compilador en otros lenguajes. Usar try/catch si está trabajando con entradas sobre las que no tiene control.

No debe tener referencias a variables no declaradas en su código.

Respondido el 20 de diciembre de 19 a las 03:12

Esto causará un ReferenceError y romperá la ejecución si la variable no está definida o no se hace referencia a ella en absoluto en el código, usar typeof es más seguro. - Mani Gandham

Eso es más un punto estilístico. Si la variable no ha sido declarada en todos los, eso es realmente una mala escritura por parte del autor. Debe saber si su variable ha sido declarada o no, eso no debería ser una pregunta. Pero si, Si por alguna razón ese es el caso, esto debería cambiarse a ventana.variable en lugar de solo variable, que no provocará un error de referencia. Debe evitarse el tipo de. - nombre_usuario_temporal

Si porque tu escribiste !== en lugar de !=. - nombre_usuario_temporal

-OP: La afirmación de que esas comparaciones son "100% equivalentes" es SIMPLEMENTE INCORRECTA, como señaló en su propia EDICIÓN, la segunda causará un ReferenceError. En cuanto a la afirmación: "No debe tener referencias a variables no declaradas en su código". ¿DE VERDAD? ¿Has oído hablar de los parámetros opcionales? jsfiddle.net/3xnbxfsu - timoteo kanski

Los parámetros opcionales de @TimothyKanski pueden no estar definidos si no se proporcionan opcionalmente, pero definitivamente son variables declaradas. Están declarados y tienen un valor de undefined, como lo haría cualquier variable declarada pero no inicializada, es decir var someVar; para que su argumento realmente no se sostenga - chiliNUT

Combinando las respuestas anteriores, parece que la respuesta más completa sería:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

Esto debería funcionar para cualquier variable no declarada o declarada y establecida explícitamente como nula o indefinida. La expresión booleana debe evaluarse como falsa para cualquier variable declarada que tenga un valor real no nulo.

Respondido 09 Feb 15, 10:02

@Aerovistae reconozco que typeof es un operador, no una función, por lo que no necesita los paréntesis, pero aprecio los paréntesis de todos modos, simplemente para leer con claridad. - user664833

¿Qué hay de verificar directamente si (variable === undefined) en lugar de usar typeof? - Crayón congelado

@ArjunU que causará un ReferenceError si la variable no se declara. Si no sabe si una variable está declarada o no, utilice la solución anterior. Si puede garantizar que la variable esté al menos declarada, puede usar variable == null - Pícaro

Esta es una mejor solución porque, como señaló @Rogue, es posible que la variable no se declare. - Abdul Sadik Yalcin

Corrígeme si me equivoco, pero ¿no es el primer condicional un superconjunto del segundo y, por lo tanto, el segundo condicional es superfluo? - Marzo Ho

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

Respondido el 26 de diciembre de 13 a las 14:12

En caso de que alguien piense que esta es otra respuesta a medias, esto realmente funciona. undefined evalúa igual a null. - Arrojar

Error en la consola de Chrome ... ReferenceError: la variable no está definida, por lo que podría funcionar, pero no para mí ... - Eran Medan

Solo funciona para variables declaradas, no variables que pueden o no declararse, lo que rara vez es el caso. (Debe usar typeof + una verificación nula para ese caso) - user216441

Sólo descubierto puedes agregar este comentario: /*jshint eqnull:true */ en la parte superior de su documento o función JS, y JSHint dejará de advertirle sobre sus usos de == null. - Diseñador web

@Aerovistae, ¿puedes señalarme una referencia que establezca explícitamente que == está roto. El coercitivo if(variable == null) en esta respuesta tiene mucho sentido para mí ... - ben aston

if (typeof EmpName != 'undefined' && EmpName) {

evaluará como verdadero si el valor no es:

  • nulo

  • indefinido

  • Yaya

  • cuerda vacía ("")

  • 0

  • false

Respondido el 14 de diciembre de 17 a las 07:12

Creo que esta es una técnica peligrosa que se ha extendido como la pólvora. Porque muchas de las variables que se comprueban pueden ser booleanas o números. Entonces, si el usuario no comprende completamente las consecuencias, esto no es bueno. - útilAbeja

Proporcione una referencia de esta especificación de JavaScript: villamejía

Esto es lo mismo que if (EmpName). Si es undefined ya será falso. - Rudy

Si la variable no está definida. entonces si (EmpName) arrojará un error - tamaraiselvam

@Thamaraiselvam Creo que Rudy podría haber querido decir esto var EmpName; if (EmpName). Donde la variable está definida pero no se le asigna un valor. - estrella del hambre

jQuery attr() La función devuelve una cadena en blanco o el valor real (y nunca null or undefined). La única vez que regresa undefined es cuando su selector no devolvió ningún elemento.

Por lo tanto, es posible que desee realizar una prueba con una cadena en blanco. Alternativamente, dado que las cadenas en blanco, nulas e indefinidas son falsas, puede hacer esto:

if (!EmpName) { //do something }

Respondido 15 Abr '10, 19:04

Chrome 17.0.963.78 m da este error: ReferenceError: EmpName is not defined - Eran Medan

@EranMedan Sé que es tarde, pero espero que ayude a las personas que vengan aquí más tarde. La razón por la que obtiene un error es porque no se ha declarado en absoluto. Por lo general, haría que EmpName (o alguna otra variable) se pasara a una función, o el valor de retorno de otra función y, por lo tanto, se declarara (Ejemplo: "var x;"). Para probar si devolvió una cadena indefinida, nula o en blanco, puede usar la solución anterior. - David

Me doy cuenta de que esta es una pregunta fría, pero jQuery volverá undefined si el atributo no existe en el elemento (no solo si el selector no tiene elementos coincidentes, según la respuesta). Por ejemplo, un img con ningún src volvería undefined por $('img').attr('src'); - codificación de manos

Probablemente la forma más corta de hacer esto es:

if(EmpName == null) { /* DO SOMETHING */ };

Aquí está la prueba:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

Y aquí hay más detalles sobre == (Fuente aquí)

Ingrese la descripción de la imagen aquí

BONUS: razón por qué === es mas claro que == (buscar en respuesta agc)

Ingrese la descripción de la imagen aquí

contestado el 11 de mayo de 20 a las 09:05

He venido a escribir mi propia función para esto. JavaScript es extraño.

Se puede utilizar literalmente en cualquier cosa. (Tenga en cuenta que esto también comprueba si la variable contiene algún valores. Pero dado que esta información generalmente también es necesaria, creo que vale la pena publicarla). Considere dejar una nota.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Compatible con TypeScript.


Esta función debería hacer exactamente lo mismo que PHP empty() función (consulte la sección del RETURN VALUES)

Considera undefined, null, false, 0, 0.0, "0" {}, [] como vacío.

"0.0", NaN, " ", true se consideran no vacíos.

respondido 08 mar '20, 23:03

Me he encontrado con un pequeño problema de verificación nula. Quiero verificar si un parámetro que se pasa es nulo o un objeto vacío { }. Este es un problema de lenguaje común y tonto, pero lo había olvidado. Todas mis búsquedas muestran respuestas para valores indefinidos o nulos, o comparaciones de igualdad sueltas (==), pero no igualdad estricta (===) o equivalente. Y luego aquí, en su respuesta clasificada -1 en el muy abajo de la página (antes de votar a favor) es la respuesta que se me escapó. Object.keys( obj ).length < 1 o quizás === 0, asumiendo que nunca será -1. De todos modos, votó a favor a 0, corteja. : p - usuario2895783

Gracias, pude colocar esta función y limpiar mucho código. Por qué esta no es una función estándar de JS me supera. - Andy

Deberías cambiar todos los de tu == a === aquí, entonces esta sería una función razonable. - ben mcintyre

El más corto y sencillo:

if(!EmpName ){
 // DO SOMETHING
}

esto evaluará verdadero si EmpName es:

  • nulo
  • indefinido
  • Yaya
  • vacío
  • cuerda ("")
  • 0
  • false

Respondido 15 ago 19, 12:08

El caso de uso aquí es que quiero saber la diferencia entre indefinido y falso. Usaré el cheque en nulo entonces. - invitado128

Si la variable que desea verificar es global, haga

if (window.yourVarName) {
    // Your code here
}

Esta forma de verificar no arrojará un error incluso si el yourVarName variable no existe.

Ejemplo: quiero saber si mi navegador es compatible con la API de historial

if (window.history) {
    history.back();
}

Cómo funciona esto:

window es un objeto que contiene todas las variables globales como sus propiedades, y en JavaScript es legal intentar acceder a una propiedad de objeto no existente. Si history no existe entonces window.history devoluciones undefined. undefined es falso, así que codifique en un if(undefined){} el bloque no se ejecutará.

Respondido 05 Feb 15, 20:02

Los lectores deben tener en cuenta que un enfoque como este es idiomático para verificar, desde JavaScript que se ejecuta en un navegador, si un global se ha declarado una variable, y especialmente si está disponible una global proporcionada por el navegador (como la API de historial). Eso no trabajará para comprobar si una variable no global es null or undefined, tampoco funcionará si su JavaScript se ejecuta fuera de un navegador (es decir, en Node.js). También tratará los globales configurados para 0, false or '' los mismos que los que no están declarados o undefined or null, que suele estar bien. - marca amery

Esto supone que el script se está ejecutando en un navegador. Eso no es un hecho. - verdecomojade

In JavaScript, según mi conocimiento, podemos comprobar un indefinido, nulo or vacío variable como a continuación.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Consulta todas las condiciones:

if(variable === undefined || variable === null || variable === ''){
}

Respondido 01 Jul 20, 08:07

var es una palabra reservada, esto arrojará SyntaxError - dhilt

@dhilt implementado de var a variable - Hardik Desai

Ya que estas usando jQuery, puede determinar si una variable no está definida o su valor es nulo utilizando una única función.

var s; // undefined
jQuery.isEmptyObject(s); // will return true;

s = null; // defined as null
jQuery.isEmptyObject(s); // will return true;

// usage
if(jQuery.isEmptyObject(s)){
    alert('Either variable: s is undefined or its value is null');
}else{
     alert('variable: s has value ' + s);
}

s = 'something'; // defined with some value
jQuery.isEmptyObject(s); // will return false;

contestado el 06 de mayo de 16 a las 01:05

Esto no funcionó para mí. Todavía tengo el error: ReferenceError: s is not defined para el primer ejemplo. - Mark

Acabo de tener este problema, es decir, comprobar si un objeto es nulo.
Yo simplemente uso esto:

if (object) {
    // Your code
}

Por ejemplo:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

contestado el 19 de mayo de 19 a las 04:05

sería mejor establecer var A = document.getElementById ("enterJob") if (A) A.className + = 'current'; de esta manera haces un 50% de trabajo para obtener el mismo resultado ... Pero tal vez solo lo hiciste para los shows y luego te saludo. - harry svensson

Simplemente puede usar lo siguiente (sé que hay formas más cortas de hacer esto, pero esto puede facilitar la observación visual, al menos para otros que miran el código).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

contestado el 11 de mayo de 20 a las 09:05

El elemento de verificación de jQuery no es nulo:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

respondido 08 mar '20, 23:03

La forma más sencilla de comprobarlo es:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

contestado el 28 de mayo de 19 a las 07:05

Esto ejecutará el código si la variable tiene un valor de false, que es potencialmente indeseable. - pantalones

La pregunta es clara "¿Cómo determinar si la variable es 'indefinida' o 'nula'?" y en javascript si una variable tiene un valor nulo o indefinido, su valor es falso. - M. Arnoldo

Lo siento, pero eso es incorrecto. Aquí hay un JSfiddle probarlo. - pantalones

Por tu respuesta, undefined, null y algunas otras cosas como cadena vacía, +0, -0 NaN y false atravesar. ! operador coacciona al operando- aquí variable- a booleano: ecma-international.org/ecma-262/#sec-toboolean - Alireza

Pero compruebe la pregunta: "Cómo determinar si una variable no está definida o es nula", el! El operando usado con un if siempre volverá a verdadero si la variable es nula o indefinida. - M. Arnoldo

Con la siguiente solución:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Puedo verificar lo siguiente:

  • nulo
  • indefinido
  • Yaya
  • vacío
  • cuerda ("")
  • 0
  • false

Respondido el 12 de diciembre de 17 a las 10:12

Esto no responde a la pregunta, que es "¿cómo puedo detectar nulos e indefinidos?" no "¿cómo capto todos los valores falsos en JavaScript?" - nombre_usuario_temporal

@Aerovistae, pensé que lo hice con console.log (isDeepEqual (null, null)); y console.log (isDeepEqual (undefined, undefined)); ? - Tony Tai Nguyen

Para probar si una variable es nula o indefinida, utilizo el siguiente código.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

Respondido el 20 de Septiembre de 19 a las 00:09

Cerca pero no. Perder el typeof y comparar con undefined directamente, no como una cuerda. Esto funciona, pero el operador adicional no tiene ningún efecto más que hacerlo más prolijo. - nombre_usuario_temporal

En este caso, sí, tiene razón, no es necesario utilizar typeof. Pero es una buena práctica utilizar typeof cuando se trata de variables indefinidas. Una razón para usar typeof es que no arroja un error si la variable no ha sido declarada. - dankodi

Eso es realmente algo malo. No desea variables no declaradas en su código. Quiere que arroje un ReferenceError para que pueda encontrar la variable y declararla. ¡Ciertamente no intentarías eso en un lenguaje compilado como C ++! El hecho de que JS lo permita no significa que deba hacerse. - nombre_usuario_temporal

Tu declaración o está al revés. Comprobar que algo no está definido sería el primer paso, no el segundo. - antonio rutledge

Ejecuto esta prueba en la consola de Chrome. Usando (void 0) puede marcar undefined:

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

respondido 08 mar '20, 23:03

Veamos esto

  1.  

    let apple; // Only declare the variable as apple
    alert(apple); // undefined
    

    En lo anterior, la variable solo se declara como apple. En este caso, si llamamos al método alert se mostrará indefinido.

  2.  

       let apple = null; /* Declare the variable as apple and initialized but the value is null */
       alert(apple); // null
    

En el segundo se muestra nulo, porque la variable de apple el valor es nulo.

Entonces puede verificar si un valor no está definido o es nulo.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

respondido 08 mar '20, 23:03

La foo == null check debería hacer el truco y resolver el caso "indefinido O nulo" de la manera más breve. (Sin considerar el caso "foo no se declara".) Pero las personas que están acostumbradas a tener 3 iguales (como la mejor práctica) podrían no aceptarlo. Solo mira eqeqeq or triple-igual reglas en eslint y tslint ...

El enfoque explícito, cuando estamos comprobando si una variable es undefined or null por separado, debe aplicarse en este caso, y mi contribución al tema (¡27 respuestas no negativas por ahora!) es utilizar void 0 como una forma corta y segura de realizar la comprobación de undefined.

Usar foo === undefined no es seguro porque undefined no es una palabra reservada y se puede sombrear (DND). Utilizando typeof === 'undefined' check es seguro, pero si no nos va a importar el caso foo-is-undeclared, se puede utilizar el siguiente enfoque:

if (foo === void 0 || foo === null) { ... }

respondido 16 mar '20, 23:03

si crea una función para verificarlo:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

contestado el 11 de mayo de 20 a las 07:05

(null == undefined)  // true

(null === undefined) // false

Porque === comprueba tanto el tipo como el valor. El tipo de ambos es diferente pero el valor es el mismo.

contestado el 27 de mayo de 18 a las 12:05

Sé que llego 10 años tarde. Pero dejaré mi respuesta aquí en caso de que alguien necesite un método corto.

Instalación Lodash en su proyecto podría ser útil debido a las funciones auxiliares que podrían resultar útiles en estas situaciones.

Usando módulos ES6, la importación se vería así:

import isNull from 'lodash/isNull';

import isUndefined from 'lodash/isUndefined';

import isNil from 'lodash/isNil';

Sería mejor si solo se importasen las funciones utilizadas.

Lodash's isNull comprueba si el valor es nulo.

const value = null;
 
 if(isNull(value)) {
    // do something if null
 }

lodash's es indefinido comprueba si el valor no está definido.

const value = undefined;

if(isUndefined(value)) {
   // do something if undefined.
}

esNil Comprueba si el valor es nulo OR indefinido. Prefiero este método sobre otros dos, porque verifica tanto undefined como null.

respondido 18 nov., 20:16

Mejor manera:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

contestado el 25 de mayo de 16 a las 12:05

Esta solución exacta ya fue proporcionada por @jkindwall el 11 de octubre de 2013. stackoverflow.com/a/19323555/2943403 Esta publicación de solo código es completamente inútil porque no agrega ningún valor nuevo a la página. De hecho, está aumentando la cantidad de páginas y haciendo perder el tiempo a los investigadores leyéndolas. Elimina esta respuesta. - mickmackusa

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

respondido 08 mar '20, 23:03

¿Qué sucede si el usuario ingresa la palabra 'indefinido'? - Arrojar

Su pregunta es buena, muestra que la condición es verdadera, por lo que debemos cambiar la opción normal indefinida a tipo de condición. @Chuck - KARTHIKEYAN.A

Esto está mal. typeof nunca cederá undefined, solo la cuerda 'undefined'. Por otra parte, i == null ya es cierto si i is undefined, por lo que el segundo booleano sería redundante incluso si funcionara. - nombre_usuario_temporal

Esta solución (con las condiciones revertidas) ya fue proporcionada por @jkindwall el 11 de octubre de 2013. stackoverflow.com/a/19323555/2943403 Esta publicación de solo código es completamente inútil porque no agrega ningún valor nuevo a la página. De hecho, está aumentando la cantidad de páginas y haciendo perder el tiempo a los investigadores leyéndolas. Elimina esta respuesta. - mickmackusa

Llamar a typeof null devuelve un valor de "objeto", ya que el valor especial null se considera una referencia de objeto vacía. Safari hasta la versión 5 y Chrome hasta la versión 7 tienen una peculiaridad en la que llamar a typeof en una expresión regular devuelve "función" mientras que todos los demás navegadores devuelven "objeto".

respondido 06 mar '14, 11:03

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

Solo puede usar el segundo: ya que verificará tanto la definición como la declaración

Respondido 15 ago 15, 11:08

Sigo pensando que la forma mejor / segura de probar estas dos condiciones es convertir el valor en una cadena:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

respondido 08 mar '20, 23:03

¿Puede explicar por qué cree que esta es la "mejor manera / segura" de realizar las pruebas? - microondas

Debido a que la conversión siempre devuelve una cadena "estandarizada" (es decir, [objeto indefinido]), no se mete en problemas al probar valores falsos. Esa es solo mi opinión basada en experiencias que tuve con valores de verdad / falsedad. - n1kkou

Gracias por la explicación. No estoy criticando, es una respuesta interesante, solo quería que proporcionara una explicación para otros de por qué esto es potencialmente superior a otros métodos. - microondas

¡Sin preocupaciones! Tuve muchos problemas con este tipo de comparaciones y, hasta ahora, lo encuentro como el enfoque más útil para este asunto. - n1kkou

Simplest answer: 

if (! EmpName) {HACER ALGO};

respondido 30 mar '21, 22:03

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.