ความแตกต่างระหว่าง null และไม่ได้กำหนดใน JavaScript คืออะไร?

ฉันต้องการทราบความแตกต่างระหว่างnullและundefinedใน JavaScript

ใน JavaScript undefinedหมายถึงตัวแปรได้รับการประกาศแล้วแต่ยังไม่ได้รับการกำหนดค่าเช่น:

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

nullเป็นค่าที่ได้รับมอบหมาย มันสามารถถูกกำหนดให้กับตัวแปรเป็นการแทนค่าไม่มี:

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

จากตัวอย่างก่อนหน้านี้เป็นที่ชัดเจนว่าundefinedและnullเป็นสองประเภทที่แตกต่าง: undefinedเป็นประเภทของตัวเอง (ไม่ได้กำหนด) ในขณะที่nullเป็นวัตถุ

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

และ

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

ฉันเลือกสิ่งนี้จากที่นี่

ค่าที่ไม่ได้กำหนดเป็นค่าดั้งเดิมที่ใช้เมื่อตัวแปรไม่ได้รับการกำหนดค่า

ค่า Null เป็นค่าดั้งเดิมที่แสดงการอ้างอิง Null, เปล่าหรือไม่มีอยู่

เมื่อคุณประกาศตัวแปรผ่าน var และไม่ให้ค่ามันจะมีค่าที่ไม่ได้กำหนด ถ้าคุณลองใช้ WScript.Echo () หรือ alert () ค่านี้คุณจะไม่เห็นอะไรเลย อย่างไรก็ตามหากคุณต่อท้ายสตริงว่าง ๆ สตริงนั้นจะปรากฏขึ้นทันที:

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

คุณสามารถประกาศตัวแปรตั้งค่าเป็นโมฆะและลักษณะการทำงานนั้นเหมือนกันยกเว้นว่าคุณจะเห็น "null" พิมพ์ออกมาเมื่อเทียบกับ "ไม่ได้กำหนด" นี่คือความแตกต่างเล็กน้อยแน่นอน

คุณสามารถเปรียบเทียบตัวแปรที่ไม่ได้กำหนดเป็นโมฆะหรือในทางกลับกันและเงื่อนไขจะเป็นจริง:

undefined == null
null == undefined

อย่างไรก็ตามมีการพิจารณาว่าเป็นสองประเภทที่แตกต่างกัน ในขณะที่ไม่ได้กำหนดเป็นประเภททั้งหมดเพื่อตัวเองเป็นโมฆะถือว่าเป็นค่าวัตถุพิเศษ คุณสามารถเห็นสิ่งนี้ได้โดยใช้ typeof () ซึ่งคืนค่าสตริงที่แทนประเภททั่วไปของตัวแปร:

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

การรันสคริปต์ด้านบนจะส่งผลให้เกิดผลลัพธ์ต่อไปนี้

undefined
object

ไม่ว่าพวกเขาจะเป็นคนประเภทใดพวกเขาจะยังคงทำเช่นเดียวกันหากคุณพยายามเข้าถึงสมาชิกของสมาชิกคนใดคนหนึ่งเช่นกล่าวคือพวกเขาจะทำให้เกิดข้อยกเว้น ด้วย WSH คุณจะเห็น "varname" ที่น่าสะพรึงกลัวเป็นโมฆะหรือไม่ใช่วัตถุ "และนั่นคือถ้าคุณโชคดี (แต่นั่นเป็นหัวข้อสำหรับบทความอื่น)

คุณสามารถตั้งค่าตัวแปรให้ไม่ได้กำหนดอย่างชัดเจน แต่ฉันขอแนะนำให้มัน ฉันแนะนำเฉพาะการตั้งค่าตัวแปรให้เป็นโมฆะและไม่ได้กำหนดค่าสำหรับสิ่งที่คุณลืมตั้งไว้ ในขณะเดียวกันฉันขอแนะนำให้คุณตั้งทุกตัวแปรเสมอ JavaScript มีขอบเขตขอบเขตที่แตกต่างจากภาษา C-style ทำให้เกิดความสับสนแม้กระทั่งโปรแกรมเมอร์ที่มีประสบการณ์และการตั้งค่าตัวแปรให้เป็นโมฆะเป็นวิธีที่ดีที่สุดในการป้องกันข้อผิดพลาด

อินสแตนซ์อื่นที่คุณจะเห็นป๊อปอัปที่ไม่ได้กำหนดคือเมื่อใช้โอเปอเรเตอร์การลบ พวกเราจากโลกซีอาจตีความผิดนี้ว่าเป็นการทำลายวัตถุ แต่มันไม่เป็นเช่นนั้น สิ่งที่การดำเนินการนี้ทำคือลบตัวห้อยจาก Array หรือสมาชิกออกจาก Object สำหรับ Array จะไม่มีผลต่อความยาว แต่จะถือว่าตัวห้อยนั้นไม่ได้กำหนด

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

