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


2853

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 ""?


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


Sería de gran ayuda si el requisito se especificara claramente. ¿Para qué valores debería ser vacío devolver verdadero? Si se comprueba "", se infiere que solo debería ser verdadero si el valor es Tipo cadena y longitud 0. Muchas respuestas aquí suponen que también debe ser verdadero para algunos o todos los valores de falsey.
RobG

Respuestas:


3572

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

174
Probar la propiedad de longitud en realidad puede ser más rápido que probar la cadena contra "", porque el intérprete no tendrá que crear un objeto String a partir del literal de cadena.
Vincent Robert

26
@Vincent está haciendo un perfil ingenuo en las herramientas para desarrolladores de Chrome, las pruebas === ''vs .lengthno mostraron ninguna mejora perceptible (y .lengthsolo funciona si puedes asumir que tienes una cadena)
bdukes

26
@bdukes cuando empiezas a preocuparte por ese tipo de micro optimizaciones, no creo que Chrome sea el navegador en el que tienes la mayoría de tus problemas de rendimiento ...
Vincent Robert

15
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

115
Como se esperaba, en .length > 0realidad es mucho más rápido que compararlo con un literal de cadena Echa un vistazo a este jsPerf
Chad

1128

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

21
¿Por qué 0 === str.length en lugar de str.length === 0?
Vincent

66
Las condiciones de @Vincent a menudo se escriben así if (variable == constant value)y si olvida un '=', 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

2
lástima que /^\s*$/.test(str)no sea realmente legible: ¿quizás sería mejor eliminar espacios usando un código más simple o regex? ver stackoverflow.com/questions/6623231/… y también stackoverflow.com/questions/10800355/…
Adrien Be

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

21
@ Vincent también se llama "Condiciones de Yoda", como if blue is the sky. Ver dodgycoder.net/2011/11/yoda-conditions-pokemon-exception.html
AZ.

316

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


61
¿Por qué es esto "aún mejor"?
Mene

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

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

23
Esta es la solución que siempre uso. !!str.trim()para asegurarse de que la cadena no esté hecha solo de espacios en blanco.
Dario Oddenino

55
No se parece a un truco, Boolean(str)es mucho más legible y menos "wtfish".
shinzou

105

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) { ...

99
¿No arrojaría una excepción si str es nulo?
Pic Mickael

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

99

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

8
Pero hace el trabajo si lo que realmente quieres probar es una cadena con contenido que no sea espacial. ¿Hay alguna forma menos costosa de probar esto?
flash

44
¿Qué hay de la propiedad de longitud?
driAn

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

34
@ Marcos FYI, no sería necesario el modificador global, ya que el partido de la primera aparición de un carácter que no sea el espacio que significaría la cadena no está vacía:str.match(/\S/)
neezer

1
¿Por qué es caro? Si realmente es así, ¿por qué jQuery usa este método? Puede encontrar esto en la fuente de jQueryvar trimLeft = /^\s+/, trimRight = /\s+$/;
Marecky

66

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

55
Esta solución es más independiente del lenguaje. La única característica 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. (IE, 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

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

El typeofen el switchno funcionó para mí. Agregué una if (typeof e == "undefined")prueba y eso funciona. ¿Por qué?
Lucas

1
@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)
beeThree

¿Podríamos usar en case undefined:lugar de case typeof(e) == "undefined":?
Boris J.

43

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.


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

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

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

@Erich, ahora entendí tu punto, gracias por mencionarlo.
Moshii

36

Tratar:

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

2
¿Es necesaria la propiedad de longitud?
frogcoder

str.trim().lengthlo haré más rápido que str.trim(), en alrededor del 1% según el resultado de mi propia prueba
devildelta

2
@devildelta: su 1% es un error en su prueba.
Stephen M Irving

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

36

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;


1
¿Alguna posibilidad de que pueda explicar lo que está haciendo cada cheque? :)
DanV

2
-1 Están probando diferentes cosas. No tiene sentido ponerlos a todos en una sola ifdeclaración.
Bennett McElwee

1
typeof MyVariable == 'undefined' no distingue entre una variable inicializada con un valor indefinido y una variable no declarada a menos que la variable se declare inicialmente y se inicialice como nula. La comprobación de la propiedad de longitud hace que la primitiva de cadena se envuelva en un objeto de cadena.
Scott Marcus

34
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""


29

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.


11
Mala idea. Serás verdadero si strVar se asigna accidentalmente 0.
Constantin

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

La verificación falla si no está definida. Entonces, si (str) funciona mejor
Valentin Heinitz

3
@ValentinHeinitz si a str se le asignó un valor falsey de 0 o "0", si (str) informara falsamente verdadero. El mejor enfoque es if (str === ""). Es simple y nunca fallará.
Scott Marcus


20

¡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é.


2
La verificación de indefinido necesitaría moverse primero a los controles, o los elementos indefinidos arrojarán excepciones en los controles anteriores.
SvdSinner

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

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

20

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.


Funciona, pero también es terriblemente costoso en cuanto a operaciones. Bien si solo quieres marcar una o dos cosas, no un conjunto grande.
Orfeo

20

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'

Ingrese la descripción de la imagen aquí

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.

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í


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

eso es un estudio exhaustivo - gracias
Deian

19
  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 
    }

17

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.

14

Usualmente uso algo como esto,

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

3
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ía una variable indefinida?
Abimael Martell

2
@AbimaelMartell ¿Por qué no? Tiene una variable que declaró o que le pasó de algún ámbito sobre el que no tiene control, como en una respuesta de un método o una llamada a la API. Puede suponer que contiene un valor y usar la verificación anterior, pero si no está definido o es nulo, obtendrá un error. prueba var = nulo; if (! test.length) {alert ("adrian is wrong");}
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, puede verificar typeof variable != "undefined"antes de verificar si está vacío.
Abimael Martell

10

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


2
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 fondo, que puede pasar por diferentes tipos de valores "nulos". Debería estar en el fondo de la mente de cada desarrollador.
cartbeforehorse

10

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

10

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.


Lanzaría un error en nulo o indefinido porque no deberíamos estar haciendo una operación directamente en una variable que es nula o indefinida: verifique que str exista antes de hacerlo 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

Considere let rand = ()=>Math.random(), luego 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.
RobG

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

10

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 .


1
¿Eh? Si está esperando una cadena empty(0)y empty(7)debe devolver el mismo valor.
Bennett McElwee

En mi caso particular, empty("0")debe regresar false(porque es una cadena no vacía), pero empty(0)debe regresar trueporque está vacío :)
Andron

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

Creo que ese nombre emptyes bueno. En documentos php para la función vacía : Returns FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE.La diferencia entre PHPy esta función: esa cadena '0'no se identificará como vacía.
Andron

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

10

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


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

9

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


8

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

¿Qué beneficio hay para hacer en !(!!this.length)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 negarlo tres veces es exactamente lo mismo que negarlo una vez.
John Montgomery

8

Prueba esto:

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

8

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

Si simplemente deja de usar == y usa ===, esto resuelve el problema if (s === "").
Scott Marcus

8

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

7

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.


7

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.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.