¿Cómo puedo comprobar si hay una cadena vacía / indefinida / nula en J

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

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

Mostrar la mejor respuesta

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 si el requisito se especificara claramente. ¿Para qué valores debería isEmpty devolver 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.

Si solo desea verificar 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 con "" es su mejor opción, usando el operador === (para que sepa que, de hecho, es una cadena con la que está comparando).

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

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 hizo algunos perfiles ingenuos en las herramientas de desarrollo de Chrome, probando === '' vs .length no mostró ninguna mejora perceptible (y usar .length solo funciona si puedes asumir que tienes una cuerda)

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

Solo para tener en cuenta, si su definición de "cadena vacía" incluye espacios en blanco, 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 /…

@Chad, su jsPerf es bastante defectuoso, ya que una de las pruebas compara un valor específico, mientras que la otra compara cualquier valor excepto el vacío. Entonces, para que sea justo, la primera prueba debe ser s!=="" que es 'solo' un 24% más lenta que s.length > 0

Dado que varía de cada versión de Chrome, la forma correcta es escribirlo de modo que identifique qué versión de Chrome está en qué lista y utiliza el método más rápido: P Pasará más ciclos comprobando qué versión de Chrome está ejecutando y cuál es el más rápido. Honestamente, últimamente está tan cerca en comparación, solo elija el sabor que más le convenga. No verificar la longitud es bueno para algunas habilidades de tipo pato. Aunque todo el mundo conoce los peligros de los patos y debería ejecutar TypeScript; fact ™.

@ kir.gera, JavaScript no da errores de compilación, ¿recibe este error del compilador de TypeScript? Si su compilador quiere un valor estricto de bool , podría Boolean(u.GroupRole) o !!u.GroupRole

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

Según el comentario de Constantin , si strVar pudiera de alguna manera terminar conteniendo un valor entero 0, entonces eso de hecho, será una de esas situaciones de aclaración de intenciones.

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

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

@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á.

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

No hay nada que represente una cadena vacía en JavaScript. Verifique con length (si sabe que la var siempre será una cadena) o con ""

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

if (!str.length) { ...
 

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

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

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

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

¿Qué tal la propiedad de la longitud?

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

@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/)

por qué es caro? Si realmente lo es, ¿por qué jQuery usa este método? Puede encontrar esto en el código fuente de jQuery var trimLeft = /^\s+/, trimRight = /\s+$/;

+1 Probé este método y funcionó para mí. El usuario puede ingresar espacios en blanco que aún están en blanco.

if(str.replace(/^\s+|\s+$/g,"")){...}+ sería suficiente

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

Quizás /\S/.test(str) es mejor que str.match(/\S/) porque no se molesta en devolver una serie de resultados coincidentes (podría haber una ganancia de rendimiento micro allí). Además, cuando solo prueba una cadena con una expresión regular, use el método RegExp .test() para transmitir mejor esa intención.

Normalmente uso algo como:

if (str == "") {
     //Do Something
}
else {
     //Do Something Else
}
 

El operador == no es estricto. Entonces, si str == "" , str puede ser null , undefined , false , 0 , [] , etc.

Avatar Jet

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
  

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.

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.

El typeof en el switch no me funcionó. Agregué una prueba de if (typeof e == "undefined") y eso funciona. ¿Por qué?

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

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

Pruebe esto

str.value.length == 0
 

"".value.length provocará un error. Debe ser str.length === 0

Este trow un TypeError Si str es igual a undefined o null

function tell()
{
    var pass = document.getElementById('pasword').value;
    var plen = pass.length;

    // Now you can check if your string is empty as like
    if(plen==0)
    {
        alert('empty');
    }
    else
    {
        alert('you entered something');
    }
}

<input type='text' id='pasword' />
 

Esta también es una forma genérica de verificar si el campo está vacío.

Utilizo una combinación y las comprobaciones más rápidas son las primeras.

function isBlank(pString) {
    if (!pString || pString.length == 0) {
        return true;
    }
    // Checks for a non-white space character
    // which I think [citation needed] is faster
    // than removing all the whitespace and checking
    // against an empty string
    return !/[^\s]+/.test(pString);
}
 

¿Me pregunto si podría explicar cuándo sería necesaria la verificación de longitud? ¿No captaría! PString algo que fuera una cadena nula / vacía? Esto parece funcionar. var test = ''; if (! test) alert ('vacío');

