Esiste una funzione JavaScript universale che controlla che una variabile abbia un valore e garantisce che non lo sia undefinedo null? Ho questo codice, ma non sono sicuro che copra tutti i casi:

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

Puoi semplicemente verificare se la variabile ha un truthyvalore oppure no. Questo significa

if( value ) {
}

valuterà truese nonvalue è :

• nullo
• non definito
• NaN
• stringa vuota ("")
• 0
• falso

L'elenco sopra rappresenta tutti i possibili falsyvalori in ECMA- / Javascript. Lo trovi nelle specifiche nella ToBooleansezione.

Inoltre, se non si conosce l' esistenza di una variabile (ciò significa che se è stata dichiarata ) è necessario verificare con l' typeofoperatore. Per esempio

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

Se puoi essere sicuro che almeno una variabile sia dichiarata, dovresti verificare direttamente se ha unatruthy valore come mostrato sopra.

Ulteriori informazioni: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

Il metodo dettagliato per verificare se il valore è indefinito o null è:

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

Puoi anche usare l' ==operatore ma questo si aspetta che tu conosca tutte le regole :

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

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

Questo tornerà vero per

undefined  // Because undefined == null

null

[]

""

e zero argomento funzioni da una funzione length è il numero di parametri dichiarati che accetta.

Per non consentire quest'ultima categoria, potresti voler controllare solo le stringhe vuote

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

Questo è il controllo più sicuro e non l'ho visto pubblicato qui esattamente così:

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

Tratterà i casi in cui il valore non è mai stato definito, e anche uno di questi:

• nullo
• undefined (il valore di undefined non è lo stesso di un parametro che non è mai stato definito)
• 0
• "" (stringa vuota)
• falso
• NaN

_{Modificato: cambiato in stretta uguaglianza (! ==) perché ormai è la norma;)}

Potresti trovare utile la seguente funzione:

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

O in ES7 (commento se ulteriori miglioramenti)

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

  return type.toLowerCase();
}

risultati:

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

"Si noti che l'operatore bind (: :) non fa parte di ES2016 (ES7) né alcuna versione successiva dello standard ECMAScript. Attualmente è una proposta di fase 0 (strawman) per essere introdotta nella lingua." - Simon Kjellberg. l'autore desidera aggiungere il suo sostegno a questa bellissima proposta di ricevere l'ascensione reale.

La prima risposta con il miglior punteggio è sbagliata. Se il valore non è definito, verrà generata un'eccezione nei browser moderni. Devi usare:

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

o

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

Questa verifica delle condizioni

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

é tutto quello di cui hai bisogno.

! controlla le stringhe vuote (""), null, non definito, false e il numero 0 e NaN. Dire, se una stringa è vuota, var name = ""quindi console.log(!name)ritorna true.

function isEmpty(val){
  return !val;
}

questa funzione restituirà vero se val è vuoto, null, indefinito, falso, il numero 0 o NaN .

O

Secondo il tuo dominio problematico puoi semplicemente usare like !valo !!val.

Una soluzione che mi piace molto:

Definiamo che una variabile vuota è null, o undefined, o se ha lunghezza, è zero, o se è un oggetto, non ha chiavi:

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

Ritorna:

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

Stai esagerando un po '. Per verificare se a una variabile non viene assegnato un valore, è necessario solo verificare undefined e null.

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

Ciò presuppone 0, ""e gli oggetti (anche oggetto vuoto e matrice) sono "valori" validi.

Se preferisci javascript semplice prova questo:

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

Altrimenti, se stai già utilizzando il trattino basso o lodash, prova:

_.isEmpty(value)

Ecco il mio - restituisce vero se il valore è null, indefinito, ecc. O vuoto (cioè contiene solo spazi vuoti):

function stringIsEmpty(value) {

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

}

return val || 'Handle empty variable'

è un modo davvero piacevole e pulito per gestirlo in molti luoghi, può anche essere usato per assegnare variabili

const res = val || 'default value'

Se la variabile non è stata dichiarata, non sarà possibile verificare la presenza di un indefinito utilizzando una funzione perché si otterrà un errore.

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

Entrambi genereranno un errore se foo non è stato dichiarato.

Se si desidera verificare se è stata dichiarata una variabile, è possibile utilizzare

typeof foo != "undefined"

se si desidera verificare se foo è stato dichiarato e ha un valore che è possibile utilizzare

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

Per controllare il valore predefinito

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.

controlla Risultato:

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

Ho usato la funzione @Vix () per verificare l'oggetto di quale 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;
}

