JavaScript'te null ve undefined arasındaki fark nedir?

Ben fark arasındaki farkın ne bilmek istiyorum nullve undefinedJavaScript.

JavaScript'te, undefinedbir değişkenin bildirildiği, ancak henüz bir değer atanmamış olduğu anlamına gelir:

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

nullbir atama değeridir. Değişkene değersiz bir gösterim olarak atanabilir:

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

Yukarıda verilen örneklerden, açık undefinedve nulliki farklı tipi vardır: undefinediken bir tür (tanımlanmamış) kendisi nullbir amacıdır.

null === undefined // false
null == undefined // true
null === null // true

ve

null = 'value' // ReferenceError
undefined = 'value' // 'value'

Bunu buradan seçtim

Undefined değeri, bir değişkene değer atanmadığında kullanılan ilkel bir değerdir.

Null değeri, null, boş veya var olmayan referansı temsil eden ilkel bir değerdir.

Bir değişkeni var üzerinden bildirir ve ona bir değer vermezseniz, değeri undefined olur. Kendi başına, bu değeri WScript.Echo () veya alert () yapmaya çalışırsanız, hiçbir şey görmezsiniz. Ancak, buna boş bir dize eklerseniz aniden görünecektir:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

Bir değişkeni bildirebilir, null olarak ayarlayabilirsiniz ve "undefined" yerine "null" çıktısını görmeniz dışında davranış aynıdır. Bu gerçekten küçük bir fark.

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

Bununla birlikte, bunların iki farklı tip olduğu düşünülmektedir. Undefined tek başına bir tür olsa da, null özel bir nesne değeri olarak kabul edilir. Bunu, bir değişkenin genel türünü temsil eden bir dize döndüren typeof () kullanarak görebilirsiniz:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

Yukarıdaki komut dosyasını çalıştırmak aşağıdaki çıktıyı verir:

undefined
object

Farklı türlerinden bağımsız olarak, herhangi bir üyeye erişmeye çalışırsanız aynı davranırlar, örneğin bir istisna atarlar. WSH ile, "varname" in null olduğunu veya bir nesne olmadığını göreceksiniz ve bu şanslıysanız (ama bu başka bir makalenin konusu).

Bir değişkeni tanımsız olarak tanımlayabilirsiniz, ancak buna karşı kesinlikle tavsiye ederim. Değişkenleri null olarak ayarlamanızı ve ayarlamayı unuttuğunuz şeyler için değeri tanımsız bırakmanızı öneririm. Aynı zamanda, her değişkeni her zaman ayarlamanızı gerçekten öneririm. JavaScript, C tarzı dillerden farklı bir kapsam zincirine sahiptir, hatta deneyimli programcıları bile kolayca karıştırabilir ve değişkenleri null değerine ayarlamak, hatalara dayanmanın en iyi yoludur.

Tanımsız açılır pencere göreceğiniz başka bir örnek, delete operatörünü kullanmaktır. Bir C dünyasındaki insanlar bunu bir nesneyi yok etmek olarak yanlış yorumlayabiliriz, ama öyle değil. Bu işlemin bir diziyi bir Diziden veya bir üyeyi Nesneden kaldırmaktır. Diziler için uzunluğu etkilemez, bunun yerine alt simge artık tanımsız olarak kabul edilir.

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

Yukarıdaki komut dosyasının sonucu:

0.) a
1.) undefined
2.) c

Ayrıca, hiç var olmayan bir aboneliği veya üyeyi okurken tanımsız bir şekilde geri gönderilirsiniz.

Null ve undefined arasındaki fark şudur: JavaScript hiçbir zaman null değerine hiçbir şey ayarlamaz, genellikle yaptığımız budur. Değişkenleri tanımsız olarak ayarlayabilmemize rağmen null'u tercih ediyoruz çünkü bu bizim için şimdiye kadar yapılmış bir şey değil. Hata ayıkladığınız zaman bu, null değerine ayarlanmış herhangi bir şeyin JavaScript değil kendi yaptığınız anlamına gelir. Bunun ötesinde, bu iki özel değer neredeyse eşdeğerdir.

