variable - verifier champ vide javascript




Existe-t-il une fonction standard pour rechercher des variables nulles, non définies ou vides dans JavaScript? (18)

Y at-il une fonction JavaScript universelle qui vérifie qu'une variable a une valeur et s'assure qu'elle n'est pas undefined ou null ? J'ai ce code, mais je ne suis pas sûr qu'il couvre tous les cas:

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

Bien qu'un oldie, ce qui oublie est qu'ils devraient emballer leur bloc de code et ensuite attraper l'erreur et ensuite tester ...

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

Donc, vous n'avez pas besoin de vérifier un problème potentiel avant de le prendre en main, vous l'attrapez simplement et vous vous en occupez comme vous voulez.


C'est très simple.

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

Cela vérifiera si la variable d'imbrication indéterminée est indéfinie

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")) {

Les vérifications ci-dessus si la fonction de traduction Google TranslateElement existe. Ceci est équivalent à:

if (!(typeof google === "undefined" 
 || typeof google.translate === "undefined" 
 || typeof google.translate.TranslateElement === "undefined")) {

Cette fonction vérifie l' empty object {} , le empty array [] , la valeur null , la blank string "" undefined et la 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 (indéfini) -> true
isEmpty (null) -> true
isEmpty ("") -> true
isEmpty (false) -> false
isEmpty (0) -> false


Dans le cas de plusieurs valeurs, il suffit de mettre '&&' entre chaque valeur.

if( var1 && var2 && var3) {
  //to do...
}

Je pense en utilisant le? l'opérateur est légèrement plus propre.

var ? function_if_exists() : function_if_doesnt_exist();

La première réponse avec la meilleure note est fausse. Si la valeur n'est pas définie, une exception sera générée dans les navigateurs modernes. Vous devez utiliser:

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

ou

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

Pour mon cas, j'ai essayé avec null, '',! Variable, Mais cela n'a pas fonctionné.

Voir mon code ci-dessous pour obtenir le texte d'un champ html

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

s'il n'y avait pas de valeur (pas de texte) dans la variable status, j'essayais de définir la valeur 'novalue' sur la variable status.

le code suivant a fonctionné.

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

quand il n'y avait pas de texte trouvé pour la variable satus, le code ci-dessus assignait 'novalue' à la variable status


Si la variable n'a pas été déclarée, vous ne pourrez pas tester undefined à l'aide d'une fonction car vous obtiendrez une erreur.

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

Les deux généreront une erreur si foo n'a pas été déclaré.

Si vous voulez tester si une variable a été déclarée, vous pouvez utiliser

typeof foo != "undefined"

si vous voulez tester si foo a été déclaré et qu'il a une valeur, vous pouvez utiliser

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

Si vous préférez le javascript simple, essayez ceci:

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

Sinon, si vous utilisez déjà underscore ou lodash, essayez:

_.isEmpty(value)

Vous en faites un peu trop. Pour vérifier si une variable n'a pas de valeur, il suffit de vérifier par rapport à undefined et à null.

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

Cela suppose 0 , "" , et les objets (même l'objet vide et le tableau) sont des "valeurs" valides.


Vous pouvez simplement vérifier si la variable a une valeur de truthy ou non. Cela signifie

if( value ) {
}

évaluera à true si la value n'est pas :

  • nul
  • indéfini
  • NaN
  • chaîne vide ("")
  • 0
  • faux

La liste ci-dessus représente toutes les valeurs de falsy possibles dans ECMA- / Javascript. Trouvez-le dans la specification de la section ToBoolean .

De plus, si vous ne savez pas si une variable existe (c'est-à-dire si elle a été déclarée ) vous devriez vérifier avec l'opérateur typeof . Par exemple

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

Si vous pouvez être sûr qu'une variable est déclarée au moins, vous devriez vérifier directement si elle a une valeur de truthy comme indiqué ci-dessus.

Lectures supplémentaires: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html


Vous pouvez utiliser directement l'opérateur d'égalité

<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 @ Comment déterminer si la variable est indéfinie ou nulle en utilisant JavaScript


vous pouvez utiliser:

Si clause à valider si la chaîne ou la valeur n'est pas vide. comme ça:

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

! vérifier les chaînes vides (""), null, undefined, false et le nombre 0 et NaN. Dites, si une chaîne est vide var name = "" alors console.log(!name) renvoie true .

function isEmpty(val){
  return !val;
}

cette fonction retournera vrai si val est vide, null, indéfini, faux, le nombre 0 ou NaN .


// value is undefined or null
return value === undefined || value === null;

Les ninjas JavaScript pourraient utiliser l'opérateur == :

return value == null;

function isEmpty(value){
  return (value == null || value.length === 0);
}

Cela reviendra vrai pour

undefined  // Because undefined == null

null

[]

""

et des fonctions d'argument nul puisque la length une fonction est le nombre de paramètres déclarés qu'elle prend.

Pour interdire cette dernière catégorie, vous pouvez vérifier les chaînes vierges

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

var myNewValue = myObject && myObject.child && myObject.child.myValue;

Cela ne jettera jamais une erreur. Si myObject , child ou myValue est null alors myNewValue sera null. Aucune erreur ne sera jetée







undefined