ผลลัพธ์ของสคริปต์ด้านบนคือ:

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

คุณจะได้รับผลตอบแทนที่ไม่ได้กำหนดเมื่ออ่านตัวห้อยหรือสมาชิกที่ไม่เคยมีอยู่

ความแตกต่างระหว่าง null และไม่ได้กำหนดคือ: JavaScript จะไม่ตั้งค่าใด ๆ ให้เป็น null นั่นคือสิ่งที่เราทำ แม้ว่าเราสามารถตั้งค่าตัวแปรเป็นไม่ได้กำหนด แต่เราชอบ null เพราะไม่ใช่สิ่งที่เราเคยทำ เมื่อคุณทำการดีบั๊กนี่หมายความว่าสิ่งใดก็ตามที่ตั้งค่าเป็นโมฆะเป็นการกระทำของคุณเองและไม่ใช่จาวาสคริปต์ ยิ่งไปกว่านั้นค่าพิเศษทั้งสองนี้เกือบจะเทียบเท่ากัน

(การเพิ่มตัวละครเนื่องจากไม่มีตัวอักษรดังนั้นฉันอนุญาตให้โพสต์สิ่งนี้)

โมฆะเป็นคำหลักพิเศษที่ระบุว่าไม่มีค่า

คิดว่ามันเป็นค่าเช่น:

• "foo" เป็นสตริง
• ความจริงคือบูลีน
• 1234 คือตัวเลข
• null ไม่ได้ถูกกำหนด

คุณสมบัติที่ไม่ได้กำหนดบ่งชี้ว่าตัวแปรไม่ได้รับการกำหนดค่ารวมถึงค่า null ด้วย ชอบ

var foo;

ตัวแปรว่างที่กำหนดเป็นnullประเภทข้อมูลundefined

ทั้งคู่แสดงถึง ค่าของตัวแปรที่ไม่มีค่า

และ nullไม่แสดงถึงสตริงที่ไม่มีค่า - สตริงว่าง -

ชอบ

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

ตอนนี้ถ้า

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

แต่

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

ดังนั้นแต่ละคนมีวิธีการใช้งานของตัวเอง

ไม่ได้กำหนดใช้เพื่อเปรียบเทียบชนิดข้อมูลตัวแปร

nullใช้เพื่อล้างค่าของตัวแปร

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

null : ไม่มีค่าสำหรับตัวแปร ไม่ได้กำหนด : ไม่มีตัวแปรเอง;

ตัวแปร ..where เป็นชื่อสัญลักษณ์ที่สัมพันธ์กับค่า

JS อาจจะใจดีพอที่จะเริ่มต้นตัวแปรที่ประกาศใหม่ด้วยnullแต่ไม่ได้

โปรดอ่านข้อความต่อไปนี้อย่างถี่ถ้วน มันจะลบข้อสงสัยทั้งหมดของคุณเกี่ยวกับความแตกต่างระหว่างnullและไม่ได้กำหนดใน JavaScript นอกจากนี้คุณสามารถใช้ฟังก์ชั่นยูทิลิตี้ที่ระบุด้านล่างเพื่อกำหนดประเภท

ใน JavaScript เราสามารถมีตัวแปรประเภทดังต่อไปนี้

1. ตัวแปรที่ไม่ได้ประกาศ
2. ประกาศ แต่ไม่ได้กำหนดตัวแปร
3. ตัวแปรที่กำหนดด้วยตัวอักษรไม่ได้กำหนด
4. ตัวแปรที่กำหนดด้วยค่า nullตามตัวอักษร
5. ตัวแปรที่กำหนดด้วยสิ่งอื่นนอกเหนือจากที่ไม่ได้กำหนดหรือเป็นโมฆะ

ต่อไปนี้จะอธิบายแต่ละกรณีเหล่านี้ทีละคน

1. ตัวแปรที่ไม่ได้ประกาศ : การติดตามเป็นจริงสำหรับตัวแปรที่ไม่ได้ประกาศ

   • สามารถตรวจสอบได้โดยtypeof ()ซึ่งส่งคืนสตริง'undefined'
   • ไม่สามารถตรวจสอบกับ==หรือ===หรือโดยถ้าหรือตัวดำเนินการตามเงื่อนไข? (พ่นข้อผิดพลาดอ้างอิง)