(karakter eksikliğinden dolayı karakterler eklediğim için bunu göndermeme izin verildi.)

null , değerin olmadığını gösteren özel bir anahtar kelimedir.

bir değer olarak düşünün, örneğin:

• "foo" dizgidir,
• true boolean,
• 1234 sayıdır,
• null tanımsız.

undefined özelliği, bir değişkene null dahil bir değer atanmadığını gösterir. Sevmek

var foo;

tanımlı boş değişken nullveri tipindedirundefined

Her ikisi de değeri olmayan bir değişkenin değerini temsil ediyor

AND değeri olmayan nullbir dizeyi temsil etmez - boş dize

Sevmek

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

Şimdi eğer

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

FAKAT

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

Yani her birinin kendi kullanma yolu var

undefined değişken veri türünü karşılaştırmak için kullan

null değişkenin değerini boşaltmak için kullan

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

null : değişken için değer yokluğu; undefined : değişkenin kendisi yokluğu;

..where değişkeni, bir değerle ilişkilendirilmiş sembolik bir addır.

JS, yeni bildirilen değişkenleri null ile dolaylı olarak başlatacak kadar nazik olabilir , ancak değildir.

Lütfen aşağıdakileri dikkatlice okuyunuz. JavaScript'te null ve undefined arasındaki farkla ilgili tüm şüphelerinizi kaldıracaktır . Ayrıca, türleri tam olarak belirlemek için aşağıda verilen yardımcı program işlevini kullanabilirsiniz.

JavaScript'te aşağıdaki değişken türlerine sahip olabiliriz.

1. Beyan Edilmeyen Değişkenler
2. Beyan Edilen, ancak Atanmamış Değişkenler
3. Değişmez tanımsız olarak atanan değişkenler
4. Değişmez olarak atanan değişkenler null
5. Tanımlanmamış veya boş dışında herhangi bir şeyle atanan değişkenler

Aşağıda bu davaların her biri tek tek açıklanmaktadır

1. Beyan Edilmeyen Değişkenler : Aşağıdaki, beyan edilmemiş değişkenler için geçerlidir

   • Yalnızca 'undefined' dizesini döndüren typeof () tarafından kontrol edilebilir
   • == veya === veya if veya koşullu operatör tarafından kontrol edilemiyor mu? (Referans Hatası verir)

2. Beyan Edilen, ancak Atanmamış Değişkenler

   • typeof 'undefined' dizesini döndürür
   • == null döndürmelerle kontrol true
   • == tanımsız getirilerle kontrol et true
   • === ile onay boş döner FALSE
   • === undefined döndürmelerle kontrol true
   • if veya koşullu operatör ? yanlış döndürür

3. Değişmez tanımlanmamış olarak atanan değişkenler: Bu değişkenler Bildirilen Ancak Atanmamış Değişkenlere benzer şekilde ele alınır .

4. Değişmez olarak atanan değişkenler null

   • typeof 'object' dizesini döndürür
   • == null döndürmelerle kontrol true
   • == tanımsız getirilerle kontrol et true
   • === null döndürmelerle kontrol true
   • === tanımsız getirilerle kontrol yanlış
   • if veya koşullu operatör ? yanlış döndürür

5. Tanımlanmamış veya boş dışında herhangi bir şeyle atanan değişkenler

   • typeof şu dizelerden birini döndürür: 'string' , 'number' , 'boolean' , 'function' , 'object' , 'symbol'

Bir değişkenin doğru tip kontrolü için algoritma aşağıda verilmiştir:

