Apakah ada fungsi JavaScript universal yang memeriksa bahwa suatu variabel memiliki nilai dan memastikan bahwa itu bukan undefinedatau tidak null? Saya sudah mendapatkan kode ini, tetapi saya tidak yakin apakah ini mencakup semua kasus:

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

Anda bisa memeriksa apakah variabel memiliki truthynilai atau tidak. Itu berarti

if( value ) {
}

akan mengevaluasi untuk truejika valueini tidak :

• batal
• tidak terdefinisi
• NaN
• string kosong ("")
• 0
• Salah

Daftar di atas mewakili semua falsynilai yang mungkin dalam ECMA- / Javascript. Temukan dalam spesifikasi di ToBooleanbagian.

Selain itu, jika Anda tidak tahu apakah ada variabel (artinya, jika dideklarasikan ), Anda harus menanyakannya kepada typeofoperator. Contohnya

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

Jika Anda dapat memastikan bahwa suatu variabel dinyatakan setidaknya, Anda harus langsung memeriksa apakah ia memiliki truthynilai seperti yang ditunjukkan di atas.

Baca lebih lanjut: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

Metode verbose untuk memeriksa apakah nilai tidak terdefinisi atau nol adalah:

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

Anda juga dapat menggunakan ==operator tetapi ini mengharapkan seseorang untuk mengetahui semua aturan :

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

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

Ini akan mengembalikan true untuk

undefined  // Because undefined == null

null

[]

""

dan fungsi argumen nol sejak fungsi length adalah jumlah parameter yang dideklarasikan yang diperlukan.

Untuk melarang kategori yang terakhir, Anda mungkin ingin memeriksa string kosong saja

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

Ini adalah pemeriksaan teraman dan saya belum melihatnya diposting di sini persis seperti itu:

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

Ini akan mencakup kasus-kasus di mana nilainya tidak pernah didefinisikan, dan juga salah satu dari ini:

• batal
• undefined (nilai undefined tidak sama dengan parameter yang tidak pernah didefinisikan)
• 0
• "" (string kosong)
• Salah
• NaN

_{Diedit: Diubah ke kesetaraan ketat (! ==) karena sudah menjadi norma sekarang;)}

Anda mungkin menemukan fungsi berikut bermanfaat:

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

Atau di ES7 (komentar jika perbaikan lebih lanjut)

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

  return type.toLowerCase();
}

Hasil:

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

"Perhatikan bahwa operator bind (: :) bukan bagian dari ES2016 (ES7) atau edisi standar ECMAScript yang lebih baru sama sekali. Ini saat ini merupakan proposal tahap 0 (strawman) untuk diperkenalkan ke bahasa tersebut." - Simon Kjellberg. penulis ingin menambahkan dukungannya untuk proposal yang indah ini untuk menerima kenaikan kerajaan.

Jawaban pertama dengan peringkat terbaik salah. Jika nilai tidak terdefinisi, itu akan membuat pengecualian di browser modern. Anda harus menggunakan:

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

atau

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

Periksa kondisi ini

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

itu yang kamu butuhkan.

! periksa string kosong (""), null, undefined, false dan angka 0 dan NaN. Katakan, jika sebuah string kosong var name = ""maka console.log(!name)kembali true.

function isEmpty(val){
  return !val;
}

fungsi ini akan mengembalikan true jika val adalah kosong, null, terdefinisi, palsu, angka 0 atau NaN .

ATAU

Menurut domain masalah Anda, Anda bisa menggunakan like !valatau !!val.

Solusi yang sangat saya sukai:

Mari kita mendefinisikan bahwa variabel kosong adalah null, atau undefined, atau jika memiliki panjang, itu adalah nol, atau jika itu adalah objek, itu tidak memiliki kunci:

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

Pengembalian:

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

Anda sedikit berlebihan. Untuk memeriksa apakah suatu variabel tidak diberi nilai, Anda hanya perlu memeriksa terhadap undefined dan null.

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

