JavaScript'teki bir nesne özelliğinin olup olmadığını kontrol etmenin en iyi yolu nedir undefined?

Bir mülkün değerinin özel değer olup olmadığını kontrol etmenin genel yolu undefined:

if(o.myProperty === undefined) {
  alert("myProperty value is the special value `undefined`");
}

Bir nesnenin böyle bir özelliğe sahip olup olmadığını ve bu nedenle undefinedona erişmeye çalıştığınızda varsayılan olarak geri dönüp dönmeyeceğini kontrol etmek için:

if(!o.hasOwnProperty('myProperty')) {
  alert("myProperty does not exist");
}

Bir tanımlayıcı ile ilişkili değer özel değer olup olmadığını kontrol etmek undefined, ya da o tanımlayıcı ilan edilmemiş ise. Not: Bu yöntem, erken bir hata olmadan bildirilmemiş (not: değerine sahip olmaktan farklı undefined) bir tanımlayıcıya başvurmanın tek yoludur :

if(typeof myVariable === 'undefined') {
  alert('myVariable is either the special value `undefined`, or it has not been declared');
}

ECMAScript 5'ten önceki JavaScript sürümlerinde, genel nesne üzerindeki "tanımsız" adlı özellik yazılabilirdi ve bu nedenle foo === undefined, yanlışlıkla yeniden tanımlanmışsa basit bir denetim beklenmedik şekilde davranabilir. Modern JavaScript'te, özellik salt okunurdur.

Bununla birlikte, modern JavaScript'te, "tanımsız" bir anahtar kelime değildir ve bu nedenle işlevlerin içindeki değişkenler "tanımsız" olarak adlandırılabilir ve global özellik gölgelenebilir.

Bu (olası olmayan) uç durumdan endişe ediyorsanız , özel değerin kendisine ulaşmak için void operatörünü kullanabilirsiniz undefined:

if(myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}

Bu konuda bazı yanlış cevaplar olduğuna inanıyorum. Genel kanının aksine, "tanımsız", JavaScript'teki bir anahtar kelime değildir ve aslında kendisine atanmış bir değere sahip olabilir.

Doğru Kod

Bu testi yapmanın en sağlam yolu:

if (typeof myVar === "undefined")

Bu her zaman doğru sonucu döndürür ve hatta myVarbeyan edilmeyen durumu ele alır .

Dejenere kod. KULLANMAYIN.

var undefined = false;  // Shockingly, this is completely legal!
if (myVar === undefined) {
    alert("You have been misled. Run away!");
}

Ayrıca, myVar === undefinedmyVar'ın bildirilmediği durumda bir hata ortaya çıkarır.

Burada birçok cevap tarafından şiddetle tavsiye edilmesine rağmen, typeof kötü bir seçimdir . Asla değişkenlerin değere sahip olup olmadığını kontrol etmek için kullanılmamalıdır undefined, çünkü değer undefinedve bir değişkenin var olup olmadığı için birleşik kontrol görevi görür . Vakaların büyük çoğunluğunda, bir değişkenin ne zaman var olduğunu bilirsiniz typeofve değişken adında veya dizgi değişmezinde bir yazım hatası yaparsanız yalnızca sessiz bir hata potansiyeli ortaya koyar 'undefined'.

var snapshot = …;

if (typeof snaposhot === 'undefined') {
    //         ^
    // misspelled¹ – this will never run, but it won’t throw an error!
}

var foo = …;

if (typeof foo === 'undefned') {
    //                   ^
    // misspelled – this will never run, but it won’t throw an error!
}

Dolayısıyla, belirli bir adın kapsamda olup olmayacağı konusunda belirsizliğin typeof module !== 'undefined'olduğu bir ortak özellik² yapmıyorsanız (bir CommonJS ortamına özgü kodda bir adım olarak kontrol etmek gibi), typeofbir değişken üzerinde kullanıldığında zararlı bir seçimdir ve doğru seçenek değeri doğrudan karşılaştırmak için:

var foo = …;

if (foo === undefined) {
    ⋮
}

