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

Question

Vi este hilo , pero No vi un ejemplo específico de JavaScript. ¿Hay un string.Empty simple disponible en JavaScript, o es solo un caso de verificación de " " ?

Answer 1

Si solo quieres comprobar si hay algún valor, puedes hacerlo

if (strValue) {
    //do something
}

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

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

Answer 2

Para verificar si una cadena está vacía, nula o no definida, 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 solo contiene espacios en blanco:

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

Answer 3

Todo lo anterior es bueno, pero esto será aún mejor. utilice el operador !! ( no ).

if(!!str){
some code here;
}

o use casting de tipo:

if(Boolean(str)){
    codes here;
}

Ambos realizan la misma función, escriba cast la variable a boolean, donde str es una variable.
Devuelve false para null, undefined, 0,000, " ", false .
Devuelve true para la cadena " 0 " y espacios en blanco " " ;.

Answer 4

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 de formularios), debe hacer un reemplazo en los espacios.

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

Answer 5

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

if (!str.length) { ...

Answer 6

Yo uso:

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

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

Answer 7

Prueba:

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

Answer 8

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

  

p.s. En Javascript, no use Line-Break después de return;

Answer 9

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

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

Answer 10

Puedes usar lodash : _.isEmpty (valor).

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

Pero siempre devuelve true para el tipo de Number de Tipos de datos primitivos de Javascript como _.isEmpty (10) o _.isEmpty (Number.MAX_VALUE) ambos devuelven < código> verdadero .

Answer 11

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

EDITAR: por comentario de Constantin , si strVar pudiera terminar con un valor entero 0, entonces eso De hecho, sé una de esas situaciones que aclaran la intención.

Answer 12

También puedes ir con expresiones regulares:

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

Comprueba si las cadenas están vacías o rellenas con espacios en blanco.

Answer 13

¡Muchas respuestas y muchas posibilidades diferentes!

Sin lugar a dudas, para una implementación rápida y sencilla, 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é.

Answer 14

1. compruebe que var a; existe

2. recorte los espacios falsos en el valor, luego pruebe emptiness

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

Answer 15

También, en caso de que consideres una cadena rellena de espacios en blanco como " vacío " ;. Puedes probarlo con este Regex:

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

Answer 16

Usualmente uso algo como esto,

if (!str.length) {
//do some thing
}

Answer 17

No he notado una respuesta que tenga en cuenta la posibilidad de que haya 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, se podría expandir para que contenga otros caracteres de JavaScript en blanco o en blanco (es decir, espacio sin romper, marca de orden de bytes, separador de línea / párrafo, etc.).

Answer 18

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

Answer 19

Todas estas respuestas son agradables.

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

Answer 20

Normalmente uso algo como:

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

Answer 21

Yo uso una combinación, las verificaciones más rápidas son primero.

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

Answer 22

Ignorando las cadenas de espacios en blanco, puede usar esto para verificar que no haya nulos, esté vacío o no definido:

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

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

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

Conciso y funciona para propiedades no definidas, aunque no es la más legible.

Answer 23

Investigué un poco lo que sucede si pasas un valor no de cadena y no vacío / nulo a una función de prueba. Como muchos saben, (0 == " ") se cumple en javascript, pero como 0 es un valor y no está vacío o es nulo, es posible que desee realizar una prueba.

Las dos funciones siguientes devuelven verdadero solo para valores no definidos, 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 realizar pruebas para undefined, ya que se incluye en (value == null) check. 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 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

He probado con la siguiente matriz de valores. Puede realizar un bucle 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 js
    ['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; } }]
];

Answer 24

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 sin valor (nulo, indefinido, 0, NaN, falso, ...):

if(!val)...

Answer 25

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

Answer 26

No hay un método isEmpty () , debes verificar el tipo y la longitud:

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

La comprobación de tipo es necesaria para evitar errores de tiempo de ejecución cuando test es undefined o null .

Answer 27

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

La cuestión es: piense detenidamente sobre lo que su aplicación debe hacer y puede aceptar. Construye algo robusto.

Si su método / función solo debe procesar una cadena no vacía, entonces pruebe si el argumento no es una cadena 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'

Por lo tanto, me quedaría con

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

Answer 28

Prueba esto

str.value.length == 0

Answer 29

Puede agregarlo fácilmente al objeto nativo Cadena en JavaScript y reutilizarlo una y otra vez ...
Algo simple como el código de abajo puede hacer el trabajo por usted si quiere 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 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

Answer 30

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.