¿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.Empty disponible en JavaScript, o es sólo un caso de comprobación de ""?

preguntado el 30 de septiembre de 08 a las 15:09

solo para su información, creo que las API más útiles para la clase String están en Mozilla y kit de javascript. [elated.com] (elated.com/articles/working-with-strings ) tiene un tutorial sobre todas las propiedades, métodos, ... Tenga en cuenta: el enlace de Mozilla se ha actualizado a developer.mozilla.org/en/JavaScript/Reference/Global_Objects/… -

Sería de gran ayuda que se especificara claramente el requisito. Por que valores deben esta vacio volver verdadero? La verificación de "" infiere que solo debería devolver verdadero si el valor es Tipo cadena y longitud 0. Muchas respuestas aquí asumen que también debería devolver verdadero para algunos o todos los valores falsos. -

str.length> -1 -

30 Respuestas

Si solo quiere comprobar si hay algún valor, puede hacerlo

if (strValue) {
    //do something
}

Si necesita verificar específicamente una cadena vacía sobre nula, creo que verificar contra "" es tu mejor apuesta, usando La === operador (para que sepa que, de hecho, es una cadena con la que está comparando).

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

Respondido el 02 de junio de 18 a las 01:06

En realidad, probar la propiedad length puede ser más rápido que probar la cadena con "", porque el intérprete no tendrá que crear un objeto String a partir del literal de cadena. - Vincent robert

@Vincent haciendo algunos perfiles ingenuos en las herramientas de desarrollo de Chrome, probando === '' vs .length no mostró ninguna mejora apreciable (y el uso .length solo funciona si puede asumir que tiene una cadena) - duques

@bdukes, cuando empiezas a preocuparte por ese tipo de microoptimizaciones, no creo que Chrome sea el navegador donde tienes la mayoría de tus problemas de rendimiento ... - Vincent robert

Solo para tener en cuenta, si su definición de "cadena vacía" incluye espacios en blanco, entonces esta solución no es apropiada. Una cadena de 1 o más espacios devuelve verdadero arriba. Si está utilizando JQuery, simplemente puede usar esto: if ($ .trim (ref) .length === 0) - según esta respuesta a una pregunta similar: stackoverflow.com/questions/2031085/… - CodeClimber

Como se esperaba .length > 0 es en realidad mucho mas rápido que comparar con un literal de cadena! Mira esto jsPerf - Chad

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

contestado el 13 de mayo de 14 a las 15:05

¿por qué 0 === str.length en lugar de str.length === 0? - Vincent

Las condiciones de @Vincent a menudo se escriben así if (variable == constant value) y si olvida un '=', entonces está asignando el valor constante a la variable en lugar de probar. El código seguirá funcionando, ya que puede asignar variables en un if. Entonces, una forma más segura de escribir esta condición es invertir el valor constante y la variable. De esta manera, cuando pruebe su código, verá un error (lado izquierdo no válido en la asignación). También puede usar algo como JSHint para no permitir la asignación en condiciones y recibir una advertencia cuando escriba una. - Florian

lástima que /^\s*$/.test(str) no es realmente legible, ¿tal vez sería mejor eliminar espacios usando un código más simple o una expresión regular? ver stackoverflow.com/questions/6623231/… y también stackoverflow.com/questions/10800355/… - adrien ser

/^\s*$/.test(str) se puede reemplazar con str.trim (). length === 0 - Schadenfreude

@Vincent, esto también se llama "Condiciones de Yoda", como if blue is the sky. Ver dodgycoder.net/2011/11/yoda-condiciones-pokemon-excepción.html - ARIZONA.

Todas las respuestas anteriores son buenas, pero esta será aún mejor. Utilice operadores NOT duales (!!):

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

O utilice el tipo de fundición:

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

Ambos hacen la misma función. Escriba la variable en booleano, donde str es una variable
Vuelve false por null, undefined, 0, 000, "", false.
Vuelve true para cuerda "0" y espacios en blanco " ".

