Pregunta ¿Existe una función estándar para verificar las variables nulas, indefinidas o en blanco en JavaScript?


¿Existe una función universal de JavaScript que compruebe que una variable tiene un valor y asegura que no es undefined o null? Tengo este código, pero no estoy seguro si cubre todos los casos:

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}

1601
2018-04-01 15:14


origen


Respuestas:


Puedes simplemente verificar si el variable tiene un truthy valor o no. Eso significa

if( value ) {
}

evaluará a true Si value es no:

  • nulo
  • indefinido
  • Yaya
  • cuerda vacía ("")
  • 0
  • falso

La lista anterior representa todo lo posible falsy valores en ECMA- / Javascript. Encuéntralo en el especificación en el ToBoolean sección.

Además, si no lo haces saber si existe una variable (es decir, si fue declarado) deberías consultar con el typeof operador. Por ejemplo

if( typeof foo !== 'undefined' ) {
    // foo could get resolved and it's defined
}

Si puedes estar seguro de que variable se declara al menos, debe verificar directamente si tiene un truthy valor como se muestra arriba.

Lea más: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html


3296
2018-04-01 15:17



El método detallado para verificar si el valor es indefinido o nulo es:

return value === undefined || value === null;

También puedes usar el == operador pero esto espera que uno conocer todas las reglas:

return value == null; // also returns true if value is undefined

150
2018-04-01 15:20



function isEmpty(value){
  return (value == null || value.length === 0);
}

Esto volverá verdadero para

undefined  // Because undefined == null

null

[]

""

y funciones de argumento cero desde la función de length es la cantidad de parámetros declarados que toma.

Para rechazar esta última categoría, es posible que desee comprobar cadenas en blanco

function isEmpty(value){
  return (value == null || value === '');
}

55
2018-04-01 15:19



Sé que esta es una vieja pregunta, pero este es el cheque más seguro y no lo he visto publicado exactamente así:

if (typeof value != 'undefined' && value) {
    //deal with value'
};

Cubrirá casos donde valor nunca fue definido, y también cualquiera de estos:

  • nulo
  • indefinido (valor de indefinido no es lo mismo que un parámetro que nunca se definió)
  • 0
  • "" (cuerda vacía)
  • falso
  • Yaya

PD no hay necesidad de una igualdad estricta en typeof value! = 'undefined'


26
2017-11-10 16:13



La primera respuesta con la mejor calificación es incorrecta. Si el valor no está definido arrojará una excepción en los navegadores modernos. Tienes que usar:

if (typeof(value) !== "undefined" && value)

o

if (typeof value  !== "undefined" && value)

25
2018-03-19 13:23



Puede encontrar útil la siguiente función:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

O en ES7 (comentario si hay más mejoras)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

Resultados:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date

"Tenga en cuenta que el operador de enlace (: :) no es parte de ES2016 (ES7) ni ninguna edición posterior del estándar ECMAScript en absoluto. Actualmente es una propuesta de etapa 0 (informal) para introducirse en el idioma". - Simon Kjellberg. el autor desea agregar su apoyo a esta hermosa propuesta para recibir la ascensión real.


23
2018-02-12 10:32



! compruebe si hay cadenas vacías (""), nulas, indefinidas, falsas y el número 0 y NaN. Digamos, si una cadena está vacía var name = "" entonces console.log(!name) devoluciones true.

function isEmpty(val){
  return !val;
}

esta función volverá verdadera si val es vacío, nulo, indefinido, falso, el número 0 o NaN.


16
2018-01-23 06:56



Estás exagerando un poco. Para verificar si a una variable no se le da un valor, solo necesitaría verificar contra indefinido y nulo.

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}

Esto está asumiendo 0, "", y los objetos (incluso el objeto vacío y la matriz) son "valores" válidos.


10
2018-04-01 15:21



Aquí está el mío: devuelve verdadero si el valor es nulo, indefinido, etc. o en blanco (es decir, contiene solo espacios en blanco):

function stringIsEmpty(value) {

    return value ? value.trim().length == 0 : true;

}

9
2018-02-12 15:45



Si prefieres javascript simple prueba esto:

  /**
   * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
   * length of `0` and objects with no own enumerable properties are considered
   * "empty".
   *
   * @static
   * @memberOf _
   * @category Objects
   * @param {Array|Object|string} value The value to inspect.
   * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty([]);
   * // => true
   *
   * _.isEmpty({});
   * // => true
   *
   * _.isEmpty('');
   * // => true
   */

function isEmpty(value) {
    if (!value) {
      return true;
    }
    if (isArray(value) || isString(value)) {
      return !value.length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

De lo contrario, si ya está usando subrayado o lodash, intente:

_.isEmpty(value)

7
2017-08-21 13:39