Ini dengan asumsi 0,, ""dan objek (bahkan objek dan array kosong) adalah "nilai" yang valid.

Jika Anda lebih suka javascript biasa coba ini:

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

Jika tidak, jika Anda sudah menggunakan garis bawah atau lodash, coba:

_.isEmpty(value)

Ini milik saya - mengembalikan true jika nilainya nol, tidak terdefinisi, dll atau kosong (yaitu hanya berisi spasi kosong):

function stringIsEmpty(value) {

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

}

return val || 'Handle empty variable'

adalah cara yang sangat bagus dan bersih untuk menanganinya di banyak tempat, juga dapat digunakan untuk menetapkan variabel

const res = val || 'default value'

Jika variabel belum dideklarasikan, Anda tidak akan dapat menguji undefined menggunakan fungsi karena Anda akan mendapatkan kesalahan.

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

Keduanya akan menghasilkan kesalahan jika foo belum dideklarasikan.

Jika Anda ingin menguji apakah suatu variabel telah dideklarasikan, Anda dapat menggunakan

typeof foo != "undefined"

jika Anda ingin menguji apakah foo telah dinyatakan dan memiliki nilai yang dapat Anda gunakan

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

Untuk memeriksa Nilai Default

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.

periksa Hasil:

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

Saya menggunakan fungsi @Vix () untuk memeriksa objek jenis apa.

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

Dalam ES6 dengan trim untuk menangani string spasi putih:

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
}

Mungkin bermanfaat.

Semua nilai dalam array mewakili apa yang Anda inginkan (null, undefined atau hal lain) dan Anda mencari apa yang Anda inginkan di dalamnya.

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

Jika Anda menggunakan TypeScriptdan tidak ingin memperhitungkan "nilai-nilai itu adalah false" maka ini adalah solusi untuk Anda:

Pertama: import { isNullOrUndefined } from 'util';

Kemudian: isNullOrUndefined(this.yourVariableName)

Harap Dicatat: Seperti yang disebutkan di bawah ini sudah tidak digunakan lagi, gunakan value === undefined || value === nullsaja. ref .

Kekosongan

Saya tidak menyarankan mencoba mendefinisikan atau menggunakan fungsi yang menghitung apakah nilai di seluruh dunia kosong. Apa artinya menjadi "kosong"? Jika sudah let human = { name: 'bob', stomach: 'empty' }, haruskah isEmpty(human)kembali true? Jika sudah let reg = new RegExp('');, haruskah isEmpty(reg)kembali true? Bagaimana dengan isEmpty([ null, null, null, null ])- daftar ini hanya berisi kekosongan, jadi apakah daftar itu sendiri kosong? Saya ingin mengajukan beberapa catatan tentang "kekosongan" (kata yang sengaja dikaburkan, untuk menghindari asosiasi yang sudah ada sebelumnya) dalam javascript - dan saya ingin berdebat bahwa "kekosongan" dalam nilai-nilai javascript tidak boleh ditangani secara umum.

Kebenaran / Kepalsuan

Untuk memutuskan bagaimana menentukan "kekosongan" dari nilai-nilai, kita perlu mengakomodasi inbuilt javascript, rasa yang melekat pada apakah nilai-nilai itu "benar" atau "salah". Secara alami, nulldan undefinedkeduanya "palsu". Kurang alami, jumlahnya 0(dan tidak ada nomor lain kecuali NaN) juga "palsu". Paling tidak secara alami: ''adalah palsu, tetapi []dan {}(dan new Set(), dan new Map()) adalah kebenaran - meskipun mereka semua tampak sama-sama hampa!

Null vs Tidak terdefinisi

Ada juga beberapa diskusi tentang nullvs undefined- apakah kita benar - benar membutuhkan keduanya untuk mengekspresikan kekosongan dalam program kita? Saya pribadi menghindari agar huruf-huruf u, n, d, e, f, i, n, e, d muncul dalam kode saya dalam urutan itu. Saya selalu menggunakan nulluntuk menandakan "kekosongan". Namun, sekali lagi, kita perlu mengakomodasi pengertian inheren javascript tentang bagaimana nulldan undefinedberbeda:

• Mencoba mengakses memberi properti tidak ada undefined
• Menghilangkan parameter saat memanggil fungsi menghasilkan parameter yang menerima undefined:

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

• Parameter dengan nilai default hanya menerima default saat diberikan undefined, bukan null:

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

Kekosongan non-generik

Saya percaya bahwa kekosongan seharusnya tidak pernah ditangani dengan cara yang umum. Sebagai gantinya, kita harus selalu memiliki kekakuan untuk mendapatkan lebih banyak informasi tentang data kita sebelum menentukan apakah data itu kosong - saya terutama melakukan ini dengan memeriksa jenis data apa yang saya hadapi:

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

Perhatikan bahwa fungsi ini mengabaikan polimorfisme - ia diharapkan valuemenjadi turunan langsung dari Cls, dan bukan turunan dari subkelas dari Cls. Saya menghindari instanceofkarena dua alasan utama:

• ([] instanceof Object) === true ("Array adalah Obyek")
• ('' instanceof String) === false ("String bukan String")

Perhatikan bahwa Object.getPrototypeOfdigunakan untuk menghindari kasus seperti let v = { constructor: String };The isTypefungsi masih kembali dengan benar untuk isType(v, String)(palsu), danisType(v, Object) (benar).

Secara keseluruhan, saya sarankan menggunakan isTypefungsi ini bersama dengan tips ini:

• Minimalkan jumlah nilai pemrosesan kode dari tipe yang tidak dikenal. Misalnya, untuk let v = JSON.parse(someRawValue);, vvariabel kami sekarang dari tipe tidak dikenal. Sedini mungkin, kita harus membatasi kemungkinan kita. Cara terbaik untuk melakukan ini bisa dengan memerlukan jenis tertentu: misalnya if (!isType(v, Array)) throw new Error('Expected Array');- ini adalah cara yang sangat cepat dan ekspresif untuk menghilangkan sifat generik v, dan memastikan itu selalu menjadi Array. Namun, kadang-kadang, kita perlu mengizinkan vbeberapa tipe. Dalam kasus tersebut, kita harus membuat blok kode vyang tidak lagi generik, sedini mungkin:

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

• Selalu gunakan "daftar putih" untuk validasi. Jika Anda membutuhkan nilai untuk menjadi, misalnya, String, Nomor, atau Array, periksa 3 kemungkinan "putih", dan melemparkan Kesalahan jika tidak ada dari 3 yang puas. Kita harus bisa melihat memeriksa bahwa untuk "hitam" kemungkinan tidak sangat berguna: Katakanlah kita menulis if (v === null) throw new Error('Null value rejected');- ini sangat bagus untuk memastikan bahwa nullnilai-nilai tidak membuatnya melalui, tetapi jika nilai tidak membuatnya melalui, kita masih tahu hampir tidak apapun tentang itu. Nilai vyang lolos dari pemeriksaan nol ini masih SANGAT generik - sama sekali tidaknull ! Daftar hitam hampir tidak menghilangkan sifat generik.

• Kecuali jika nilainya null, jangan pernah menganggap "nilai yang kosong". Sebagai gantinya, pertimbangkan "sebuah X yang kosong". Pada dasarnya, jangan pernah mempertimbangkan untuk melakukan hal seperti if (isEmpty(val)) { /* ... */ }- tidak peduli bagaimana isEmptyfungsi itu diimplementasikan (saya tidak ingin tahu ...), itu tidak berarti! Dan itu terlalu generik! Kekosongan seharusnya hanya dihitung dengan valtipe pengetahuan . Pengecekan kekosongan seharusnya terlihat seperti ini:

  • "Sebuah string, tanpa karakter": if (isType(val, String) && val.length === 0) ...
  • "Sebuah Objek, dengan 0 properti": if (isType(val, Object) && Object.entries(val).length === 0) ...
  • "Angka, sama atau kurang dari nol": if (isType(val, Number) && val <= 0) ...

  • "An Array, tanpa item": if (isType(val, Array) && val.length === 0) ...

  • Satu-satunya pengecualian adalah ketika nulldigunakan untuk menandakan fungsi tertentu. Dalam hal ini, bermakna untuk mengatakan: "Nilai kosong":if (val === null) ...

