Existe uma function padrão para verificar variables ​​nulas, indefinidas ou em branco em JavaScript?

Existe uma function JavaScript universal que verifica se uma variável tem um valor e garante que ela não seja undefined ou null ? Eu tenho esse código, mas não tenho certeza se ele cobre todos os casos:

 function isEmpty(val){ return (val === undefined || val == null || val.length <= 0) ? true : false; } 

Você pode apenas verificar se a variável tem um valor definido ou não. Que significa

 if( value ) { } 

será avaliado como true se o value não for:

  • nulo
  • Indefinido
  • NaN
  • seqüência vazia (“”)
  • 0
  • falso

A lista acima representa todos os possíveis valores de falsy no ECMA / Javascript. Encontre-o na especificação na seção ToBoolean .

Além disso, se você não sabe se existe uma variável (ou seja, se ela foi declarada ), você deve verificar com o operador typeof . Por exemplo

 if( typeof foo !== 'undefined' ) { // foo could get resolved and it's defined } 

Se você pode ter certeza de que uma variável é declarada pelo menos, você deve verificar diretamente se ela possui um valor geral, como mostrado acima.

Leia mais: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

O método detalhado para verificar se o valor é indefinido ou nulo é:

 return value === undefined || value === null; 

Você também pode usar o operador == , mas isso espera que você conheça todas as regras :

 return value == null; // also returns true if value is undefined 
 function isEmpty(value){ return (value == null || value.length === 0); } 

Isso retornará verdadeiro para

 undefined // Because undefined == null null [] "" 

e zero funções de argumento, uma vez que o length uma function é o número de parâmetros declarados.

Para não permitir a última categoria, você pode querer apenas verificar se há sequências em branco

 function isEmpty(value){ return (value == null || value === ''); } 

Eu sei que esta é uma pergunta antiga, mas esta é a verificação mais segura e eu não a vi aqui exatamente assim:

 if (typeof value != 'undefined' && value) { //deal with value' }; 

Abrangerá casos em que o valor nunca foi definido e também qualquer um destes:

  • nulo
  • indefinido (o valor de undefined não é o mesmo que um parâmetro que nunca foi definido)
  • 0
  • “” (string vazia)
  • falso
  • NaN

PS não precisa de igualdade rigorosa no tipo de valor! = ‘Indefinido’

A primeira resposta com melhor sorting está errada. Se o valor for indefinido, será lançada uma exceção nos navegadores modernos. Você tem que usar:

 if (typeof(value) !== "undefined" && value) 

ou

 if (typeof value !== "undefined" && value) 

Você pode achar útil a seguinte function:

 function typeOf(obj) { return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase(); } 

Ou no ES7 (comentar se melhorias adicionais)

 function typeOf(obj) { const { toString } = Object.prototype; const stringified = obj::toString(); const type = stringified.split(' ')[1].slice(0, -1); return type.toLowerCase(); } 

Resultados:

 typeOf(); //undefined typeOf(null); //null typeOf(NaN); //number typeOf(5); //number typeOf({}); //object typeOf([]); //array typeOf(''); //string typeOf(function () {}); //function typeOf(/a/) //regexp typeOf(new Date()) //date typeOf(new WeakMap()) //weakmap typeOf(new Map()) //map 

“Note que o operador bind (: 🙂 não é parte do ES2016 (ES7) nem qualquer edição posterior do padrão ECMAScript. Atualmente, é uma proposta do estágio 0 (palha) para ser introduzida no idioma.” Simon Kjellberg. o autor deseja adicionar seu apoio a esta bela proposta para receber a ascensão real.

! verifique se há strings vazias (“”), nulas, indefinidas, falsas e o número 0 e NaN. Digamos que, se uma string estiver vazia var name = "" então console.log(!name) retorna true .

 function isEmpty(val){ return !val; } 

esta function retornará true se val estiver vazia, nula, indefinida, falsa, o número 0 ou NaN .

Você está exagerando. Para verificar se uma variável não recebe um valor, você só precisa verificar undefined e null.

 function isEmpty(value){ return (typeof value === "undefined" || value === null); } 

Isto está assumindo 0 , "" , e objects (mesmo object vazio e array) são “valores” válidos.

Aqui está o meu – retorna verdadeiro se o valor é nulo, indefinido, etc ou em branco (ou seja, contém apenas espaços em branco):

 function stringIsEmpty(value) { return value ? value.trim().length == 0 : true; } 

Se você preferir javascript simples tente isto:

  /** * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a * length of `0` and objects with no own enumerable properties are considered * "empty". * * @static * @memberOf _ * @category Objects * @param {Array|Object|string} value The value to inspect. * @returns {boolean} Returns `true` if the `value` is empty, else `false`. * @example * * _.isEmpty([1, 2, 3]); * // => false * * _.isEmpty([]); * // => true * * _.isEmpty({}); * // => true * * _.isEmpty(''); * // => true */ function isEmpty(value) { if (!value) { return true; } if (isArray(value) || isString(value)) { return !value.length; } for (var key in value) { if (hasOwnProperty.call(value, key)) { return false; } } return true; } 

Caso contrário, se você já estiver usando sublinhado ou lodash, tente:

 _.isEmpty(value) 

Esta verificação de condição

 if (!!foo) { //foo is defined } 

é tudo o que você precisa.

Isto é muito simples.

 if(data) { //Comes inside only if the data is not empty and not null } 

Pode ser útil.

 [null, undefined, ''].indexOf(document.DocumentNumberLabel) > -1 

Se a variável não foi declarada, você não poderá testar indefinido usando uma function porque você receberá um erro.

 if (foo) {} function (bar) {}(foo) 

Ambos irão gerar um erro se foo não foi declarado.

Se você quiser testar se uma variável foi declarada, você pode usar

 typeof foo != "undefined" 

se você quer testar se foo foi declarado e tem um valor que você pode usar

 if (typeof foo != "undefined" && foo) { //code here } 

você pode usar:

Se cláusula para validar se a string ou valor não está vazio. como isso:

 if (someVar.value) { //its not emppty } else { //Its empty } 

Para verificar o valor padrão

 function typeOfVar (obj) { return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase(); } function isVariableHaveDefaltVal(variable) { if ( typeof(variable) === 'string' ) { // number, boolean, string, object console.log(' Any data Between single/double Quotes is treated as String '); return (variable.trim().length === 0) ? true : false; }else if ( typeof(variable) === 'boolean' ) { console.log('boolean value with default value \'false\''); return (variable === false) ? true : false; }else if ( typeof(variable) === 'undefined' ) { console.log('EX: var a; variable is created, but has the default value of undefined.'); return true; }else if ( typeof(variable) === 'number' ) { console.log('number : '+variable); return (variable === 0 ) ? true : false; }else if ( typeof(variable) === 'object' ) { // -----Object----- if (typeOfVar(variable) === 'array' && variable.length === 0) { console.log('\t Object Array with length = ' + [].length); // Object.keys(variable) return true; }else if (typeOfVar(variable) === 'string' && variable.length === 0 ) { console.log('\t Object String with length = ' + variable.length); return true; }else if (typeOfVar(variable) === 'boolean' ) { console.log('\t Object Boolean = ' + variable); return (variable === false) ? true : false; }else if (typeOfVar(variable) === 'number' ) { console.log('\t Object Number = ' + variable); return (variable === 0 ) ? true : false; }else if (typeOfVar(variable) === 'regexp' && variable.source.trim().length === 0 ) { console.log('\t Object Regular Expression : '); return true; }else if (variable === null) { console.log('\t Object null value'); return true; } } return false; } var str = "A Basket For Every Occasion"; str = str.replace(/\s/g, "-"); //The "g" flag in the regex will cause all spaces to get replaced. 

verifique o resultado:

 isVariableHaveDefaltVal(' '); // string isVariableHaveDefaltVal(false); // boolean var a; isVariableHaveDefaltVal(a); isVariableHaveDefaltVal(0); // number isVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - true isVariableHaveDefaltVal(null); isVariableHaveDefaltVal([]); isVariableHaveDefaltVal(/ /); isVariableHaveDefaltVal(new Object('')); isVariableHaveDefaltVal(new Object(false)); isVariableHaveDefaltVal(new Object(0)); typeOfVar( function() {} ); 

Eu usei a function @Vix () para verificar o object de qual tipo.

usando instansof «

 var prototypes_or_Literals = function (obj) { switch (typeof(obj)) { // object prototypes case 'object': if (obj instanceof Array) return '[object Array]'; else if (obj instanceof Date) return '[object Date]'; else if (obj instanceof RegExp) return '[object regexp]'; else if (obj instanceof String) return '[object String]'; else if (obj instanceof Number) return '[object Number]'; else return 'object'; // object literals default: return typeof(obj); } }; output test « prototypes_or_Literals( '' ) // "string" prototypes_or_Literals( new String('') ) // "[object String]" Object.prototype.toString.call("foo bar") //"[object String]" 

Você pode usar o código abaixo para verificar todas as quatro (4) condições de validação, como não null, não em branco, não indefinido e não zero, use este código (! (! (Variable))) em javascript e jquery.

 function myFunction() { var data; //The Values can be like as null, blank, undefined, zero you can test if(!(!(data))) { alert("data "+data); } else { alert("data is "+data); } } 

Se você estiver usando o TypeScript e não quiser considerar “valores que são false , esta é a solução para você:

Primeiro: import { isNullOrUndefined } from 'util';

Então: isNullOrUndefined(this.yourVariableName)

Para todo mundo que vem aqui por ter uma pergunta semelhante, o seguinte funciona muito bem e eu tenho isso na minha biblioteca nos últimos anos:

 (function(g3, $, window, document, undefined){ g3.utils = g3.utils || {}; /********************************Function type()******************************** * Returns a lowercase string representation of an object's constructor. * @module {g3.utils} * @function {g3.utils.type} * @public * @param {Type} 'obj' is any type native, host or custom. * @return {String} Returns a lowercase string representing the object's * constructor which is different from word 'object' if they are not custom. * @reference http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/ * http://stackoverflow.com/questions/3215046/differentiating-between-arrays-and-hashes-in-javascript * http://javascript.info/tutorial/type-detection *******************************************************************************/ g3.utils.type = function (obj){ if(obj === null) return 'null'; else if(typeof obj === 'undefined') return 'undefined'; return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1].toLowerCase(); }; }(window.g3 = window.g3 || {}, jQuery, window, document)); 
 function isEmpty(obj) { if (typeof obj == 'number') return false; else if (typeof obj == 'string') return obj.length == 0; else if (Array.isArray(obj)) return obj.length == 0; else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0; else if (typeof obj == 'boolean') return false; else return !obj; } 

Isto irá verificar se a variável de aninhamento indeterminado é indefinida

 function Undef(str) { var ary = str.split('.'); var w = window; for (i in ary) { try { if (typeof(w = w[ary[i]]) === "undefined") return true; } catch(e) { return true; } } return false; } if (!Undef("google.translate.TranslateElement")) { 

O texto acima verifica se a function Translação do Google Translate existe. Isso é equivalente a:

 if (!(typeof google === "undefined" || typeof google.translate === "undefined" || typeof google.translate.TranslateElement === "undefined")) { 
 function isEmpty(val){ return !val; } 

mas esta solução é superprojetada, se você não quiser modificar a function posteriormente para necessidades do modelo de negócios, então é mais limpo usá-la diretamente no código:

 if(!val)... 
 var myNewValue = myObject && myObject.child && myObject.child.myValue; 

Isso nunca causará um erro. Se myObject , child ou myValue for nulo, então myNewValue será nulo. Nenhum erro será lançado

Eu acho que usando o? operador é um pouco mais limpo.

 var ? function_if_exists() : function_if_doesnt_exist(); 

Embora um oldie, o que esquece é que eles devem quebrar o bloco de código e, em seguida, pegar o erro e, em seguida, testar …

 function checkup( t ){ try{ for(p in t){ if( p.hasOwnProperty( t ) ){ return true; } } return false; }catch(e){ console.log("ERROR : "+e); return e; } } 

Então, você realmente não tem que verificar um possível problema antes da mão, basta pegá-lo e, em seguida, lidar com ele como quiser.

Você pode usar diretamente o operador de igualdade

  

demo @ Como determinar se a variável é indefinida ou nula usando JavaScript

Esta function verifica o empty object {} , empty array [] , null , undefined e blank string ""

 function isEmpty(val) { //check for empty object {}, array [] if (val !== null && typeof val === 'object') { if (Object.keys(obj).length === 0) { return true; } } //check for undefined, null and "" else if (val == null || val === "") { return true; } return false; } 

var val = {};
isEmpty (val) -> true
val = [];
isEmpty (val) -> true
isEmpty (undefined) -> true
isEmpty (null) -> true
isEmpty (“”) -> true
isEmpty (false) -> false
isEmpty (0) -> falso

Para o meu caso eu tentei com se null, ”,! Variável, mas não funcionou.

Veja meu código abaixo para pegar o texto de um campo html

 var status=$(this).text(); //for example (for my case) 

se não houvesse nenhum valor (nenhum texto) na variável de status, eu estava tentando definir o valor ‘novalue’ para a variável de status.

o seguinte código funcionou.

 if(status == false) { status='novalue'; } 

quando não foi encontrado nenhum texto para a variável satus, o código acima atribuído ‘novalue’ à variável de status

Intereting Posts