JavaScript'te neden "boş" değer var?

JavaScript'te, temelde 'Ben yokum' yazan iki değer vardır - undefinedve null.

Bir programcı herhangi bir numara olabilir atanmamış olan A özellik undefinedolmak için bir özellik için, ama sırayla null, nullaçıkça kendisine atanmalıdır.

Bir keresinde buna ihtiyaç olduğunu düşünmüştüm nullçünkü undefinedilkel bir değer ve nullbir nesnedir. Hatta eğer değil typeof nullverecektir 'object'- vasıtalar, Aslında, her ikisi de ilkel değerler şunlardır: undefinedveya nullher ikisi de boş nesne dönüştürülebilir gibi (bir kurucu içinde, açığa başarısızlığa bir hata oluşturması sahiptir), bir yapıcı işlevi döndürülebilir.

Ayrıca ikisi de falseboole bağlamlarında değerlendirir . Aklıma gelen tek gerçek fark, birinin sayısal bağlamlarda NaN, diğerinin değerlendirmesidir 0.

Öyleyse neden her ikisi de var undefinedve nullbu, nullbir özelliğin ayarlanıp ayarlanmadığını bulmaya çalışırken yanlış bir şekilde kontrol eden programcıların kafasını karıştırıyorsa ?

Bilmek istediğim şey, kullanılması gereken ve bunun yerine nullkullanılarak ifade edilemeyen makul bir örneğe sahip olup olmadığıdır undefined.

Dolayısıyla, genel fikir birliği undefined, 'böyle bir mülkiyet yok' nullanlamına gelirken , 'mülk var, ancak değeri yok' anlamına geliyor gibi görünüyor .

JavaScript uygulamaları bu davranışı gerçekten zorlasaydı undefined, ancak tamamen geçerli bir ilkel değer olsaydı, bununla yaşayabilirim, bu nedenle bu sözleşmeyi bozmak için mevcut mülklere kolayca atanabilir. Bu nedenle, bir özelliğin var olduğundan emin olmak istiyorsanız, inoperatörü veya hasOwnProperty()yine de kullanmanız gerekir . Yani bir kez daha: için ayrı değerler için pratik kullanım nedir undefinedve null?

Aslında undefinedartık kullanımda olmayan ancak istemediğim özelliklerin değerlerini geri almak istediğimde kullanıyorum delete. Onun nullyerine kullanmalı mıyım ?

Soru gerçekten "JS'de neden boş bir değer var?" Değildir - çoğu dilde bir tür boş değer vardır ve genellikle çok yararlı kabul edilir.

Soru, " JS'de neden tanımlanmamış bir değer var ". Kullanıldığı başlıca yerler:

1. ilan ettiğinizde var x;ancak ona atamadığınızda x, tanımsız tutar;
2. işleviniz bildirdiğinden daha az argüman aldığında;
3. var olmayan bir nesne özelliğine eriştiğinizde.

null(1) ve (2) * için de kesinlikle işe yarardı. (3) gerçekten bir istisnayı hemen atmalı ve undefineddaha sonra başarısız olacak bu tuhaflığı geri döndürmek yerine , hata ayıklama zorluğunun büyük bir kaynağıdır.

*: (2) 'nin bir istisna atması gerektiğini de iddia edebilirsiniz, ancak o zaman varsayılan / değişken argümanları için daha iyi, daha açık bir mekanizma sağlamanız gerekir.

Bununla birlikte, JavaScript'in başlangıçta istisnaları yoktu veya bir nesneye belirli bir isim altında bir üyesi olup olmadığını sormanın herhangi bir yolu yoktu - tek yol (ve bazen hala) üyeye erişmek ve ne aldığınızı görmektir. Bunun nullzaten bir amacı olduğu ve ona bir üye atamak isteyebileceğiniz düşünüldüğünde, farklı bir bant dışı değer gerekiyordu. Yani undefined, sizin de belirttiğiniz gibi sorunlu ve asla kurtulamayacağımız başka bir harika JavaScript 'özelliği' var.

Artık kullanımda olmayan ancak silmek istemediğim özelliklerin değerlerini geri almak istediğimde aslında undefined kullanıyorum. Bunun yerine null kullanmalı mıyım?