2. ประกาศ แต่ไม่ได้กำหนดตัวแปร

   • typeofส่งคืนสตริง'undefined'
   • ==ตรวจสอบด้วยnullส่งคืนจริง
   • ==ตรวจสอบกับผลตอบแทนที่ไม่ได้กำหนดจริง
   • ===ตรวจสอบกับnullกลับเท็จ
   • ===ตรวจสอบกับผลตอบแทนที่ไม่ได้กำหนดจริง
   • ถ้าหรือผู้ประกอบการตามเงื่อนไข? ส่งคืนค่าเท็จ

3. ตัวแปรที่กำหนดด้วยตัวอักษรที่ ไม่ได้กำหนด : ตัวแปรเหล่านี้จะได้รับการปฏิบัติเช่นเดียวกันกับตัวแปรที่ประกาศ แต่ยังไม่ได้กำหนด

4. ตัวแปรที่กำหนดด้วย ค่า nullตามตัวอักษร

   • typeofส่งคืนสตริง'วัตถุ'
   • ==ตรวจสอบด้วยnullส่งคืนจริง
   • ==ตรวจสอบกับผลตอบแทนที่ไม่ได้กำหนดจริง
   • ===ตรวจสอบด้วยnullส่งคืนจริง
   • ===ตรวจสอบด้วยที่ไม่ได้กำหนดผลตอบแทนที่เป็นเท็จ
   • ถ้าหรือผู้ประกอบการตามเงื่อนไข? ผลตอบแทนที่เป็นเท็จ

5. ตัวแปรที่กำหนดด้วยสิ่งอื่นนอกเหนือจากที่ ไม่ได้กำหนดหรือเป็นโมฆะ

   • typeof ส่งคืนหนึ่งในสตริงต่อไปนี้: 'string' , 'number' , 'boolean' , 'function' , 'object' , 'symbol'

ต่อไปนี้ให้อัลกอริทึมสำหรับการตรวจสอบชนิดของตัวแปรที่ถูกต้อง:

1. ตรวจสอบไม่ได้ประกาศ / ยังไม่ได้มอบหมาย / รับมอบหมาย ไม่ได้กำหนดใช้typeof ส่งคืนถ้าสตริง'undefined'ถูกส่งคืน
2. ตรวจสอบnullใช้=== ผลตอบแทน'null'ถ้าเป็นจริง
3. ตรวจสอบสำหรับประเภทที่เกิดขึ้นจริงโดยใช้typeof ประเภทผลตอบแทนถ้าไม่เท่ากับ'วัตถุ'
4. โทรObject.prototype.toString.call (o)เพื่อกำหนดประเภทวัตถุที่แท้จริง มันจะส่งคืนสตริงประเภท'[object ObjectType]'สำหรับ Javascript หรือวัตถุที่กำหนดDOMทั้งหมด สำหรับวัตถุที่ผู้ใช้กำหนดจะส่งคืน'[วัตถุวัตถุ]'

คุณยังสามารถใช้ฟังก์ชันยูทิลิตี้ต่อไปนี้เพื่อกำหนดประเภท ปัจจุบันรองรับ ECMA 262 2017 ทุกประเภท

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 
}

คุณอาจพิจารณาไม่ได้กำหนดเพื่อแสดงถึงการขาดค่าระดับระบบที่ไม่คาดคิดหรือไม่เหมือนกับข้อผิดพลาดและเป็นโมฆะเพื่อแสดงถึงระดับโปรแกรมปกติหรือขาดค่าที่คาดหวัง

ผ่าน JavaScript: คู่มือการแตกหัก

ฉันจะอธิบายundefined, nullและUncaught ReferenceError :

1 - Uncaught ReferenceError: ตัวแปรไม่ได้รับการประกาศในสคริปต์ของคุณไม่มีการอ้างอิงถึง varaible นี้
2 - undefined: ประกาศตัวแปร แต่ไม่ได้เริ่มต้น
3 - null: ประกาศตัวแปรและเป็นค่าว่าง

ไม่ได้กำหนดหมายถึงมีการประกาศตัวแปร แต่ไม่มีค่า:

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

Null คือการมอบหมาย:

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

เป็นโมฆะและไม่ได้กำหนดเป็นสองประเภทวัตถุที่แตกต่างกันซึ่งมีดังต่อไปนี้ร่วมกัน:

• ทั้งสองสามารถเก็บค่าเดียวเป็นโมฆะและไม่ได้กำหนดตามลำดับ
• ทั้งไม่มีคุณสมบัติหรือวิธีการและความพยายามในการอ่านคุณสมบัติใด ๆ จะทำให้เกิดข้อผิดพลาดขณะทำงาน (สำหรับวัตถุอื่นทั้งหมดคุณจะได้รับค่าไม่ได้กำหนดถ้าคุณพยายามอ่านคุณสมบัติที่ไม่มีอยู่จริง);
• ค่าโมฆะและไม่ได้กำหนดจะถือว่าเท่ากับแต่ละอื่น ๆ และไม่มีอะไรอื่นโดย==และ!=ผู้ประกอบการ