Coba Dengan Logika Berbeda . Anda dapat menggunakan kode di bawah ini untuk memeriksa keempat (4) kondisi untuk validasi seperti tidak nol, tidak kosong, tidak terdefinisi dan tidak nol hanya menggunakan kode ini (! (! (Variabel))) dalam javascript dan 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);
    }
}

Lihatlah operator penggabungan ECMAScript Nullish yang baru

Anda dapat memikirkan fitur ini - ??operator - sebagai cara untuk "mundur" ke nilai default saat berhadapan dengan nullatau undefined.

let x = foo ?? bar();

Sekali lagi, kode di atas setara dengan yang berikut ini.

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

function isEmpty(val){
    return !val;
}

tetapi solusi ini direkayasa berlebihan, jika Anda tidak ingin memodifikasi fungsi nanti untuk keperluan model bisnis, maka lebih bersih untuk menggunakannya langsung dalam kode:

if(!val)...

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

Ini tidak akan pernah membuat kesalahan. Jika myObject , anak , atau myValue adalah null maka myNewValue akan null. Tidak ada kesalahan yang akan terjadi

Untuk semua orang yang datang ke sini karena memiliki pertanyaan serupa, berikut ini berfungsi dengan baik dan saya memilikinya di perpustakaan saya tahun-tahun terakhir:

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

Jika Anda ingin menghindari kebenaran jika nilainya salah satu dari yang berikut, menurut jawaban jAndy :

• batal
• tidak terdefinisi
• NaN
• string kosong ("")
• 0
• Salah

Salah satu solusi yang mungkin menghindari menghindari nilai-nilai kebenaran adalah sebagai berikut:

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

Ini akan digunakan sebagai berikut:

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

Selain skenario itu, Anda mungkin ingin mengembalikan false jika objek atau array kosong:

• Obyek: {} (Menggunakan ECMA 7+ )
• Array: [] (Menggunakan ECMA 5+ )

Anda akan melakukannya dengan cara ini:

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

Jika Anda ingin memeriksa semua string spasi putih (""), Anda dapat melakukan hal berikut:

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

Catatan: hasOwnPropertymengembalikan true untuk string kosong, 0, false, NaN, null, dan undefined, jika variabel dinyatakan sebagai salah satu dari mereka, jadi itu mungkin bukan yang terbaik untuk digunakan. Fungsi dapat dimodifikasi untuk menggunakannya untuk menunjukkan bahwa itu dideklarasikan, tetapi tidak dapat digunakan.

Kode pada 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]';

Tes orang miskin 😁

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

Hasil tes:

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

Ini akan memeriksa apakah variabel sarang tidak ditentukan tidak terdefinisi

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

Di atas memeriksa apakah fungsi terjemahan Google TranslateElement ada. Ini setara dengan:

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

Operator rantai opsional menyediakan cara untuk menyederhanakan mengakses nilai melalui objek yang terhubung saat itu mungkin bahwa referensi atau fungsi mungkin tidak terdefinisi atau nol.

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

Operator penggabungan nullish dapat digunakan setelah perangkaian opsional untuk membangun nilai default ketika tidak ada yang ditemukan:

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

itu juga akan memeriksa spasi putih ('') bersama dengan yang berikut:

• null, tidak terdefinisi, NaN, kosong, string (""), 0, false

Saya pikir menggunakan? Operator sedikit lebih bersih.

var ? function_if_exists() : function_if_doesnt_exist();