web-dev-qa-db-fra.com

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

Existe-t-il une fonction JavaScript universelle qui vérifie qu'une variable a une valeur et garantit que ce n'est pas undefinedou nullname__? 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;
}
javascriptnullundefined
1910
Alex

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

if( value ) {
}

sera évalué à true si value est pas :

  • nul
  • undefined
  • NaN
  • chaîne vide ("")
  • false

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

De plus, si vous ne savez pas si une variable existe (c'est-à-dire si elle était 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 devez vérifier directement si elle a une valeur truthy comme indiqué ci-dessus.

Pour en savoir plus: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

3801
jAndy

La méthode détaillée pour vérifier si la valeur est indéfinie ou nulle est la suivante:

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

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

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

Cela reviendra vrai pour

undefined  // Because undefined == null

null

[]

""

et zéro argument de fonctions puisque la fonction length est le nombre de paramètres déclarés requis.

Pour interdire cette dernière catégorie, vous pouvez simplement rechercher des chaînes vides.

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

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, ni aucun de ceux-ci:

  • nul
  • undefined (la valeur de undefined n'est pas identique à un paramètre qui n'a jamais été défini)
  • "" (chaîne vide)
  • false
  • NaN

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

31
guya

Vous pouvez trouver la fonction suivante utile:

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

Ou dans ES7 (commentaire si améliorations ultérieures)

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
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

"Notez que l'opérateur de liaison (: :) ne fait pas partie de ES2016 (ES7), ni d'aucune édition ultérieure du standard ECMAScript. Il s'agit actuellement d'une proposition de stade 0 (Strawman) pour l'introduction du langage." - Simon Kjellberg. l'auteur souhaite ajouter son soutien à cette belle proposition de recevoir l'ascension royale.

27
Vix

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

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

ou

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

! recherchez 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 true si val est vide, nul, indéfini, false, le nombre 0 ou NaN.

OU

Selon votre domaine de problème, vous pouvez simplement utiliser comme !val ou !!val.

19
Arif

Vous en faites un peu trop. Pour vérifier si une valeur ne reçoit pas de valeur, il vous suffira de vérifier contre undefined et null.

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

Ceci suppose que 0, "" et les objets (même les objets et tableaux vides) sont des "valeurs" valides.

12
tcooc

Voici le mien - retourne vrai si la valeur est nulle, non définie, etc. ou vide (c'est-à-dire ne contient que des espaces):

function stringIsEmpty(value) {

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

}
9
DavidWainwright

Si vous préférez le javascript ordinaire, 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à du soulignement ou du lodash, essayez:

_.isEmpty(value)
9
l3x

Cette vérification de l'état

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

c'est tout ce dont vous avez besoin.

8
JerryP

Je vais laisser une solution enregistrée que j'ai beaucoup aimé:

Définissons d'abord qu'une variable vide est nullname__, ou undefinedname__, ou si elle a une longueur, elle est égale à zéro ou, s'il s'agit d'un objet, elle n'a pas de clé:

function isEmpty (value) {
  return (
    // null or undefined
    (value == null) ||

    // has length and it's zero
    (value.hasOwnProperty('length') && value.length === 0) ||

    // is an Object and has no keys
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

Résultats:

  • true:undefined___, null_, "", [], {}
  • false:true___, false_, 1, 0, -1, "foo", [1, 2, 3], { foo: 1 }
6
Alexandre Magro
return val || 'Handle empty variable'

est un moyen vraiment agréable et propre de le gérer dans de nombreux endroits, peut également être utilisé pour attribuer des variables

const res = val || 'default value'
5
cubefox

pour vérifier la valeur par défaut

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.

vérifier le résultat:

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

J'ai utilisé @Vix function () pour vérifier l'objet de quel type.

en utilisant 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]"
5
Yash
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;
}

Dans ES6 avec ajustement pour gérer les chaînes d'espaces:

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
}
4
jales cardoso

Cela peut être utile.

Toutes les valeurs du tableau représentent ce que vous voulez être (null, indéfini ou autre chose) et vous recherchez ce que vous voulez.

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1
4
ddagsan

Si vous utilisez TypeScriptNAME _ et que vous ne voulez pas prendre en compte "les valeurs sont falsename __" alors voici la solution pour vous:

D'abord: import { isNullOrUndefined } from 'util';

Alors: isNullOrUndefined(this.yourVariableName)

Remarque: comme mentionné ci-dessous ceci est maintenant obsolète, utilisez plutôt value === undefined || value === null. ref .

4
BlackBeard

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

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

Les deux vont générer 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 que vous pouvez utiliser

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

Vous pouvez utiliser le code ci-dessous pour vérifier les quatre (4) conditions de validation comme not null, ni vide, ni indéfini ni zéro. Utilisez uniquement ce code (! (! (Variable))) en javascript et 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);
    }
}
3
Ravikant