In ES6 con trim per gestire stringhe di spazi bianchi:

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
}

Potrebbe essere utile.

Tutti i valori nella matrice rappresentano ciò che vuoi essere (null, indefinito o altro) e cerchi ciò che vuoi in esso.

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

Se stai usando TypeScripte non vuoi tenere conto di "valori che sono false" questa è la soluzione che fa per te:

Primo: import { isNullOrUndefined } from 'util';

Poi: isNullOrUndefined(this.yourVariableName)

Nota: come indicato di seguito, questo è ora obsoleto, utilizzare value === undefined || value === nullinvece. rif .

Vacuità

Non consiglio di provare a definire o utilizzare una funzione che calcola se un valore in tutto il mondo è vuoto. Cosa significa veramente essere "vuoti"? Se ho let human = { name: 'bob', stomach: 'empty' }, dovrebbe isEmpty(human)tornare true? Se ho let reg = new RegExp('');, dovrebbe isEmpty(reg)tornare true? Che dire isEmpty([ null, null, null, null ])- questo elenco contiene solo il vuoto, quindi l'elenco stesso è vuoto? Voglio presentare qui alcune note su "vacuità" (una parola intenzionalmente oscura, per evitare associazioni preesistenti) in javascript - e voglio sostenere che "vacuità" nei valori di javascript non dovrebbe mai essere trattata genericamente.

Truthiness / Falsiness

Per decidere come determinare la "vacuità" dei valori, dobbiamo soddisfare il senso innato e intrinseco di javascript sul fatto che i valori siano "veritieri" o "falsi". Naturalmente, nulle undefinedsono entrambi "falsi". Meno naturalmente, il numero 0(e nessun altro numero tranne NaN) è anche "falsa". Almeno naturalmente: ''è falso, ma []e {}(e new Set(), e new Map()) sono sinceri, anche se sembrano tutti ugualmente vacui!

Null vs Undefined

C'è anche qualche discussione riguardante il nullvs undefined: abbiamo davvero bisogno di entrambi per esprimere vacuità nei nostri programmi? Personalmente evito di far apparire nel mio codice le lettere u, n, d, e, f, i, n, e, d in questo ordine. Uso sempre nullper indicare "vacuità". Ancora una volta, tuttavia, dobbiamo soddisfare il senso intrinseco di JavaScript di come nulle undefineddifferire:

• Cercare di accedere a una proprietà inesistente dà undefined
• Se si omette un parametro quando si chiama una funzione, il parametro riceve undefined:

let f = a => a;
console.log(f('hi'));
console.log(f());

• I parametri con valori predefiniti ricevono il valore predefinito solo se indicato undefined, non null:

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

Vacuosità non generica

Credo che la vacuità non debba mai essere trattata in modo generico. Dovremmo invece sempre avere il rigore di ottenere maggiori informazioni sui nostri dati prima di determinare se sono vacui - lo faccio principalmente controllando il tipo di dati con cui ho a che fare:

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

Si noti che questa funzione ignora il polimorfismo: si aspetta valueche sia un'istanza diretta Clse non un'istanza di una sottoclasse di Cls. Evito instanceofper due motivi principali:

• ([] instanceof Object) === true ("Una matrice è un oggetto")
• ('' instanceof String) === false ("Una stringa non è una stringa")

Si noti che Object.getPrototypeOfviene utilizzato per evitare un caso come let v = { constructor: String };La isTypefunzione restituisce ancora correttamente per isType(v, String)(false) eisType(v, Object) (true).

Nel complesso, consiglio di utilizzare questa isTypefunzione insieme a questi suggerimenti:

• Ridurre al minimo la quantità di valori di elaborazione del codice di tipo sconosciuto. Ad esempio, per let v = JSON.parse(someRawValue);, la nostra vvariabile è ora di tipo sconosciuto. Il prima possibile, dovremmo limitare le nostre possibilità. Il modo migliore per farlo può essere quello di richiedere un tipo particolare: ad esempio if (!isType(v, Array)) throw new Error('Expected Array');- questo è un modo davvero rapido ed espressivo per rimuovere la natura generica di v, e assicurarsi che sia sempre un Array. A volte, tuttavia, dobbiamo consentire vdi essere di più tipi. In questi casi, dovremmo creare blocchi di codice dove vnon è più generico, il più presto possibile:

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