Bununla ilgili bazı yaygın yanılgılar şunları içerir:

• “başlatılmamış” bir değişken ( var foo) veya parametre ( function bar(foo) { … }olarak adlandırılır ) okunmasının bar()başarısız olacağını. Bu doğru değildir - açık başlatma ve değişkenler verilmeyen parametreler her undefinedzaman kapsamdadır.

• O undefinedüzerine yazılır olabilir. Bundan daha fazlası var. undefinedJavaScript'teki bir anahtar kelime değil. Bunun yerine, genel nesne üzerinde Tanımsız değere sahip bir özelliktir. Ancak, ES5'ten bu yana, bu özellik salt okunur ve yapılandırılamaz . Hiçbir modern tarayıcı undefinedmülkün değiştirilmesine izin vermeyecek ve 2017'den bu yana uzun zamandır durum böyleydi. Katı modun olmaması undefinedda davranışını etkilemez - sadece undefined = 5atmak yerine hiçbir şey yapmamak gibi ifadeler yapar . O bir anahtar kelime olmadığından, gerçi yapabilirsiniz beyan adıyla değişkenleri undefinedbu kez ortak desen yapma, ve bu değişkenler değiştirilebilir:

  (function (undefined) {
      // …
  })()

  küresel kullanmaktan daha tehlikeli undefined. Eğer ES3-uyumlu olması gerekiyorsa, yerine undefinedbirlikte void 0- çare yoktur typeof. ( voidher zaman herhangi bir işlenen için Tanımlanmamış değeri değerlendiren tekli bir operatör olmuştur.)

Değişkenlerin yoldan nasıl çıktığıyla, asıl soruyu ele alma zamanı: nesne özellikleri. typeofNesne özellikleri için kullanmak için hiçbir neden yoktur . Özellik algılama ile ilgili önceki istisna burada geçerli değildir - typeofyalnızca değişkenler üzerinde özel davranışlar vardır ve nesne özelliklerine başvuran ifadeler değişken değildir.

Bu:

if (typeof foo.bar === 'undefined') {
    ⋮
}

her zaman tam olarak buna eşittir³:

if (foo.bar === undefined) {
    ⋮
}

ve yukarıdaki önerileri dikkate alarak, okuyucuları neden kullandığınız konusunda kafa karıştırmaktan kaçınmaktır typeof, çünkü ===eşitliği kontrol etmek için kullanmak en mantıklıdır , çünkü daha sonra bir değişkenin değerini kontrol etmek için yeniden düzenlenebilir ve sadece düz olduğu için daha iyi görünüyorsa, burada da her zaman === undefined³ kullanmalısınız .

Nesne özellikleri söz konusu olduğunda dikkate alınması gereken başka bir şey, gerçekten kontrol etmek isteyip istemediğinizdir undefined. Belirli bir özellik adı, bir nesnede ( undefinedokunduğunda değeri üreterek ), nesnenin kendisinde değerle undefined, nesnenin prototipinde değerle undefinedmevcut olabilir veya değeri olmayanlardan birinde bulunabilir undefined. 'key' in objbir anahtarın bir nesnenin prototip zincirinde herhangi bir yerde Object.prototype.hasOwnProperty.call(obj, 'key')olup olmadığını ve doğrudan nesnenin üzerinde olup olmadığını söyleyecektir. Bununla birlikte, prototipler ve nesneleri dize anahtarlı haritalar olarak kullanma hakkındaki bu cevapta ayrıntıya girmeyeceğim, çünkü çoğunlukla orijinal sorunun olası yorumlarına bakılmaksızın diğer cevaplardaki tüm kötü tavsiyelere karşı koymayı amaçlıyor. Üzerinde okumakdaha fazla bilgi için MDN üzerinde prototipler !

