Değişken o kadar zor olmadığını bir değer ve garanti kontrolleri vardır o evrensel JavaScript işlevi var mı undefinedyoksa null? Bu kodu aldım, ancak tüm durumlarda kapsar emin değilim:

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

Değişkenin bir truthydeğeri olup olmadığını kontrol edebilirsiniz . Bunun anlamı

if( value ) {
}

için değerlendirecek trueeğer valueolduğunu değil :

• boş
• Tanımsız
• NaN
• boş dize ("")
• 0
• yanlış

Yukarıdaki liste falsyECMA- / Javascript içindeki tüm olası değerleri göstermektedir. Bunu bulun şartnamede de ToBooleanbölüm.

Ayrıca, bir değişkenin olup olmadığını bilmiyorsanız (yani, bildirilmişse ) typeofoperatöre danışmalısınız. Örneğin

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

Bir değişkenin en azından bildirildiğinden emin olabilirseniz , truthyyukarıdaki gibi bir değere sahip olup olmadığını doğrudan kontrol etmelisiniz .

Daha fazla bilgi için: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

Değerin tanımsız veya null olup olmadığını kontrol etmek için ayrıntılı yöntem:

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

==Operatörü de kullanabilirsiniz, ancak bu tüm kuralların bilinmesini bekler :

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

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

Bu,

undefined  // Because undefined == null

null

[]

""

ve sıfır argüman işlevi, çünkü bir fonksiyonun aldığı lengthbeyan edilen parametre sayısıdır.

İkinci kategoriye izin vermemek için yalnızca boş dizeleri kontrol etmek isteyebilirsiniz

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

Bu en güvenli kontrol ve ben burada tam olarak böyle yayınlanmıştır görmedim:

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

Değerin hiçbir zaman tanımlanmadığı durumları ve bunlardan herhangi birini kapsayacaktır :

• boş
• undefined (undefined değeri hiçbir zaman tanımlanmayan bir parametre ile aynı değil)
• 0
• "" (boş dize)
• yanlış
• NaN

_{Düzenlendi: Sıkı eşitlik (! ==) olarak değiştirildi çünkü şu ana kadar norm;)}

Aşağıdaki işlevi yararlı bulabilirsiniz:

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

Veya ES7'de (daha fazla iyileştirme olursa yorum yapın)

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

  return type.toLowerCase();
}

Sonuçlar:

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

"Bağlama işlecinin (: :) ES2016'nın (ES7) veya ECMAScript standardının daha sonraki bir sürümü olmadığını unutmayın. Şu anda dile tanıtılmak üzere bir aşama 0 (strawman) önerisi." - Simon Kjellberg. yazar kraliyet yükselişi almak için bu güzel öneriye desteğini eklemek istiyor.

En iyi not alan ilk cevap yanlış. Değer tanımsızsa, modern tarayıcılarda bir istisna atar. Kullanmanız gerekenler:

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

veya

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

Bu durum kontrolü

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

tüm ihtiyacın olan.

! boş dizeler (""), null, undefined, false ve 0 ve NaN sayısını kontrol edin . De ki, bir dize boşsa var name = ""o zaman console.log(!name)döner true.

function isEmpty(val){
  return !val;
}

eğer bu fonksiyon gerçek dönecektir val ise boş, null, tanımsız, yalancı, sayı 0 veya NaN .

VEYA

Sorun alanınıza göre sadece !valveya gibi kullanabilirsiniz !!val.

Çok sevdiğim bir çözüm:

Boş bir değişkenin tanımlayalım null, ya undefinedda uzunluğu varsa sıfırdır ya da bir nesne ise anahtarları yoktur:

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

İadeler:

• Gerçek: undefined , null, "", [],{}
• Yanlış: true , false, 1, 0, -1, "foo", [1, 2, 3],{ foo: 1 }

Biraz abartıyorsun. Bir değişkene değer verilmediğini kontrol etmek için, yalnızca tanımsız ve null değerlerini kontrol etmeniz gerekir.

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

