Null neden bir nesnedir ve null ile undefined arasındaki fark nedir?

Neden JavaScript'te nullbir olarak kabul edilir object?

Kontrol ediyor

if ( object == null )
      Do something

aynı

if ( !object )
      Do something

?

Ve ayrıca:

Arasındaki fark nedir nullve undefined?

(name is undefined)

Siz: Nedir name? ^(*)
JavaScript: name ? Nedir name? Ne hakkında konuştuğunu bilmiyorum. Daha nameönce hiç bahsetmedin . (İstemci-) tarafında başka bir komut dosyası dili görüyor musunuz?

name = null;

Siz: Nedir name?
JavaScript: Bilmiyorum.

Kısacası; undefinedhiçbir şey kavramının olmadığı yer; türü yoktur ve bu kapsamda daha önce hiç başvurulmamıştır; nullşeyin var olduğu biliniyor, ancak değerin ne olduğu bilinmiyor.

Hatırlanması gereken bir şey olduğunu null, kavramsal olarak değil, aynı falseya ""da tip döküm, yani sonra eşit olsa bile, ya da bu tür

name = false;

Siz: Nedir name?
JavaScript: Boolean yanlış.

name = '';

Siz: Nedir name?
JavaScript: Boş dize

^{*: namebu bağlamda, daha önce tanımlanmamış bir değişken olarak kastedilmektedir. Herhangi bir tanımsız değişken olabilir, ancak ad hemen hemen her HTML form öğesinin bir özelliğidir. Yol, geri dönüş ve id'den çok önce kurulmuş. Kimlikleri benzersiz olmak zorundadır, ancak adların olması gerekmez.}

Fark bu snippet'te özetlenebilir:

alert(typeof(null));      // object
alert(typeof(undefined)); // undefined

alert(null !== undefined) //true
alert(null == undefined)  //true

Kontrol etme

object == nullkontrol etmek farklı if ( !object ).

İkincisi eşittir ! Boolean(object), çünkü tekli !operatör sağ işleneni otomatik olarak bir Boole'ye dönüştürür.

O Boolean(null)zaman yanlış olduğu için !false === true.

Sizin nesnedir Yani eğer boş değil , ancak yanlış veya 0 veya "" onay çünkü geçecek:

alert(Boolean(null)) //false
alert(Boolean(0))    //false
alert(Boolean(""))   //false

nullolan bir nesne olup , bu bir temel değer . Örneğin, buna özellik ekleyemezsiniz. Bazen insanlar yanlış bir şekilde bunun bir nesne olduğunu varsayar, çünkü typeof nullgeri döner "object". Ancak bu aslında bir hatadır (ECMAScript 6'da bile düzeltilebilir).

Arasındaki fark nullve undefinedaşağıdaki gibi olduğu:

• undefined: JavaScript tarafından kullanılır ve “değer yok” anlamına gelir. Başlatılmamış değişkenler, eksik parametreler ve bilinmeyen değişkenler bu değere sahiptir.

  > var noValueYet;
  > console.log(noValueYet);
  undefined
  
  > function foo(x) { console.log(x) }
  > foo()
  undefined
  
  > var obj = {};
  > console.log(obj.unknownProperty)
  undefined

  Ancak bilinmeyen değişkenlere erişmek bir istisna oluşturur:

  > unknownVariable
  ReferenceError: unknownVariable is not defined

• null: programcılar tarafından “değer yok” u belirtmek için kullanılır, örneğin bir işleve parametre olarak.

Bir değişkeni inceleme:

console.log(typeof unknownVariable === "undefined"); // true

var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true

var bar = null;
console.log(bar === null); // true

Genel bir kural olarak, JavaScript'te her zaman === ve asla == kullanmamalısınız (== beklenmedik sonuçlar üretebilecek her türlü dönüşümü gerçekleştirir ). Çek x == nullo ikisi için çalıştığı için, bir kenar durumdur nullve undefined:

> null == null
true
> undefined == null
true

Bir değişkenin bir değere sahip olup olmadığını kontrol etmenin yaygın bir yolu, onu boole dönüştürmek ve olup olmadığını görmektir true. Bu dönüşüm, ififade ve boole operatörü tarafından gerçekleştirilir ! ("değil").

function foo(param) {
    if (param) {
        // ...
    }
}
function foo(param) {
    if (! param) param = "abc";
}
function foo(param) {
    // || returns first operand that can't be converted to false
    param = param || "abc";
}

Bu yaklaşımın dezavantajı: Aşağıdaki değerlerin tümü değerlendirilir false, bu yüzden dikkatli olmanız gerekir (örn. Yukarıdaki kontroller undefinedve ile ayırt edilemez 0).

• undefined, null
• Boolean: false
• Sayılar: +0, -0,NaN
• Teller: ""

BooleanBir işlev olarak kullanarak boole dönüşümünü test edebilirsiniz (normalde kullanılacak bir yapıcıdır new):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

Null ve undefined ?? arasındaki fark nedir?

Tanımı olmayan bir özellik tanımsız. null bir nesnedir. Türü nesne. null, "değer yok. undefined bir nesne değil, türü undefined.

Bir değişkeni bildirebilir, null olarak ayarlayabilirsiniz ve "undefined" yerine "null" çıktısını görmeniz dışında davranış aynıdır. Tanımlanmamış bir değişkeni null veya tersi ile de karşılaştırabilirsiniz ve koşul doğru olacaktır:

 undefined == null
 null == undefined

Daha fazla ayrıntı için JavaScript null ve undefined arasındaki farklara bakın .

ve yeni düzenlemenizle evet

if (object == null)  does mean the same  if(!object)

nesnenin yanlış olup olmadığını test ederken, ikisi de yalnızca yanlış olup olmadığını test ederken durumu karşılar , ancak doğru olduğunda değil

Buraya bakın: Javascript gotcha

Sorunun ilk bölümü:

Null neden JavaScript'te bir nesne olarak kabul edilir?

Şimdi düzeltemedikleri bir JavaScript tasarım hatasıdır. Nesne değil, boş olmalı ya da hiç olmamalıdır. Gerçek nesneleri tespit ederken ekstra bir kontrol gerektirir (bazen unutulur) ve hata kaynağıdır.

Sorunun ikinci kısmı:

İle


if (object == null)
Do something

aynı kontrol ediyor

if (!object)
Do something

İki kontrol aşağıdakiler dışında her zaman yanlıştır:

• nesne tanımsız veya null: her ikisi de true.

• nesne ilkel ve 0 ""veya yanlış: ilk önce yanlış, ikinci doğru.

Nesne ilkel değil, ama gerçek bir nesne gibi olursa new Number(0), new String("")ya new Boolean(false)sonra her iki kontroller yanlış.

Eğer 'nesne' gerçek bir Nesne olarak yorumlanırsa, her iki kontrol de hep aynıdır. İlkellere izin verilirse, kontroller 0 "", ve yanlış için farklıdır .

Böyle durumlarda object==null, net olmayan sonuçlar bir hata kaynağı olabilir. Kullanımı ==hiç önerilmez, ===bunun yerine kullanın.

Sorunun üçüncü kısmı:

Ve ayrıca:

null ve undefined arasındaki fark nedir?

JavaScript'te bir fark, null türünün nesne ve undefined öğesinin undefined türünde olmasıdır.

JavaScript'te null==undefineddoğrudur ve tür yoksayılırsa eşit kabul edilir. Buna neden karar verdiler, ama 0 ""ve yanlış eşit değil, bilmiyorum. Keyfi bir görüş gibi görünüyor.

JavaScript'te, null===undefinedtürün aynı olması gerektiğinden doğru değildir ===.

Gerçekte, null ve undefined aynıdır, çünkü her ikisi de yokluğu temsil eder. Öyleyse 0 yapın, ""bu nedenle de boş kapları []ve {}. Aynı şeylerin pek çok türü böcekler için bir reçetedir. Bir tür veya hiçbiri daha iyi değildir. Mümkün olduğunca az kullanmaya çalışıyordum.

'yanlış', 'doğru' ve '!' örneğin basitleştirilebilecek başka bir solucan torbası if(!x)veif(x) tek başına yeterli, doğru ve yanlışa ihtiyacınız yok.

Bildirilen bir var xdeğer verilmemişse, bildirilen tür undefined'dir, ancak x hiç bildirilmediği gibi olmalıdır. Başka bir hata kaynağı boş bir şey kapsayıcısıdır. Bu yüzden, birlikte ilan etmek ve tanımlamak en iyisidir var x=1.

İnsanlar, tüm bu çeşitli şeyleri anlamaya çalışan çevrelerde dolaşıyorlar, ancak hepsi karmaşık farklı kıyafetlerde aynı şey. Gerçek şu ki

undefined===undeclared===null===0===""===[]==={}===nothing

Ve belki de herkes istisnalar atmalıdır.

var x = null;

x null olarak tanımlanır

y tanımlanmamıştır; // çünkü tanımlamadım

if (!x)

null yanlış olarak değerlendirilir

Null ve undefined anlamlarını anlamanın bir yolu, her birinin nerede meydana geldiğini anlamaktır.

Aşağıdaki durumlarda boş bir dönüş değeri bekleyin:

• DOM'yi sorgulayan yöntemler

  console.log(window.document.getElementById("nonExistentElement"));
  //Prints: null

• Bir Ajax isteğinden alınan JSON yanıtları

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• Akı durumundaki yeni işlevsellik. Aşağıdakiler null değerini döndürür:

        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

        Object.getOwnPropertyDescriptor({}, "a");

Diğer tüm var olmama durumları tanımlanmamıştır (@Axel tarafından belirtildiği gibi). Aşağıdaki baskıların her biri "tanımsız" olarak yazdırılır:

    var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());        

Elbette var unitialised = null; veya bir yöntemden null değerini kendiniz döndürdüğünüzde, başka durumlarda null değeri oluşur. Ama bu oldukça açık olmalı.

Üçüncü durum, bir değişkene erişmek istediğinizde, ancak değişkenin bildirilip bildirilmediğini bilmemenizdir. Bu durumda, bir referans hatasını önlemek için typeof komutunu kullanın:

if(typeof unknown !== "undefined"){
    //use unknown
}

Özet olarak DOM'yi manipüle ederken, Ajax ile uğraşırken veya belirli ECMAScript 5 özelliklerini kullanırken null olup olmadığını kontrol edin. Diğer tüm durumlar için katı eşitlikle tanımsız olup olmadığını kontrol etmek güvenlidir:

if(value === undefined){
  // stuff
}

JavaScript'teki birçok farklı null denetimin karşılaştırılması:

http://jsfiddle.net/aaronhoffman/DdRHB/5/

// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;

...trim...

http://aaron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html

null ve undefined değerleri eşitlik için false (null == undefined): ikisi de boolean false değerine daraltır. Aynı nesne değiller (null! == undefined).

undefined, global nesnenin (tarayıcılarda "pencere") bir özelliğidir, ancak bir nesnenin kendisi değil, ilkel bir türdür. Bir return deyimi olmadan biten başlatılmamış değişkenler ve işlevler için varsayılan değerdir.

null bir Object örneğidir. null, boş bir sonucu belirtmek için toplama nesnelerini döndüren DOM yöntemleri için kullanılır; bu, bir hata belirtmeden yanlış bir değer sağlar.

Bazı kesinlikler:

boş ve tanımlanmamış olan iki farklı değerler. Biri bir isim için bir değerin yokluğunu, diğeri ise bir ismin yokluğunu temsil ediyor.

ifAşağıdaki gibi bir gidişte ne olur?if( o ) :

Parantez o içindeki ifade değerlendirilir ve daha sonra ifparantez içindeki ifadenin değerini tipte zorlayan tekmeler - bizim durumumuzdao .

JavaScript'teki Falsy (false değerine zorlanacak) değerler şunlardır: '', null, undefined, 0 ve false .

Verilen yanıta eklemek için aralarında aradaki fark nedir undefinedvenull gelen JavaScript Kesin Kılavuzu 6th Edition, bu sayfadaki s.41 :

undefinedSistem düzeyinde, beklenmedik veya hata benzeri bir değer nulleksikliğini ve program düzeyinde, normal veya beklenen değer eksikliğini temsil etmeyi düşünebilirsiniz . Bu değerlerden birini bir değişkene veya özelliğe atamanız veya bu değerlerden birini bir işleve geçirmeniz gerekiyorsa null, neredeyse her zaman doğru seçimdir.

nullbir nesnedir. Türü null. undefinedbir nesne değildir; türü tanımsız.

Aşağıdaki işlev, farkı neden ve neden çözümleyebildiğini gösterir:

function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

Eğer ararsan

test();

Alıyorsun

Tanımsız

boş

İlk console.log(...)çalışır almak için myPropertygelen myObjhenüz tanımlanmamış ise - geri "tanımsız" alır böylece. Null değerini atadıktan sonra, ikincisi var console.log(...)olduğu için "null" olduğu açıktır myProperty, ancaknull atanan .

Sipariş bu farkı sorgulamak için muktedir olarak, JavaScript sahiptir nullve undefined: iken null- sadece bir nesne dillerde olduğu gibi, undefinedhiçbir örneği (hatta bir olmadığından bir nesne olamaz nullmevcut örneği).

Örneğin window.someWeirdProperty tanımsız, yani

"window.someWeirdProperty === null" yanlış olarak değerlendirir

"window.someWeirdProperty === undefined" doğru olarak değerlendirir.

Üstelik checkif if (!o)kontrol aynı değildir if (o == null)için ovarlık false.

Null ile ilgili tanımlanmamış olan diğer eğlenceli şey, artırılabilmesidir.

x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

Bu, sayaçlar için varsayılan sayısal değerleri ayarlamak için kullanışlıdır. Bir değişkeni bildiriminde kaç kez -1 olarak ayarladınız?

In JavaScript null bir değil objectbir olan tip primitavetürü.

Fark ne? Tanımsız , ayarlanmamış bir işaretçiyi ifade eder. Null , null işaretçiyi ifade eder; örneğin, bir şey bir değişkeni el ile tür olarak ayarlamıştırnull

Şuna bak:

   <script>
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}
</script>
                                          //return:
