vacio - variable vacia javascript




¿Cómo verifica una cadena vacía en JavaScript? (20)

  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 
    }
    

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


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


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

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.


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)


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

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


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 .


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.


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

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 .


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

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

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.


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


Tratar:

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

Usualmente uso algo como:

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

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

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

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.







is-empty