Como posso verificar se há uma string vazia / indefinida / nula no JavaScript?

Vi essa pergunta , mas não vi um exemplo específico de JavaScript. Existe um simples string.Emptydisponível em JavaScript, ou é apenas um caso de verificação ""?

Se você quiser apenas verificar se há algum valor, pode fazer

if (strValue) {
    //do something
}

Se você precisar verificar especificamente se há uma seqüência de caracteres vazia em vez de nulo, acho que fazer uma comparação ""é a sua melhor aposta, usando o ===operador (para que você saiba que é, de fato, uma sequência com a qual você está comparando).

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

Para verificar se uma string está vazia, nula ou indefinida, eu uso:

function isEmpty(str) {
    return (!str || 0 === str.length);
}

Para verificar se uma string está em branco, nula ou indefinida, eu uso:

function isBlank(str) {
    return (!str || /^\s*$/.test(str));
}

Para verificar se uma sequência está em branco ou contém apenas espaço em branco:

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

Todas as respostas anteriores são boas, mas isso será ainda melhor. Use o operador !!( não não ).

if(!!str){
    // Some code here
}

Ou use a conversão de tipo:

if(Boolean(str)){
    // Code here
}

Ambos fazem a mesma função. Crie a variável como Boolean, onde stré uma variável.
Retorna falsepara null,undefined,0,000,"",false.
Retorna truepara a string "0" e espaço em branco "".

A coisa mais próxima que você pode chegar str.Empty(com a pré-condição de que str é uma String) é:

if (!str.length) { ...

Se você precisar se certificar de que a sequência não seja apenas um monte de espaços vazios (suponho que seja para validação de formulário), será necessário substituir os espaços.

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

Eu 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

Você pode usar lodash : _.isEmpty (valor).

Ele abrange uma série de casos como {}, '', null, undefined, etc.

Mas sempre retorna truepara o Numbertipo de dados primitivos do JavaScript como _.isEmpty(10)ou _.isEmpty(Number.MAX_VALUE)ambos os retornos true.

Função:

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

PS: No JavaScript, não use quebra de linha depois return;

Tentar:

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

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

Não há nada representando uma string vazia no JavaScript. Faça uma verificação contra length(se você sabe que o var sempre será uma string) ou contra""

Eu não me preocuparia muito com o método mais eficiente . Use o que for mais claro para sua intenção. Para mim, isso geralmente é strVar == "".

De acordo com o comentário de Constantin , se strVar puder de alguma maneira acabar contendo um valor inteiro 0, então essa seria realmente uma daquelas situações de esclarecimento de intenção.

Muitas respostas e muitas possibilidades diferentes!

Sem dúvida, para uma implementação rápida e simples, o vencedor é: if (!str.length) {...}

No entanto, como muitos outros exemplos estão disponíveis. O melhor método funcional para fazer isso, eu sugeriria:

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

Um pouco excessivo, eu sei.

Você também pode usar expressões regulares:

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

Verifica se há strings vazias ou preenchidas com espaço em branco.

atuação

Realizo testes no macOS v10.13.6 (High Sierra) para 18 soluções escolhidas. O Solutions funciona um pouco diferente (para dados de entrada em maiúsculas), apresentado no snippet abaixo.

Conclusões

• as soluções simples com base em !str, ==, ===elength são rápidos para todos os navegadores (A, B, C, G, I, J)
• as soluções baseadas na expressão regular ( test, replace) echarAt são mais lentas para todos os navegadores (H, L, M, P)
• as soluções marcadas como mais rápidas foram as mais rápidas apenas para uma execução de teste - mas em muitas execuções elas são alteradas dentro do grupo de soluções 'rápidas'

Detalhes

No snippet abaixo, comparo os resultados dos 18 métodos escolhidos, usando diferentes parâmetros de entrada

• "" "a" " "- string vazia, string com letra e string com espaço
• [] {} f- matriz, objeto e função
• 0 1 NaN Infinity - números
• true false - Boleano
• null undefined

Nem todos os métodos testados suportam todos os 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);

E, em seguida, para todos os métodos str = "", realizo o teste de velocidade dos navegadores Chrome v78.0.0, Safari v13.0.4 e Firefox v71.0.0 - você pode executar testes em sua máquina aqui

1. verifique se var a;existe

2. apare false spaceso valor no e teste paraemptiness

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

Além disso, caso você considere uma string preenchida com espaço em branco como "vazia".

Você pode testá-lo com esta expressão regular:

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

Eu costumo usar algo assim,

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

Não notei uma resposta que leve em consideração a possibilidade de caracteres nulos em uma string. Por exemplo, se tivermos uma cadeia 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 testar sua nulidade, pode-se fazer algo assim:

String.prototype.isNull = function(){ 
  return Boolean(this.match(/^[\0]*$/)); 
}
...
"\0".isNull() // true

Funciona em uma cadeia nula, em uma cadeia vazia e é acessível para todas as cadeias. Além disso, ele pode ser expandido para conter outros caracteres em branco ou em branco do JavaScript (por exemplo, espaço não separável, marca de ordem de bytes, separador de linha / parágrafo etc.).

Enquanto isso, podemos ter uma função que verifica todos os 'vazios' como nulo, indefinido, '', '', {}, [] . Então eu acabei de escrever isso.

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 e 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 agora não há método direto como string.empty para verificar se uma string está vazia ou não. Mas no seu código você pode usar uma verificação de wrapper para uma string vazia 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.

}

Usando isso, você também pode garantir que a sequência não seja indefinida ou nula também. Lembre-se, indefinido, nulo e vazio são três coisas diferentes.

Todas essas respostas são legais.

Mas não posso ter certeza de que a variável é uma string, não contém apenas espaços (isso é importante para mim) e pode conter '0' (string).

Minha versão:

function empty(str){
    return !str || !/[^\s]+/.test(str);
}

empty(null); // true
empty(0); // true
empty(7); // false
empty(""); // true
empty("0"); // false
empty("  "); // true

Amostra no jsfiddle .

Não vi uma boa resposta aqui (pelo menos não uma resposta adequada para mim)

Então eu decidi me responder:

value === undefined || value === null || value === "";

Você precisa começar a verificar se está indefinido. Caso contrário, seu método poderá explodir e você poderá verificar se é igual a nulo ou se é uma string vazia.

Você não pode ter !! ou somente if(value)porque, se você verificar, 0isso dará uma resposta falsa (0 é falso).

Com isso dito, envolva-o em um método como:

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

PS .: Você não precisa verificar o typeof , pois ele explodiria e lançaria antes mesmo de entrar no método

Se for necessário detectar não apenas cadeias vazias, mas também em branco, adicionarei à resposta de Goral:

function isEmpty(s){
    return !s.length;    
}

function isBlank(s){
    return isEmpty(s.trim());    
}

Tente isto

str.value.length == 0

Você pode adicioná-lo facilmente ao objeto String nativo em JavaScript e reutilizá-lo repetidamente ...
Algo simples, como o código abaixo, pode fazer o trabalho para você, se você quiser verificar ''cadeias vazias:

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

Caso contrário, se você quiser verificar a ''sequência vazia e o ' 'espaço, faça isso apenas adicionando trim()algo como o código abaixo:

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

e você pode chamar assim:

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

Tente o seguinte:

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

Eu fiz algumas pesquisas sobre o que acontece se você passar um valor não-string e não-vazio / nulo para uma função testadora. Como muitos sabem, (0 == "") é verdadeiro em JavaScript, mas como 0 é um valor e não é vazio ou nulo, convém testá-lo.

As duas funções a seguir retornam true somente para valores indefinidos, nulos, vazios / espaços em branco e false para todo o resto, como números, booleano, objetos, expressões etc.

function IsNullOrEmpty(value)
{
    return (value == null || value === "");
}
function IsNullOrWhiteSpace(value)
{
    return (value == null || !/\S/.test(value));
}

Existem exemplos mais complicados, mas são simples e fornecem resultados consistentes. Não há necessidade de testar indefinidamente, pois ele está incluído na verificação (valor == nulo). Você também pode imitar o comportamento do C # adicionando-o ao String assim:

String.IsNullOrEmpty = function (value) { ... }

Você não deseja colocá-lo no protótipo Strings, porque se a instância da classe String for nula, ocorrerá um erro:

String.prototype.IsNullOrEmpty = function (value) { ... }
var myvar = null;
if (1 == 2) { myvar = "OK"; } // Could be set
myvar.IsNullOrEmpty(); // Throws error

Eu testei com a seguinte matriz de valores. Você pode fazer um loop para testar suas funções em caso de dúvida.

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

Para verificar se é exatamente uma string vazia:

if(val==="")...

Para verificar se é uma string vazia OU um equivalente lógico para no-value (nulo, indefinido, 0, NaN, false, ...):

if(!val)...

Não há isEmpty()método, você precisa verificar o tipo e o comprimento:

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

A verificação de tipo é necessária para evitar erros de tempo de execução quando testé undefinedou null.

Ignorando cadeias de espaço em branco, você pode usar isso para verificar se há nulos, vazios e indefinidos:

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

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

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

É conciso e funciona para propriedades indefinidas, embora não seja o mais legível.