vacio - ¿Cómo verifica una cadena vacía en JavaScript?

variable null javascript

Question

Vi este thread , pero no vi un ejemplo específico de JavaScript. ¿Hay una string.Empty disponible en JavaScript, o es solo un caso de comprobación para "" ?

Answer 1

1. compruebe que var a; existe

2. recorte los false spaces en el valor, luego pruebe el emptiness

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

Answer 2

¡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 3

Además, en caso de que consideres una cadena rellena de espacios en blanco como "vacía". Puedes probarlo con este Regex:

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

Answer 4

Función:

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

Answer 5

Ignorando las cadenas de espacios en blanco, puede usar esto para verificar si está nulo, vacío e indefinido:

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 6

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

Las siguientes dos funciones devuelven verdadero solo para valores no definidos, nulos, vacíos / espacios en blanco y falso para todo lo demás, como números, valores 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 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

He probado con la siguiente matriz de valores. Puede hacer 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 7

La biblioteca de guiones bajos del guión http://underscorejs.org/ proporciona una función _.isEmpty() muy útil para verificar si hay cadenas vacías y otros objetos vacíos.

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

isEmpty _.isEmpty(object)
Devuelve verdadero si un objeto enumerable no contiene valores (no posee propiedades propias enumerables). Para cadenas y objetos similares a una matriz _.isEmpty comprueba si la propiedad de longitud es 0.

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

_.isEmpty({});
=> verdadero

Otras funciones de subrayado muy útiles incluyen:
http://underscorejs.org/#isNull _.isNull(object)
http://underscorejs.org/#isUndefined _.isUndefined(value)
http://underscorejs.org/#has _.has(object, key)

Answer 8

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

if (!str.length) { ...

Answer 9

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 10

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

La cosa es: piense cuidadosamente 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 quedo con

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

Answer 11

No hay isEmpty() 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 la test undefined está undefined o es null .

Answer 12

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 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 13

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

EDITAR: según el comentario de Constantin , si strVar pudiera llegar a contener un valor entero 0, entonces esa sería una de esas situaciones que aclaran la intención.

Answer 14

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 solo contiene espacios en blanco:

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

Answer 15

Prueba esto

   str.value.length == 0

Answer 16

Puede utilizar 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) devuelve true .

Answer 17

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 18

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

if (strValue) {
    //do something
}

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

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

Answer 19

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 20

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 21

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

Answer 22

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

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

o utilizar el tipo de fundición:

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 el espacio en blanco "".

Answer 23

Tratar:

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

Answer 24

Usualmente uso algo como esto,

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

Answer 25

Usualmente uso algo como:

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

Answer 26

Yo suelo :

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 27

Yo uso una combinación, los cheques más rápidos son los primeros.

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 28

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

Answer 29

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 es también una forma genérica de verificar si el campo está vacío.

Answer 30

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

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