respondido 11 nov., 20:06

¿Por qué esto es "incluso mejor"? - Mene

¿Hay alguna diferencia entre el comportamiento de if(str) y if(!!str)? - Pedro Olson

@PeterOlson si está tratando de guardar una variable como un booleano que verifica el contenido de varias cadenas, entonces querrá hacer esto. var any = (!!str1 && !!str2 && !!str3) manejo si hay un número allí también - Juan Ruddell

Esta es la solución que siempre uso. !!str.trim() para asegurarse de que la cadena no esté formada únicamente por espacios en blanco. - Darío Oddenino

No parece un hack, Boolean(str) es mucho más legible y menos "wtfish". - Shinzou

Lo más cercano a lo que puedes llegar str.Empty (con la condición previa de que str sea una cadena) es:

if (!str.length) { ...

Respondido 31 ago 18, 17:08

¿No lanzaría una excepción si str es nulo? - Pic Mickael

@PicMickael ¡Sí! También lo haría str.Empty. - Ates Goral

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,"") == ""){
}

Respondido 01 Oct 08, 00:10

Pero funciona si lo que realmente desea probar es una cadena con contenido sin espacio. ¿Existe una forma menos costosa de probar esto? - flash

¿Qué tal la propiedad de la longitud? - drian

En lugar de eliminar todos los espacios, ¿por qué no simplemente verificar si hay un no espacio? Tiene 2 ventajas de que puede rescatar temprano si hay un carácter sin espacio, y no devuelve una nueva cadena con la que luego verifica. if(str.match(/\S/g)){} - mpen

@Mark FYI, no necesitaría el modificador global, ya que la coincidencia de la primera aparición de un carácter sin espacio significaría que la cadena no está vacía: str.match(/\S/) - Neezer

¿Por qué no usarías if(str.trim()) {...} ? - Darryl

Yo uso:

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

respondido 08 mar '20, 23:03

Esta solución es más independiente del idioma. La única función de JavaScript en la que se basa es typeof. Por lo tanto, es un buen ejemplo de una solución que puede usar cuando no confía en las implementaciones en diferentes navegadores y no tiene tiempo para buscar una solución mejor. (Es decir, sin acceso a Internet). Es algo así como una prueba. No es el más limpio, pero puede estar seguro de que funcionará sin saber demasiado sobre JavaScript. - Jeff Davis

Iría incluso un poco más allá y lo clavaría con un operador === para el caso indefinido. De lo contrario, es simplemente la respuesta perfecta. - xarlymg89

La typeof en la switch no funcionó para mí. Agregué un if (typeof e == "undefined") prueba y eso funciona. ¿Por qué? - Lucas

@Lucas Porque esto fue un error tipográfico o un descuido. Su modificación es el enfoque correcto. (el original se refiere al contexto de la función vacía, no al parámetro e, que es lo que se supone que debe verificar la función) - abejaTres

Podríamos usar case undefined: en lugar de case typeof(e) == "undefined":? - boris j.

Puede usar el lodash: _.isEmpty (valor).

Cubre muchos casos como {}, '', null, undefined, etc.

Pero siempre vuelve true por Number tipo de Tipos de datos primitivos de JavaScript como _.isEmpty(10) or _.isEmpty(Number.MAX_VALUE) ambos retornos true.

respondido 09 mar '20, 00:03

_.isEmpty(" "); // => false - Erich

@Erich Porque " " no está vacío. _.isEmpty(""); devuelve verdadero. - Moshii

bastante cierto: mencioné esto porque algunas de las otras respuestas aquí implican la validación del formulario y la verificación de si una cadena consta solo de espacios en blanco, y esta única función lodash por sí sola no resolverá ese problema. - Erich

Función "todo en uno" muy genérica (aunque no recomendado):

