Vi essa pergunta , mas não vi um exemplo específico de JavaScript. Existe um simples string.Empty
disponível em JavaScript, ou é apenas um caso de verificação ""
?
Vi essa pergunta , mas não vi um exemplo específico de JavaScript. Existe um simples string.Empty
disponível em JavaScript, ou é apenas um caso de verificação ""
?
Respostas:
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 === "") {
//...
}
=== ''
vs .length
não mostrou qualquer melhora perceptível (e usando .length
só funciona se você pode assumir que você tem uma string)
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());
};
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.
/^\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/…
if blue is the sky
. Veja dodgycoder.net/2011/11/yoda-conditions-pokemon-exception.html
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 false
para null,undefined,0,000,"",false
.
Retorna true
para a string "0" e espaço em branco "".
if(str)
e if(!!str)
?
var any = (!!str1 && !!str2 && !!str3)
manuseamento se houver um número de lá também
!!str.trim()
para garantir que a sequência não seja feita apenas de espaços em branco.
Boolean(str)
é muito mais legível e menos "wtfish".
A coisa mais próxima que você pode chegar str.Empty
(com a pré-condição de que str é uma String) é:
if (!str.length) { ...
str.Empty
.
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,"") == ""){
}
if(str.match(/\S/g)){}
str.match(/\S/)
var trimLeft = /^\s+/, trimRight = /\s+$/;
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
typeof
no switch
não funcionou para mim. Eu adicionei um if (typeof e == "undefined")
teste e isso funciona. Por quê?
case undefined:
vez de case typeof(e) == "undefined":
?
Você pode usar lodash : _.isEmpty (valor).
Ele abrange uma série de casos como {}
, ''
, null
, undefined
, etc.
Mas sempre retorna true
para o Number
tipo de dados primitivos do JavaScript como _.isEmpty(10)
ou _.isEmpty(Number.MAX_VALUE)
ambos os retornos true
.
_.isEmpty(" "); // => false
" "
não está vazio. _.isEmpty("");
retorna verdadeiro.
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
;
if
declaração.
Tentar:
if (str && str.trim().length) {
//...
}
str.trim().length
fará mais rápido do que str.trim()
, em cerca de 1%, de acordo com o meu próprio resultado de teste.
if (!str) { ... }
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.
===
seria melhor. Ele só retorna true se strVar
for uma string vazia.
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.
str.length === 0
retorna true para qualquer função que não tenha parâmetros formais.
Você também pode usar expressões regulares:
if((/^\s*$/).test(str)) { }
Verifica se há strings vazias ou preenchidas com espaço em branco.
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
!str
, ==
, ===
elength
são rápidos para todos os navegadores (A, B, C, G, I, J)test
, replace
) echarAt
são mais lentas para todos os navegadores (H, L, M, P)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ção0
1
NaN
Infinity
- númerostrue
false
- Boleanonull
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
var a;
existeapare false spaces
o valor no e teste paraemptiness
if ((a)&&(a.trim()!=''))
{
// if variable a is not empty do this
}
Eu costumo usar algo assim,
if (!str.length) {
// Do something
}
typeof variable != "undefined"
antes de verificar se está vazio.
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.
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.
Math.random()
retorna um número e não uma string. E essa resposta é sobre strings. ;-)
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 .
empty(0)
e empty(7)
deve retornar o mesmo valor.
empty("0")
deve retornar false
(porque isso é uma string não vazia), mas empty(0)
deve retornar true
porque ele está vazio :)
empty
é um nome enganoso nesse caso.
empty
é um nome impreciso e enganoso. É interessante que o PHP também tenha uma empty
função com nomes inadequados , mas as falhas do PHP não têm nada a ver com JavaScript.
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, 0
isso 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
Tente isto
str.value.length == 0
"".value.length
causará um erro. Deveria serstr.length === 0
TypeError
se str
é igual a undefined
ounull
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
!(!!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.
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; } }]
];
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
é undefined
ou 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.