ความคล้ายคลึงกันสิ้นสุดที่นี่ สำหรับครั้งมีความแตกต่างพื้นฐานในทางที่ว่าคำหลักเป็นโมฆะและไม่ได้กำหนดจะดำเนินการ สิ่งนี้ไม่ชัดเจน แต่ให้พิจารณาตัวอย่างต่อไปนี้:

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

ไม่ได้กำหนด , น่านและอินฟินิตี้เป็นเพียงชื่อของ preinitialized ตัวแปร "superglobal" - พวกเขาจะเริ่มต้นที่ใช้เวลาและสามารถแทนที่โดยตัวแปรทั่วโลกหรือท้องถิ่นปกติที่มีชื่อเดียวกัน

ตอนนี้ลองทำสิ่งเดียวกันกับnull :

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

อ๊ะ! null , trueและfalseเป็นคีย์เวิร์ดที่สงวนไว้ - คอมไพเลอร์จะไม่อนุญาตให้คุณใช้มันเป็นชื่อตัวแปรหรือคุณสมบัติ

ความแตกต่างก็คือว่าไม่ได้กำหนดเป็นประเภทดั้งเดิมในขณะที่nullเป็นประเภทวัตถุ (ระบุ absense ของการอ้างอิงวัตถุ) พิจารณาสิ่งต่อไปนี้:

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

นอกจากนี้ยังมีความแตกต่างที่สำคัญในวิธีที่เป็นโมฆะและไม่ได้กำหนดจะได้รับการปฏิบัติในบริบทที่เป็นตัวเลข:

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 (!!!)

ศูนย์กลายเป็น0เมื่อใช้ในการคำนวณทางคณิตศาสตร์หรือการเปรียบเทียบตัวเลข - คล้ายกับเท็จมันเป็นเพียง "ศูนย์" ชนิดพิเศษ undefinedในอีกทางหนึ่งคือ "ไม่มีอะไร" ที่แท้จริงและกลายเป็นNaN ("ไม่ใช่ตัวเลข") เมื่อคุณพยายามใช้ในบริบทตัวเลข

โปรดทราบว่าnullและไม่ได้กำหนดได้รับการดูแลเป็นพิเศษจาก==และ!=ผู้ประกอบการ แต่คุณสามารถทดสอบความเสมอภาคเป็นตัวเลขที่แท้จริงของและBที่มีการแสดงออก(a >= b && a <= b)

TL; DR

ใช้nullสำหรับตั้งค่าตัวแปรที่คุณรู้ว่าเป็นวัตถุ

ใช้undefinedสำหรับตั้งค่าตัวแปรที่มีชนิดผสม

นี่คือการใช้งานของฉันทั้ง 5 วิทยาการและประเภทวัตถุที่อธิบายความแตกต่างระหว่าง«กรณีใช้»ของหรือundefinednull

เชือก

หากคุณรู้ว่าตัวแปรเป็นเพียงสตริงในขณะที่วงจรชีวิตทั้งหมดโดยการประชุมคุณสามารถเริ่มต้นมันเพื่อ"":

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

จำนวน

หากคุณรู้ว่าตัวแปรเป็นเพียงตัวเลขในขณะที่วงจรชีวิตทั้งหมดโดยการประชุมคุณสามารถกำหนดค่าเริ่มต้นให้กับ0(หรือNaNถ้า0เป็นค่าที่สำคัญในการใช้งานของคุณ):

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

หรือ

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

บูลีน

หากคุณรู้ว่าตัวแปรเป็นบูลีนเท่านั้นตลอดวงจรชีวิตทั้งหมดโดยการประชุมคุณสามารถกำหนดค่าเริ่มต้นให้กับfalse:

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

วัตถุ

หากคุณรู้ว่าตัวแปรเป็นเพียงวัตถุในขณะที่วงจรชีวิตทั้งหมดโดยการประชุมคุณสามารถเริ่มต้นได้ที่null:

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

หมายเหตุ: การใช้งานสมาร์ทปิด null คือการเป็นfalsyรุ่นของวัตถุเนื่องจากวัตถุอยู่เสมอtrueและเนื่องจากผลตอบแทนtypeof null objectนั่นหมายถึงtypeof myVarObjectคืนค่าที่สอดคล้องกันสำหรับทั้ง Object และ null

ทั้งหมด

ถ้าคุณรู้ว่าตัวแปรที่มีชนิดผสม (ชนิดใด ๆ ในขณะที่วงจรชีวิตทั้งหมด) undefinedโดยการประชุมคุณสามารถเริ่มต้นมันไป