function is_empty(x)
{
    return (                                                           //don't put newline after return
        (typeof x == 'undefined')
              ||
        (x == null)
              ||
        (x == false)        //same as: !x
              ||
        (x.length == 0)
              ||
        (x == 0)            // note this line, you might not need this. 
              ||
        (x == "")
              ||
        (x.replace(/\s/g,"") == "")
              ||
        (!/[^\s]/.test(x))
              ||
        (/^\s*$/.test(x))
    );
}

Sin embargo, no recomiendo usar eso, porque su variable de destino debe ser de un tipo específico (es decir, ¿cadena, numérica u objeto?), Así que aplique las comprobaciones relativas a esa variable.

Respondido 07 Oct 20, 01:10

¿Alguna posibilidad de que pueda explicar qué hace cada cheque? :) - DanV

-1 Están probando cosas diferentes. No tiene sentido ponerlos todos en uno if declaración. - Bennet McElwee

typeof MyVariable == 'undefined' no distingue entre una variable inicializada con un valor indefinido y una variable no declarada a menos que la variable haya sido inicialmente declarada e inicializada como nula. La verificación de la propiedad de longitud hace que la primitiva de cadena se envuelva en un objeto de cadena. - scott marcus

Rendimiento

Realizo pruebas en mac OS v10.13.6 (High Sierra) para 18 soluciones elegidas. Solutions funciona ligeramente diferente (para datos de entrada de casos de esquina) que se presentó en el fragmento a continuación.

Conclusiones

  • las soluciones simples basadas en !str,==,=== y length son rápidos para todos los navegadores (A, B, C, G, I, J)
  • las soluciones basadas en la expresión regular (test,replace) y charAt son los más lentos 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'

Ingrese la descripción de la imagen aquí

Beneficios

En el siguiente fragmento, comparo los resultados de los 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 son compatibles con 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í

Ingrese la descripción de la imagen aquí

respondido 09 mar '20, 06:03

¡Esto es realmente asombroso! ¡Me encanta ver todo esto presentado! ¡Gracias! - WebWanderer

Algo engañoso ya que combina soluciones de recorte con soluciones sin recorte. - Sean

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

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

Respondido el 30 de Septiembre de 08 a las 18:09

Tratar:

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

Respondido el 09 de enero de 13 a las 03:01

¿Es necesaria la propiedad de longitud? - codificador de rana

str.trim().length lo hará más rápido que str.trim(), en alrededor del 1% según el resultado de mi propia prueba. - Devildelta

OP está buscando probar cadenas vacías, indefinidas o nulas. Esta es una prueba de una cadena que no cumple ninguna de esas condiciones. Tampoco dijo nada sobre espacios en blanco solo cadenas. Puede probar las condiciones de OP con solo esto, siempre que esté seguro de que no hay otros tipos de datos almacenados en la variable: if (!str) { ... } - Stephen M. Irving

No me preocuparía demasiado por la mayor parte eficiente método. Utilice lo que sea más claro para su intención. Para mi eso es usualmente strVar == "".

Según el comentario de Constantin, si strVar pudiera de alguna manera terminar conteniendo un valor entero 0, entonces esa sería una de esas situaciones que aclaran la intención.

respondido 08 mar '20, 23:03

Mala idea. Se volverá verdadero si strVar se asigna accidentalmente a 0. - Constantin

Estoy de acuerdo en que dejar en claro su intención es más importante que cualquier microoptimización que puedan producir otros métodos, pero usar el operador de comparación estricto === seria mejor. Solo devuelve verdadero si strVar es una cadena vacía. - Código inútil

La comprobación falla si no está definida. Entonces, si (str) funciona mejor - Valentín Heinitz

@ValentinHeinitz si a str se le asignara un valor falso de 0 o "0", si (str) informaría falsamente como verdadero. El mejor enfoque es if (str === ""). Es simple y nunca fallará. - scott marcus

También puedes usar expresiones regulares:

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

Comprueba si hay cadenas vacías o llenas de espacios en blanco.

respondido 08 mar '20, 23:03

