¿Cómo puedo verificar si hay una cadena vacía / indefinida / nula en JavaScript?

Vi esta pregunta , pero no vi un ejemplo específico de JavaScript. ¿Hay un simple string.Emptydisponible en JavaScript, o es solo un caso de verificación ""?

Si solo desea verificar si hay algún valor, puede hacerlo

if (strValue) {
    //do something
}

Si necesita verificar específicamente si hay una cadena vacía sobre nula, creo que verificar ""es su mejor opción, utilizando el ===operador (para que sepa que, de hecho, es una cadena con la que está comparando).

if (strValue === "") {
    //...
}

Para verificar si una cadena está vacía, nula o indefinida, uso:

function isEmpty(str) {
    return (!str || 0 === str.length);
}

Para verificar si una cadena está en blanco, nula o indefinida, uso:

function isBlank(str) {
    return (!str || /^\s*$/.test(str));
}

Para verificar si una cadena está en blanco o contiene solo espacios en blanco:

String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());
};

Todas las respuestas anteriores son buenas, pero esto será aún mejor. Utilice el operador !!( no no ).

if(!!str){
    // Some code here
}

O use el tipo de fundición:

if(Boolean(str)){
    // Code here
}

Ambos hacen la misma función. Escriba la variable en booleano, donde stres una variable.
Vuelve falsepor null,undefined,0,000,"",false.
Se devuelve truepara la cadena "0" y el espacio en blanco "".

Lo más cercano a lo que puede llegar str.Empty(con la condición previa de que str es un String) es:

if (!str.length) { ...

Si necesita asegurarse de que la cadena no sea solo un montón de espacios vacíos (supongo que esto es para la validación del formulario), debe reemplazar los espacios.

if(str.replace(/\s/g,"") == ""){
}

Yo suelo:

function empty(e) {
  switch (e) {
    case "":
    case 0:
    case "0":
    case null:
    case false:
    case typeof(e) == "undefined":
      return true;
    default:
      return false;
  }
}

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return ""
})) // false

Puede usar lodash : _.isEmpty (value).

Abarca una gran cantidad de casos como {}, '', null, undefined, etc.

Pero siempre regresa truepara el Numbertipo de tipos de datos primitivos de JavaScript como _.isEmpty(10)o _.isEmpty(Number.MAX_VALUE)ambos retornos true.

Tratar:

if (str && str.trim().length) {  
    //...
}

Función:

function is_empty(x)
{
    return (
        (typeof x == 'undefined')
                    ||
        (x == null)
                    ||
        (x == false)  //same as: !x
                    ||
        (x.length == 0)
                    ||
        (x == "")
                    ||
        (x.replace(/\s/g,"") == "")
                    ||
        (!/[^\s]/.test(x))
                    ||
        (/^\s*$/.test(x))
    );
}

PD: en JavaScript, no use el salto de línea después return;

var s; // undefined
var s = ""; // ""
s.length // 0

No hay nada que represente una cadena vacía en JavaScript. Haga una verificación en contra length(si sabe que la var siempre será una cadena) o en""

No me preocuparía demasiado por el método más eficiente . Use lo que sea más claro para su intención. Para mí eso suele ser strVar == "".

Según el comentario de Constantin , si strVar podría de alguna manera terminar conteniendo un valor entero 0, entonces esa sería una de esas situaciones de aclaración de intenciones.

¡Muchas respuestas y muchas posibilidades diferentes!

Sin duda para una implementación rápida y simple, el ganador es: if (!str.length) {...}

Sin embargo, como muchos otros ejemplos están disponibles. El mejor método funcional para hacer esto, sugeriría:

function empty(str)
{
    if (typeof str == 'undefined' || !str || str.length === 0 || str === "" || !/[^\s]/.test(str) || /^\s*$/.test(str) || str.replace(/\s/g,"") === "")
    {
        return true;
    }
    else
    {
        return false;
    }
}

Un poco excesivo, lo sé.

También puedes ir con expresiones regulares:

if((/^\s*$/).test(str)) { }

Comprueba las cadenas que están vacías o llenas de espacios en blanco.

Actuación