Ignorando las cadenas de espacios en blanco, puede usar esto para verificar si hay 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.

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

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.

También es una buena idea comprobar que no está intentando pasar un término indefinido.

function TestMe() {
  if((typeof str != 'undefined') && str) {
    alert(str);
  }
 };

TestMe();

var str = 'hello';

TestMe();
 

Por lo general, me encuentro con el caso en el que quiero hacer algo cuando un atributo de cadena para una instancia de objeto no está vacío. Lo cual está bien, excepto que el atributo no siempre está presente.

Prueba:

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

¿Es necesaria la propiedad de longitud?

str.trim().length funcionará más rápido que str.trim() , alrededor del 1% según mi propio resultado de prueba.

OP está buscando probar una cadena vacía, indefinida o nula. Esta es una prueba para 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) { ... }

Una forma alternativa, pero creo que la respuesta de bdukes es la mejor.

var myString = 'hello'; 
if(myString.charAt(0)){
    alert('no empty');
}
alert('empty');
 

Todas estas respuestas son buenas.

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

Mi versión:

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 .

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

En mi caso particular, empty("0") debe devolver false (porque no es una cadena vacía), pero empty(0) debe devolver true porque esta vacio :)

¡Pero 0 no está 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.

Creo que el nombre empty es 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 PHP y esta función: esa cadena '0' no se identificará como vacía.

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 tiene una función empty mal llamada, pero las fallas de PHP no tienen nada que ver con JavaScript.

Avatar JHM

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 como 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 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 el comportamiento de C # 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; } }]
];
 

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

Prefiero utilizar una prueba no en blanco en lugar de en blanco

function isNotBlank(str) {
   return (str && /^\s*$/.test(str));
}
 

Poner negación en los nombres de las funciones es una mala idea. El código en sí mismo está bien, pero la función debería llamarse algo como hasValue (). ¿Por qué? ¿Qué sucede cuando ve un código como este: "if (! IsNotBlank (str))" ... No está claro de inmediato cuál se supone que es la intención. Puede que no le parezca relevante para este simple ejemplo, pero agregar negación al nombre de una función siempre es una mala idea.

IsNotBlank es una función estándar y muy popular en StringUtils commons.apache.org/proper/commons-lang/apidocs/org/apache/…

también proporciona IsBlank para evitar los dobles negativos. Creo que los nombres de las funciones deben reflejar la funcionalidad que realizan y sería más fácil para los desarrolladores entenderlos cuando vean la función isBlank e IsNotBlank en la misma clase.

Avatar Kev

No asuma que la variable que marca es una cadena. No asuma que si esta var tiene una longitud, entonces es una cadena.

La cuestión es que piense detenidamente qué debe hacer y qué puede aceptar su aplicación. Construye algo robusto.

Si su método / función solo debe procesar una cadena no vacía, pruebe si el argumento es una cadena no vacía y no haga ningún "truco".

Como ejemplo de algo que explotará si sigue algunos consejos aquí sin cuidado.


var getLastChar = function (str) {
 if (str.length > 0)
   return str.charAt(str.length - 1)
}

getLastChar('hello')
=> "o"

getLastChar([0,1,2,3])
=> TypeError: Object [object Array] has no method 'charAt'
 

Entonces, me quedo con


if (myVar === '')
  ...
 

Normalmente uso algo como esto,

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

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

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

@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");}

OP estaba preguntando por "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.

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 saltos de línea después de return ;

-1 Están probando cosas diferentes. No tiene sentido ponerlos todos en una instrucción if .

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 length hace que la primitiva de cadena se envuelva en un objeto de cadena.

var x ="  ";
var patt = /^\s*$/g;
isBlank = patt.test(x);
alert(isBlank); // Is it blank or not??
x = x.replace(/\s*/g, ""); // Another way of replacing blanks with ""
if (x===""){
    alert("ya it is blank")
}
 

Siempre debe verificar el tipo también, ya que JavaScript es un lenguaje de escritura pato, por lo que es posible que no sepa cuándo y cómo cambiaron los datos en medio del proceso. Entonces, aquí está la mejor solución:

     let undefinedStr;
    if (!undefinedStr) {
      console.log("String is undefined");
    }
    
    let emptyStr = "";
    if (!emptyStr) {
      console.log("String is empty");
    }
    
    let nullStr = null;
    if (!nullStr) {
      console.log("String is null");
    }  

