Existe-t-il une fonction JavaScript universelle qui vérifie qu'une variable a une valeur et s'assure qu'elle ne l'est pas undefinedou null? J'ai ce code, mais je ne sais pas s'il couvre tous les cas:

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

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

if( value ) {
}

évaluera truesi ce valuen'est pas le cas :

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

La liste ci-dessus représente toutes les falsyvaleurs possibles en ECMA- / Javascript. Trouvez-le dans la spécification auToBoolean section.

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 auprès de l' typeofopérateur. 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 untruthy valeur comme indiqué ci-dessus.

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

La méthode détaillée pour vérifier si la valeur n'est pas définie ou nulle est:

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

Vous pouvez également utiliser l' ==opérateur, mais celui-ci attend de connaître toutes les règles :

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

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

Cela reviendra vrai pour

undefined  // Because undefined == null

null

[]

""

et zéro fonction d'argument car une fonction lengthest le nombre de paramètres déclarés qu'elle prend.

Pour interdire cette dernière catégorie, vous voudrez peut-être simplement vérifier les chaînes vides

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

C'est le chèque le plus sûr et je ne l'ai pas vu affiché exactement comme ça:

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

Il couvrira les cas où la valeur n'a jamais été définie, et également l'un d'eux:

• 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

_{Modifié: changé en stricte égalité (! ==) car c'est la norme maintenant;)}

Vous pouvez trouver la fonction suivante utile:

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

Ou dans ES7 (commentez 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
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 de la norme ECMAScript. C'est actuellement une proposition de l'étape 0 (homme de paille) à introduire dans la langue." - Simon Kjellberg. l'auteur souhaite ajouter son soutien à cette belle proposition de recevoir l'ascension royale.

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

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

ou

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

Cette vérification de l'état

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

est tout ce dont vous avez besoin.

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

function isEmpty(val){
  return !val;
}

cette fonction retournera true si val est vide, null, non défini, false, le nombre 0 ou NaN .

OU

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

Une solution que j'aime beaucoup:

Définissons qu'une variable vide est null, ou undefined, ou si elle a une longueur, elle est nulle, ou si c'est un objet, elle n'a pas de clés:

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

Retour:

• vrai: undefined , null, "", [],{}
• faux: true , false, 1, 0, -1, "foo", [1, 2, 3],{ foo: 1 }

Vous en faites un peu trop. Pour vérifier si une variable ne reçoit pas de valeur, il vous suffit de vérifier par rapport à undefined et null.

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

Cela suppose 0, ""et des objets (même objet et tableau vide) sont valides « valeurs ».

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à un trait de soulignement ou un lodash, essayez:

_.isEmpty(value)

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

function stringIsEmpty(value) {

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

}

return val || 'Handle empty variable'

est un moyen très 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'

Si la variable n'a pas été déclarée, vous ne pourrez pas tester l'indéfini en utilisant 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 que vous pouvez utiliser

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

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 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é la fonction @Vix () 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]"        

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

En ES6 avec garniture 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
}

Cela peut être utile.

Toutes les valeurs du tableau représentent ce que vous voulez être (nul, non défini ou autre) et vous recherchez ce que vous voulez dedans.

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

Si vous utilisez TypeScriptet que vous ne voulez pas prendre en compte les "valeurs qui sont false", voici la solution pour vous:

Première: import { isNullOrUndefined } from 'util';

Alors: isNullOrUndefined(this.yourVariableName)

Remarque: comme mentionné ci - dessous, il est désormais obsolète, utilisez-le à la value === undefined || value === nullplace.réf .

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. Que signifie vraiment être "vide"? Si je l'ai let human = { name: 'bob', stomach: 'empty' }, devrait isEmpty(human)revenir true? Si je l'ai let reg = new RegExp('');, devrait isEmpty(reg)revenirtrue ? Qu'en est-il isEmpty([ null, null, null, null ])- cette liste ne contient que du vide, donc la liste elle-même est-elle vide? Je veux présenter ici quelques notes sur la "vacuité" (un mot intentionnellement obscur, pour éviter les associations préexistantes) en javascript - et je veux faire valoir que la "vacuité" dans les valeurs javascript ne doit jamais être traitée de manière générique.

Vérité / fausseté

Pour décider comment déterminer la «vacuité» des valeurs, nous devons tenir compte du sens intrinsèque intégré de javascript de savoir si les valeurs sont «véridiques» ou «fausses». Naturellement, nullet undefinedsont tous les deux "falsifiés". Moins naturellement, le nombre 0(et aucun autre nombre sauf NaN) est également "falsifié". Le moins naturellement: ''est faux, mais []et {}(et new Set(), et new Map()) sont vrais - bien qu'ils semblent tous également vides!