1. Olup olmadığını kontrol edin bildirilmemiş / atanmamış / ile atanan tanımsız kullanarak typeof . 'undefined' dizesi döndürülürse return .
2. === kullanarak null olup olmadığını kontrol edin . return'in 'boş' eğer doğruysa .
3. Typeof kullanarak gerçek türü kontrol edin . 'nesneye' eşit değilse dönüş türü
4. Gerçek nesne türünü belirlemek için Object.prototype.toString.call (o) öğesini çağırın . Tüm yerleşik Javascript veya DOM tanımlı Nesneler için '[object ObjectType]' türünde bir dize döndürür . Kullanıcı tanımlı nesneler için '[object Object]' döndürür

Türleri belirlemek için aşağıdaki yardımcı programı işlevini de kullanabilirsiniz. Şu anda tüm ECMA 262 2017 tiplerini desteklemektedir.

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


    //Indexed Collection and Helper Types:13
     case '[object Array]': type='array';break;
     case '[object Int8Array]': type='int8array';break;
     case '[object Uint8Array]': type='uint8array';break;
     case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
     case '[object Int16Array]': type='int16array';break;
     case '[object Uint16Array]': type='uint16array';break;
     case '[object Int32Array]': type='int32array';break;
     case '[object Uint32Array]': type='uint32array';break;
     case '[object Float32Array]': type='float32array';break;
     case '[object Float64Array]': type='float64array';break;
     case '[object ArrayBuffer]': type='arraybuffer';break;
     case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
     case '[object DataView]': type='dataview';break;

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

Undefined öğesinin sistem düzeyinde, beklenmedik veya hata benzeri bir değer yokluğunu ve null değerini program düzeyinde, normal veya beklenen değer yokluğunu temsil etmek için kullanabilirsiniz.

JavaScript ile: Kesin Kılavuz

Ben açıklayacağım undefined, nullve Uncaught ReferenceError:

1 - Uncaught ReferenceError: değişken betiğinizde bildirilmedi, bu değişkene referans yok
2 - undefined: Değişken bildirildi ancak başlatılmadı
3 - null: Değişken bildirildi ve boş bir değer

Tanımsız, bir değişkenin bildirildiği, ancak değeri olmadığı anlamına gelir:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Null bir ödevdir:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

null ve undefined , aşağıdakilere ortak olarak sahip olan iki farklı nesne türüdür:

• her ikisi de sırasıyla null ve undefined olmak üzere yalnızca tek bir değeri tutabilir ;
• her ikisinin de özellikleri veya yöntemleri yoktur ve ikisinin herhangi bir özelliğini okuma girişimi bir çalışma zamanı hatasına neden olur (diğer tüm nesneler için, var olmayan bir özelliği okumaya çalışırsanız tanımsız değer alırsınız );
• null ve undefined değerleri , operatörler tarafından birbirine ==ve başka hiçbir şeye eşit kabul edilmez !=.

Ancak benzerlikler burada sona eriyor. Bir kerelik, null ve undefined anahtar kelimelerinin nasıl uygulandığı konusunda temel bir fark vardır. Bu açık değildir, ancak aşağıdaki örneği göz önünde bulundurun:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

undefined , NaN ve Infinity sadece önceden başlatılmış "süper küresel" değişkenlerin isimleridir - çalışma zamanında başlatılırlar ve aynı adlara sahip normal küresel veya yerel değişken tarafından geçersiz kılınabilirler.

Şimdi null ile aynı şeyi deneyelim :

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

Hata! null , true ve false ayrılmış anahtar kelimelerdir - derleyici bunları değişken veya özellik adları olarak kullanmanıza izin vermez

Başka bir fark, undefined öğesinin ilkel bir türken null bir nesne türüdür (bir nesne referansının yokluğunu gösterir). Aşağıdakileri göz önünde bulundur:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

Ayrıca, null ve undefined işlevlerinin sayısal bağlamda ele alınış biçiminde önemli bir fark vardır:

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

null , aritmetik ifadelerde veya sayısal karşılaştırmalarda kullanıldığında 0 olur - false değerine benzer şekilde , temelde yalnızca özel bir tür "sıfır" dır. undefined ise, gerçek bir "hiçbir şey " değildir ve sayısal bağlamda kullanmaya çalıştığınızda NaN ("bir sayı değil") olur.