Realizo pruebas en macOS v10.13.6 (High Sierra) para 18 soluciones elegidas. Las soluciones funcionan ligeramente diferentes (para datos de entrada de mayúsculas y minúsculas) que se presentó en el fragmento a continuación.

Conclusiones

• las soluciones simples basado en !str, ==, ===y lengthson rápidos para todos los navegadores (A, B, C, G, I, J)
• Las soluciones basadas en la expresión regular ( test, replace) y charAtson más lentas para todos los navegadores (H, L, M, P)
• las soluciones marcadas como más rápidas fueron las más rápidas solo para una ejecución de prueba, pero en muchas ejecuciones cambia dentro del grupo de soluciones 'rápidas'

Detalles

En el fragmento de abajo comparo los resultados de 18 métodos elegidos mediante el uso de diferentes parámetros de entrada

• "" "a" " "- cadena vacía, cadena con letra y cadena con espacio
• [] {} f- matriz, objeto y función
• 0 1 NaN Infinity - números
• true false - booleano
• null undefined

No todos los métodos probados admiten todos los casos de entrada.

function A(str) {
  let r=1;
  if (!str)
    r=0;
  return r;
}

function B(str) {
  let r=1;
  if (str == "")
    r=0;
  return r;
}

function C(str) {
  let r=1;
  if (str === "")
    r=0;
  return r;
}

function D(str) {
  let r=1;
  if(!str || 0 === str.length)
    r=0;
  return r;
}

function E(str) {
  let r=1;
  if(!str || /^\s*$/.test(str))
    r=0;
  return r;
}

function F(str) {
  let r=1;
  if(!Boolean(str))
    r=0;
  return r;
}

function G(str) {
  let r=1;
  if(! ((typeof str != 'undefined') && str) )
    r=0;
  return r;
}

function H(str) {
  let r=1;
  if(!/\S/.test(str))
    r=0;
  return r;
}

function I(str) {
  let r=1;
  if (!str.length)
    r=0;
  return r;
}

function J(str) {
  let r=1;
  if(str.length <= 0)
    r=0;
  return r;
}

function K(str) {
  let r=1;
  if(str.length === 0 || !str.trim())
    r=0;
  return r;
}

function L(str) {
  let r=1;
  if ( str.replace(/\s/g,"") == "")
    r=0;
  return r;
}

function M(str) {
  let r=1;
  if((/^\s*$/).test(str))
    r=0;
  return r;
}


function N(str) {
  let r=1;
  if(!str || !str.trim().length)
    r=0;
  return r;
}

function O(str) {
  let r=1;
  if(!str || !str.trim())
    r=0;
  return r;
}

function P(str) {
  let r=1;
  if(!str.charAt(0))
    r=0;
  return r;
}

function Q(str) {
  let r=1;
  if(!str || (str.trim()==''))
    r=0;
  return r;
}

function R(str) {
  let r=1;
  if (typeof str == 'undefined' ||
      !str ||
      str.length === 0 ||
      str === "" ||
      !/[^\s]/.test(str) ||
      /^\s*$/.test(str) ||
      str.replace(/\s/g,"") === "")

    r=0;
  return r;
}




// --- TEST ---

