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


2853

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


2
apenas para sua informação, acho que as APIs mais úteis para a classe String estão no kit Mozilla e javascript . [elated.com] ( elated.com/articles/working-with-strings ) tem um tutorial sobre todas as propriedades, métodos, String ... Observação: o link Mozilla foi atualizado para developer.mozilla.org/en/ JavaScript / Referência / Global_Objects /…
Gene T


Ajudaria muito se o requisito fosse claramente especificado. Para quais valores isEmpty deve retornar true? A verificação de "" infere que ele só deve retornar verdadeiro se o valor for Tipo string e comprimento 0. Muitas respostas aqui assumem que ele também deve retornar verdadeiro para alguns ou todos os valores falsey.
RobG 16/10/19

Respostas:


3572

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

174
Testar a propriedade length pode ser realmente mais rápido do que testar a string contra "", porque o intérprete não precisará criar um objeto String a partir da literal da string.
Vincent Robert

26
@Vincent fazer algumas profiling ingênua em ferramentas de desenvolvimento do Chrome, testando === ''vs .lengthnão mostrou qualquer melhora perceptível (e usando .lengthsó funciona se você pode assumir que você tem uma string)
bdukes

26
@bdukes quando você começar a se preocupar com esse tipo de micro-otimizações, eu não acho que Chrome é o navegador que você está tendo a maioria de seus problemas de desempenho ...
Vincent Robert

15
Apenas para observar, se sua definição de "cadeia vazia" inclui espaço em branco, então esta solução não é apropriada. Uma sequência de 1 ou mais espaços retorna true acima. Se você estiver usando o JQuery, pode simplesmente usar o seguinte: if ($ .trim (ref) .length === 0) - conforme esta resposta a uma pergunta semelhante: stackoverflow.com/questions/2031085/…
CodeClimber

115
Como esperado, .length > 0é realmente muito mais rápido do que comparar com uma string literal! Confira este JSPerf
Chad

1128

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

21
por que 0 === comprimento do comprimento em vez de comprimento do comprimento === 0?
Vincent

66
As condições @Vincent geralmente são escritas assim if (variable == constant value)e se você esquecer um '=', estará atribuindo o valor constante à variável em vez de testar. O código ainda funcionará, pois você pode atribuir uma variável em um if. Portanto, uma maneira mais segura de escrever essa condição é reverter o valor constante e a variável. Dessa forma, ao testar seu código, você verá um erro (lado esquerdo esquerdo na atribuição). Você também pode usar algo como JSHint para proibir a atribuição em condições e ser avisado ao escrever uma.
florian 23/09

2
pena que /^\s*$/.test(str)não é realmente legível - talvez remover espaços usando código ou regex mais simples seria melhor? consulte stackoverflow.com/questions/6623231/… e também stackoverflow.com/questions/10800355/…
Adrien Seja

6
/^\s*$/.test(str) pode ser substituído por str.trim (). length === 0
Schadenfreude

21
@ Vincent isso também é chamado de "Condições Yoda", como if blue is the sky. Veja dodgycoder.net/2011/11/yoda-conditions-pokemon-exception.html
AZ.

316

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


61
Por que isso é "ainda melhor"?
Mene

33
Existe alguma diferença entre o comportamento de if(str)e if(!!str)?
Peter Olson

6
@PeterOlson se você está tentando salvar uma variável como um booleano que verifica várias seqüências de conteúdo, então você iria querer fazer isso .. aka var any = (!!str1 && !!str2 && !!str3)manuseamento se houver um número de lá também
John Ruddell

23
Esta é a solução que eu sempre uso. !!str.trim()para garantir que a sequência não seja feita apenas de espaços em branco.
Dario Oddenino

5
Não parece um hack, Boolean(str)é muito mais legível e menos "wtfish".
Shinzou 17/10/16

105

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