Not null adlı ve tanımsız bir özel muamele ==ve !=operatörler, ancak gerçek sayısal eşitliğini test edebilirsiniz bir ve b ifadesi ile (a >= b && a <= b).

tl; Dr.

nullNesne olduğunu bildiğiniz bir değişkeni ayarlamak için kullanın .

undefinedTürü karışık olan bir değişken ayarlamak için kullanın .

Bu benim hem 5 ilkeli hem de Nesne türünü kullanmam ve undefinedveya “kullanım örneği” arasındaki farkı açıklıyor null.

sicim

Bir değişkenin tüm yaşam döngüsü yalnızca bir dize olduğunu biliyorsanız, kural olarak, bunu şu şekilde başlatabilirsiniz "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

Numara

Eğer bir değişken tüm yaşam döngüsü, Kongre tarafından, size, bunu ilklendireceğiniz ise sadece bir sayıdır biliyorsanız 0(veya NaNeğer 0sizin kullanımında önemli bir değerdir):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

veya

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

Boole

Bir değişkenin tüm yaşam döngüsü yalnızca bir boolean olduğunu biliyorsanız, kural olarak, bunu şu şekilde başlatabilirsiniz false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

Nesne

Bir değişkenin yalnızca tüm Nesne döngüsü sırasında bir Nesne olduğunu biliyorsanız, kural olarak, bunu şu şekilde başlatabilirsiniz null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Not: null kapalı akıllı kullanım , bir Object'in her zaman olduğu ve dönüş nedeniyle bir Object'in falsy versiyonu olacaktır . Bu , hem Object hem de null tip için tutarlı tutarlı dönüş anlamına gelir .truetypeof nullobjecttypeof myVarObject

Herşey

Bir değişkenin karışık bir türü (tüm yaşam döngüsü sırasında herhangi bir tür) olduğunu biliyorsanız, kural olarak, öğesini başlatabilirsiniz undefined.

null"değer yok" anlamına gelen özel bir değerdir. 'nesne' döndürdüğü nulliçin özel bir nesnedir typeof null.

Öte yandan, undefineddeğişkenin bildirilmediği veya bir değer verilmediği anlamına gelir.

Farkı anlamanın en iyi yolu, önce JavaScript'in iç işleyişiyle ilgili fikrinizi temizlemek ve sadece aşağıdakiler arasındaki anlam farklılıklarını anlamaktır:

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

Bu üç durum arasında anlam farkı vardır ve JavaScript son iki vakayı iki farklı değerle ayırır nullve undefined. Bu değerleri, bu anlamları aktarmak için açıkça kullanabilirsiniz.

Peki bu felsefi temel nedeniyle ortaya çıkan JavaScript'e özgü sorunlardan bazıları nelerdir?

1. Başlatıcısı olmayan bildirilen bir değişken değeri alır undefinedçünkü amaçlanan değerin ne olduğu hakkında hiçbir şey söylemediniz.

   let supervisor;
   assert(supervisor === undefined);

2. Daha önce hiç ayarlanmamış bir nesnenin bir özelliği olarak değerlendirilir, undefinedçünkü hiç kimse o mülk hakkında hiçbir şey söylememiştir .

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);

3. nullve undefinedbirbirlerine benziyorlar çünkü Brendan Eich öyle dedi. Ancak bunlar kesinlikle birbirine eşit değildir.

   assert(null == undefined);
   assert(null !== undefined);

4. nullve undefinedneyse ki farklı türleri var. nulltürüne ait Nullve undefinedtürüne Undefined. Bu özellikte, ama typeofburada tekrarlamayacağım tuhaflık nedeniyle bunu asla bilemezsiniz .

5. Açık bir dönüş ifadesi olmadan gövdesinin sonuna ulaşan bir işlev, geri döndüğü undefinedhakkında hiçbir şey bilmediğiniz için geri döner .

