Como verificar corda / indefinido / null vazio em JavaScript?

Question

Eu vi esta discussão , mas eu não vi um exemplo específico JavaScript. Existe uma string.Empty simples disponível em JavaScript, ou é apenas um caso de verificação de ""?

Answer 1

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

if (strValue) {
    //do something
}

Se você precisa verificar especificamente para uma seqüência vazia ao longo nulo, eu acho que a verificação contra "" é a sua melhor aposta, usando operador === (de modo que você sabe que ele é, na verdade, uma seqüência que você está comparando contra).

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

Answer 2

Para verificar se uma string está vazio, nulo ou indefinido eu uso:

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

Para verificar se uma string está em branco, nulo ou indefinido eu uso:

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

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

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

Answer 3

Todos os acima são boas, mas isso vai ser ainda melhor. uso !! ( não não ) operador.

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

ou tipo de uso elenco:

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

Ambos fazem a mesma função, tipo de converter a variável para booleano, onde str é uma variável.
Devoluções false para null,undefined,0,000,"",false.
Devoluções true para string "0" e os espaços em branco "".

Answer 4

Se você precisa ter certeza de que a cadeia não é só um monte de espaços vazios (eu estou supondo que isto é para validação de formulário) que você precisa fazer uma substituição nos espaços.

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

Answer 5

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

if (!str.length) { ...

Answer 6

Eu 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

Tente:

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

Answer 8

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

P.S. Em Javascript, não use quebra de linha após return;

Answer 9

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

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

Answer 10

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

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

Mas ele sempre retorna true para o tipo Number de Javascript tipos de dados primitivos como _.isEmpty(10) ou _.isEmpty(Number.MAX_VALUE) tanto retornos true.

Answer 11

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

EDIT: por comentário de Constantin , se strVar poderia de alguma forma acabam contendo um valor inteiro 0, então isso na verdade, ser uma daquelas situações de esclarecer intenção.

Answer 12

Você também pode ir com regexps:

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

cheques para cordas que estão vazios ou cheios com espaços em branco.

Answer 13

Um monte de respostas, e um monte de diferentes possibilidades!

Sem dúvida para a 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 ir a este respeito, gostaria de sugerir:

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.

Answer 14

1. Verifique se existem var a;

2. remates para fora o false spaces no valor, em seguida, teste para emptiness

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

Answer 15

Além disso, no caso de você considerar um espaço em branco preenchido string como "vazio". Você pode testá-lo com este Regex:

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

Answer 16

Eu costumo usar alguma coisa como esta,

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

Answer 17

Eu não tenho notado uma resposta que leva em conta a possibilidade de caracteres nulos em uma string. Por exemplo, se temos uma cadeia de caracteres nulo:

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 o seu um nullness poderia fazer algo parecido com isto:

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

Ele funciona em uma cadeia nula, e em uma cadeia vazia e é acessível para todas as cadeias. Além disso, ele pode ser expandido para conter outro JavaScript vazio ou espaço em branco caracteres (isto é, o espaço não separável, marca ordem de byte, linha / n separador, etc.).

Answer 18

Se um precisa para detectar não só esvaziar mas também cordas em branco, vou acrescentar a resposta de Goral:

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

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

Answer 19

Todas estas respostas são agradáveis.

Mas eu não posso ter certeza de que variável é uma string, não contém apenas espaços (isto é 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 on jsFiddle .

Answer 20

Eu costumo usar algo como:

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

Answer 21

Eu uso uma combinação, verificações mais rápidas estão em primeiro lugar.

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 cordas de espaço em branco, você pode usar isso para verificar se há null, esvaziar e indefinido:

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

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

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

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

Answer 23

Eu fiz alguma pesquisa que acontece se você passar um não-string eo valor / null não-vazia para uma função testador. Como muitos sabem, (0 == "") é verdadeira em javascript, mas desde que 0 é um valor e não esvaziar ou nulo, você pode querer teste para ele.

As duas funções seguintes retornar true somente para indefinida, null, esvaziar / espaço em branco valores e falsa para tudo o resto, como números, boolean, objetos, expressões etc.

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

exemplos mais complicados existe, mas estes são simples e dar resultados consistentes. Não há necessidade de teste para indefinida, uma vez que está incluído no (valor == null) cheque. Você também pode imitar C # comportamento, adicionando-os para String como este:

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

Você não quer colocá-lo em protótipo Cordas, porque se a instância do String-classe é nulo, ele irá 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 matriz valor seguinte. Você pode fazer um loop através de 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 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 se é exatamente uma string vazia:

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

para verificar se ele é uma cadeia vazia ou um equivalente lógico para não-valor (null, indefinido, 0, NaN, falsa, ...):

if(!val)...

Answer 25

Enquanto isso, podemos ter uma função que verifica a existência de todos os 'esvazia' como null, indefinido, '', '', {}, [] . Então, eu só escrevi 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;
    }
}

Os 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

Answer 26

Não há nenhum método isEmpty(), você tem que verificar para o tipo eo comprimento:

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

A verificação de tipo é necessária, a fim de erros de execução evitar ao test é undefined ou null.

Answer 27

Não suponha que a variável que verificar é uma string. Não presuma que, se este var tem um comprimento, então é uma string.

A coisa é: pensar cuidadosamente sobre o que a sua aplicação deve fazer e pode aceitar. Construir algo robusto.

Se o seu método / função só deve processar uma string não vazia, então, testar se o argumento é uma string não vazia e não fazer algum 'truque'.

Como um exemplo de algo que vai explodir se você seguir alguns conselhos aqui não 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'

Então, eu ia ficar com

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

Answer 28

Tente este

str.value.length == 0

Answer 29

Você pode facilmente adicioná-lo à nativa string objeto JavaScript e reutilizá-lo mais e mais ...
Algo simples como abaixo código 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ê gostaria de verificar tanto string vazia '' e ' ' com o espaço, você pode fazer isso apenas adicionando trim(), algo como o código abaixo:

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

e você pode chamá-lo desta maneira:

''.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 é também uma forma genérica para verificar se o campo está vazio.