nullเป็นค่าพิเศษหมายถึง "ไม่มีค่า" nullเป็นวัตถุพิเศษเพราะtypeof nullส่งคืน 'วัตถุ'

ในทางกลับกันundefinedหมายความว่าตัวแปรยังไม่ได้รับการประกาศหรือไม่ได้รับค่า

วิธีที่ดีที่สุดที่จะเข้าใจความแตกต่างคือการล้างจิตใจของคุณจากการทำงานภายในของ JavaScript และเพียงแค่เข้าใจความแตกต่างในความหมายระหว่าง:

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.

มีความแตกต่างในความหมายระหว่างทั้งสามกรณีมีความแตกต่างและ JavaScript หลังสองกรณีมีสองค่าที่แตกต่างกันและnull undefinedคุณมีอิสระที่จะใช้ค่าเหล่านั้นอย่างชัดเจนเพื่อถ่ายทอดความหมายเหล่านั้น

ดังนั้นปัญหาเฉพาะของ JavaScript ที่เกิดขึ้นเนื่องจากพื้นฐานทางปรัชญานี้คืออะไร

1. ตัวแปรที่ประกาศโดยไม่มี initializer รับค่าundefinedเนื่องจากคุณไม่เคยพูดอะไรเกี่ยวกับค่าที่ตั้งใจไว้

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

2. คุณสมบัติของวัตถุที่ไม่เคยถูกกำหนดให้ประเมินundefinedเพราะไม่มีใครพูดอะไรเกี่ยวกับคุณสมบัตินั้น

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

3. nullและundefined"คล้ายกัน" กันเพราะเบรนแดนเอชพูดอย่างนั้น แต่พวกเขาไม่เด่นชัดเท่ากัน

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

4. nullและundefinedโชคดีที่มีประเภทแตกต่างกัน nullเป็นชนิดNullและการพิมพ์undefined Undefinedนี่เป็นสเป็ค แต่คุณคงไม่มีทางรู้เรื่องนี้เพราะtypeofความประหลาดซึ่งฉันจะไม่พูดซ้ำที่นี่

5. ฟังก์ชั่นถึงจุดสิ้นสุดของร่างกายโดยไม่ต้องกลับคำสั่งกลับมาอย่างชัดเจนundefinedเพราะคุณไม่รู้อะไรเกี่ยวกับสิ่งที่มันกลับมา

โดยวิธีการที่มี "ไม่มีอะไร" รูปแบบอื่น ๆ ใน JavaScript (มันเป็นเรื่องดีที่ได้ศึกษาปรัชญา .... )

• NaN
• การใช้ตัวแปรที่ไม่เคยมีการประกาศและรับ ReferenceError
• การใช้ตัวแปรท้องถิ่นletหรือที่constกำหนดไว้ในเขตตายชั่วคราวของมันและรับReferenceError

• เซลล์ว่างในอาร์เรย์หร็อมแหร็ม ใช่สิ่งเหล่านี้ไม่ได้undefinedแม้ว่าจะเปรียบเทียบ===กับไม่ได้กำหนด

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

ใน JavasSript มี 5 ชนิดข้อมูลดั้งเดิม String, Number, Boolean, null และ undefined ฉันจะพยายามอธิบายด้วยตัวอย่างง่ายๆ