Funciona, pero también es terriblemente caro en términos de operaciones. Bueno si solo desea verificar una o dos cosas, no un conjunto grande. - Orpheus

  1. Mira esto var a; existe
  2. recortar el false spaces en el valor, luego prueba para emptiness

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

Respondido el 07 de Septiembre de 16 a las 08:09

¡Muchas respuestas y muchas posibilidades diferentes!

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

Sin embargo, hay muchos otros ejemplos 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é.

respondido 03 nov., 20:12

La verificación de undefined debería moverse al primero en las verificaciones, o los elementos no definidos arrojarán excepciones en las verificaciones anteriores. - SvdPecador

¡Completamente de acuerdo! BUENA ATRAPADA. ¡Editaré mi respuesta anterior! - fuente

str.length === 0 devuelve verdadero para cualquier función que no tenga parámetros formales. - robar

str.length === 0 || str === "" ambos harían la misma tarea. - Praveen MP

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.

respondido 08 mar '20, 23:03

Yo suelo usar algo como esto

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

respondido 08 mar '20, 23:03

Lo más rápido si sabe que la variable es una cadena. Lanza un error si la variable no está definida. - Adrian Hope-Bailie

@ AdrianHope-Bailie ¿por qué probarías una variable indefinida? - Abimael Martell

@AbimaelMartell ¿Por qué no? Tiene una variable que declaró o que se le pasó desde algún ámbito sobre el que no tiene control, como en una respuesta de un método o una llamada a la API. Puede asumir que contiene un valor y usar la verificación anterior, pero si no está definido o es nulo, obtendrá un error. var test = null; if (! test.length) {alert ("adrian está equivocado");} - Adrian Hope-Bailie

OP estaba preguntando "cómo verificar una cadena vacía", una variable indefinida no es una cadena vacía. De todos modos podrías comprobar typeof variable != "undefined" antes de comprobar si está vacío. - Abimael Martell

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

Respondido 01 Oct 14, 07:10

Empezando con:

return (!value || value == undefined || value == "" || value.length == 0);

Mirando la última condición, si valor == "", su longitud debe: ser 0. Por lo tanto, déjelo:

return (!value || value == undefined || value == "");

¡Pero espera! En JavaScript, una cadena vacía es falsa. Por lo tanto, drop value == "":

return (!value || value == undefined);

Y! Undefined es verdadero, por lo que no es necesario comprobarlo. Entonces tenemos:

return (!value);

Y no necesitamos paréntesis:

return !value

respondido 09 mar '20, 00:03

Qué pasa si value = false or value = 0. ¿devolverá la respuesta correcta de acuerdo con la pregunta? - Nerez

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 JavaScript vacíos o de espacio en blanco (es decir, espacio que no se separa, marca de orden de bytes, separador de línea / párrafo, etc.).

Respondido 31 Jul 12, 15:07

Interesante análisis. No creo que esto sea relevante en el 99.9% de los casos. PERO recientemente descubrí que MySQL evalúa una columna como "nula" si (y solo si) esa columna contiene el carácter nulo ("\ 0"). Oracle, por otro lado, no evaluaría "\ 0" como nulo, prefiriendo tratarlo como una cadena de longitud 1 (donde ese carácter es el carácter nulo). Esto podría causar confusión si no se trata adecuadamente, porque muchos desarrolladores web trabajan con una base de datos de back-end, que puede pasar por diferentes tipos de valores "nulos". Debería estar en el fondo de la mente de todos los desarrolladores. - carro de caballos

Mientras tanto, podemos tener una función que compruebe todos los 'vacíos' como nulo, indefinido, '', '', {}, []. Así que 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

respondido 12 mar '18, 08:03

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 envoltura 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.

}

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

Respondido el 03 de Septiembre de 19 a las 09:09

Arrojaría un error en nulo o indefinido porque no deberíamos estar haciendo directamente una operación en una variable que sea nula o indefinida; verifique si existe str antes de hacer esto como se indica en otras respuestas y también tenga en cuenta que esto funcionaría en let abc = '' pero no en let abc = '', estos dos son diferentes. - whoami - fakeFaceTrueSoul