if (!str.length) { ...

9
Isso não lançaria uma exceção é str é nulo?
Mickael Pic

3
@PicMickael Yes! O mesmo faria str.Empty.
Ates Goral 12/09

99

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

8
Mas funciona se o que você realmente deseja testar for uma sequência com conteúdo que não seja de espaço. Existe uma maneira mais barata de testar isso?
flash

4
E a propriedade length?
Drian

27
Em vez de remover todos os espaços, por que não apenas verificar se há um não-espaço? Tem 2 vantagens que podem ser resgatadas mais cedo se houver um caractere não espacial, e não retornará uma nova sequência na qual você verificará. if(str.match(/\S/g)){}
MPEN

34
@ Marcos FYI, você não precisa o modificador global, uma vez que o jogo da primeira ocorrência de um caractere não-espaço significaria a cadeia não está vazia:str.match(/\S/)
neezer

1
por que é caro? Se realmente é, então por que o jQuery usa esse método? Você pode encontrar isso na fonte do jQueryvar trimLeft = /^\s+/, trimRight = /\s+$/;
Marecky 7/12/12

66

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

5
Esta solução é mais independente de idioma. O único recurso JavaScript em que ele se baseia é typeof. Portanto, é um bom exemplo de solução que você pode usar quando não confia nas implementações em diferentes navegadores e não tem tempo para buscar uma solução melhor. (IE, sem acesso à Internet). É algo como uma prova. Não é o mais limpo, mas você pode ter certeza de que funcionará sem saber muito sobre JavaScript.
Jeff Davis

2
Eu iria um pouco mais longe e pregaria com um operador === para o caso indefinido. Caso contrário, é simplesmente a resposta perfeita.
precisa saber é o seguinte

O typeofno switchnão funcionou para mim. Eu adicionei um if (typeof e == "undefined")teste e isso funciona. Por quê?
21718 Lucas

1
@ Lucas Porque este foi um erro de digitação ou supervisão. Sua modificação é a abordagem correta. (o original se refere ao contexto da função vazia, não ao parâmetro e, que é o que a função deve verificar)
beeThree

Poderíamos usar em case undefined:vez de case typeof(e) == "undefined":?
Boris J.

43

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.


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

1
@ Erich Porque " "não está vazio. _.isEmpty("");retorna verdadeiro.
Moshii 25/03

1
bem verdade - mencionei isso porque algumas das outras respostas aqui implicam validação de formulário e verificação se uma string consiste apenas em espaço em branco, e essa função única de lodash por si só não resolverá esse problema.
Erich

@ Erich, agora entendi seu ponto de vista, obrigado por mencionar.
Moshii 26/03

36

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;


1
Alguma chance de você explicar o que cada verificação está fazendo? :)
DanV

2
-1 Eles estão testando coisas diferentes. Não faz sentido colocar todos eles em uma única ifdeclaração.
Bennett McElwee

1
typeof MyVariable == 'undefined' não discerne entre uma variável inicializada com um valor indefinido e uma variável não declarada, a menos que a variável tenha sido inicialmente declarada e inicializada como nula. A verificação da propriedade length faz com que a primitiva da string seja quebrada em um objeto de string.
Scott Marcus

35

Tentar:

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

2
A propriedade length é necessária?
Frogcoder #

str.trim().lengthfará mais rápido do que str.trim(), em cerca de 1%, de acordo com o meu próprio resultado de teste.
Devildelta 6/03/19

2
@evildelta - Seu 1% é um erro no seu teste.
Stephen M Irving

O OP está procurando testar a cadeia vazia, indefinida ou nula. Isso está testando uma cadeia que não é nenhuma dessas condições. Ele não disse nada sobre espaço em branco, apenas cordas também. Você pode testar as condições do OP com exatamente isso, desde que tenha certeza de que nenhum outro tipo de dados esteja armazenado na variável: if (!str) { ... }
Stephen M Irving

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


29

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.


11
Péssima ideia. Você será verdadeiro se strVar for atribuído a zero acidentalmente.
Constantin

5
Concordo que deixar sua intenção clara é mais importante do que qualquer micro-otimização que outros métodos possam produzir, mas usar o operador de comparação estrita === seria melhor. Ele só retorna true se strVarfor uma string vazia.
Código inútil

A verificação falha se não for definida. Então, se (str) funciona melhor
Valentin Heinitz

3
@ValentinHeinitz se str for atribuído com um valor de falsey de 0 ou "0", se (str) reportar falsamente true. A melhor abordagem é if (str === ""). É simples e nunca irá falhar.
Scott Marcus


20

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.


2
A verificação de indefinido precisaria ser movida para primeiro nas verificações, ou itens indefinidos lançarão exceções nas verificações anteriores.
SJSinner

Totalmente de acordo! BOA PEGADA. Vou editar minha resposta acima!
tfont

str.length === 0retorna true para qualquer função que não tenha parâmetros formais.
RobG

20

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

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

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