_{Variable alışılmadık örnek değişken adı seçimi? Bu, Firefox için NoScript uzantısından gerçek ölü koddur.
² Yine de, kapsamda ne olduğunu bilmemenin genel olarak iyi olduğunu varsaymayın. Dinamik kapsamın kötüye kullanılması nedeniyle ortaya çıkan ilave güvenlik açığı: Sıfır Noktası 1225 Project bir
kez daha ES5 + ortamını kabul undefinededer ve bu undefined, global nesnenin özelliğine işaret eder . yerine void 0, aksi.}

JavaScript'te null ve undefined var . Farklı anlamları var.

• undefined , değişken değerin tanımlanmadığı anlamına gelir; değerin ne olduğu bilinmemektedir.
• null , değişken değerinin tanımlandığı ve null olarak ayarlandığı anlamına gelir (değeri yoktur).

Marijn Haverbeke, " Eloquent JavaScript " adlı ücretsiz çevrimiçi kitabında (benimki vurgu):

Benzer bir değer de vardır, null, anlamı 'bu değer tanımlanır, ancak bir değeri yoktur'. Undefined ve null arasındaki anlam farkı çoğunlukla akademiktir ve genellikle çok ilginç değildir. Pratik programlarda, genellikle bir şeyin 'değeri olup olmadığını' kontrol etmek gerekir. Bu durumlarda, == undefined ifadesi kullanılabilir, çünkü tam olarak aynı değer olmasa da, null == undefined true değerini üretir.

Yani, sanırım bir şeyin tanımsız olup olmadığını kontrol etmenin en iyi yolu:

if (something == undefined)

Bu yardımcı olur umarım!

Düzenleme: Düzenlemenize yanıt olarak, nesne özellikleri aynı şekilde çalışmalıdır.

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

Bu ne anlama geliyor: "tanımsız nesne özelliği" ?

Aslında bu iki farklı anlama gelebilir! Birincisi, nesnede hiç tanımlanmamış özellik anlamına gelebilir ve ikincisi, tanımlanmamış bir değere sahip özellik anlamına gelebilir . Şimdi bu koda bakalım:

var o = { a: undefined }

Is o.atanımsız? Evet! Değeri tanımlanmamış. Is o.btanımsız? Elbette! Hiç 'b' özelliği yoktur! Tamam, şimdi her iki durumda da farklı yaklaşımların nasıl davrandığını görün:

typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false

Bunu açıkça görebiliyoruz typeof obj.prop == 'undefined've obj.prop === undefinedeşdeğeriz ve bu farklı durumları ayırt etmiyorlar. Ve 'prop' in objbir mülk hiç tanımlanmadığında ve tanımlanamayan mülk değerine dikkat etmediğinde durumu tespit edebilir.

Peki ne yapmalı?

1) Bir mülkün birinci veya ikinci anlamı ile tanımlanıp tanımlanmadığını bilmek istersiniz (en tipik durum).

obj.prop === undefined // IMHO, see "final fight" below

2) Nesnenin bir özelliği olup olmadığını bilmek istiyorsunuz ve değerini önemsemiyorsunuz.

'prop' in obj

Notlar:

• Bir nesneyi ve onun özelliğini aynı anda kontrol edemezsiniz. Örneğin, x tanımlanmamışsa bu x.a === undefinedya da bu typeof x.a == 'undefined'yükselir ReferenceError: x is not defined.
• Değişken undefinedgenel bir değişkendir (yani aslında window.undefinedtarayıcılardadır). ECMAScript 1st Edition'dan beri desteklenmektedir ve ECMAScript 5'ten beri salt okunurdur . Modern tarayıcılarda , birçok yazar bizi korkutmayı sevdiği için doğru olarak yeniden tanımlanamaz , ancak bu hala eski tarayıcılar için geçerlidir.

Son mücadele: obj.prop === undefinedvstypeof obj.prop == 'undefined'

Artıları obj.prop === undefined:

• Biraz daha kısa ve biraz daha güzel görünüyor
• Yanlış yazdıysanız JavaScript motoru size bir hata verecektir undefined

Eksileri obj.prop === undefined:

• undefined eski tarayıcılarda geçersiz kılınabilir

Artıları typeof obj.prop == 'undefined':