Null vs Undefined

Il y a aussi une discussion concernant nullvs undefined- avons-nous vraiment besoin des deux pour exprimer la vacuité 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 nullpour signifier la «vacuité». Encore une fois, cependant, nous devons tenir compte du sens inhérent de javascript de la manière nullet de la undefineddifférence:

• 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 des valeurs par défaut reçoivent la valeur par défaut uniquement lorsqu'ils sont donnés undefined, pas null:

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

Vacuité non générique

Je pense que la vacuité ne doit jamais être traitée de manière générique. Au lieu de cela, nous devrions toujours avoir la rigueur pour 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 que 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 valueà être une instance directe de Cls, et non une instance d'une sous-classe de Cls. J'évite instanceofpour 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 cela Object.getPrototypeOfest utilisé pour éviter un cas comme let v = { constructor: String };La isTypefonction renvoie toujours correctement pour isType(v, String)(false), etisType(v, Object) (true).

Dans l'ensemble, je recommande d'utiliser cette isTypefonction avec ces conseils:

• Réduisez la quantité de valeurs de traitement de code de type inconnu. Par exemple, pour let v = JSON.parse(someRawValue);, notre vvariable est maintenant de type inconnu. Le plus tôt possible, nous devons limiter nos possibilités. La meilleure façon de le faire peut être d'exiger un type particulier: par exemple if (!isType(v, Array)) throw new Error('Expected Array');- c'est un moyen très rapide et expressif de supprimer la nature générique de v, et de s'assurer que c'est toujours un Array. Parfois, cependant, nous devons permettre vd'être de plusieurs types. Dans ces cas, nous devons créer des blocs de code qui vne sont plus génériques, 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');
}

• Utilisez toujours des "listes blanches" pour la validation. Si vous voulez qu'une valeur soit, par exemple, une chaîne, un nombre ou un tableau, vérifiez ces 3 possibilités "blanches" et lancez une erreur si aucun des 3 n'est satisfait. Nous devrions être en mesure de voir que la vérification des possibilités "noires" n'est pas très utile: disons que nous écrivons if (v === null) throw new Error('Null value rejected');- c'est très bien pour s'assurer que les nullvaleurs ne passent pas, mais si une valeur le fait , nous savons encore à peine quoi que ce soit à ce sujet. Une valeur vqui passe ce null-check est encore TRÈS générique - c'est tout saufnull ! Les listes noires dissipent à peine le caractère générique.

• À moins qu'une valeur ne soit null, ne considérez jamais «une valeur vide de sens». Considérez plutôt "un X qui est vide". Essentiellement, n'envisagez jamais de faire quelque chose comme if (isEmpty(val)) { /* ... */ }- peu importe comment cette isEmptyfonction est implémentée (je ne veux pas savoir ...), ce n'est pas significatif! Et c'est bien trop générique! La vacuité ne doit être calculée qu'en connaissant valle type de. Les contrôles de vacuité devraient ressembler à ceci:

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

  • "An Array, with no items": if (isType(val, Array) && val.length === 0) ...

  • La seule exception est quand nullest utilisé pour signifier certaines fonctionnalités. Dans ce cas, il est significatif de dire: "Une valeur vide":if (val === null) ...

Essayez avec une logique différente . Vous pouvez utiliser le code ci-dessous pour vérifier les quatre (4) conditions de validation comme non nul, non vide, non indéfini et non nul uniquement utiliser 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);
    }
}

Jetez un œil au nouveau ECMAScript Découvrez opérateur de coalescence Nullish

Vous pouvez considérer cette fonctionnalité - l' ??opérateur - comme un moyen de «retomber» à une valeur par défaut lorsque vous traitez avecnull ou undefined.

let x = foo ?? bar();

Encore une fois, le code ci-dessus est équivalent au suivant.

let x = (foo !== null && foo !== undefined) ? foo : bar();

function isEmpty(val){
    return !val;
}

mais cette solution est sur-conçue, si vous ne souhaitez pas modifier la fonction plus tard pour les besoins du modèle commercial, il est plus propre de l'utiliser directement dans le code:

if(!val)...

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

Cela ne générera jamais d'erreur. Si myObject , child ou myValue est null, myNewValue sera null. Aucune erreur ne sera levée

Pour tous ceux qui viennent ici pour avoir une question similaire, ce qui suit fonctionne très bien et je l'ai dans ma bibliothèque les 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));

Si vous voulez éviter de devenir vrai si la valeur est l'une des suivantes, selon la réponse de jAndy :

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

Une solution possible qui pourrait éviter d'obtenir des valeurs véridiques est la suivante:

function isUsable(valueToCheck) {
    if (valueToCheck === 0     || // Avoid returning false if the value is 0.
        valueToCheck === ''    || // Avoid returning false if the value is an empty string.
        valueToCheck === false || // Avoid returning false if the value is false.
        valueToCheck)             // Returns true if it isn't null, undefined, or NaN.
    {
        return true;
    } else {
        return false;
    }
}

Il serait utilisé comme suit:

if (isUsable(x)) {
    // It is usable!
}
// Make sure to avoid placing the logical NOT operator before the parameter (isUsable(!x)) and instead, use it before the function, to check the returned value.
if (!isUsable(x)) {
    // It is NOT usable!
}

En plus de ces scénarios, vous pouvez vouloir retourner false si l' objet ou le tableau est vide:

• Objet: {} (en utilisant ECMA 7+ )
• Tableau: [] (avec ECMA 5+ )

Vous vous y prendriez de cette façon:

function isEmptyObject(valueToCheck) {
    if(typeof valueToCheck === 'object' && !Object.keys(valueToCheck).length){
        // Object is empty!
        return true;
    } else {
        // Object is not empty!
        return false;
    }
}

function isEmptyArray(valueToCheck) {
    if(Array.isArray(valueToCheck) && !valueToCheck.length) {
        // Array is empty!
        return true;
    } else {
        // Array is not empty!
        return false;
    }
}

Si vous souhaitez vérifier toutes les chaînes d'espaces (""), vous pouvez procéder comme suit:

function isAllWhitespace(){
    if (valueToCheck.match(/^ *$/) !== null) {
        // Is all whitespaces!
        return true;
    } else {
        // Is not all whitespaces!
        return false;
    }
}

Remarque: hasOwnPropertyrenvoie true pour les chaînes vides, 0, false, NaN, null et undefined, si la variable a été déclarée comme l'une d'entre elles, donc ce n'est peut-être pas la meilleure à utiliser. La fonction peut être modifiée pour l'utiliser pour montrer qu'elle a été déclarée, mais n'est pas utilisable.

Code sur GitHub

const isEmpty = value => (
  (!value && value !== 0 && value !== false)
  || (Array.isArray(value) && value.length === 0)
  || (isObject(value) && Object.keys(value).length === 0)
  || (typeof value.size === 'number' && value.size === 0)

  // `WeekMap.length` is supposed to exist!?
  || (typeof value.length === 'number'
      && typeof value !== 'function' && value.length === 0)
);

// Source: https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7
const isObject = value =>
  Object.prototype.toString.call(value) === '[object Object]';

Les tests du pauvre 😁

const test = () => {
  const run = (label, values, expected) => {
    const length = values.length;
    console.group(`${label} (${length} tests)`);
    values.map((v, i) => {
      console.assert(isEmpty(v) === expected, `${i}: ${v}`);
    });
    console.groupEnd();
  };

  const empty = [
    null, undefined, NaN, '', {}, [],
    new Set(), new Set([]), new Map(), new Map([]),
  ];
  const notEmpty = [
    ' ', 'a', 0, 1, -1, false, true, {a: 1}, [0],
    new Set([0]), new Map([['a', 1]]),
    new WeakMap().set({}, 1),
    new Date(), /a/, new RegExp(), () => {},
  ];
  const shouldBeEmpty = [
    {undefined: undefined}, new Map([[]]),
  ];

  run('EMPTY', empty, true);
  run('NOT EMPTY', notEmpty, false);
  run('SHOULD BE EMPTY', shouldBeEmpty, true);
};

Résultats de test:

EMPTY (10 tests)
NOT EMPTY (16 tests)
SHOULD BE EMPTY (2 tests)
  Assertion failed: 0: [object Object]
  Assertion failed: 1: [object Map]

Ceci vérifiera si la variable d'imbrication indéterminée n'est pas dé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 de Google TranslateElement existe. Cela équivaut à:

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

L'opérateur de chaînage facultatif permet de simplifier l'accès aux valeurs via des objets connectés lorsqu'il est possible qu'une référence ou une fonction soit indéfinie ou nulle.

let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls" // detailed address is unknown
  }
};
let customerCity = customer.details?.address?.city;

L'opérateur coalescent nul peut être utilisé après un chaînage optionnel afin de construire une valeur par défaut quand aucune n'a été trouvée:

let customer = {
  name: "Carl",
  details: { age: 82 }
};
const customerCity = customer?.city ?? "Unknown city";
console.log(customerCity); // Unknown city

function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

il vérifiera également les espaces blancs ('') ainsi que les éléments suivants:

• null, non défini, NaN, vide, chaîne (""), 0, faux

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

var ? function_if_exists() : function_if_doesnt_exist();