สมมติว่าเรามีฟังก์ชั่นง่าย ๆ

 function test(a) {

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

ในฟังก์ชั่นด้านบนถ้า (a == null) เหมือนกับถ้า (! a)

ตอนนี้เมื่อเราเรียกใช้ฟังก์ชันนี้โดยไม่ผ่านพารามิเตอร์ a

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

ด้วย

var a;
alert(typeof a); 

นี้จะให้ไม่ได้กำหนด เราได้ประกาศตัวแปร แต่เราไม่ได้กำหนดค่าให้กับตัวแปรนี้ แต่ถ้าเราเขียน

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

ดังนั้น null เป็นวัตถุ ในวิธีที่เราได้กำหนดค่า null ให้กับ 'a'

สำหรับประเภทมีหนึ่งและมีเพียงหนึ่งค่า:undefinedundefined

สำหรับประเภทมีหนึ่งและมีเพียงหนึ่งค่า:nullnull

ดังนั้นสำหรับทั้งคู่ฉลากมีทั้งประเภทและความคุ้มค่า

ความแตกต่างระหว่างพวกเขา ตัวอย่างเช่น:

• null เป็นค่าว่าง
• undefined เป็นค่าที่หายไป

หรือ:

• undefined ยังไม่ได้มีค่า
• null มีค่าและไม่มีอีกต่อไป

จริงๆแล้วnullเป็นคำหลักพิเศษไม่ใช่ตัวระบุและทำให้คุณไม่สามารถถือเป็นตัวแปรที่จะกำหนดให้

แต่undefinedเป็นตัวบ่งชี้ อย่างไรก็ตามในnon-strictโหมดและstrictโหมดคุณสามารถสร้างตัวแปรโลคัลของชื่อที่ไม่ได้กำหนด แต่นี่เป็นความคิดที่แย่มาก!

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

foo();

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

foo();

เมื่อคุณกำหนดตัวแปรใน JavaScript undefinedก็มีการกำหนดค่า ซึ่งหมายความว่าตัวแปรจะไม่ถูกแตะต้องและสามารถกำหนดค่าใด ๆ ได้ในอนาคต นอกจากนี้ยังหมายความว่าคุณไม่ทราบค่าที่ตัวแปรนี้จะถือในเวลาที่ประกาศ

nullตอนนี้คุณอย่างชัดเจนสามารถกำหนดตัวแปร หมายความว่าตัวแปรไม่มีค่าใด ๆ ตัวอย่างเช่น - บางคนไม่มีชื่อกลาง ดังนั้นในกรณีเช่นนี้ควรกำหนดค่า null ให้กับตัวแปร middlename ของวัตถุบุคคล

ตอนนี้สมมติว่ามีใครเข้าถึงตัวแปร middlename undefinedของวัตถุบุคคลของคุณและมันมีค่า เขาจะไม่รู้ว่านักพัฒนาซอฟต์แวร์ลืมเริ่มต้นตัวแปรนี้หรือไม่หรือไม่มีค่าใด ๆ หากมันมีค่าnullผู้ใช้สามารถอนุมานได้ง่ายว่า middlename ไม่มีค่าใด ๆ และไม่ใช่ตัวแปรที่ไม่ถูกแตะต้อง

ทั้งสองเป็นโมฆะและไม่ได้กำหนดจะใช้เพื่อเป็นตัวแทนของค่าบางอย่าง

var a = null;

เริ่มต้นและกำหนด

typeof(a)
//object

null เป็นวัตถุใน JavaScript

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

var b;

b ไม่ได้ถูกกำหนดและไม่ได้กำหนดค่าเริ่มต้น

คุณสมบัติของวัตถุที่ไม่ได้กำหนดยังไม่ได้กำหนด ตัวอย่างเช่น "x" ไม่ได้ถูกกำหนดไว้บน object c และถ้าคุณพยายามเข้าถึง cx มันจะกลับมาไม่ได้กำหนด

โดยทั่วไปเรากำหนด null ให้กับตัวแปรที่ไม่ได้กำหนด

บทความโดยละเอียดของ Ryan Morr ต่อเรื่องนี้ ...

"โดยทั่วไปถ้าคุณต้องการกำหนดค่าที่ไม่ใช่ค่าให้กับตัวแปรหรือคุณสมบัติให้ส่งไปยังฟังก์ชันหรือคืนค่าจากฟังก์ชัน null เป็นตัวเลือกที่ดีที่สุดเสมอหากต้องการวางไว้อย่างง่ายๆ JavaScript จะใช้ undefined และโปรแกรมเมอร์ควร ใช้ null "

ดูการสำรวจ Eternal Abyss of Null และ Undefined

ทั้ง Null และไม่ได้กำหนดใน JavaScript ระบุว่าไม่มีค่า

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

แม้ว่าความจริงแล้วทั้งสองมีอยู่สำหรับการขาดค่า แต่: ไม่ได้กำหนดจริงหมายถึงตัวแปรที่ไม่ได้เริ่มต้น ฟังก์ชั่นที่คืนค่าพารามิเตอร์ใด ๆ และฟังก์ชั่นที่ไม่มีค่าใดถูกส่งคืนค่าที่ไม่ได้กำหนดจะถูกส่งคืน ใช้โอเปอเรเตอร์ความเท่าเทียมอย่างเข้มงวด === เพื่อแยกความแตกต่างระหว่างค่า null และค่าที่ไม่ได้กำหนด

การอ้างอิง: http://www.thesstech.com/javascript/null-and-undefined

ตกลงเราอาจสับสนเมื่อเราได้ยินเกี่ยวกับnullและundefinedแต่เริ่มง่าย ๆ พวกเขาทั้งคู่มีความเท็จและคล้ายกันในหลาย ๆ ด้าน แต่ส่วนที่แปลกประหลาดของ JavaScript ทำให้พวกเขามีความแตกต่างที่สำคัญตัวอย่างเช่นtypeof nullคือ'object'ในขณะที่typeof undefinedคือ'undefined'.

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

แต่ถ้าคุณตรวจสอบพวกเขามี==ดังต่อไปนี้คุณจะเห็นพวกเขาทั้งสองfalsy :

null==undefined; //true

นอกจากนี้คุณสามารถกำหนดให้nullกับคุณสมบัติของวัตถุหรือดั้งเดิมได้ในขณะที่undefinedสามารถทำได้โดยไม่กำหนดให้อะไร

ฉันสร้างภาพด่วนเพื่อแสดงความแตกต่างให้คุณได้อย่างรวดเร็ว

ในขณะที่ typeof คืนค่าที่ไม่ได้กำหนด undefined เป็นประเภทที่เป็นโมฆะเป็นเครื่องมือเริ่มต้นบ่งชี้ว่าตัวแปรชี้ไปที่ไม่มีวัตถุ (แทบทุกอย่างใน Javascript เป็นวัตถุ)

ในจาวาสคริปต์ตัวแปรทั้งหมดจะถูกเก็บไว้เป็นคู่ของค่าคีย์ แต่ละตัวแปรถูกเก็บไว้เป็นvariable_name: variable_value / referencevariable_value

ไม่ได้กำหนดหมายถึงตัวแปรได้รับการเว้นวรรคในหน่วยความจำ แต่ไม่มีการกำหนดค่าให้กับมัน ตามแนวทางปฏิบัติที่ดีที่สุดคุณไม่ควรใช้ประเภทนี้เป็นการมอบหมาย

ในกรณีดังกล่าวจะแสดงว่าอย่างไรเมื่อคุณต้องการให้ตัวแปรไม่มีค่าในจุดต่อมาของรหัส คุณสามารถใช้ประเภท nullซึ่งเป็นประเภทที่ใช้ในการกำหนดสิ่งเดียวกันไม่มีค่า แต่ไม่เหมือนกันไม่ได้กำหนดเช่นในกรณีนี้คุณมีค่าในหน่วยความจำ ค่านั้นเป็นโมฆะ

ทั้งสองมีความคล้ายคลึงกัน แต่การใช้งานและความหมายต่างกัน

ฉันต้องการที่จะเพิ่มความแตกต่างที่ลึกซึ้งมากระหว่างnullและundefinedซึ่งเป็นสิ่งที่ดีที่จะรู้ว่าเมื่อคุณกำลังพยายามที่จะเรียนรู้วานิลลา JavaScript (JS) จากพื้นดินขึ้น:

• nullเป็นคำหลักที่สงวนไว้ใน JS ในขณะที่undefinedเป็นตัวแปรบนวัตถุโกลบอลของสภาพแวดล้อมแบบรันไทม์ที่คุณอยู่

ในขณะที่เขียนโค้ดความแตกต่างนี้ไม่สามารถระบุได้ว่าเป็นทั้งคู่nullและundefinedมักจะใช้ใน RHS ของคำสั่ง JavaScript แต่เมื่อคุณใช้มันในรูปแบบ LHS คุณสามารถสังเกตเห็นความแตกต่างนี้ได้อย่างง่ายดาย ดังนั้นล่าม JS ตีความรหัสด้านล่างเป็นข้อผิดพลาด:

var null = 'foo'

มันให้ข้อผิดพลาดด้านล่าง:

Uncaught SyntaxError: โทเค็นที่ไม่คาดคิดเป็นโมฆะ

แม้ว่าโค้ดด้านล่างจะทำงานได้สำเร็จแม้ว่าฉันจะไม่แนะนำให้ทำในชีวิตจริง:

var undefined = 'bar'

ใช้งานได้เนื่องจากundefinedเป็นตัวแปรบนวัตถุส่วนกลาง (วัตถุหน้าต่างเบราว์เซอร์ในกรณีที่ฝั่งไคลเอ็นต์ JS)

ความแตกต่างระหว่างundefinedและnullน้อยที่สุด แต่มีความแตกต่าง ตัวแปรที่มีค่าundefinedไม่เคยถูกเตรียมใช้งาน ตัวแปรที่มีค่าจะnullได้รับค่าอย่างชัดเจนnullซึ่งหมายความว่าตัวแปรนั้นถูกตั้งค่าอย่างชัดเจนว่าไม่มีค่า หากคุณเปรียบเทียบundefinedและnullใช้null==undefinedนิพจน์พวกเขาจะเท่ากัน

โดยทั่วไปแล้วUndefinedเป็นตัวแปรทั่วโลกที่จาวาสคริปต์สร้างขึ้นในขณะใช้งานไม่ว่าจะเป็นโมฆะหมายความว่าไม่มีการกำหนดค่าให้กับตัวแปร

ลองมาตัวอย่าง:

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

ไม่ได้กำหนดนั่นคือสิ่งที่คุณจะได้รับตามผลลัพธ์

ตอนนี้

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

และคุณจะได้รับ5เป็นผลลัพธ์ นั่นคือความแตกต่างที่สำคัญระหว่างการไม่ได้กำหนดและโมฆะ

null - เป็นค่าการมอบหมายซึ่งใช้กับตัวแปรเพื่อแทนค่าไม่มี (เป็นวัตถุ)

ไม่ได้กำหนด - มันเป็นตัวแปรที่ไม่มีค่าใด ๆ ให้กับมันดังนั้น JavaScript จะกำหนดค่าที่ไม่ได้กำหนด (เป็นชนิดข้อมูล)

undeclared - ถ้าตัวแปรไม่ได้ถูกสร้างขึ้นก็จะเรียกว่า undeclared

ลองดู. ผลลัพธ์มีค่านับพันคำ

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>

ดูสิ่งนี้ด้วย:

• 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

ไชโย!

ค่าพิเศษทั้งสองบ่งบอกถึงสถานะที่ว่างเปล่า

ความแตกต่างที่สำคัญคือการที่ไม่ได้กำหนดหมายถึงค่าของตัวแปรที่ยังไม่ได้เริ่มต้นในขณะที่โมฆะหมายถึงการขาดวัตถุโดยเจตนา

อย่างไรก็ตามหมายเลขตัวแปรถูกกำหนด แต่ไม่ได้กำหนดด้วยค่าเริ่มต้น:

let number;
number; // => undefined

ตัวแปรหมายเลขไม่ได้ถูกกำหนดซึ่งระบุอย่างชัดเจนว่าเป็นตัวแปรที่ไม่ได้กำหนดค่าเริ่มต้น

แนวคิดที่ไม่ได้กำหนดค่าเริ่มต้นเดียวกันเกิดขึ้นเมื่อมีการเข้าถึงคุณสมบัติวัตถุที่ไม่มีอยู่:

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

เนื่องจากคุณสมบัติ lastName ไม่มีอยู่ใน obj JavaScript จะประเมิน obj.lastName ให้เป็น undefined อย่างถูกต้อง

ในกรณีอื่นคุณรู้ว่าตัวแปรคาดว่าจะเก็บวัตถุหรือฟังก์ชันเพื่อส่งคืนวัตถุ แต่ด้วยเหตุผลบางอย่างคุณไม่สามารถยกตัวอย่างวัตถุได้ ในกรณีเช่นนี้ null เป็นตัวบ่งชี้ที่มีความหมายของวัตถุที่หายไป

ตัวอย่างเช่น clone () เป็นฟังก์ชันที่โคลนวัตถุ JavaScript ธรรมดา ฟังก์ชันคาดว่าจะส่งคืนวัตถุ:

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

อย่างไรก็ตามการโคลน () อาจถูกเรียกด้วยอาร์กิวเมนต์ที่ไม่ใช่วัตถุ: 15 หรือ null (หรือโดยทั่วไปเป็นค่าดั้งเดิม, null หรือไม่ได้กำหนด) ในกรณีเช่นนี้ฟังก์ชั่นไม่สามารถสร้างโคลนดังนั้นมันจึงส่งกลับค่า null - ตัวบ่งชี้ของวัตถุที่หายไป

ตัวดำเนินการtypeofสร้างความแตกต่างระหว่างค่าสองค่า:

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

ผู้ควบคุมคุณภาพอย่างเข้มงวด===แยกความแตกต่างที่ไม่ได้กำหนดอย่างถูกต้องจากค่า null:

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

นอกจากความหมายที่แตกต่างมีความแตกต่างอื่น ๆ :

1. การทำลายวัตถุทำงานแตกต่างกันสำหรับค่าทั้งสองนี้:

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

2. JSON.stringify ()เก็บnullแต่ละเว้นundefined

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

3. ผู้ประกอบการ typeof

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

หากตัวแปรไม่ได้เริ่มต้นแล้วมันจะไม่ได้กำหนด ไม่ได้กำหนดไม่ได้เป็นวัตถุ ตัวอย่าง: var MyName; console.log (ประเภท MyName);

ตรวจสอบเครื่องมือในการพัฒนาคอนโซลบันทึกมันจะถูกพิมพ์เป็นไม่ได้กำหนด

null เป็นวัตถุ aa หากคุณต้องการให้ตัวแปรบางอย่างเป็นโมฆะจะใช้ null เป็นตัวแปรที่มีอยู่ แต่ไม่ทราบค่าควรกำหนดให้กับตัวแปรตามหลักไวยากรณ์ null ไม่เริ่มต้นโดยอัตโนมัติ

ตัวอย่าง: var MyName = null; console.log (ประเภท MyName); ตรวจสอบเครื่องมือในการเข้าสู่ระบบ csole มันจะเป็นวัตถุ