Bu varsayarak 0, ""ve nesnelerin (hatta boş bir nesne ve dizi) geçerli "değerleri" dir.

Düz javascript tercih ediyorsanız şunu deneyin:

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

Aksi takdirde, zaten alt çizgi veya lodash kullanıyorsanız şunları deneyin:

_.isEmpty(value)

İşte benimki - değer null, undefined vb. Veya blank ise true değerini döndürür (yani yalnızca boşluklar içerir):

function stringIsEmpty(value) {

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

}

return val || 'Handle empty variable'

birçok yerde işlemek için gerçekten güzel ve temiz bir yoldur, değişkenleri atamak için de kullanılabilir

const res = val || 'default value'

Değişken bildirilmezse, bir işlev kullanarak tanımsız bir işlevi test edemezsiniz çünkü bir hata alırsınız.

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

Foo bildirilmezse her ikisi de bir hata oluşturur.

Bir değişkenin bildirilip bildirilmediğini test etmek için şunu kullanabilirsiniz:

typeof foo != "undefined"

foo'nun beyan edilip edilmediğini ve değerinin olup olmadığını test etmek isterseniz

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

Varsayılan Değeri kontrol etmek için

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.

Sonucu kontrol et:

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

Hangi türdeki nesneyi kontrol etmek için @Vix function () kullandım.

instansof kullanarak «

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

Boşluk dizelerini işlemek için süslemeli ES6'da:

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
}

Yararlı olabilir.

Dizideki tüm değerler ne olmak istediğinizi (null, undefined veya başka bir şey) temsil eder ve içinde ne istediğinizi ararsınız.

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

Kullandığınız değilseniz TypeScriptve hesaba istemiyoruz "Bu değerlere olan false" o zaman bu sizin için bir çözümdür:

İlk: import { isNullOrUndefined } from 'util';

Sonra: isNullOrUndefined(this.yourVariableName)

Lütfen Dikkat: Aşağıda belirtildiği gibi , artık kullanımdan kaldırılmıştır, value === undefined || value === nullbunun yerine kullanın. ref .

Vacuousness

Tüm dünyadaki herhangi bir değerin boş olup olmadığını hesaplayan bir işlev tanımlamaya veya kullanmaya çalışmanızı önermiyorum. Gerçekten "boş" olmak ne anlama geliyor? Eğer varsa let human = { name: 'bob', stomach: 'empty' }, isEmpty(human)geri dönmeli truemi? Eğer varsa let reg = new RegExp('');, isEmpty(reg)geri dönmeli truemi? Ne oldu isEmpty([ null, null, null, null ])- bu liste sadece boşluk içeriyor, bu yüzden listenin kendisi boş mu? Ben burada javascript "boşluk" (kasıtlı olarak karanlık bir kelime, önceden var olan ilişkilendirmeleri önlemek için) bazı notlar koymak istiyorum - ve ben javascript değerleri "boşluk" asla genel olarak ele gerektiğini tartışmak istiyorum.

Truthiness / Falsiness

Değerlerin "boşluğunu" nasıl belirleyeceğimize karar vermek için, javascript'in dahili, içsel, değerlerin "doğru" veya "sahte" olup olmadığını anlamamız gerekir. Doğal olarak, nullve undefinedher ikisi de "falsy" dir. Daha az doğal olarak, sayı 0(ve başka hiçbir sayı hariç NaN) de "sahte" dir. Doğal olarak en az: ''sahtelik, ama []ve {}(ve new Set(), ve new Map()) doğrudur - hepsi eşit derecede boş görünüyor!

Null ve Tanımsız

İle ilgili bazı tartışmalar da vardır nullvs undefinedbiz gerçekten bizim programlarında vacuousness ifade etmek amacıyla ikisine de ihtiyacım var? - Şahsen ben bu sırayla kodumda u, n, d, e, f, i, n, e, d harflerinin görünmesini önlerim. Her zaman null"boşluk" anlamına gelir. Yine de, javascript'in doğasında nasıl nullve nasıl undefinedfarklı olduğu fikrini karşılamak zorundayız :

