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


Y a-t-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;
}

1601
2018-04-01 15:14


origine


Réponses:


Vous pouvez juste vérifier si le variable a un truthy valeur ou non. Cela signifie

if( value ) {
}

évaluera à true si value est ne pas:

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

La liste ci-dessus représente tous les possibles falsy valeurs en ECMA- / Javascript. Trouvez-le dans le spécification au ToBoolean section.

En outre, si vous ne le faites pas connaître si une variable existe (cela signifie, si c'était déclaré) vous devriez vérifier avec le typeof opérateur. Par exemple

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

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

Lire en outre: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html


3296
2018-04-01 15:17



La méthode verbose pour vérifier si la valeur est indéfinie ou null est:

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

Vous pouvez également utiliser le == opérateur, mais cela s'attend à un connaître toutes les règles:

return value == null; // also returns true if value is undefined

150
2018-04-01 15:20



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

Cela reviendra vrai pour

undefined  // Because undefined == null

null

[]

""

et les fonctions d'argument zéro depuis une fonction de length est le nombre de paramètres déclarés qu'il prend.

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

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

55
2018-04-01 15:19



Je sais que c'est une vieille question, mais c'est le chèque le plus sûr et je ne l'ai pas vu posté ici exactement comme ça:

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

Il couvrira les cas où valeur n'a jamais été défini, et aussi l'un de ceux-ci:

  • nul
  • undefined (la valeur de undefined n'est pas la même chose qu'un paramètre qui n'a jamais été défini)
  • 0
  • "" (chaîne vide)
  • faux
  • NaN

P.S. pas besoin de stricte égalité dans typeof value! = 'undefined'


26
2017-11-10 16:13



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)

25
2018-03-19 13:23



Vous pouvez trouver la fonction suivante utile:

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

Ou en ES7 (commentaire si d'autres améliorations)

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

  return type.toLowerCase();
}

Résultats:

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

"Notez que l'opérateur bind (: :) ne fait partie d'aucune ES2016 (ES7) ni d'aucune édition ultérieure de la norme ECMAScript. Il s'agit actuellement d'une proposition d'étape 0 (strawman) pour être introduit dans la langue." - Simon Kjellberg. l'auteur souhaite ajouter son soutien à cette belle proposition pour recevoir l'ascension royale.


23
2018-02-12 10:32



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

function isEmpty(val){
  return !val;
}

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


16
2018-01-23 06:56



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

C'est en supposant 0, ""et les objets (même objet vide et tableau) sont des "valeurs" valides.


10
2018-04-01 15:21



Voici la mienne - retourne true si la valeur est null, indéfinie, etc. ou vide (ie ne contient que des espaces vides):

function stringIsEmpty(value) {

    return value ? value.trim().length == 0 : true;

}

9
2018-02-12 15:45



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)

7
2017-08-21 13:39