เพราะเหตุใดวัตถุจึงเป็นนัลและอะไรคือความแตกต่างระหว่างโมฆะและไม่ได้กำหนด?

เหตุใดจึงnullถือว่าเป็นobjectJavaScript

กำลังตรวจสอบ

if ( object == null )
      Do something

เหมือนกับ

if ( !object )
      Do something

?

และนอกจากนี้ยังมี:

ความแตกต่างระหว่างnullและundefinedคืออะไร?

(name is undefined)

คุณคือnameอะไร ^(*)
JavaScript: name ? คืออะไรname? ฉันไม่รู้ว่าคุณกำลังพูดถึงเรื่องอะไร คุณไม่เคยเอ่ยถึงnameมาก่อน คุณเห็นภาษาสคริปต์อื่น ๆ ในฝั่ง (ลูกค้า) หรือไม่

name = null;

คุณคือnameอะไร
JavaScript:ฉันไม่รู้

ในระยะสั้น; undefinedเป็นที่ที่ไม่มีความคิดในเรื่องนี้; มันไม่มีประเภทและไม่มีการอ้างอิงมาก่อนในขอบเขตนั้น nullคือสิ่งที่รู้ว่ามีอยู่ แต่ไม่ทราบว่าคุณค่าคืออะไร

สิ่งหนึ่งที่ต้องจำไว้คือnullไม่ได้เป็นแนวคิดเดียวกับfalseหรือ""หรือดังกล่าวถึงแม้ว่าพวกเขาถือเอาหลังจากหล่อพิมพ์คือ

name = false;

คุณคือnameอะไร
JavaScript:บูลีนเท็จ

name = '';

คุณคือnameอะไร
JavaScript:สตริงว่าง

^{*: nameในบริบทนี้มีความหมายว่าเป็นตัวแปรที่ไม่เคยถูกกำหนด มันอาจเป็นตัวแปรที่ไม่ได้กำหนดอย่างไรก็ตามชื่อเป็นคุณสมบัติขององค์ประกอบรูปแบบ HTML ใด ๆ มันไปทางกลับและก่อตั้งอย่างดีก่อน id มันมีประโยชน์เพราะรหัสต้องไม่ซ้ำกัน แต่ชื่อไม่จำเป็นต้องเป็น}

ความแตกต่างสามารถสรุปได้ในตัวอย่างนี้:

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

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

การตรวจสอบ

object == nullif ( !object )จะแตกต่างกันในการตรวจสอบ

หลังมีค่าเท่ากับ! Boolean(object)เนื่องจากตัวดำเนิน!การเอกนารีทิ้งตัวถูกดำเนินการที่ถูกต้องลงในบูลีนโดยอัตโนมัติ

ตั้งแต่เท่ากับเท็จแล้วBoolean(null)!false === true

ดังนั้นหากวัตถุของคุณคือไม่เป็นโมฆะ , แต่ ที่เป็นเท็จหรือ0หรือ""การตรวจสอบจะผ่านเนื่องจาก:

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

nullจะไม่ได้วัตถุมันเป็นค่าดั้งเดิม ตัวอย่างเช่นคุณไม่สามารถเพิ่มคุณสมบัติได้ บางครั้งคนผิดคิดว่ามันเป็นวัตถุเพราะผลตอบแทนtypeof null "object"แต่นั่นเป็นข้อผิดพลาดจริง ๆ (อาจแก้ไขได้ใน ECMAScript 6)

ความแตกต่างระหว่างnullและundefinedมีดังนี้:

• undefined: ใช้งานโดย JavaScript และหมายถึง“ ไม่มีค่า” ตัวแปรที่ไม่ได้กำหนดพารามิเตอร์ที่ขาดหายไปและตัวแปรที่ไม่รู้จักมีค่าดังกล่าว

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

  อย่างไรก็ตามการเข้าถึงตัวแปรที่ไม่รู้จักนั้นสร้างข้อยกเว้น:

  > unknownVariable
  ReferenceError: unknownVariable is not defined

