JavaScript'te tanımsız veya boş bir değişken olup olmadığı nasıl kontrol edilir?

JavaScript kodumuzda sıklıkla aşağıdaki kod modelini kullanıyoruz

if (typeof(some_variable) != 'undefined' && some_variable != null)
{
    // Do something with some_variable
}

Aynı etkiye sahip daha az ayrıntılı bir kontrol yöntemi var mı?

Bazı forumlara ve literatüre göre, aşağıdakilerin basitçe söylenmesi aynı etkiye sahip olmalıdır.

if (some_variable)
{
    // Do something with some_variable
}

Ne yazık ki, Firebugsome_variable tanımsız olduğunda çalışma zamanında hata gibi bir ifadeyi değerlendirirken , ilki sadece bunun için iyi. Bu sadece Firebug'un (istenmeyen) bir davranışı mı yoksa bu iki yol arasında gerçekten bir fark var mı?

Vakaları birbirinden ayırmanız gerekir:

1. Değişkenler olabilir undefinedveya bildirilmemiş olabilir . Başka bir bağlamda bildirilmemiş bir değişkene erişirseniz hata alırsınız typeof.

if(typeof someUndeclaredVar == whatever) // works
if(someUndeclaredVar) // throws error

Bildirilmiş ancak başlatılmamış bir değişken undefined .

let foo;
if (foo) //evaluates to false because foo === undefined

2. Tanımsız özellikler , gibi someExistingObj.someUndefProperty. Tanımsız bir özellik bir hata vermez ve undefinedbir boole değerine dönüştürüldüğündefalse . Yani, umursamıyorsanız 0ve falsekullanmak if(obj.undefProp)tamam. Bu gerçeğe dayanan ortak bir deyim var:

   value = obj.prop || defaultValue

   " objözelliği varsa prop, atayın value, aksi takdirde varsayılan değeri atayın " anlamına gelir defautValue.

   Bazı insanlar, bulması zor hatalara yol açtığını ve inbunun yerine operatörün kullanılmasını önererek bu davranışı kafa karıştırıcı olarak düşünür.

   value = ('prop' in obj) ? obj.prop : defaultValue

"Değeridir için ben test etmek için en etkili yolu düşünmek nullveya undefinededilir"

if ( some_variable == null ){
  // some_variable is either null or undefined
}

Yani bu iki çizgi eşdeğerdir:

if ( typeof(some_variable) !== "undefined" && some_variable !== null ) {}
if ( some_variable != null ) {}

Not 1

Soruda belirtildiği gibi, kısa varyant some_variable bildirilmiş , aksi takdirde bir ReferenceError atılacaktır. Bununla birlikte, birçok kullanım durumunda bunun güvenli olduğunu varsayabilirsiniz:

isteğe bağlı bağımsız değişkenleri kontrol edin:

function(foo){
    if( foo == null ) {...}

varolan bir nesnenin özelliklerini denetleme

if(my_obj.foo == null) {...}

Öte yandan typeof, kayıt dışı küresel değişkenlerle başa çıkabilir (sadece geri döner undefined). Yine de, Alsciende'nin açıkladığı gibi, bu durumlar iyi nedenlerle en aza indirilmelidir.

Not 2

Bu - daha kısa - varyant eşdeğer değildir :

if ( !some_variable ) {
  // some_variable is either null, undefined, 0, NaN, false, or an empty string
}

yani

if ( some_variable ) {
  // we don't get here if some_variable is null, undefined, 0, NaN, false, or ""
}

Not 3

Genel olarak bunun ===yerine kullanılması önerilir ==. Önerilen çözüm bu kuralın bir istisnasıdır. JSHint sözdizimi denetleyicisi bile sağlareqnull bu nedenle seçeneği.

Gönderen jQuery stil kılavuzu :

== lehine katı eşitlik kontrolleri (===) kullanılmalıdır. Tek istisna, null yoluyla tanımsız ve null olup olmadığının kontrol edilmesidir.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

Null değerinin normal eşitlikle kontrol edilmesi de tanımsız için true değerini döndürecektir.

if (window.variable == null) alert('variable is null or undefined');

ES5 ve ES6 gibi daha yeni JavaScript standartlarında şunu söyleyebilirsiniz:

> Boolean(0) //false
> Boolean(null)  //false
> Boolean(undefined) //false

tümü yanlış döndürür, bu da Python'un boş değişkenleri kontrol etmesine benzer. Eğer bir değişkenin etrafına koşullu mantık yazmak istiyorsanız,

if (Boolean(myvar)){
   // Do something
}

burada "null" veya "boş dize" veya "tanımsız" etkin bir şekilde işlenir.

Tanımlanmamış bir değişkene başvurmaya çalışırsanız, tüm JavaScript uygulamalarında bir hata atılır.

Nesnelerin özellikleri aynı koşullara tabi değildir. Bir nesne özelliği tanımlanmamışsa, ona erişmeye çalışırsanız bir hata atılmaz. Yani bu durumda kısaltabilirsiniz:

 if (typeof(myObj.some_property) != "undefined" && myObj.some_property != null)

için

if (myObj.some_property != null)

Bunu göz önünde bulundurarak ve global değişkenlerin global nesnenin özellikleri olarak erişilebilir windowolması (bir tarayıcı durumunda), global değişkenler için aşağıdakileri kullanabilirsiniz:

if (window.some_variable != null) {
    // Do something with some_variable
}

Yerel kapsamlarda, değişkenlerin kod bloğunuzun üst kısmında bildirildiğinden emin olmak her zaman yararlıdır, bu, yinelenen kullanımlarından tasarruf sağlayacaktır typeof.

Öncelikle ne test ettiğiniz konusunda çok net olmalısınız. JavaScript, sizi harekete geçirecek her türlü örtük dönüşüme ve iki farklı türde eşitlik karşılaştırıcısına sahiptir: ==ve ===.

Aşağıdaki özellikleri test(val)test eden nullveya undefinediçermesi gereken bir işlev :

 test(null)         => true
 test(undefined)    => true
 test(0)            => false
 test(1)            => false
 test(true)         => false
 test(false)        => false
 test('s')          => false
 test([])           => false

Bakalım buradaki fikirlerden hangisi testimizi geçti.

Bu işler:

val == null
val === null || val === undefined
typeof(val) == 'undefined' || val == null
typeof(val) === 'undefined' || val === null

Bunlar çalışmıyor:

typeof(val) === 'undefined'
!!val

Doğruluk ve performansı karşılaştırmak için bir jsperf girişi oluşturdumBu yaklaşımların . Farklı tarayıcılarda / platformlarda yeterli sayıda çalışma olmadığı için sonuçlar şimdilik kesin değil. Testi bilgisayarınızda çalıştırmak için bir dakikanızı ayırın!

Şu anda, basit val == nulltestin en iyi performansı verdiği görülmektedir . Aynı zamanda çok kısa. val != nullTamamlayıcıyı istiyorsanız test reddedilebilir .

==kullanılması gereken tek durum budur :

if (val == null) console.log('val is null or undefined')

Tek bir tam ve doğru cevap olmadığından özetlemeye çalışacağım:

Genel olarak, ifade:

if (typeof(variable) != "undefined" && variable != null)

sadeleştirilemez, çünkü variablebildirilmemiş olabilir , bu nedenle atlanması typeof(variable) != "undefined"ReferenceError ile sonuçlanır. Ancak, ifadeyi bağlama göre basitleştirebilirsiniz :

Eğer variablebir küresel şunları yapmanız kolaylaştırabilirsiniz:

if (window.variable != null)

Eğer durum bu ise yerel , bu değişken atanarak edildiğinde muhtemelen durumlardan kaçınmak ve ayrıca kolaylaştırabilirsiniz:

if (variable != null)

Eğer öyleyse nesne özelliği , sen ReferenceError konusunda endişelenmenize gerek yoktur:

if (obj.property != null)

Değişkenin bir değeri olup olmadığını kontrol edebilirsiniz. anlam,

if( myVariable ) {
//mayVariable is not :
//null
//undefined
//NaN
//empty string ("")
//0
//false

}

Bir değişkenin olup olmadığını bilmiyorsanız (yani, bildirilmişse) typeof operatörüne danışmalısınız. Örneğin

if( typeof myVariable !== 'undefined' ) {
    // myVariable will get resolved and it is defined
}

Bunu bu yöntemi kullanarak yaptım

kimliği bazı değişkenlere kaydet

var someVariable = document.getElementById("someId");

sonra koşul kullanın

if(someVariable === ""){
 //logic
} else if(someVariable !== ""){
 //logic
}

Cevaplardan birinde belirtildiği gibi, küresel bir kapsama sahip bir değişken hakkında konuşuyorsanız şanslı olabilirsiniz. Bildiğiniz gibi, global olarak tanımladığınız değişkenler windows nesnesine ekleme eğilimindedir. Bu gerçeğin avantajlarından faydalanabilirsiniz, böylece bleh adlı bir değişkene eriştiğinizi varsayalım, sadece çift ters çevrilmiş operatörü kullanın (!!)

!!window['bleh'];

Bleh bildirilmemiş ve bir değer atanmamışken, bu bir yanlış döndürür.

Array include () yöntemini kullanmanın başka bir yolu :

[undefined, null].includes(value)

Bu, ==yerine kullanılması tavsiye edilen çok nadir bir duruma bir örnektir ===. İfade somevar == nulliçin de geçerli dönecektir undefinedvenull için her şey için , ancak diğer her şey için false döndürür (değişken bildirilmezse bir hata).

Kullanmak != beklendiği gibi sonuç çevirmek olacaktır.

Modern editörler kullanarak uyarmak olmaz ==ya !=operatörü ilenull , neredeyse her zaman istenen davranış olduğundan, kullanım uyarmazlar.

En yaygın karşılaştırmalar:

undeffinedVar == null     // true
obj.undefinedProp == null // true
null == null              // true
0 == null                 // false
'0' == null               // false
'' == null                // false

Kendin dene:

let undefinedVar;
console.table([
    { test : undefinedVar,     result: undefinedVar     == null },
    { test : {}.undefinedProp, result: {}.undefinedProp == null },
    { test : null,             result: null             == null },
    { test : false,            result: false            == null },
    { test : 0,                result: 0                == null },
    { test : '',               result: ''               == null },
    { test : '0',              result: '0'              == null },
]);

yyy tanımsız veya null olursa olsun , doğru dönecektir

if (typeof yyy == 'undefined' || !yyy) {
    console.log('yes');
} else {
    console.log('no');
}

Evet

if (!(typeof yyy == 'undefined' || !yyy)) {
    console.log('yes');
} else {
    console.log('no');
}

Hayır

Tarayıcınızda Geliştirici araçlarını açın ve aşağıdaki resimde gösterilen kodu deneyin.

Anlamak için, tanımlanmamış, null ve '' (Boş bir dize de) dönüştürürken Javascript Altyapısı tarafından döndürülen değerin ne olacağını analiz edelim. Aynı şeyi doğrudan geliştirici konsolunuzdan da kontrol edebilirsiniz.

Her şeyin yanlış olana dönüştüğünü görebilirsiniz, bu üçünün hepsinin javascript tarafından 'varlık eksikliği' olduğunu varsaydığı anlamına gelir. Bu nedenle, kodunuzdaki üçünün tümünü aşağıdaki gibi açıkça kontrol etmenize gerek yoktur.

if (a === undefined || a === null || a==='') {
    console.log("Nothing");
} else {
    console.log("Something");
}

Ayrıca bir şey daha belirtmek istiyorum.

Boolean'ın (0) sonucu ne olacak?

Elbette yanlış. 0, beklenen sonuçlarınızda geçerli bir değer olduğunda kodunuzda bir hata oluşturur. Bu yüzden lütfen kodu yazarken bunu kontrol ettiğinizden emin olun.

Sahip olduğunuza benzer şekilde,

if (some_variable === undefined || some_variable === null) { do stuff }

Nullity ( if (value == null)) veya nullity ( if (value != null)) öğesinin test edilmesi, bir değişkenin tanım durumunu test etmekten daha az ayrıntılıdır.

Ayrıca, bir boole değeri ile tanımlanmışsa değişkeninizin (veya nesne özelliğinizin) varlığını sağlamak için yapılan test if (value)(veya if( obj.property)) başarısız olur false. Uyarı emptor :)