• Utilizzare sempre "whitelist" per la convalida. Se richiedi che un valore sia, ad esempio, una stringa, un numero o una matrice, controlla le 3 possibilità "bianche" e genera un errore se nessuna delle 3 è soddisfatta. Dovremmo essere in grado di vedere che il controllo per la possibilità di "nero" non è molto utile: Dire che scriviamo if (v === null) throw new Error('Null value rejected');- questo è grande per garantire che nulli valori non fanno fino in fondo, ma se un valore lo fa fare attraverso, sappiamo ancora poco niente al riguardo. Un valore vche supera questo controllo null è ancora MOLTO generico - è tutt'altro chenull ! Le blacklist difficilmente dissipano la genericità.

• A meno che non sia un valore null, non considerare mai "un valore vacuo". Invece, considera "una X che è vacua". In sostanza, non considerare mai di fare qualcosa del genere if (isEmpty(val)) { /* ... */ }- non importa come isEmptysia implementata quella funzione (non voglio saperlo ...), non è significativo! Ed è troppo generico! La vacuità dovrebbe essere calcolata solo con la conoscenza del valtipo. I controlli di vacuità dovrebbero apparire così:

  • "Una stringa, senza caratteri": if (isType(val, String) && val.length === 0) ...
  • "Un oggetto, con 0 oggetti di scena": if (isType(val, Object) && Object.entries(val).length === 0) ...
  • "Un numero, uguale o inferiore a zero": if (isType(val, Number) && val <= 0) ...

  • "Una matrice, senza elementi": if (isType(val, Array) && val.length === 0) ...

  • L'unica eccezione è quando nullviene utilizzato per indicare determinate funzionalità. In questo caso è significativo dire: "Un valore vacuo":if (val === null) ...

Prova con logica diversa . Puoi usare il codice seguente per controllare tutte e quattro le condizioni (4) per la convalida come non null, non vuoto, non definito e non zero utilizzare questo codice (! (! (Variabile))) in javascript e 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);
    }
}

Dai un'occhiata al nuovo operatore di coalescenza Nullish ECMAScript

Puoi pensare a questa funzione - l' ??operatore - come un modo per "ripiegare" su un valore predefinito quando hai a che fare con nullo undefined.

let x = foo ?? bar();

Ancora una volta, il codice sopra è equivalente al seguente.

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

function isEmpty(val){
    return !val;
}

ma questa soluzione è troppo ingegnerizzata, se non si desidera modificare la funzione in un secondo momento per le esigenze del modello aziendale, è più pulito utilizzarla direttamente nel codice:

if(!val)...

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

Questo non genererà mai un errore. Se myObject , child o myValue è null, myNewValue sarà null. Non verranno generati errori

Per tutti coloro che vengono qui per avere una domanda simile, il seguente funziona alla grande e ce l'ho nella mia biblioteca negli ultimi anni:

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

Se vuoi evitare di diventare vero se il valore è uno dei seguenti, secondo la risposta di jAndy :

• nullo
• non definito
• NaN
• stringa vuota ("")
• 0
• falso

Una possibile soluzione che potrebbe evitare di ottenere valori veritieri è la seguente:

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

Sarebbe usato come segue:

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

Oltre a questi scenari, potresti voler restituire false se l' oggetto o la matrice sono vuoti:

• Oggetto: {} (utilizzando ECMA 7+ )
• Matrice: [] (utilizzando ECMA 5+ )

Ci andresti in questo modo:

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

Se si desidera verificare tutte le stringhe di spazi bianchi (""), è possibile effettuare le seguenti operazioni:

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

Nota: hasOwnPropertyrestituisce true per stringhe vuote, 0, false, NaN, null e non definito, se la variabile è stata dichiarata come una qualsiasi di esse, quindi potrebbe non essere la migliore da utilizzare. La funzione può essere modificata per usarla per mostrare che è stata dichiarata, ma non è utilizzabile.

Codice su 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]';

Test da povero 😁

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

Risultati del test:

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

Questo verificherà se la variabile di annidamento indeterminato non è definita

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

Quanto sopra controlla se esiste la funzione di traduzione di Google TranslateElement. Ciò equivale a:

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

L'operatore di concatenamento opzionale fornisce un modo per semplificare l'accesso ai valori tramite oggetti connessi quando è possibile che un riferimento o una funzione possano essere indefiniti o nulli.

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

L'operatore di coalescenza nullish può essere utilizzato dopo il concatenamento facoltativo per creare un valore predefinito quando non ne viene trovato nessuno:

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

controllerà anche gli spazi bianchi ('') insieme a quanto segue:

• null, non definito, NaN, vuoto, stringa (""), 0, falso

Penso che usando il? l'operatore è leggermente più pulito.

var ? function_if_exists() : function_if_doesnt_exist();