Para comprobar si está vacío:

var str = "Hello World!";
var n = str.length;
if(n === ''){alert("THE STRING str is EMPTY");}
 

Para comprobar si no está vacío

var str = "Hello World!";
var n = str.length;
if(n != ''){alert("THE STRING str isn't EMPTY");}
 

Incorrecto. length no es null . str = ''; str.length == 0 no str.length == null . Pero en general, su enfoque está bien.

Verificar la propiedad de longitud hará que la primitiva de cadena se envuelva en un objeto de cadena y la verificación de nulo tampoco es correcta, ya que no busca indefinido (que no es lo mismo). Para probar una cadena vacía, simplemente compárela con "" (es decir, si (myString === ""))

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

  1. verifique que var a; exista
  2. recorta el false spaces en el valor, luego prueba emptiness

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

<html>
    <head>
        <script lang="javascript">

            function nullcheck()
            {
                var n = "fdgdfg";
                var e = n.length;
                if (e == 0)
                {
                    return true;
                }
                else
                {
                    alert("success");
                    return false;
                }
            }
        </script>
    </head>

    <body>
        <button type="submit" value="add" onclick="nullcheck()"></button>
    </body>
</html>
 

Una explicación estaría en orden.

La biblioteca de JavaScript Underscore.js , http://underscorejs.org/ , proporciona una función _.isEmpty() muy útil para comprobar cadenas vacías y otros objetos vacíos.

Referencia: http://underscorejs.org/#isEmpty

está vacío _.isEmpty(object)
Devuelve verdadero si un objeto enumerable no contiene valores (no propiedades propias enumerables). Para cadenas y objetos tipo matriz, _.isEmpty comprueba si la propiedad de longitud es 0.

_.isEmpty([1, 2, 3]);
=> falso

_.isEmpty({});
=> verdadero

Otras funciones muy útiles de Underscore.js incluyen:

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

La comprobación de indefinidos debería moverse al primero en las comprobaciones, o los elementos no definidos arrojarán excepciones en las comprobaciones anteriores.

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

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

No hay un método isEmpty() , 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 es undefined o null .

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

Puede utilizar lodash : _.isEmpty (valor).

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

Pero siempre devuelve true para Number tipo de tipos de datos primitivos de JavaScript como _.isEmpty(10) o _.isEmpty(Number.MAX_VALUE) ambos devuelven true .

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

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

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.

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 marcar tanto '' cadena vacía como ' ' con espacio, puede hacerlo simplemente agregando trim() , algo como el código siguiente:

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

y puedes llamarlo de esta manera:

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

¿Qué beneficio tiene 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.

Puede validar las siguientes formas y comprender la diferencia.

 var j = undefined;
console.log((typeof j == 'undefined') ? "true":"false");
var j = null; 
console.log((j == null) ? "true":"false");
var j = "";
console.log((!j) ? "true":"false");
var j = "Hi";
console.log((!j) ? "true":"false");  

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
 

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.

}
 

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

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.

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 Math.random() devuelve un número y no una cadena. Y esta respuesta se trata de cadenas. ;-)

Pruebe esto:

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

La siguiente expresión regular es otra solución, que se puede usar para cadenas nulas, vacías o indefinidas.

(/(null|undefined|^$)/).test(null)
 

Agregué esta solución, porque se puede extender más para marcar vacío o algún valor como el siguiente. La siguiente expresión regular está comprobando que la cadena puede estar vacía nula indefinida o solo tiene números enteros.

(/(null|undefined|^$|^\d+$)/).test()
 

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

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

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

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

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

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. Consulte stackoverflow.com/questions/856324/…

Compruebe todos los escenarios siguientes:

  1. nulo

  2. indefinido

  3. 0

  4. "" (la cadena vacía)

  5. falso

  6. NaN

Rendimiento

Realizo pruebas en macOS v10.13.6 (High Sierra) para 18 soluciones seleccionadas. Las soluciones funcionan de forma ligeramente diferente (para datos de entrada de casos de esquina) que se presentan en el fragmento a continuación.

<

  • las soluciones simples basadas en !str,==,=== y length son rápidas para todos los navegadores (A, B, C , G, I, J)
  • las soluciones basadas en la expresión regular (test , replace ) y charAt son las 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 siguiente fragmento, comparo los resultados de los 18 métodos elegidos utilizando 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 el 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 presentado! ¡Gracias!