<button onclick="f()">nothing</button>    //undefined    null    false
<button onclick="f(null)">null</button>   //object       null    false
<button onclick="f('')">empty</button>    //string               false
<button onclick="f(0)">zero</button>      //number               false
<button onclick="f(1)">int</button>       //number               true
<button onclick="f('x')">str</button>     //string               true

Nicholas C. Zakas'ın "Nesneye Dayalı Javascript İlkeleri" nden

Fakat niçin tür boş olduğunda bir nesne? (Aslında bu, JavaScript'i tasarlayan ve sürdüren komite TC39 tarafından bir hata olarak kabul edilmiştir. Null değerinin, "nesne" yi mantıksal bir dönüş değeri haline getiren boş bir nesne işaretçisi olmasına neden olabilirsiniz, ancak bu yine de kafa karıştırıcıdır.)

Zakas, Nicholas C. (2014-02-07). Nesneye Dayalı JavaScript İlkeleri (Kindle Locations 226-227). Nişasta Bastırma Yok. Kindle Sürümü.

Bahsedilen:

var game = null; //typeof(game) is "object"

game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

Tanımsız vaka:

var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.

'Null' düşünmenin en iyi yolu, benzer kavramın veritabanlarında nasıl kullanıldığını hatırlamaktır; burada bir alanın "hiç değer içermediğini" gösterir.

• Evet, öğenin değeri bilinir; Bu edilir 'tanımlandığı gibidir.' Bu gelmiştir başlatıldı.
• Öğenin değeri: "değer yok."

Bu, daha kolay hata ayıklanan programlar yazmak için çok kullanışlı bir tekniktir. Bir 'tanımsız' değişken bir hata ... kaynaklanıyor olabilir (eğer bilemez nasıl?) ... ama değişken değerini içeriyorsa 'null,' sen, bu programda o "birisi, bir yere biliyorum ayarlamak için "null." "Bu nedenle, bir değişkenin değerinden kurtulmanız gerektiğinde" silmeyin "... 'null' olarak ayarlanmasını öneriyorum. Eski değer yetim kalacak ve yakında çöp toplanacak; yeni değer "artık değer yok" şeklindedir. Her iki durumda da, değişkenin durumu kesindir: "belli ki, kasıtlı olarak, bu şekilde var."

1. Tanımsız, bir değişkenin bildirildiği, ancak herhangi bir değerin atanmadığı anlamına gelirken Null, "değer yok" u temsil eden bir değişkene atanabilir. (Null, bir atama operatörüdür)

Null bir nesne iken 2.Tamamlanmamış bir tür kendisi.

Javascript, atanmamış herhangi bir değişkeni tanımsız olarak başlatabilir, ancak hiçbir zaman değişkenin değerini null olarak ayarlayamaz. Bu programlı olarak yapılmalıdır.