console.log(                  '   ""  "a"  " " [] {} 0 1 NaN Infinity f true false null undefined ');
let log1 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}     ${f(null)}    ${f(undefined)}`);
let log2 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}`);
let log3 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}`);

log1('A', A);
log1('B', B);
log1('C', C);
log1('D', D);
log1('E', E);
log1('F', F);
log1('G', G);
log1('H', H);

log2('I', I);
log2('J', J);

log3('K', K);
log3('L', L);
log3('M', M);
log3('N', N);
log3('O', O);
log3('P', P);
log3('Q', Q);
log3('R', R);

Y luego, para todos los métodos, realizo un caso de prueba de velocidad str = ""para los navegadores Chrome v78.0.0, Safari v13.0.4 y Firefox v71.0.0: puede ejecutar pruebas en su máquina aquí

1. comprobar que var a;existe

2. recorte false spacesel valor, luego pruebeemptiness

   if ((a)&&(a.trim()!=''))
   {
     // if variable a is not empty do this 
   }

Además, en caso de que considere una cadena llena de espacios en blanco como "vacía".

Puedes probarlo con esta expresión regular:

!/\S/.test(string); // Returns true if blank.

Usualmente uso algo como esto,

if (!str.length) {
    // Do something
}

No he notado una respuesta que tenga en cuenta la posibilidad de caracteres nulos en una cadena. Por ejemplo, si tenemos una cadena de caracteres nula:

var y = "\0"; // an empty string, but has a null character
(y === "") // false, testing against an empty string does not work
(y.length === 0) // false
(y) // true, this is also not expected
(y.match(/^[\s]*$/)) // false, again not wanted

Para probar su nulidad, se podría hacer algo como esto:

String.prototype.isNull = function(){ 
  return Boolean(this.match(/^[\0]*$/)); 
}
...
"\0".isNull() // true

Funciona en una cadena nula y en una cadena vacía y es accesible para todas las cadenas. Además, podría expandirse para contener otros caracteres de espacio en blanco o vacíos de JavaScript (es decir, espacio sin interrupción, marca de orden de bytes, separador de línea / párrafo, etc.).

Mientras tanto, podemos tener una función que verifica todos los 'vacíos' como nulo, indefinido, '', '', {}, [] . Entonces acabo de escribir esto.

var isEmpty = function(data) {
    if(typeof(data) === 'object'){
        if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
            return true;
        }else if(!data){
            return true;
        }
        return false;
    }else if(typeof(data) === 'string'){
        if(!data.trim()){
            return true;
        }
        return false;
    }else if(typeof(data) === 'undefined'){
        return true;
    }else{
        return false;
    }
}

Casos de uso y resultados.

console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty('  ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false

A partir de ahora no existe un método directo como string.empty para verificar si una cadena está vacía o no. Pero en su código puede usar una verificación de contenedor para una cadena vacía como:

// considering the variable in which your string is saved is named str.

if (str && str.length>0) { 

  // Your code here which you want to run if the string is not empty.

}

Con esto, también puede asegurarse de que la cadena no esté indefinida o nula. Recuerde, indefinido, nulo y vacío son tres cosas diferentes.

Todas estas respuestas son buenas.

Pero no puedo estar seguro de que la variable es una cadena, no contiene solo espacios (esto es importante para mí) y puede contener '0' (cadena).

Mi version:

function empty(str){
    return !str || !/[^\s]+/.test(str);
}

empty(null); // true
empty(0); // true
empty(7); // false
empty(""); // true
empty("0"); // false
empty("  "); // true

Muestra en jsfiddle .

No vi una buena respuesta aquí (al menos no una respuesta que me quede bien)

Entonces decidí responderme:

value === undefined || value === null || value === "";

Debe comenzar a verificar si no está definido. De lo contrario, su método puede explotar, y luego puede verificar si es igual a nulo o es igual a una cadena vacía.

No puedes tener !! o solo if(value)porque si marca, 0le dará una respuesta falsa (0 es falso).

Dicho esto, envuélvelo en un método como:

public static isEmpty(value: any): boolean { return value === undefined || value === null || value === ""; }

PD .: No es necesario verificar typeof , ya que explotaría y arrojaría incluso antes de ingresar al método

Si uno necesita detectar no solo cadenas vacías sino también en blanco, agregaré a la respuesta de Goral:

function isEmpty(s){
    return !s.length;    
}

function isBlank(s){
    return isEmpty(s.trim());    
}

Prueba esto

str.value.length == 0

Puede agregarlo fácilmente al objeto String nativo en JavaScript y reutilizarlo una y otra vez ...
Algo simple como el siguiente código puede hacer el trabajo por usted si desea verificar ''cadenas vacías:

String.prototype.isEmpty = String.prototype.isEmpty || function() {
  return !(!!this.length);
}

De lo contrario, si desea verificar tanto la ''cadena vacía como el ' 'espacio, puede hacerlo simplemente agregando trim()algo como el código a continuación:

String.prototype.isEmpty = String.prototype.isEmpty || function() {
   return !(!!this.trim().length);
}

y puedes llamarlo así:

''.isEmpty(); //return true
'alireza'.isEmpty(); //return false

Prueba esto:

export const isEmpty = string => (!string || !string.length);

Investigué un poco sobre lo que sucede si pasa un valor sin cadena y no vacío / nulo a una función de prueba. Como muchos saben, (0 == "") es verdadero en JavaScript, pero dado que 0 es un valor y no está vacío o es nulo, es posible que desee probarlo.

Las siguientes dos funciones devuelven verdadero solo para valores indefinidos, nulos, vacíos / espacios en blanco y falso para todo lo demás, como números, booleanos, objetos, expresiones, etc.

function IsNullOrEmpty(value)
{
    return (value == null || value === "");
}
function IsNullOrWhiteSpace(value)
{
    return (value == null || !/\S/.test(value));
}

Existen ejemplos más complicados, pero estos son simples y dan resultados consistentes. No es necesario hacer una prueba de indefinido, ya que está incluido en la verificación (valor == nulo). También puede imitar el comportamiento de C # agregándolos a String de esta manera:

String.IsNullOrEmpty = function (value) { ... }

No desea ponerlo en el prototipo de cadenas, porque si la instancia de la clase de cadena es nula, se producirá un error:

String.prototype.IsNullOrEmpty = function (value) { ... }
var myvar = null;
if (1 == 2) { myvar = "OK"; } // Could be set
myvar.IsNullOrEmpty(); // Throws error

Probé con la siguiente matriz de valores. Puede recorrerlo para probar sus funciones si tiene dudas.

// Helper items
var MyClass = function (b) { this.a = "Hello World!"; this.b = b; };
MyClass.prototype.hello = function () { if (this.b == null) { alert(this.a); } else { alert(this.b); } };
var z;
var arr = [
// 0: Explanation for printing, 1: actual value
    ['undefined', undefined],
    ['(var) z', z],
    ['null', null],
    ['empty', ''],
    ['space', ' '],
    ['tab', '\t'],
    ['newline', '\n'],
    ['carriage return', '\r'],
    ['"\\r\\n"', '\r\n'],
    ['"\\n\\r"', '\n\r'],
    ['" \\t \\n "', ' \t \n '],
    ['" txt \\t test \\n"', ' txt \t test \n'],
    ['"txt"', "txt"],
    ['"undefined"', 'undefined'],
    ['"null"', 'null'],
    ['"0"', '0'],
    ['"1"', '1'],
    ['"1.5"', '1.5'],
    ['"1,5"', '1,5'], // Valid number in some locales, not in JavaScript
    ['comma', ','],
    ['dot', '.'],
    ['".5"', '.5'],
    ['0', 0],
    ['0.0', 0.0],
    ['1', 1],
    ['1.5', 1.5],
    ['NaN', NaN],
    ['/\S/', /\S/],
    ['true', true],
    ['false', false],
    ['function, returns true', function () { return true; } ],
    ['function, returns false', function () { return false; } ],
    ['function, returns null', function () { return null; } ],
    ['function, returns string', function () { return "test"; } ],
    ['function, returns undefined', function () { } ],
    ['MyClass', MyClass],
    ['new MyClass', new MyClass()],
    ['empty object', {}],
    ['non-empty object', { a: "a", match: "bogus", test: "bogus"}],
    ['object with toString: string', { a: "a", match: "bogus", test: "bogus", toString: function () { return "test"; } }],
    ['object with toString: null', { a: "a", match: "bogus", test: "bogus", toString: function () { return null; } }]
];

Para verificar si es exactamente una cadena vacía:

if(val==="")...

Para verificar si es una cadena vacía O un equivalente lógico para ningún valor (nulo, indefinido, 0, NaN, falso, ...):

if(!val)...

No hay ningún isEmpty()método, debe verificar el tipo y la longitud:

if (typeof test === 'string' && test.length === 0){
  ...

La verificación de tipo es necesaria para evitar errores de tiempo de ejecución cuando testes undefinedo null.

Ignorando las cadenas de espacios en blanco, puede usar esto para verificar nulos, vacíos e indefinidos:

var obj = {};
(!!obj.str) // Returns false

obj.str = "";
(!!obj.str) // Returns false

obj.str = null;
(!!obj.str) // Returns false

Es conciso y funciona para propiedades indefinidas, aunque no es el más legible.