• Var olmayan bir mülke erişmeye çalışmak, undefined
• Bir işlevi çağırırken bir parametrenin atlanması o parametrenin alınmasına neden olur undefined:

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

• Varsayılan değerlere sahip parametreler varsayılanı yalnızca verildiğinde alır undefined, değil null:

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

Jenerik Olmayan Boşluk

Boşluğun asla genel bir şekilde ele alınmaması gerektiğine inanıyorum. Bunun yerine her zaman boş olup olmadığını belirlemeden önce verilerimiz hakkında daha fazla bilgi almak için titizliğe sahip olmalıyız - Bunu esas olarak hangi tür verilerle uğraştığımı kontrol ederek yaparım:

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

Bu işlevin polimorfizmi yok saydığına dikkat edin - bunun bir alt sınıfının örneği değil, valuedoğrudan bir örneği olmasını bekler . İki ana nedenden dolayı kaçınırım :ClsClsinstanceof

• ([] instanceof Object) === true ("Dizi Nesnedir")
• ('' instanceof String) === false ("Bir Dize Bir Dize Değildir")

Bu işlev Object.getPrototypeOfgibi bir durumu önlemek için kullanıldığını unutmayın let v = { constructor: String };( isTypeişlev) hala isType(v, String)(false) ve isType(v, Object)(true) için doğru döner .

Genel olarak, bu isTypeişlevi aşağıdaki ipuçlarıyla birlikte kullanmanızı öneririz :

• Bilinmeyen türdeki kod işleme değerlerinin miktarını en aza indirin. Örneğin, için let v = JSON.parse(someRawValue);, bizim vdeğişken artık bilinmeyen türde. Mümkün olduğunca erken, olasılıklarımızı sınırlamalıyız. Bunu yapmanın en iyi yolu, belirli bir tür gerektirmek olabilir: örneğin if (!isType(v, Array)) throw new Error('Expected Array');- bu, genel doğasını kaldırmak ve vher zaman bir sağlamak için gerçekten hızlı ve etkileyici bir yoldur Array. Ancak bazen, vbirden fazla türde olmasına izin vermemiz gerekir . Bu durumlarda, vmümkün olduğunca erken, artık genel olmayan kod blokları oluşturmalıyız :

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

• Doğrulama için her zaman "beyaz listeleri" kullanın. Bir değerin örneğin Dize, Sayı veya Dizi olmasını istiyorsanız, bu 3 "beyaz" olasılığı kontrol edin ve 3'ten hiçbiri tatmin olmazsa bir Hata atın. "Siyah" olasılıkları kontrol etmenin çok yararlı olmadığını görebilmeliyiz: Diyelim ki yazıyoruz if (v === null) throw new Error('Null value rejected');- bu, nulldeğerlerin bunu gerçekleştirmemesini sağlamak için harikadır , ancak bir değer bunu başarırsa , hala çok az şey biliyoruz bunun hakkında herhangi bir şey. vBu boş denetimi geçen bir değer hala ÇOK genel - bir şey amanull ! Kara listeler jenerikliği neredeyse hiç yok etmez.

• Bir değer olmadığı sürece null, asla "boş bir değer" olarak düşünmeyin. Bunun yerine "boş olan bir X" düşünün. Esasen, asla böyle bir şey yapmayı düşünmeyin if (isEmpty(val)) { /* ... */ }- bu isEmptyfonksiyon nasıl uygulanırsa uygulansın (bilmek istemiyorum ...), anlamlı değil! Ve bu çok genel! Boşluk yalnızca türünün bilgisi ile hesaplanmalıdır val. Boşluk kontrolleri şöyle görünmelidir:

  • "Karakter içermeyen bir dize": if (isType(val, String) && val.length === 0) ...
  • "0 sahne olan bir nesne": if (isType(val, Object) && Object.entries(val).length === 0) ...
  • "Sıfıra eşit veya sıfırdan küçük bir sayı": if (isType(val, Number) && val <= 0) ...

  • "Öğe içermeyen bir Dizi": if (isType(val, Array) && val.length === 0) ...

  • Bunun tek istisnası, nullbelirli işlevleri belirtmek için kullanıldığındadır. Bu durumda "Boş bir değer" demek anlamlı:if (val === null) ...