Evet. undefinedDiğer diller bunun yerine bir istisna oluşturduğunda sinyal vermek için özel bir değer olarak tutun .

nullbir şeyi ayarlamanın nullsize hata verebileceği bazı IE DOM arayüzleri dışında genellikle daha iyidir . Çoğunlukla bu durumda boş dizgeye ayarlamak işe yarayacaktır.

En iyi burada açıklanmıştır , ancak özet olarak:

tanımsız, bir tür ve değerin olmaması ve null, bir değerin olmamasıdır.

Dahası, basit '==' karşılaştırmaları yapıyorsanız, haklısınız, ikisi de aynı çıkıyor. Ama hem türü hem de değeri karşılaştıran === deneyin ve farkı göreceksiniz.

Her ikisine de sahip olmak için herhangi bir neden olduğunu sanmıyorum nullve undefinedçünkü birçok insanın önerdiği tek neden (" undefinedböyle bir değişken / özellik olmadığı anlamına gelir") en azından JavaScript'te geçerli değil. undefineddeğişkenin / özelliğin var olup olmadığını söyleyemem.

console.log(foo);               // "ReferenceError: foo is not defined"
                                // foo does not exist
var foo;
console.log(foo);               // "undefined", a different response
console.log(foo === undefined); // "true", but it does exist

var obj = {};
console.log(obj.hasOwnProperty("foo")); // "false", no such property
obj.foo = undefined;
console.log(obj.hasOwnProperty("foo")); // "true", it exists and has the value "undefined"
console.log(obj.foo === undefined);     // "true", but it does exist

obj.bar = "delete me";
obj.bar = undefined;
console.log(obj.hasOwnProperty("bar")); // "true", not actually deleted
delete obj.bar;
console.log(obj.hasOwnProperty("bar")); // "false", deleted

Gördüğünüz gibi, kontrol etmek foo === undefinedsize foovar olup olmadığını söylemez ve ayar obj.bar = undefinedaslında silinmez bar.

undefined"Varolmayışı" temsil etmesi gereken JavaScript yazarının orijinal amacı olabilir . Ancak uygulama böyle olmadı.

Her ikisine de ihtiyaç duymak tamamen mümkündür. Örneğin, WMI'yi sorgularsanız, boş değere sahip bir sınıf döndürme özelliklerine sahip olmak tamamen mümkündür. Tanımlanmışlardır, sadece o anda boş kalırlar.

JavaScript'in undefined"böyle bir özellik yoktur" ve null"mülkün değeri yoktur" şeklindeki sonucunuzun tamamen doğru olduğunu düşünüyorum. Ve JavaScript kadar dinamik bir dilde çok önemli bir ayrımdır. Ördek yazmanın kullanılması, var olmayan ve bir değere sahip olmayan bir özelliği ayırt edebilmemiz gerektiği anlamına gelir. Tür bilgilerini elde etmenin birincil yoludur. statik olarak yazılmış bir dilde, bir alanın boş olması ile mevcut olmayan bir alan arasında kesin bir ayrım vardır. JavaScript'te bu farklı değil. Ancak çalışma zamanında kontrol edilir ve o zamana kadar değiştirilebilir.

Çoğu zaman ayrım bulanık olduğu için uygulamanın tuhaf olduğunu kabul etmek zorundayım. Bununla birlikte, JavaScript'te ayrımın önemli olduğunu düşünüyorum. Ve atama yapabilmek undefinedesastır.

Bir süre önce JavaScript ile yazılmış bir çevrimiçi RPG hakkında bir blog yazısı okuduğumu hatırlıyorum. Nesnelerin prototipler (sınıflar, işlevler, her neyse) yerine mevcut örneklerin kopyaları olarak oluşturulduğu ve daha sonra değiştirildiği örnekler kullandı. Bu gerçekten undefinedvar olan nesneleri değiştirirken bunun ne kadar güçlü olabileceğini anlamamı sağladı , ancak onu kimin yazdığını hatırlayamıyorum.

Anlamsal olarak farklı şeyler ifade ederler. Null türünün etki alanında tam olarak bir değeri vardır, null ve bu özel değere bir özellik atanabilir. Tanımsız, atanmış herhangi bir değerin belirgin bir eksikliğini gösterir.