• null: ใช้โดยโปรแกรมเมอร์เพื่อระบุ“ ไม่มีค่า” เช่นเป็นพารามิเตอร์ของฟังก์ชัน

ตรวจสอบตัวแปร:

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

ตามกฎทั่วไปคุณควรใช้ === และไม่ควร == ใน JavaScript (== ทำการแปลงทุกชนิดที่สามารถให้ผลลัพธ์ที่ไม่คาดคิด) การตรวจสอบx == nullเป็นกรณีที่เป็นขอบเพราะใช้ได้ทั้งnullและundefined:

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

วิธีทั่วไปในการตรวจสอบว่าตัวแปรมีค่าคือการแปลงเป็นบูลีนและดูว่าเป็นtrueหรือไม่ การแปลงนั้นดำเนินการโดยifข้อความสั่งและตัวดำเนินการบูลีน! ("ไม่").

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";
}

ข้อเสียของวิธีการนี้: ค่าทั้งหมดต่อไปนี้ประเมินได้falseดังนั้นคุณต้องระมัดระวัง (เช่นการตรวจสอบข้างต้นไม่สามารถแยกความแตกต่างระหว่างundefinedและ0)

• undefined, null
• booleans: false
• เบอร์: +0, -0,NaN
• Strings: ""

คุณสามารถทดสอบการแปลงเป็นบูลีนโดยใช้Booleanเป็นฟังก์ชั่น (โดยปกติจะเป็นตัวสร้างที่จะใช้กับnew):

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

ความแตกต่างระหว่าง null และ undefined คืออะไร?

คุณสมบัติเมื่อไม่มีนิยามจะไม่ถูกกำหนด null เป็นวัตถุ ประเภทของมันคือวัตถุ null เป็นค่าพิเศษหมายถึง "ไม่มีค่า undefined ไม่ใช่วัตถุชนิดของมันคือไม่ได้กำหนด

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

 undefined == null
 null == undefined

อ้างถึงJavaScript ความแตกต่างระหว่าง null และ undefinedเพื่อดูรายละเอียดเพิ่มเติม

และด้วยการแก้ไข ใหม่ของคุณใช่

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

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

ตรวจสอบที่นี่: Javascript gotcha

ส่วนแรกของคำถาม:

เพราะเหตุใด null จึงถือว่าเป็นวัตถุใน JavaScript

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

ส่วนที่สองของคำถาม:

กำลังตรวจสอบ


if (object == null)
Do something

เช่นเดียวกับ

if (!object)
Do something

การตรวจสอบสองครั้งนั้นเป็นเท็จทั้งคู่เสมอยกเว้น:

• วัตถุไม่ได้กำหนดหรือเป็นโมฆะ: ทั้งจริง

• วัตถุเป็นดั้งเดิมและ 0, ""หรือเท็จ: ตรวจสอบครั้งแรกเท็จครั้งที่สองที่แท้จริง

ถ้าวัตถุไม่ได้เป็นแบบดั้งเดิม แต่วัตถุจริงเช่นnew Number(0), new String("")หรือnew Boolean(false)แล้วการตรวจสอบทั้งที่เป็นเท็จ

ดังนั้นถ้า 'object' ถูกตีความหมายถึงวัตถุจริงการตรวจสอบทั้งสองจะเหมือนกันเสมอ หากได้รับอนุญาตพื้นฐานแล้วการตรวจสอบจะแตกต่างกันสำหรับ 0 "", และเท็จ

ในกรณีเช่นobject==nullผลลัพธ์ที่ไม่เด่นชัดอาจเป็นแหล่งของข้อบกพร่อง ใช้==ไม่แนะนำที่เคยใช้===แทน

ส่วนที่สามของคำถาม:

และยัง:

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