Bu arada, JavaScript'te başka "hiçlik" biçimleri de var (Felsefe üzerinde çalışmak iyi ...)

• NaN
• Daha önce hiç bildirilmemiş bir değişken kullanma ve ReferenceError
• Geçici ölü bölgesinde letveya consttanımlanmış bir yerel değişken kullanma veReferenceError

• Seyrek dizilerde boş hücreler. Evet , tanımlanmamış olanlarla undefinedkarşılaştırılsa bile bunlar değil ===.

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]

JavasSript'te String, Number, Boolean, null ve undefined olmak üzere 5 temel veri türü vardır. Bazı basit örneklerle açıklamaya çalışacağım

diyelim ki basit bir fonksiyonumuz var

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

ayrıca yukarıdaki fonksiyonda (a == null) (! a) ile aynı ise

şimdi bu fonksiyonu a parametresini geçmeden çağırdığımızda

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

Ayrıca

var a;
alert(typeof a); 

bu tanımsızdır; bir değişken bildirdik ancak bu değişkene herhangi bir değer atamadık; ama yazarsak

var a = null;
alert(typeof a); will give alert as object

yani null bir nesnedir. bir şekilde 'a' için null değeri atadık

İçin undefinedtipi, sadece ve sadece bir değeri vardır: undefined.

İçin nulltipi, sadece ve sadece bir değeri vardır: null.

Yani her ikisi için de etiket hem türü hem de değeridir.

Aralarındaki fark. Örneğin:

• null boş bir değerdir
• undefined eksik bir değer

Veya:

• undefined henüz bir değeri yok
• null bir değeri vardı ve artık yok

Aslında, nullbir olduğunu özel anahtar kelime değil, bir tanımlayıcı ve böylece atanacak bir değişken olarak ele olamaz.

Ancak, undefinedbir tanımlayıcıdır . Bununla birlikte, hem non-strictmod hem de modda strict, tanımsız adının yerel bir değişkenini oluşturabilirsiniz. Ama bu korkunç bir fikir!

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

Javascript'te bir değişken bildirdiğinizde, ona değer atanır undefined. Bu, değişkenin dokunulmamış olduğu ve gelecekte herhangi bir değer atanabileceği anlamına gelir. Ayrıca, bu değişkenin bildirim sırasında tutacağı değeri bilmediğiniz anlamına gelir.

Şimdi açıkça bir değişken atayabilirsiniz null. Bu, değişkenin herhangi bir değeri olmadığı anlamına gelir. Örneğin - Bazı kişilerin göbek adı yoktur. Yani böyle bir durumda null değerini bir person nesnesinin middlename değişkenine atamak daha iyidir.

Şimdi birisinin kişi nesnenizin orta adı değişkenine eriştiğini ve değerinin olduğunu varsayalım undefined. Geliştiricinin bu değişkeni başlatmayı unuttuğunu veya herhangi bir değeri olmadığını bilemezdi. Değeri nullvarsa, kullanıcı aracı adının herhangi bir değeri olmadığını ve el değmemiş bir değişken olmadığını kolayca çıkarabilir.

null ve undefined, her ikisi de bir değerin yokluğunu temsil etmek için kullanılır.

var a = null;

a başlatılır ve tanımlanır.

typeof(a)
//object

null, JavaScript'teki bir nesnedir

Object.prototype.toString.call(a) // [object Object]

var b;

b tanımsız ve başlatılmamış

undefined nesne özellikleri de undefined. Örneğin c nesnesinde "x" tanımlanmamıştır ve cx'e erişmeye çalışırsanız tanımsız olarak geri döner.

Genellikle tanımlanmamış değişkenlere null atarız.

Ryan Morr'un bu konudaki kapsamlı makalesine göre ...

"Genellikle, bir değişkene veya özelliğe değer olmayan bir değer atamanız, onu bir işleve aktarmanız veya bir işlevden döndürmeniz gerekiyorsa, null neredeyse her zaman en iyi seçenektir. Basitçe söylemek gerekirse, JavaScript tanımsız kullanır ve programcılar null kullan. "