Bir Java programcısı olarak, undefined ve null arasında büyük bir fark görüyorum. JavaScript kodlama, o kadar değil, çünkü JavaScript güçlü bir şekilde yazılmamıştır ve tanımsız ve boş arasındaki farklar, çalışma zamanı tarafından sıklıkla gerçekleştirilen otomatik dönüştürmeler tarafından bulanıklaştırılır. BTW, bu dönüşümlerden sık sık yararlanıyorum; JS kodumu daha kompakt ve okunabilir hale getiriyorlar.

Sorunuzu yanıtlamak için, tanımsız, bir değerin asla ayarlanmadığı anlamına gelir. Pratik olarak konuşursak, bu genellikle bir hataya işaret eder. YourObject.property undefined ise, bu, özelliği herhangi bir nedenle ayarlamadığınız veya hiç var olmayan bir şey arıyorum demektir. Birden fazla kodlayıcı ile bir proje üzerinde çalışırken bu gerçek bir sorundur.

null, "değer yok" ifadesinin açıkça ayarlandığı anlamına gelir. Pratik olarak konuşursak, bana mülk hakkında, belki de bu bağlamda kullanılmadığını veya henüz bir değerin belirlenmediğini söylüyorsunuz.

Java'da, tanımlanmamış bir alana erişme girişimleri her zaman bir istisnayla sonuçlanır. Aslında, derleyicinin kodunuzda sizi bu konuda uyarması sağlanabilir.

Bu örneği deneyin:

<html>
<head>
    <script type="text/javascript">
        function ShowObjProperties(obj) {
            var property, propCollection = "";

            for(property in obj) {
                propCollection += (property + ": " + obj[property] + "\n");
            }

            alert(propCollection);
        }

        var obj = {
            userid: 3,
            name: 'me!',
            speak: function() { alert('Hi! My name is ' + this.name + ' and my ID is ' + this.userid + '.'); }
        }

        //Shows all properties
        ShowObjProperties(obj);

        //The Speak function is no longer in the list!
        delete obj.speak;
        alert(typeof obj.speak);
        ShowObjProperties(obj);

        //The UserID is still listed, it just has no value!
        obj.userid = null;
        ShowObjProperties(obj);
    </script>
</head>
<body>

</body>
</html>

Burada 2 farklı tip için çok gerçek bir kullanım olduğunu düşünüyorum.

Sonuç olarak javascripts dinamik doğası var.

Şeyler daha sonra eklenebilmeleri için tanımlanmamış olabilir. Muhtemelen javascript'in bu kadar güçlü ve genişletilebilir olmasının nedeni budur.

Programınızı javascript'in olaylı paradigması etrafına sararsanız, bu önemli bir dil özelliğidir.

// a key exists as a placeholder for something
if(obj[name] === null) 
// no key exists int eh hashtable that is in this object
if(obj[name] === undefined)

Varsayılan eylemi belirtmek için 'hiçbir şey' kullanmaktan farklı bir eylemi belirtmek için 'hiçbir şey'i temsil edecek bir değere ihtiyaç duyan bir veri kümesiyle uğraşıyorsanız bu çok kullanışlıdır.

filter_func_pt = {
  date:function(d){ return Math.round(d.getTime()/1000);},
  user: null,
}

function transform(obj){
    var ret = {};
    for( var prop in obj){
       var f = filter_func_pt[prop];
       if(f)
          ret[prop] = f(obj);
       else if(filter_func_pt[prop] === null)
         continue;
       else
         ret[prop] == obj;
    }
  return ret;
}

var a = {
   date: new Date(),
   user: 'sam'
   votes: [23, 41, 55] 
};

var b = transform(a);

/* b = {
 *    date: 1298582417
 *    votes: [23, 41, 55]
 * }
 */

Yukarıdaki kodda null anahtar kelime ve tanımsız sunucu çok açık ve farklı amaçlar. tanımsız döndüren filter_func_pt nesnesinde bulunmayan arama , özelliği dönüş nesnesine olduğu gibi eklemek için araçlar, boş bir değer ise değerin saklanması ve eklenmemesi gerektiğini ve bunda herhangi bir gerçek değerin varlığını belirtir. case, değeri ret nesnesine eklemeden önce dönüştürmek için kullanılan bir işlevi temsil eder .