ใน JavaScript ความแตกต่างอย่างหนึ่งคือ null นั้นเป็นประเภทวัตถุและไม่ได้กำหนดเป็นประเภทไม่ได้กำหนด

ใน JavaScript นั้นnull==undefinedเป็นจริงและถือว่าเท่ากันหากละเว้นประเภท ทำไมพวกเขาถึงตัดสินใจ แต่ 0 ""และเท็จไม่เท่ากันฉันไม่รู้ ดูเหมือนว่าจะเป็นความเห็นโดยพลการ

ใน JavaScript, ไม่เป็นความจริงตั้งแต่ชนิดจะต้องเหมือนกันในnull===undefined===

ในความเป็นจริง null และ undefined เหมือนกันเนื่องจากทั้งคู่เป็นตัวแทนของการไม่มีอยู่จริง ดังนั้น 0 และ""สำหรับเรื่องที่มากเกินไปและอาจจะเป็นตู้เปล่าและ[] {}ไม่มีอะไรเหมือนกันมากมายเลยที่เป็นสูตรสำหรับแมลง ประเภทเดียวหรือไม่มีเลยดีกว่า ฉันจะพยายามใช้ให้น้อยที่สุด

'false', 'true' และ '!' เป็นอีกหนึ่งเวิร์มที่สามารถทำให้ง่ายขึ้นตัวอย่างเช่นif(!x)และif(x)เพียงอย่างเดียวก็เพียงพอแล้วคุณไม่ต้องการความจริงและเท็จ

ประกาศvar xเป็นประเภทไม่ได้กำหนดถ้าไม่มีค่าจะได้รับ แต่มันควรจะเหมือนกันว่าถ้า x ไม่เคยประกาศเลย แหล่งที่มาของบั๊กอื่นคือคอนเทนเนอร์ที่ว่างเปล่า var x=1ดังนั้นจึงเป็นสิ่งที่ดีที่สุดที่จะประกาศและกำหนดมันเข้าด้วยกันเช่น

ผู้คนจะวนไปวนมาเป็นวงกลมพยายามที่จะเข้าใจสิ่งต่าง ๆ เหล่านี้ แต่มันก็เหมือนกันในเสื้อผ้าที่ซับซ้อน ความจริงก็คือ

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

และบางทีทุกคนควรโยนข้อยกเว้น

var x = null;

x ถูกกำหนดเป็นโมฆะ

y ไม่ได้ถูกกำหนด // เพราะฉันไม่ได้กำหนดไว้

if (!x)

null ถูกประเมินว่าเป็นเท็จ

วิธีหนึ่งในการทำให้เป็นโมฆะและไม่ได้กำหนดคือการเข้าใจที่เกิดขึ้น

คาดหวังค่าส่งคืน null ในสถานการณ์ต่อไปนี้:

• วิธีการที่ค้นหา DOM

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

• ได้รับคำตอบของ JSON จากคำขอ Ajax

    {
      name: "Bob",
      address: null
    }

• RegEx.exec

• ฟังก์ชั่นใหม่ที่อยู่ในสถานะฟลักซ์ ผลตอบแทนต่อไปนี้เป็นโมฆะ:

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

       // But this returns undefined:

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

กรณีอื่น ๆ ที่ไม่มีอยู่จะแสดงโดยไม่ได้กำหนด (ดังที่ระบุไว้โดย @Axel) แต่ละรายการจะพิมพ์ "undefined":

    var uninitalised;
    console.log(uninitalised);

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

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

    missingParam();

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

แน่นอนถ้าคุณตัดสินใจที่จะเขียน var unitialised = null; หรือคืนค่า null จากเมธอดด้วยตัวคุณเองจากนั้นคุณมีโมฆะเกิดขึ้นในสถานการณ์อื่น ๆ แต่นั่นควรจะชัดเจน