Imagine let rand = ()=>Math.random(), entonces rand && rand.length > 0) devuelve falso, pero claramente fn no está vacío". Es decir, devuelve falso para cualquier función que no tenga parámetros de formato. - robar

@RobG Math.random() devuelve un número y no una cadena. Y esta respuesta se trata de cadenas. ;-) - Harshit Agarwal

No vi una buena respuesta aquí (al menos no una respuesta que se ajuste a mí)

Entonces decidí responderme a mí mismo:

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) ya que si miras 0 le dará una respuesta falsa (0 es falso).

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

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

PS.: No es necesario marcar el tipo de, ya que explotaría y lanzaría incluso antes de entrar en el método

respondido 09 mar '20, 00:03

Probablemente sea mejor usar la construcción booleana (valor) que trata los valores nulos y no definidos (y también 0, -0, falso, NaN) como falso. Ver stackoverflow.com/questions/856324/… - Zhuravlev A.

Todas estas respuestas son agradables.

Pero no puedo estar seguro de que la variable sea una cadena, no contenga solo espacios (esto es importante para mí) y pueda 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.

respondido 08 mar '20, 23:03

¿Eh? Si espera una cadena, empty(0) y empty(7) debería devolver el mismo valor. - Bennet McElwee

En mi caso particular - empty("0") debe volver false (porque esa no es una cadena vacía), pero empty(0) debe volver true porque está vacío :) - andrón

Pero 0 no es ¡vacío! Es un número y los números no pueden estar completos ni vacíos. Por supuesto, es su función y, por lo tanto, debe satisfacer sus requisitos, pero empty es un nombre engañoso en este caso. - Bennet McElwee

Creo que ese nombre empty es bueno. En php docs para vacío función: Returns FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE. La diferencia entre los PHP y esta función - esa cadena '0' no se identificará como vacío. - andrón

Como digo, es tu función: llámalo como quieras. Pero empty es un nombre inexacto y engañoso. Es interesante que PHP también tenga un nombre deficiente empty función, pero las fallas de PHP no tienen nada que ver con JavaScript. - Bennet McElwee

Para comprobar si es exactamente una cadena vacía:

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

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

if(!val)...

respondido 09 mar '20, 00:03

Prueba esto:

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

Respondido el 14 de junio de 19 a las 12:06

Investigué un poco sobre lo que sucede si pasa un valor que no es una cadena ni un valor 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 ni 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 hay necesidad de probar indefinido, ya que está incluido en la verificación (valor == nulo). También puede imitar C# comportamiento agregándolos a String de esta manera:

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

No desea ponerlo en el prototipo Strings, porque si la instancia de la clase String 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 en caso de duda.

// 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; } }]
];

respondido 08 mar '20, 23:03

Si simplemente deja de usar == y usa ===, esto resuelve el problema si (s === ""). - scott marcus

No hay 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 en tiempo de ejecución cuando test is undefined or null.

respondido 04 nov., 16:22

Prueba esta

str.value.length == 0

Respondido el 08 de enero de 19 a las 04:01

"".value.length causará un error. Debería ser str.length === 0 - Y Pescador

Esta trow un TypeError If str es igual a undefined or null - RousseauAlexandre

Puede agregarlo fácilmente a nativos Cordón objeto 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 ambos '' cuerda vacía y ' ' con espacio, puede hacerlo simplemente agregando trim(), algo como el siguiente código:

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

y puedes llamarlo de esta manera:

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

Respondido el 19 de enero de 19 a las 06:01

¿Qué beneficio hay para hacer !(!!this.length) en lugar de solo !this (o !this.trim() para la segunda opción)? Una cadena de longitud cero ya es falsa, los paréntesis son redundantes y negarla tres veces es exactamente lo mismo que negarla una vez. - John montgomery

Por favor, no contamine los prototipos. - Sean

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