Bkz . Null ve Tanımlanmamış Ebedi Uçurumu Keşfetme

JavaScript'te hem Null hem de undefined, değerin olmadığını gösterir.

var a = null; //variable assigned null value
var b;  // undefined

Rağmen her ikisi de değer yokluğu için var ama: Tanımsız aslında değişken başlatılmamış anlamına gelir. Hiçbir şey döndürmeyen işlevler ve değeri girilmeyen işlev parametreleri, tanımsız değer döndürülür. Null ve undefined arasında ayrım yapmak için katı eşitlik operatörü === kullanın.

Referans: http://www.thesstech.com/javascript/null-and-undefined

Tamam, biz deyince karıştı alabilirsiniz nullve undefinedfakat hadi basit, ikisi de vardır başlamak falsy onları anlamlı farklılıklar bir çift yapmak ve birçok yönden benzer, ancak JavaScript garip kısmı, örneğin, typeof null olduğunu 'object'iken typeof undefined olduğunu 'undefined'.

typeof null; //"object"
typeof undefined; //"undefined";

Ancak ==aşağıdaki gibi kontrol ederseniz, her ikisinin de sahte olduğunu görürsünüz :

null==undefined; //true

Ayrıca null, bir nesneye veya ilkel bir öğeye atayabilirsiniz , ancak undefinedhiçbir şeye atamamanız yeterlidir.

Bir bakışta sizin için farklılıkları göstermek için hızlı bir görüntü oluşturuyorum.