boş güzeldir

diğer tüm Canlı Komut Dosyası Türleri gibi.

cite: JavaScript'te temelde 'Ben yokum' diyen iki değer vardır - tanımsız ve boş.

Neden yanlış şeyler söylemek istersiniz ?!

"boş" olduğunu "boş Nesne" sadece "0" bir olduğu gibi "boş Numara" . 0, hiçbir şey değildir - ancak bir Sayı Türü olarak var olur. null elbette boştur ama "öyle" ve bir Nesne Türü için iyi tanımlanmış bir şey .

Bu şeylerden, olmadıkları zaman "tipler" olarak bahsetmek yaygındır. Aslında bunlar "kategoriler" dir. Ama artık bitti.

Bu nedenle, "boş" un bir Türü olmayan bir Nesne Türü olduğunu söylemeye devam edeceğiz. Ve "boş" der ki "Ben çok varım [!], Ama benim türümden içeriğim yok".

Oysa tanımsız , hem Tür hem de Tür'den yoksundur; burada tanımsız , aynı zamanda Tür tanımıdır. Tanımlanmamış bir tür türü, onun ayırt edici tipolojisi haline gelir. Bir tür ["hiçbir şey" yoktur ve "hiçbir şey" i nasıl tanımlarsınız?] Sorusu.

cite: undefined veya null, her ikisi de boş bir nesneye dönüştürücü olacağından, bir yapıcı işlevinden döndürülebilir

Bir kez daha yanlış bir şey söylemeyi başardın. Tabii ki hayır, "tanımlanmamış" bir Nesne değil, biz insanların anladığı basit bir Token; ama bu boşluğun aksine - ve size şunu söylüyor: Türü doğru, ama aradığınız Tür onun içinde yok veya en azından şu anda değil. Daha sonra, içine bir nesne \ atadığımızda bizi ziyaret edin.

cite: Aklıma gelen tek gerçek fark, birinin NaN, diğerinin sayısal bağlamlarda 0 olarak değerlendirilmesidir.

Bu, belirtildiği gibi temel ayrımının tüm noktasını yapar: tanımsız , basit bir belirteçtir ve uzak akrabalarıyla aynı 'genetik' materyalden oluştuğu için: dizeler, [+ tanımsız] işlem onu ​​baş aşağı çevirecektir. NaN, benzer şekilde null, tabii ki kendisini doğru bir 0 \ Number türüne dönüştürecektir ve tanımsız olanın aksine, bu bir dizgeye dönüşecektir (! Boş değildir!) Ve bu yüzden bunun yerine NaN verir . Nerede: + undefined >> + "undefined" >> NaN. Sayısal bağlam açık bir değer beklediğinden.

Boole bağlamı referans beklerken - dönüştürülecek hiçbir şey bulmaz ve 'false' verir.

Şimdi keselim ...

cite: O halde bir kez daha: undefined ve null için ayrı değerler için pratik kullanım nedir?

Size sadece iki ampirik örnek vermeye çalışacağım ve yeterli olmasını umacağım

oElement.onclick >> null

// -özellik var demektir; beklenen değeri Type: Object ve bu oElement "onclick" olayını destekliyor!

oElement.innerText >> ""

// anlamına gelir - özellik var; beklenen değeri Type: String'dir , bu, oElement'in "innerText" özelliğini desteklediği anlamına gelir.

her iki durumda da - "tanımsız" mesajı alırsanız bu, mülkün mevcut olmadığı anlamına gelir; desteklenmiyor veya yanlış (ua satıcı) bir uygulamaya sahip.

Donmaya devam edin ve eğlenin.

undefined ve null ile ilgili harika tartışmaları okuduktan sonra, google'daki küçük arama beni Mozilla Belgelerine götürdü https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null bundan bahsediliyor - genellikle boş bir nesnenin beklenebileceği ancak hiçbir nesnenin ilgili olmadığı bir yerde geri alınır.

Boş nesne desenine benzer değil https://en.wikipedia.org/wiki/Null_object_pattern

Sanırım bu Null veri türüne sahip olmak mantıklı.

Belgelerde ayrıca typeof null // "nesne" olarak bahsedilir (eski nedenlerden dolayı "boş" değil)

Eski nedenlerin ne olduğundan emin değilim