Funciona, mas também é horrivelmente caro em termos de operações. Bom se você quiser apenas verificar uma ou duas coisas, não um conjunto grande.
Orpheus

20

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'

Digite a descrição da imagem aqui

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.

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

Digite a descrição da imagem aqui


Isso é realmente incrível! Adoro ver tudo isso exposto! Obrigado!
WebWanderer 24/01

estudo aprofundado - obrigado
Deian 31/01

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

17

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.

14

Eu costumo usar algo assim,

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

3
Mais rápido se você souber que a variável é uma sequência. Lança um erro se a variável não estiver definida.
Adrian Hope-Bailie

@ AdrianHope-Bailie, por que você testaria uma variável indefinida?
Abimael Martell

2
@AbimaelMartell Por que não? Você tem uma variável que você declarou ou que foi passada a você de algum escopo que você não tem controle, como em uma resposta de uma chamada de método ou API. Você pode assumir que ele contém um valor e usar a verificação acima, mas se não estiver definido ou for nulo, você receberá um erro. teste var = nulo; Se {alert ( "Adrian está errado");} (test.length!)
Adrian Hope-Bailie

O OP estava solicitando "como verificar uma cadeia vazia", ​​a variável indefinida não é uma cadeia vazia. De qualquer forma, você pode verificar typeof variable != "undefined"antes de verificar se está vazio.
Abimael Martell

10

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


2
Análise interessante. Eu não acho que isso seria relevante em 99,9% dos casos. MAS recentemente descobri que o MySQL avalia uma coluna como "nula" se (e somente se) essa coluna contiver o caractere nulo ("\ 0"). O Oracle, por outro lado, não avaliaria "\ 0" como nulo, preferindo tratá-lo como uma sequência de comprimento 1 (onde esse caractere é o caractere nulo). Isso pode causar confusão se não for tratado adequadamente, porque muitos desenvolvedores da Web trabalham com um banco de dados de back-end, que pode passar por diferentes tipos de valores "nulos". Deve estar no fundo da mente de todo desenvolvedor.
cartbeforehorse

10

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

10

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.


Isso geraria um erro por causa nula ou indefinida. Não devemos executar diretamente uma operação em uma variável que seja nula ou indefinida - verifique se existe str antes de fazer isso, conforme indicado em outras respostas, e também observe que isso funcionaria em let abc. = '' mas não vamos deixar abc = '', esses dois são diferentes.
whoami

Considere let rand = ()=>Math.random(), então rand && rand.length > 0)retorna false, mas claramente fn não está "vazio". Ou seja, ele retorna false para qualquer função que não possui parâmetros de formato.
RobG

@RobG Math.random()retorna um número e não uma string. E essa resposta é sobre strings. ;-)
Harshit Agarwal 15/11/19

10

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 .


1
Hã? Se você está esperando uma sequência, empty(0)e empty(7)deve retornar o mesmo valor.
Bennett McElwee

No meu caso particular - empty("0")deve retornar false(porque isso é uma string não vazia), mas empty(0)deve retornar trueporque ele está vazio :)
Andron

Mas 0 não está vazio! É um número e os números não podem estar cheios ou vazios. Obviamente, é sua função e, portanto, deve atender aos seus requisitos, mas emptyé um nome enganoso nesse caso.
Bennett McElwee

Eu acho que esse nome emptyé bom. Nos documentos php para a função vazia : Returns FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE.A diferença entre PHPe esta função - essa string '0'não será identificada como vazia.
Andron

Como eu disse, é sua função: chame como quiser. Mas emptyé um nome impreciso e enganoso. É interessante que o PHP também tenha uma emptyfunção com nomes inadequados , mas as falhas do PHP não têm nada a ver com JavaScript.
Bennett McElwee

10

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


Provavelmente, use melhor a construção booleana (valor) que trata valores indefinidos e nulos (e também 0, -0, falso, NaN) como falso. Veja stackoverflow.com/questions/856324/…
Zhuravlev A.

9

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


8

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

Que benefício há em fazer, !(!!this.length)e não apenas !this(ou !this.trim()na segunda opção)? Uma string de comprimento zero já é falsa, os parênteses são redundantes e negá-la três vezes é exatamente o mesmo que negá-la uma vez.
John Montgomery

8

Tente o seguinte:

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

8

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

Se você simplesmente parar de usar == e usar ===, isso resolverá o problema se (s === "").
Scott Marcus

8

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

7

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.


7

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.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.