Farklı Mantık ile deneyin . Dört (4) koşulun tümünü null değil, boş değil, tanımsız değil ve sıfır değil, yalnızca javascript ve jquery'de bu kodu (! (! (Değişken))) doğrulamak için kontrol etmek için feryat kodunu kullanabilirsiniz.

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

Yeni ECMAScript Nullish birleştirme operatörüne bir göz atın

Bu özelliği - ??operatör - nullveya ile uğraşırken varsayılan bir değere “geri dönmenin” bir yolu olarak düşünebilirsiniz undefined.

let x = foo ?? bar();

Yine, yukarıdaki kod aşağıdakine eşdeğerdir.

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

function isEmpty(val){
    return !val;
}

ancak bu çözüm aşırı tasarlanmış olup, daha sonra busines-model ihtiyaçları için işlevi değiştirmek istemiyorsanız, doğrudan kodda kullanmak daha temizdir:

if(!val)...

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

Bu asla bir hata yapmaz. Eğer myObject , çocuk veya MyValue null sonra myNewValue boş olacaktır. Hata atılmayacak

Benzer bir soruya varmak için buraya gelen herkes için aşağıdakiler harika çalışıyor ve son yıllarda kütüphanemde var:

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

JAndy'nin cevabına göre, değer aşağıdakilerden herhangi biriyse doğru olmaktan kaçınmak istiyorsanız :

• boş
• Tanımsız
• NaN
• boş dize ("")
• 0
• yanlış

Doğru değerler elde etmekten kaçınabilecek olası bir çözüm şudur:

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

Aşağıdaki gibi kullanılır:

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

Bu senaryolara ek olarak, nesne veya dizi boşsa false değerini döndürmek isteyebilirsiniz :

• Nesne: {} ( ECMA 7+ Kullanarak )
• Dizi: [] ( ECMA 5+ kullanarak )

Bu şekilde devam edersiniz:

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

Tüm boşluk dizelerini ("") kontrol etmek istiyorsanız, aşağıdakileri yapabilirsiniz:

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

Not: hasOwnPropertydeğişken, herhangi biri olarak bildirildiyse 0, false, NaN, null ve undefined gibi boş dizeler için true değerini döndürür, bu nedenle kullanmak en iyisi olmayabilir. İşlev, bildirildiğini ancak kullanılamadığını göstermek üzere kullanmak üzere değiştirilebilir.

GitHub'daki kod

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

Zavallı adamın testleri 😁

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

Test sonuçları:

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

Bu, belirsiz iç içe yerleştirme değişkeninin tanımlanıp tanımlanmadığını kontrol eder

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

Yukarıdakiler, Google çeviri işlevi olan TranslateElement'in mevcut olup olmadığını kontrol eder. Bu şuna eşittir:

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

İsteğe bağlı zincirleme operatörü, bir referansın veya fonksiyonun tanımlanmamış veya boş olması mümkün olduğunda, bağlı nesneler üzerinden değerlere erişimi basitleştirmenin bir yolunu sunar.

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

Nullish birleştirme operatörü, hiçbiri bulunmadığında varsayılan bir değer oluşturmak için isteğe bağlı zincirlemeden sonra kullanılabilir:

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

ayrıca beyaz boşlukları ('') aşağıdakilerle birlikte kontrol edecektir:

• null, undefined, NaN, boş, dize (""), 0, yanlış

Bence? operatör biraz daha temiz.

var ? function_if_exists() : function_if_doesnt_exist();