Her iki değer de katı karşılaştırma operatörü kullanılarak kolayca ayırt edilebilir:

Çalışma örneği:

http://www.thesstech.com/tryme?filename=nullandundefined

Basit kod:

function compare(){
    var a = null; //variable assigned null value
    var b;  // undefined
    if (a === b){
        document.write("a and b have same datatype.");
    }
    else{
        document.write("a and b have different datatype.");
    }   
}

İf ifadesinin amacı , bir değişkene değer atamadan önce nullveya undefineddeğerleri kontrol etmekse , tarayıcı desteği sınırlı olmasına rağmen , Nullish Coalescing Operator'ı kullanabilirsiniz . Caniuse verilerine göre , tarayıcıların sadece% 48,34'ü desteklenmektedir (Nisan 2020 itibariyle).

const a = some_variable ?? '';

Bu değişken boş bir dizeye (veya başka bir varsayılan değer) atanacak sağlayacaktır some_variableolduğu nullveyaundefined .

Bu işleç, 0ve gibi diğer falsy değeri türleri için varsayılan değeri döndürmediği için kullanım durumunuz için en uygundur ''.

Bu formun bir işlevini tanımlamanız gerekir:

validate = function(some_variable){
    return(typeof(some_variable) != 'undefined' && some_variable != null)
}

ES5 veya ES6'da birkaç kez kontrol etmeniz gerekiyorsa:

const excluded = [null, undefined, ''];

if (!exluded.includes(varToCheck) {
  // it will bee not null, not undefined and not void string
}

Ramda ile Lodash R.isNil(yourValue) ve diğer yardımcı kütüphanelerin aynı işlevi görmesini sağlayabilirsiniz.