การตรวจสอบจาวาสคริปต์สำหรับ null เทียบกับไม่ได้กำหนดและความแตกต่างระหว่าง == และ ===

1. ฉันจะตรวจสอบตัวแปรได้อย่างไรว่ามันเป็นnullหรือundefinedและสิ่งที่เป็นความแตกต่างระหว่างnullและundefined?

2. อะไรคือความแตกต่างระหว่าง==และ===(มันยากที่จะค้นหา Google สำหรับ "===")?

ฉันจะตรวจสอบตัวแปรได้อย่างไรว่ามันเป็นnullหรือundefined...

เป็นตัวแปรnull:

if (a === null)
// or
if (a == null) // but see note below

... แต่ทราบหลังจะยังเป็นความจริงถ้ามีaundefined

มันคือundefined:

if (typeof a === "undefined")
// or
if (a === undefined)
// or
if (a == undefined) // but see note below

... แต่อีกครั้งโปรดทราบว่าอันสุดท้ายนั้นคลุมเครือ มันจะเป็นจริงถ้าaเป็นnullเช่นนั้น

ตอนนี้แม้จะมีวิธีการข้างต้นแล้ว แต่ วิธีการปกติในการตรวจสอบสิ่งเหล่านั้นก็คือการใช้ความจริงที่ว่าพวกเขาเข้าใจผิด :

if (!a) {
    // `a` is falsey, which includes `undefined` and `null`
    // (and `""`, and `0`, and `NaN`, and [of course] `false`)
}

สิ่งนี้ถูกกำหนดโดยToBooleanในสเป็ค

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

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

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

ที่น่าสนใจ (หรือไม่) พวกเขาเป็นประเภทของตัวเอง ซึ่งจะกล่าวว่าnullเป็นค่าเฉพาะในประเภท Null และundefinedเป็นค่าเดียวในประเภทไม่ได้กำหนด

อะไรคือความแตกต่างระหว่าง "==" และ "==="

ข้อแตกต่างระหว่างพวกเขาเพียงอย่างเดียวคือ==จะใช้การบีบบังคับเพื่อพยายามให้ได้ค่าที่ตรงกันและ===จะไม่ ดังนั้นสำหรับตัวอย่างเช่น"1" == 1เป็นความจริงเพราะ"1"coerces 1ไป แต่"1" === 1เป็นเท็จเพราะประเภทไม่ตรงกัน ( "1" !== 1เป็นจริง) ขั้นตอนแรก (จริง) ของ===คือ "ประเภทของตัวถูกดำเนินการเหมือนกันหรือไม่" และถ้าคำตอบคือ "ไม่" falseผลที่ได้คือ ถ้าประเภทที่เหมือนกันก็ไม่ตรงกับสิ่ง==ที่ไม่

การข่มขู่ประเภทใช้กฎที่ค่อนข้างซับซ้อนและอาจมีผลลัพธ์ที่น่าแปลกใจ (เช่น"" == 0เป็นจริง)

เพิ่มเติมใน spec:

• การเปรียบเทียบความเท่าเทียมกันทางนามธรรม ( ==หรือที่เรียกว่าความเท่าเทียม "หลวม")
• การเปรียบเทียบความเท่าเทียมกันอย่างเข้มงวด ( ===)

ความแตกต่างนั้นลึกซึ้ง

ใน JavaScript undefinedตัวแปรเป็นตัวแปรที่ไม่เคยมีการประกาศหรือไม่เคยกำหนดค่า สมมติว่าคุณประกาศvar a;เช่นนั้นaจะเป็นundefinedเพราะไม่เคยกำหนดค่าใด ๆ

แต่ถ้าคุณแล้วกำหนดa = null;แล้วในขณะนี้จะa nullใน JavaScript nullเป็นวัตถุ (ลองtypeof nullใช้คอนโซล JavaScript หากคุณไม่เชื่อฉัน) ซึ่งหมายความว่า null เป็นค่า (อันที่จริงแล้วundefinedคือค่า)

ตัวอย่าง:

var a;
typeof a;     # => "undefined"

a = null;
typeof null;  # => "object"

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

function doSomething(first, second, optional) {
    if (typeof optional === "undefined") {
        optional = "three";
    }
    // do something
}

หากคุณละเว้นoptionalพารามิเตอร์doSomething(1, 2) thenตัวเลือกจะเป็น"three"สตริง แต่ถ้าคุณผ่านแล้วไม่จำเป็นจะdoSomething(1, 2, null)null

สำหรับตัวเปรียบเทียบที่เท่ากัน==และเคร่งครัดเท่ากัน===ตัวแรกนั้นจะเป็นประเภทที่อ่อนแอในขณะที่ผู้ที่เท่าเทียมกันอย่างเคร่งครัดจะตรวจสอบประเภทของค่าด้วยเช่นกัน นั่นหมายความว่า0 == "0"จะกลับมาจริง ในขณะที่0 === "0"จะคืนค่าเท็จเนื่องจากตัวเลขไม่ใช่สตริง

คุณอาจจะใช้ประกอบการเหล่านั้นเพื่อตรวจสอบระหว่าง ตัวอย่างเช่น:undefinednull

null === null            # => true
undefined === undefined  # => true
undefined === null       # => false
undefined == null        # => true

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

function test(val) {
    return val == null;
}
test(null);       # => true
test(undefined);  # => true

ข้อมูลจำเพาะเป็นที่สำหรับตอบคำถามเหล่านี้อย่างสมบูรณ์ นี่คือบทสรุป:

1. สำหรับตัวแปรxคุณสามารถ:
   
   
   • ตรวจสอบไม่ว่าจะเป็นโดยการเปรียบเทียบโดยตรงโดยใช้null ===ตัวอย่าง:x === null
   • ตรวจสอบไม่ว่าจะเป็นundefinedโดยทั้งสองวิธีการขั้นพื้นฐาน: การเปรียบเทียบโดยตรงด้วยหรือundefined typeofสำหรับเหตุผลต่างๆtypeof x === "undefined"ผมชอบ
   • ตรวจสอบว่าเป็นหนึ่งในnullและundefinedโดยการใช้==และอาศัยกฎบังคับประเภท arcane เล็กน้อยซึ่งหมายความว่าx == nullทำสิ่งที่คุณต้องการ
     
     
2. ความแตกต่างพื้นฐานระหว่าง==และ===คือถ้าตัวถูกดำเนินการเป็นประเภทที่แตกต่างกัน===จะกลับมาเสมอfalseในขณะที่==จะแปลงตัวถูกดำเนินการหนึ่งหรือทั้งสองเป็นประเภทเดียวกันโดยใช้กฎที่นำไปสู่พฤติกรรมที่ไม่คุ้นเคยบางอย่างเล็กน้อย หากตัวถูกดำเนินการเป็นประเภทเดียวกัน (เช่นทั้งคู่เป็นสตริงเช่นในการtypeofเปรียบเทียบด้านบน) ==และ===จะทำงานเหมือนกันทุกประการ

อ่านเพิ่มเติม:

• ความจริงความเท่าเทียมและ JavaScriptของ Angus Croll
• Coercion JavaScriptของ Andrea Giammarchi ได้ทำการศึกษาอย่างถูกต้อง
• comp.lang.javascript คำถามที่พบบ่อย: JavaScript Type-Conversion

ฉันจะตรวจสอบตัวแปรได้อย่างไรว่ามันเป็นโมฆะหรือไม่ได้กำหนด

ตรวจสอบว่าตัวแปรมีค่าที่ถูกต้องเช่นนี้หรือไม่:

if(variable)

มันจะกลับมาจริงถ้าตัวแปรไม่ประกอบด้วย:

• โมฆะ
• ไม่ได้กำหนด
• 0
• เท็จ
• "" (สตริงว่าง)
• น่าน

ไม่ได้กำหนด

มันหมายความว่าตัวแปรยังไม่ได้ปรับตำแหน่ง

ตัวอย่าง:

var x;
if(x){ //you can check like this
   //code.
}

เท่ากับ (==)

ตรวจสอบค่าเท่านั้นไม่เท่ากับประเภทข้อมูล

ตัวอย่าง:

var x = true;
var y = new Boolean(true);
x == y ; //returns true

เพราะมันจะตรวจสอบค่าเท่านั้น

เท่ากับเข้มงวด (===)

ตรวจสอบค่าและประเภทข้อมูลที่ควรจะเหมือนกัน

ตัวอย่าง:

var x = true;
var y = new Boolean(true);
x===y; //returns false.

เพราะมันตรวจสอบประเภทข้อมูล x เป็นชนิดดั้งเดิมและ y เป็นวัตถุบูลีน

โฆษณา 1. nullไม่ใช่ตัวระบุสำหรับคุณสมบัติของวัตถุทั่วโลกเช่นundefined สามารถ

let x;      // undefined
let y=null; // null
let z=3;    // has value
// 'w'      // is undeclared

if(!x) console.log('x is null or undefined');
if(!y) console.log('y is null or undefined');
if(!z) console.log('z is null or undefined');

try { if(w) 0 } catch(e) { console.log('w is undeclared') }
// typeof not throw exception for undelared variabels
if(typeof w === 'undefined') console.log('w is undefined');

โฆษณา 2. การ===ตรวจสอบค่าและประเภท ==Dont ต้องประเภทเดียวกันและทำให้การแปลงนัยก่อนที่จะเปรียบเทียบ (โดยใช้.valueOf()และ.toString()) ที่นี่คุณมีทั้งหมด ( src ):

ถ้า

== (การปฏิเสธของมัน! = )

=== (การปฏิเสธ! == )

หากการตรวจสอบ (เชิงตรรกะ) ของคุณเป็นการปฏิเสธ (!) และคุณต้องการจับทั้ง JS nullและundefined (เนื่องจากเบราว์เซอร์ที่แตกต่างกันจะให้ผลลัพธ์ที่แตกต่างกัน) คุณจะใช้การเปรียบเทียบที่ จำกัด น้อยลงเช่น:

var ItemID = Item.get_id();
if (ItemID != null)
{
 //do stuff
}

นี้จะจับทั้งnullและundefined

ลองด้วยเหตุผลที่แตกต่างกัน คุณสามารถใช้รหัสร้องเพื่อตรวจสอบเงื่อนไขทั้งสี่ (4) สำหรับการตรวจสอบเช่นไม่เป็นโมฆะไม่ว่างไม่ได้ไม่ได้กำหนดและไม่เป็นศูนย์เท่านั้นใช้รหัสนี้ (! (! (ตัวแปร))) ใน javascript และ jquery

function myFunction() {
var data;  //The Values can be like as null, blank, undefined, zero you can test

if(!(!(data)))
{
   //If data has valid value
    alert("data "+data);
} 
else 
{
    //If data has null, blank, undefined, zero etc.
    alert("data is "+data);
}

}