Typeof undefined döndürdüğü için undefined, null değeri bir başlatıcı olduğu için değişkenin hiçbir nesneye işaret etmediği bir türdür (Javascript'teki hemen hemen her şey bir nesnedir).

Javascript'te tüm değişkenler anahtar / değer çiftleri olarak saklanır. Her değişken, değişken_adı: değişken_değeri / başvuru olarak depolanır .

undefined , değişkene bellekte boşluk verildiği, ancak değişkene herhangi bir değer atanmadığı anlamına gelir. En iyi uygulama olarak, bu türü atama olarak kullanmamalısınız.

Bu durumda, bir değişkenin kodun sonraki bir noktasında değersiz olmasını istediğinizde nasıl belirtilir? Aynı şeyi, bir değerin yokluğunu tanımlamak için kullanılan bir tür olan null türünü kullanabilirsiniz , ancak tanımlanmamışla aynı değildir, bu durumda aslında bellekteki değere sahipsiniz. Bu değer boş

Her ikisi de benzerdir ancak kullanım ve anlam farklıdır.

Vanilla JavaScript'i (JS) sıfırdan öğrenmeye çalıştığınızda bilmek çok iyi nullve undefinediyi bir fark eklemek istiyorum :

• nullJS'de ayrılmış bir anahtar kelime iken undefined, bulunduğunuz çalışma ortamı ortamının genel nesnesindeki bir değişkendir.

Kod yazılırken, bu fark her ikisi olarak tanımlanamaz nullve undefinedher zaman bir JavaScript ifadesinin RHS'sinde kullanılır. Ancak bunları bir ifadenin LHS'sinde kullandığınızda, bu farkı kolayca gözlemleyebilirsiniz. JS yorumlayıcısı aşağıdaki kodu hata olarak yorumlar:

var null = 'foo'

Aşağıdaki hatayı verir:

Yakalanmayan Sözdizimi Hatası: Beklenmeyen simge null

Her ne kadar gerçek hayatta bunu tavsiye etmeyeceğim rağmen aşağıdaki kod başarıyla çalışır:

var undefined = 'bar'

Bu undefined, genel nesnede (istemci tarafı JS olması durumunda tarayıcı penceresi nesnesi) bir değişken olduğu için çalışır

Arasındaki fark undefinedve nullçok az, ama bir fark yoktur. Değeri undefinedhiç başlatılmamış bir değişken . Değeri bir değişken olan nullaçık bir değer verilmiştir, ki nulldeğişken açıkça bir değere sahip ayarlanmış olduğu anlamına gelir. Karşılaştırırsanız undefinedve ifadeyi nullkullanarak null==undefinedbunlar eşit olur.

Temel olarak Tanımsız , jull değişkeninin çalışma zamanında oluşturduğu global bir değişkendir, null değişkene hiçbir değerin atanmadığı anlamına gelir (aslında null kendisinin bir nesnedir).

Bir örnek verelim:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

Tanımsız olarak çıktı olarak elde edeceğiniz şey budur.

Şimdi,

        x=5;
        y=null;
        z=x+y;

ve çıktı olarak 5 alacaksınız . Tanımsız ve sıfır arasındaki temel fark budur

null - Değeri temsil etmek için değişkenle kullanılan bir atama değeridir (bu bir nesnedir).

undefined - Kendisine atanmış herhangi bir değeri olmayan bir değişkendir, bu nedenle JavaScript ona tanımsız bir değer atayacaktır (bu bir veri türüdür).

bildirilmemiş - Bir değişken hiç oluşturulmamışsa, bildirilmemiş olarak bilinir.

Şuna bir bak. Çıktı bin kelimeye bedeldir.

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

Ayrıca bakınız:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

Şerefe!

Her iki özel değer de boş bir durumu ifade eder.

Temel fark, undefined öğesinin henüz başlatılmamış bir değişkenin değerini, null ise bir nesnenin kasıtlı yokluğunu temsil etmesidir.

Değişken numarası tanımlanır, ancak başlangıç ​​değeri atanmaz:

let number;
number; // => undefined

sayı değişkeni tanımsız, bu da başlatılmamış bir değişkeni açıkça gösteriyor

Aynı başlatılmamış konsept, var olmayan bir nesne özelliğine erişildiğinde gerçekleşir:

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

LastName özelliği obj'de bulunmadığından, JavaScript obj.lastName öğesini tanımsız olarak doğru bir şekilde değerlendirir.

Diğer durumlarda, bir değişkenin nesneyi döndürmek için bir nesneyi veya işlevi tutmayı beklediğini bilirsiniz. Ancak bazı nedenlerden dolayı nesneyi başlatamazsınız. Böyle bir durumda null, eksik bir nesnenin anlamlı bir göstergesidir.

Örneğin, clone (), düz bir JavaScript nesnesini klonlayan bir işlevdir. İşlevin bir nesneyi döndürmesi beklenir:

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

Bununla birlikte, clone () nesne olmayan bir argüman ile çağrılabilir: 15 veya null (veya genellikle ilkel bir değer, null veya undefined). Bu durumda, işlev bir klon oluşturamaz, bu nedenle null değerini döndürür - eksik bir nesnenin göstergesi.

typeof operatörü iki değer arasında ayrım yapar:

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

Sıkı kalite operatörü === undefined öğesini null değerinden doğru şekilde ayırır:

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

Farklı bir anlama ek olarak başka farklılıklar da vardır:

1. Nesne imhası bu iki değer için farklı çalışır:

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null

2. JSON.stringify () tutar, nullancak atlarundefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}

3. operatör türü

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"

Bir değişken başlatılmazsa tanımsızdır. undefined bir nesne değil. Örnek: var Adım; console.log (AdımAdım);

Konsol giriş geliştirme aracını kontrol edin, tanımsız olarak yazdırılacaktır.

null aa nesnesidir.Bazı değişkenin null olmasını istiyorsanız null kullanılır. null değişken var ancak değer bilinmiyor. pro değişkenine grammatik olarak atanmalıdır. null otomatik olarak başlatılmaz.

Örnek: var BenimAdı = boş; console.log (AdımAdım); Csole giriş geliştirme aracını kontrol edin, bir nesne olacaktır.