กรณีที่สามคือเมื่อคุณต้องการเข้าถึงตัวแปร แต่คุณไม่รู้ด้วยซ้ำว่ามีการประกาศหรือไม่ สำหรับกรณีนั้นให้ใช้ typeof เพื่อหลีกเลี่ยงข้อผิดพลาดในการอ้างอิง:

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

ในการตรวจสอบสรุปสำหรับ null เมื่อคุณจัดการ DOM จัดการกับ Ajax หรือใช้คุณสมบัติ ECMAScript 5 บางอย่าง สำหรับกรณีอื่น ๆ ทั้งหมดนั้นปลอดภัยที่จะตรวจสอบว่าไม่ได้ถูกกำหนดด้วยความเท่าเทียมอย่างเข้มงวด:

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

การเปรียบเทียบการตรวจสอบ null ที่แตกต่างกันจำนวนมากใน JavaScript:

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 == ไม่ได้กำหนด): พวกเขาทั้งสองล้มลงเพื่อบูลีนเท็จ พวกเขาไม่ใช่วัตถุเดียวกัน (null! == undefined)

ไม่ได้กำหนดเป็นคุณสมบัติของวัตถุทั่วโลก ("หน้าต่าง" ในเบราว์เซอร์) แต่เป็นประเภทดั้งเดิมและไม่ใช่วัตถุเอง เป็นค่าเริ่มต้นสำหรับตัวแปรและฟังก์ชันที่ไม่ได้กำหนดค่าเริ่มต้นโดยไม่มีคำสั่ง return

null เป็นตัวอย่างของ Object null ใช้สำหรับเมธอด DOM ที่ส่งคืนออบเจ็กต์การรวบรวมเพื่อระบุผลลัพธ์ที่ว่างเปล่าซึ่งให้ค่าเท็จโดยไม่ระบุข้อผิดพลาด

บางประการ:

null และ undefined เป็นสองค่าที่ต่างกัน หนึ่งคือการขาดงานของค่าสำหรับชื่อและอื่น ๆ ที่เป็นตัวแทนของการขาดชื่อ

เกิดอะไรขึ้นในโกลifดังนี้if( o ):

การแสดงออกในวงเล็บ o การประเมินแล้วifเตะในประเภทบีบบังคับค่าของนิพจน์ในวงเล็บที่ - oในกรณีของเรา

Falsy (ที่จะได้รับการบังคับให้เป็นเท็จ) ค่าใน JavaScript คือ: '', null, undefined, 0, และเท็จ

เพื่อเพิ่มคำตอบของข้อแตกต่างระหว่างundefinedและnullจากJavaScript Definitive Guide 6th Edition, p.41 ในหน้านี้ :

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

nullเป็นวัตถุ ประเภทของมันเป็นโมฆะ undefinedไม่ใช่วัตถุ ประเภทของมันไม่ได้กำหนด

ฟังก์ชั่นต่อไปนี้แสดงสาเหตุและความสามารถในการหาข้อแตกต่าง:

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

หากคุณโทรมา

test();

คุณได้รับ

ไม่ได้กำหนด

โมฆะ

ความconsole.log(...)พยายามครั้งแรกที่จะได้รับmyPropertyจากmyObjในขณะที่มันยังไม่ได้กำหนด - ดังนั้นจึงได้รับกลับมา "ไม่ได้กำหนด" หลังจากกำหนดค่า Null ให้กับมันค่าที่สองconsole.log(...)จะคืนค่าเป็น "Null" อย่างชัดเจนเนื่องจากmyPropertyมีอยู่ แต่มีค่าที่nullกำหนดให้

เพื่อให้สามารถสืบค้นความแตกต่างนี้ JavaScript ได้nullและundefined: ขณะnullอยู่ - เหมือนในภาษาอื่น ๆ ที่เป็นวัตถุundefinedไม่สามารถเป็นวัตถุได้เนื่องจากไม่มีอินสแตนซ์ (แม้ไม่ใช่nullอินสแตนซ์)