• Gerçekten evrensel! Yeni ve eski tarayıcılarda çalışır.

Eksileri typeof obj.prop == 'undefined':

• 'undefned'( yanlış yazılmış ) burada sadece bir dize sabiti var, bu yüzden yaptığım gibi yanlış yazdıysanız JavaScript motoru size yardımcı olamaz.

Güncelleme (sunucu tarafı JavaScript için):

Node.js, global değişkeni undefinedşu şekilde destekler global.undefined('global' öneki olmadan da kullanılabilir). Sunucu tarafı JavaScript'in diğer uygulamaları hakkında bilmiyorum.

Sorun üç vakayla ilgilidir:

1. Nesnenin özelliği vardır ve değeri değildir undefined.
2. Nesnenin özelliği vardır ve değeri undefined.
3. Nesnenin özelliği yok.

Bu bize önemli olduğunu düşündüğüm bir şey söylüyor:

Tanımlanmamış bir üye ile tanımlanmamış bir değere sahip tanımlı bir üye arasında bir fark vardır.

Ancak mutsuzca typeof obj.foobize bu üç durumdan hangisinin olduğunu söylemiyor. Bununla birlikte "foo" in obj, vakaları ayırt etmek için bunu birleştirebiliriz .

                               |  typeof obj.x === 'undefined' | !("x" in obj)
1.                     { x:1 } |  false                        | false
2.    { x : (function(){})() } |  true                         | false
3.                          {} |  true                         | true

Bu testlerin nullgirişler için de aynı olduğunu belirtmek gerekir.

                               |  typeof obj.x === 'undefined' | !("x" in obj)
                    { x:null } |  false                        | false

Bazı durumlarda, mülkün var olup olmadığını kontrol etmenin, tanımlanıp tanımlanmadığını kontrol etmekten daha mantıklı olduğunu (ve daha açık olduğunu) ve bu kontrolün farklı olacağı tek durumun durum 2 olduğunu, nesnede tanımlanmamış bir değere sahip gerçek bir girdi.

Örneğin: Bir nesnenin belirli bir özelliğe sahip olup olmadığını kontrol eden bir grup kodu yeniden düzenledim.

if( typeof blob.x != 'undefined' ) {  fn(blob.x); }

Hangi tanımsız bir çek olmadan yazıldığında daha açıktı.

if( "x" in blob ) { fn(blob.x); }

Ancak belirtildiği gibi bunlar tam olarak aynı değildir (ancak ihtiyaçlarım için yeterince iyi değildir).

if ( typeof( something ) == "undefined") 

Diğerleri yapmazken bu benim için çalıştı.

Kullanarak kökeni nerede emin değilim ===ile typeofgeldi ve bir kongre olarak bunu birçok kütüphanelerde kullanılan görüyorum, ama typeof operatörü dize döndürür ve biz o kadar ön biliyoruz, neden ayrıca tip isteyeyim kontrol etmek mi?