Pour tout le monde qui vient ici pour avoir une question similaire, les travaux suivants sont excellents et je les ai dans ma bibliothèque ces dernières années:

(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));
2
centurian
var myNewValue = myObject && myObject.child && myObject.child.myValue;

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

2
Keith Blanchard
function isEmpty(val){
    return !val;
}

mais cette solution est trop technique, si vous ne voulez pas modifier la fonction plus tard pour les besoins du modèle busines, il est alors plus propre de l’utiliser directement dans le code:

if(!val)...
2
Luca C.

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

Ce qui précède vérifie si la fonction de traduction Google TranslateElement existe. Ceci est équivalent à:

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

Vacuité

Je ne recommande pas d'essayer de définir ou d'utiliser une fonction qui calcule si une valeur dans le monde entier est vide. Qu'est-ce que cela signifie vraiment d'être "vide"? Si j'ai let human = { name: 'bob', stomach: 'empty' }, isEmpty(human) devrait retourner true? Si j'ai let reg = new RegExp('');, isEmpty(reg) devrait-il retourner true? Qu'en est-il de isEmpty([ null, null, null, null ]) - cette liste ne contient que de la vacuité, la liste elle-même est-elle vide? Je souhaite mettre ici quelques notes sur la "vacuité" (un mot volontairement obscur, pour éviter les associations préexistantes) en javascript - et je tiens à soutenir que la "vacuité" dans les valeurs javascript ne devrait jamais être traitée de manière générique.

Vérité/fausseté

Pour décider de la manière de déterminer la "vacuité" des valeurs, nous devons tenir compte du sens inhérent et inhérent à javascript de savoir si les valeurs sont "vérité" ou "fausseté". Naturellement, null et undefined sont tous deux "faux". Moins naturellement, le nombre 0 (et nul autre que NaN) est également "faux". Le moins naturellement: '' est de la fausseté, mais [] et {} (et new Set(), et new Map()) sont la vérité - bien qu'ils semblent tous également vides!

Null vs Undefined

Il y a aussi quelques discussions concernant null vs undefined - avons-nous vraiment besoin des deux pour exprimer le vide dans nos programmes? Personnellement, j'évite que les lettres u, n, d, e, f, i, n, e, d apparaissent dans mon code dans cet ordre. J'utilise toujours null pour signifier "vacuité". Encore une fois, cependant, nous devons tenir compte du sens inhérent à javascript de la différence entre null et undefined:

  • Essayer d'accéder à une propriété inexistante donne undefined
  • L'omission d'un paramètre lors de l'appel d'une fonction entraîne la réception de ce paramètre undefined:
let f = a => a;
console.log(f('hi'));
console.log(f());
  • Les paramètres avec les valeurs par défaut ne reçoivent la valeur par défaut que lorsque undefined est donné, et non pas null:
let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

Vacuité non générique

Je crois que le vide ne devrait jamais être traité de manière générique. Nous devrions au contraire toujours avoir la rigueur d’obtenir plus d’informations sur nos données avant de déterminer si elles sont vides - je le fais principalement en vérifiant le type de données avec lequel je traite:

let isType = (value, Cls) => {
  try {
    return Object.getPrototypeOf(value).constructor === Cls;
  } catch(err) {
    return false;
  }
};