ตัวอย่างเช่นwindow.someWeirdPropertyไม่ได้กำหนดดังนั้น

"window.someWeirdProperty === null" ประเมินว่าเป็นเท็จในขณะที่

"window.someWeirdProperty === undefined" ประเมินเป็นจริง

checkif นอกจากนี้if (!o)ไม่ได้เป็นเช่นเดียวกับการตรวจสอบif (o == null)สำหรับความเป็นอยู่ofalse

สิ่งที่สนุกอื่น ๆ เกี่ยวกับ null เมื่อเทียบกับ undefined คือสามารถเพิ่มได้

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

สิ่งนี้มีประโยชน์สำหรับการตั้งค่าตัวเลขเริ่มต้นสำหรับตัวนับ มีกี่ครั้งที่คุณตั้งค่าตัวแปรเป็น -1 ในการประกาศ?

ในJavascript nullไม่ใช่objectประเภท แต่เป็นprimitaveประเภท

อะไรคือความแตกต่าง? ไม่ได้กำหนดหมายถึงตัวชี้ที่ยังไม่ได้ตั้งค่า Nullอ้างถึงตัวชี้โมฆะตัวอย่างบางสิ่งบางอย่างได้ตั้งค่าตัวแปรให้เป็นชนิดด้วยตนเองnull

ดูนี่สิ:

   <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

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

Zakas, Nicholas C. (2014-02-07) หลักการของ JavaScript เชิงวัตถุ (จุดติดตั้ง 226-227) ไม่มีแป้งกด จุด Edition.

ที่กล่าวว่า:

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;

กรณีที่ไม่ได้กำหนด:

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' คือการจำวิธีการใช้แนวคิดที่คล้ายกันในฐานข้อมูลซึ่งแสดงว่าเขตข้อมูลมี "ไม่มีค่าเลย"

• ใช่มูลค่าของรายการเป็นที่รู้จัก มันคือ 'กำหนด' มันได้รับการเริ่มต้น
• ค่าของรายการคือ: "ไม่มีค่า"

นี่เป็นเทคนิคที่มีประโยชน์มากสำหรับการเขียนโปรแกรมที่ง่ายขึ้น ตัวแปร 'ไม่ได้กำหนด' อาจจะเป็นผลมาจากข้อผิดพลาดที่ ... (วิธีการที่คุณจะได้รู้ว่า?) ... แต่ถ้าตัวแปรมีค่าที่ 'โมฆะ' คุณรู้ไหมว่า "ใครสักคนหนึ่งในโปรแกรมนี้ตั้งไว้เพื่อ 'null.' "ดังนั้นฉันแนะนำว่าเมื่อคุณต้องการกำจัดค่าของตัวแปรอย่า" ลบ "... ตั้งเป็น 'null' ค่าเก่าจะถูกกำพร้าและในไม่ช้าจะมีการเก็บขยะ ค่าใหม่คือ "ไม่มีค่า (ตอนนี้)" ในทั้งสองกรณีสถานะของตัวแปรนั้นแน่นอนว่า: "เห็นได้ชัดว่าจงใจใช้วิธีนั้น"

1. ไม่ได้กำหนดหมายถึงมีการประกาศตัวแปร แต่ยังไม่ได้รับการกำหนดค่าใด ๆ ในขณะที่ Null สามารถกำหนดให้กับตัวแปรที่แสดงว่า "ไม่มีค่า" (Null เป็นตัวดำเนินการกำหนดค่า)

2.Undefined เป็นประเภทของตัวเองในขณะที่ Null เป็นวัตถุ

3.Javascript เองสามารถเริ่มต้นตัวแปรที่ไม่ได้กำหนดใด ๆ เพื่อไม่ได้กำหนด แต่ไม่สามารถกำหนดค่าของตัวแปรให้เป็นโมฆะ สิ่งนี้จะต้องทำอย่างเป็นระบบ