typeof x;                      // some string literal "string", "object", "undefined"
if (typeof x === "string") {   // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") {    // sufficient

Benim yollamaktasınız cevabı ilgili sorudan Nasıl JavaScript "tanımsız" için kontrol edilir?

Bu soruya özgü olan test senaryolarına bakın someObject.<whatever>.

Çeşitli cevapların sonuçlarını gösteren bazı senaryolar: http://jsfiddle.net/drzaus/UVjM4/

(Not kullanımı bu variçin intestler bir fark olduğunda, bir kapsamlı sargı içinde)

Referans kodu:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.log(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

Ve sonuçlar:

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined

Yaparsan

if (myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

değişken myvarvar olmadığında başarısız olur , çünkü myvar tanımlanmamıştır, bu yüzden komut dosyası bozulur ve testin bir etkisi olmaz.

Pencere nesnesi bir işlevin dışında genel bir kapsama (varsayılan nesne) sahip olduğundan, pencere nesnesine bir bildirim eklenir.

Örneğin:

var myvar = 'test';

Genel değişken myvar , window.myvar veya window ['myvar'] ile aynıdır

Genel bir değişken olduğunda test edilecek hatalardan kaçınmak için şunları kullanın:

if(window.myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

Bir değişkenin gerçekten var olup olmadığı önemli değildir, değeri yanlıştır. Aksi takdirde, değişkenleri tanımsız olarak başlatmak saçmadır ve başlatmak için false değerini kullanmak daha iyidir. Bildirdiğiniz tüm değişkenlerin false ile başlatıldığını bildiğinizde, türünü kontrol edebilir veya !window.myvaruygun / geçerli bir değere sahip olup olmadığını kontrol etmek için güvenebilirsiniz . Değişken tanımlanmamış olsa bile, veya veya !window.myvariçin aynıdır .myvar = undefinedmyvar = falsemyvar = 0

Belirli bir tür beklediğinizde, değişkenin türünü test edin. Bir koşulu test etmeyi hızlandırmak için şunları yapabilirsiniz:

if( !window.myvar || typeof window.myvar != 'string' )
{
    alert('var does not exists or is not type of string');
}

İlk ve basit koşul doğru olduğunda, tercüman sonraki testleri atlar.

Geçerli bir değere sahip olup olmadığını kontrol etmek için değişkenin örneğini / nesnesini kullanmak her zaman daha iyidir. Daha kararlı ve daha iyi bir programlama yöntemidir.

(Y)

Kimse özellik önce nesneyi kontrol görmedim (umut özledim vermedi). Yani, bu en kısa ve en etkili olanıdır (her ne kadar mutlaka en açık olmasa da):

if (obj && obj.prop) {
  // Do something;
}

Obj veya obj.prop tanımsız, null veya "falsy" ise, if ifadesi kod bloğunu yürütmez. Bu, çoğu kod bloğu deyiminde (JavaScript'te) genellikle istenen davranıştır.

JavaScript'te Boş ve Tanımlanmamış Uçurumu Keşfetme makalesinde Underscore.js gibi çerçevelerin bu işlevi kullandığını okudum :

function isUndefined(obj){
    return obj === void 0;
}

JavaScript'te tanımlanmayan herhangi bir şey tanımlanmamıştır , bir Object / Array içindeki bir özellik mi yoksa sadece basit bir değişken mi olduğu önemli değildir ...

JavaScript, typeoftanımlanmamış bir değişkeni algılamayı çok kolaylaştırır.

Sadece typeof whatever === 'undefined'bir boolean döndürüp döndürmeyeceğini kontrol edin .

isUndefined()AngularJs v.1x'deki ünlü fonksiyon şöyle yazılır:

function isUndefined(value) {return typeof value === 'undefined';} 

Bu nedenle, işlevin bir değer aldığını gördüğünüz gibi, bu değer tanımlanmışsa, döndürülür false, aksi takdirde tanımlanmamış değerler için geri döner true.

Öyleyse, aşağıdaki gibi nesne özellikleri de dahil olmak üzere değerleri geçerken sonuçların ne olacağına bir göz atalım, sahip olduğumuz değişkenlerin listesi:

var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;

ve bunları aşağıdaki gibi kontrol ediyoruz, önlerindeki sonuçları bir yorum olarak görebilirsiniz:

isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true

Gördüğünüz gibi, kodumuzda böyle bir şey kullanarak herhangi bir şeyi kontrol edebiliriz, belirtildiği gibi kodunuzda kullanabilirsiniz typeof, ancak tekrar tekrar kullanıyorsanız, paylaştığım açısal örnek gibi bir işlev oluşturun ve yeniden kullanmaya devam edin aşağıdaki KURU kod deseni.

Ayrıca, nesnenin var olup olmadığından emin olmadığınız gerçek bir uygulamadaki bir nesnenin özelliğini denetlemek için, nesnenin önce var olup olmadığını kontrol edin.

Bir nesnedeki bir özelliği kontrol ederseniz ve nesne yoksa, bir hata atar ve tüm uygulamanın çalışmasını durdurur.

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

Çok basit bir if ifadesinin içine aşağıdaki gibi sarılabilirsiniz:

if(typeof x !== 'undefined') {
  //do something
}

Bu da eşittir Açısal 1.x ...

function isDefined(value) {return typeof value !== 'undefined';}

Ayrıca alt çizgi gibi diğer javascript çerçeveleri benzer tanımlayıcı kontrole sahiptir, ancak typeofzaten herhangi bir çerçeve kullanmıyorsanız kullanmanızı öneririz .

Ayrıca bu bölümü typeof, undefined ve void (0) hakkında yararlı bilgilere sahip olan MDN'den de ekliyorum.

Katı eşitlik ve tanımsız
Bir değişkenin değerine sahip olup olmadığını belirlemek için undefined ve katı eşitlik ve eşitsizlik işleçlerini kullanabilirsiniz. Aşağıdaki kodda, x değişkeni tanımlanmamıştır ve if ifadesi true olarak değerlendirilir.

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

Not: Burada standart eşitlik operatörü yerine katı eşitlik operatörü kullanılmalıdır, çünkü x == undefined ayrıca katı eşitlik olmasa da x'in boş olup olmadığını kontrol eder. null, tanımsız ile eşdeğer değil. Ayrıntılar için karşılaştırma operatörlerine bakın.

Operatör ve tanımsız tip
Alternatif olarak, typeof kullanılabilir:

var x;
if (typeof x === 'undefined') {
   // these statements execute
}

Typeof kullanmanın bir nedeni, değişken bildirilmemişse bir hata atmamasıdır.

// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

if (x === undefined) { // throws a ReferenceError

}

Ancak bu tür tekniklerden kaçınılmalıdır. JavaScript statik olarak kapsamlandırılmış bir dildir, bu nedenle bir değişkenin bildirilip bildirilmediğini bilmek, onu çevreleyen bir bağlamda bildirilip bildirilmediğini okuyarak okunabilir. Tek istisna global kapsamdır, ancak global kapsam global nesneye bağlıdır, bu nedenle global bağlamda bir değişkenin varlığını kontrol etmek, global nesne üzerinde bir özelliğin varlığını kontrol ederek (in operatörünü, Örneğin).

Geçersiz operatör ve tanımsız

Geçersiz operatör üçüncü bir alternatiftir.

var x;
if (x === void 0) {
   // these statements execute
}

// y has not been declared before
if (y === void 0) {
   // throws a ReferenceError (in contrast to `typeof`)
}

daha> burada

' if (window.x) {} ' hata korumalıdır

Büyük olasılıkla istiyorsun if (window.x). Bu kontrol, x bildirilmemiş olsa bile güvenlidir ( var x;) - tarayıcı bir hata atmaz.

Örnek: Tarayıcımın Geçmiş API'sını destekleyip desteklemediğini bilmek istiyorum

if (window.history) {
    history.call_some_function();
}

Bu nasıl çalışır:

window , tüm global değişkenleri üyesi olarak tutan bir nesnedir ve var olmayan bir üyeye erişmeye çalışmak yasaldır. Eğer x sonra beyan edilmiş veya ayarlanmamış window.xdöndürür tanımsız . undefined , if () tarafından değerlendirildiğinde false değerine yol açar .

Bunu okurken, bunu görmediğime şaşırdım. Bunun için işe yarayacak birden fazla algoritma buldum.

Asla Tanımlanmamış

Bir nesnenin değeri hiçbir zaman tanımlanmadıysa, veya trueolarak tanımlanırsa bu nesnenin geri dönmesini engeller . Değer olarak ayarlanmış değerler için true değerinin döndürülmesini istiyorsanız bu yararlıdırnullundefinedundefined

if(obj.prop === void 0) console.log("The value has never been defined");

Undefined olarak tanımlandı veya asla tanımlanmadı

Bunun truedeğeriyle tanımlanan undefinedveya hiç tanımlanmayan değerler için sonuçlanmasını istiyorsanız,=== undefined

if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");

Bir falsy değeri olarak tanımlanmış, undefined, null veya asla tanımlanmamış.

Genellikle, insanlar bir değer ya falsy olup, olmadığını anlamaya bir algoritma için beni istedi undefinedya null. Aşağıdaki işler.

if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}

"propertyName" in obj //-> true | false

void 0Kıvam için, ile karşılaştırın .

if (foo !== void 0)

Bu kadar ayrıntılı değil if (typeof foo !== 'undefined')

Çözüm yanlış. JavaScript'te,

null == undefined

true döndürür, çünkü ikisi de bir boole'ye "dökülür" ve yanlıştır. Doğru yol kontrol etmektir

if (something === undefined)

kimlik operatörü olan ...

Aşağıdaki kodu kullanarak, yolla tanımsız bir dizi alabilirsiniz.

 function getAllUndefined(object) {

        function convertPath(arr, key) {
            var path = "";
            for (var i = 1; i < arr.length; i++) {

                path += arr[i] + "->";
            }
            path += key;
            return path;
        }


        var stack = [];
        var saveUndefined= [];
        function getUndefiend(obj, key) {

            var t = typeof obj;
            switch (t) {
                case "object":
                    if (t === null) {
                        return false;
                    }
                    break;
                case "string":
                case "number":
                case "boolean":
                case "null":
                    return false;
                default:
                    return true;
            }
            stack.push(key);
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    v = getUndefiend(obj[k], k);
                    if (v) {
                        saveUndefined.push(convertPath(stack, k));
                    }
                }
            }
            stack.pop();

        }

        getUndefiend({
            "": object
        }, "");
        return saveUndefined;
    }

jsFiddle bağlantısı

İşte benim durumum:

Bir REST çağrısının sonucunu kullanıyorum. Sonuç JSON'dan bir JavaScript nesnesine ayrıştırılmalıdır.

Savunmam gereken bir hata var. Geri kalan çağrının bağımsız değişkenleri, kullanıcının yanlışları belirlediği ölçüde yanlışsa, geri kalan çağrı temelde boş olur.

Buna karşı savunmama yardım etmek için bu yazıyı kullanırken bunu denedim.

if( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }

Benim durumum için, eğer restResult.data [0] === "nesne", o zaman güvenli bir şekilde diğer üyelerin teftiş başlayabilirsiniz. Tanımsızsa hatayı yukarıdaki gibi atın.

Söylediğim, durumum için, bu yazıda yukarıdaki tüm önerilerin işe yaramadığı. Haklı olduğumu ve herkesin yanlış olduğunu söylemiyorum. Ben bir JavaScript ustası değilim, ama umarım bu birine yardımcı olur.

Tanımlı bir özelliği, tanımlanmışsa yeni bir değişkene atamanın veya tanımlanmamışsa varsayılan değer olarak yedek olarak atamanın güzel ve zarif bir yolu vardır.

var a = obj.prop || defaultValue;

Ek bir yapılandırma özelliği alan bir işleviniz varsa uygundur:

var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.log(this.yourConfigValue);

}

Şimdi yürütülüyor

yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

Bütün cevaplar eksik. 'Undefined olarak tanımlanmış' bir özellik olduğunu bilmenin doğru yolu budur:

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;

Misal:

var a = { b : 1, e : null } ;
a.c = a.d ;

hasUndefinedProperty(a, 'b') ; // false : b is defined as 1
hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined
hasUndefinedProperty(a, 'd') ; // false : d is undefined
hasUndefinedProperty(a, 'e') ; // false : e is defined as null

// And now...
delete a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined

Bunun doğru cevap olması çok kötü yanlış cevaplara gömüldü> _ <

Yani, geçen herkes için, size ücretsiz olarak tanımsızları vereceğim !!

var undefined ; undefined ; // undefined
({}).a ;                    // undefined
[].a ;                      // undefined
''.a ;                      // undefined
(function(){}()) ;          // undefined
void(0) ;                   // undefined
eval() ;                    // undefined
1..a ;                      // undefined
/a/.a ;                     // undefined
(true).a ;                  // undefined

Yorumları gözden geçirmek, her ikisini de kontrol etmek isteyenler için tanımsız mı yoksa değeri boş mu:

//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}

JQuery Library kullanıyorsanız jQuery.isEmptyObject()her iki durumda da yeterli olacaktır,

var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;

s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;

//Usage
if (jQuery.isEmptyObject(s)) {
    alert('Either variable:s is undefined or its value is null');
} else {
     alert('variable:s has value ' + s);
}

s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;

Açısal kullanıyorsanız:

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

Underscore.js:

_.isUndefined(obj) 
_.isUndefined(obj.prop) 

if (this.variable)Tanımlanıp tanımlanmadığını test etmek için kullanıyorum . Basit if (variable), yukarıda tavsiye , benim için başarısız. Söz konusu değişkenin obj.someFieldsözlükte tanımlanıp tanımlanmadığını kontrol etmek için yalnızca değişken bir nesnenin alanı olduğunda işe yarar. Ama anladığım gibi herhangi bir değişken geçerli pencerede bir alan olduğundan thisveya windowsözlük nesnesi olarak kullanabiliriz . Bu yüzden işte bir test

if (this.abc) alert("defined"); else alert("undefined");

abc = "abc";
if (this.abc) alert("defined"); else alert("undefined");

Önce değişkenin abctanımsız olduğunu algılar ve başlatmadan sonra tanımlanır.

Burada garip cevaplar bekleyenler için üç yol sağlıyorum:

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}
function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
    const defaultVal={};
    return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
    console.group(`test start :`+func.name);
    console.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