Notez que cette fonction ignore le polymorphisme - elle s'attend à ce que value soit une instance directe de Cls, et non une instance d'une sous-classe de Cls. J'évite instanceof pour deux raisons principales:

  • ([] instanceof Object) === true ("Un tableau est un objet")
  • ('' instanceof String) === false ("Une chaîne n'est pas une chaîne")

Notez que Object.getPrototypeOf est utilisé pour éviter un cas tel que let v = { constructor: String };. La fonction isType revient toujours correctement pour isType(v, String) (false) et isType(v, Object) (true).

Globalement, je recommande d’utiliser cette fonction isType avec ces astuces:

  • Minimise la quantité de valeurs de traitement de code de type inconnu. p. Ex., Pour let v = JSON.parse(someRawValue);, notre variable v est maintenant de type inconnu. Le plus tôt possible, nous devrions limiter nos possibilités. La meilleure façon de le faire peut être de demander un type particulier: par ex. if (!isType(v, Array)) throw new Error('Expected Array'); - il s'agit d'un moyen très rapide et expressif de supprimer le caractère générique de v et de s'assurer qu'il s'agit toujours d'un Array. Parfois, cependant, nous devons permettre à v d’être de plusieurs types. Dans ces cas, nous devrions créer des blocs de code où v n'est plus générique, le plus tôt possible:
if (isType(v, String)) {
  /* v isn't generic in this block - It's a String! */
} else if (isType(v, Number)) {
  /* v isn't generic in this block - It's a Number! */
} else if (isType(v, Array)) {
  /* v isn't generic in this block - it's an Array! */
} else {
  throw new Error('Expected String, Number, or Array');
}
  • tilisez toujours des "listes blanches" pour la validation. Si vous souhaitez qu'une valeur soit, par exemple, une chaîne, un nombre ou un tableau, recherchez ces 3 possibilités "blanches" et émettez une erreur si aucun 3 sont satisfaits. Nous devrions être en mesure de voir que la recherche de possibilités "noires" n’est pas très utile: disons que nous écrivons if (v === null) throw new Error('Null value rejected'); - c’est génial de garantir que null les valeurs ne parviennent pas à passer à travers, valeur ne réussit, nous en savons presque rien. Une valeur v qui passe ce contrôle nul est toujours TRÈS générique - c'est n'importe quoi mais null! Les listes noires dissipent à peine le générique.

  • Sauf si une valeur est null, ne considérez jamais "une valeur vide". Au lieu de cela, considérez "un X qui est vide". Essentiellement, n'envisagez jamais de faire quelque chose comme if (isEmpty(val)) { /* ... */ } - no Peu importe la façon dont cette fonction isEmpty est mise en œuvre (je ne veux pas savoir ...), cela n'a pas de sens! Et c'est trop générique! Les vacances ne doivent être calculées qu'avec la connaissance du type de val. Les contrôles de vacuité devraient ressembler à ceci:

    • "Une chaîne sans caractère": if (isType(val, String) && val.length === 0) ...
    • "Un objet avec 0 accessoire": if (isType(val, Object) && Object.entries(val).length === 0) ...
    • "Un nombre égal ou inférieur à zéro": if (isType(val, Number) && val <= 0) ...

    • "Un tableau sans éléments": if (isType(val, Array) && val.length === 0) ...

    • La seule exception est lorsque null est utilisé pour désigner certaines fonctionnalités. Dans ce cas, il est utile de dire: "Une valeur vide": if (val === null) ...

1
Gershom Maes

Bien qu’il s’agisse d’un vieil homme, ce qu’ils oublient, c’est qu’ils devraient envelopper leur bloc de code, puis détecter 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;
  }
}

Vous n'avez donc pas à rechercher un problème potentiel au préalable, vous le détectez et vous le traitez comme bon vous semble.

0
Mark Giblin
try{

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

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

Je pense que l'utilisation de try catch évitera toute erreur de vérification de la valeur NULL, également dans Angular ou JavaScript. Il suffit juste de capturer une exception NULL et de la traiter.

0
nobjta_9x_tq

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

var ? function_if_exists() : function_if_doesnt_exist();
0
Pedro Pereira