not - set undefined javascript




Existe uma função padrão para verificar variáveis nulas, indefinidas ou em branco em JavaScript? (20)

A primeira resposta com melhor classificação 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)

Existe uma função 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;
}

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;

}

Esta função 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


Esta verificação de condição

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

é tudo o que você precisa.


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'


Isto é muito simples.

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

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

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


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 função 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
}

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)

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 objetos (mesmo objeto vazio e array) são "valores" válidos.


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 specification 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


Você pode usar diretamente o operador de igualdade

<script>
    var firstName;
    var lastName = null;
    /* Since null == undefined is true, the following statements will catch both null and undefined */
        if(firstName == null){
            alert('Variable "firstName" is undefined.');
        }    
        if(lastName == null){
           alert('Variable "lastName" is null.');
        }
</script>

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


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 função @Vix () para verificar o objeto 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]"        

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

No ES6 com trim para manipular as seqüências de espaços em branco:

const isEmpty = value => {
    if (typeof value === 'number') return false
    else if (typeof value === 'string') return value.trim().length === 0
    else if (Array.isArray(value)) return value.length === 0
    else if (typeof value === 'object') return value == null || Object.keys(value).length === 0
    else if (typeof value === 'boolean') return false
    else return !value
}

function isEmpty(val){
    return !val;
}

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

if(!val)...

try{

     let vari = obj.propTest; // obj may be don't have propTest property

        ...
} catch(NullException){
    // do something here
}

Eu acho que usando try catch irá evitar qualquer erro de verificação nula, também em Angular ou JavaScript Apenas pegando exceção nula e processo nele.


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





undefined