isUndefined1:

Giriş değerinin bir özelliğini almaya çalışın, varsa hata mesajını kontrol edin. Giriş değeri tanımsızsa, hata iletisi Yakalanmadı olur TypeError: undefined'in 'b' özelliği okunamıyor

isUndefined2:

Giriş değerini karşılaştırmak "undefined"ve dizenin negatif değerinden emin olmak için dizeye dönüştürün .

isUndefined3:

Js'de, isteğe bağlı parametre giriş değeri tam olarak olduğunda çalışır undefined.

function isUnset(inp) {
  return (typeof inp === 'undefined')
}

Değişken ayarlanmışsa false değerini ve tanımsızsa true değerini döndürür.

Sonra kullan:

if (isUnset(var)) {
  // initialize variable here
}

undefinedDeğişkeni korumak için kullandığım bir şeyi size göstermek istiyorum :

Object.defineProperty(window, 'undefined', {});

Bu, herhangi birinin window.undefineddeğeri değiştirmesini yasaklar, bu nedenle bu değişkene dayalı olarak kodu yok eder. Kullanılırsa "use strict", değerini değiştirmeye çalışan herhangi bir şey yanlışlıkla sona erer, aksi takdirde sessizce göz ardı edilir.

Proxy'yi de kullanabilirsiniz, iç içe aramalarla çalışır, ancak bir ek kontrol gerektirir:

function resolveUnknownProps(obj, resolveKey) {
  const handler = {
    get(target, key) {
      if (
        target[key] !== null &&
        typeof target[key] === 'object'
      ) {
        return resolveUnknownProps(target[key], resolveKey);
      } else if (!target[key]) {
        return resolveUnknownProps({ [resolveKey]: true }, resolveKey);
      }

      return target[key];
    },
  };

  return new Proxy(obj, handler);
}

const user = {}

console.log(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }

böylece onu kullanacaksınız:

const { isUndefined } = resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else;
if (!isUndefined) {
  // do someting
}

Lodash.js dosyasından.

var undefined;
function isUndefined(value) {
  return value === undefined;
}

undefinedVarsayılan değerle başlatılan adlı bir LOCAL değişkeni yaratır - real undefined, daha sonra valuedeğişkenle karşılaştırır undefined.

9/9/2019 Güncellemesi

Lodash'ın uygulanmasını güncellediğini gördüm. Bkz sorunumu ve kod .

Kurşun geçirmez olmak için şunları kullanın:

function isUndefined(value) {
  return value === void 0;
}