ตรวจสอบ JavaScript เป็นศูนย์

ฉันเจอรหัสต่อไปนี้:

function test(data) {
    if (data != null && data !== undefined) {
        // some code here
    }
}

ฉันค่อนข้างใหม่กับ JavaScript แต่จากคำถามอื่น ๆ ที่ฉันได้อ่านที่นี่ฉันรู้สึกว่ารหัสนี้ไม่สมเหตุสมผล

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

อัปเดต:คำตอบ (อ้างถึง) ด้านบนอาจทำให้เข้าใจผิด มันควรจะพูดว่า«ตัวแปรที่ไม่ได้ประกาศ»แทนที่จะ«ตัวแปรไม่ได้กำหนด»

ดังที่ฉันค้นพบในคำตอบของRyan ♦ , maericsและnwellnhofถึงแม้ว่าจะไม่มีการขัดแย้งกับฟังก์ชันฟังก์ชันตัวแปรสำหรับอาร์กิวเมนต์จะถูกประกาศเสมอ ความจริงข้อนี้ยังพิสูจน์ข้อแรกในรายการด้านล่าง

จากความเข้าใจของฉันสถานการณ์ต่อไปนี้อาจประสบ:

• ฟังก์ชั่นได้รับการเรียกว่ามีการขัดแย้งใดจึงทำให้ตัวแปรไม่ได้กำหนดและการสร้างข้อผิดพลาดในdatadata != null

• ฟังก์ชั่นถูกเรียกโดยเฉพาะอย่างยิ่งกับnull(หรือundefined) เป็นอาร์กิวเมนต์ในกรณีที่data != nullได้รับการปกป้องรหัสภายในทำให้การแสดงผลที่&& data !== undefinedไร้ประโยชน์

• ฟังก์ชั่นถูกเรียกด้วยอาร์กิวเมนต์ null ไม่ใช่ในกรณีที่มันนิด ๆ จะผ่านทั้งสองและdata != null data !== undefined

ถาม: ความเข้าใจของฉันถูกต้องหรือไม่

ฉันได้ลองทำสิ่งต่อไปนี้ในคอนโซลของ Firefox:

--
[15:31:31.057] false != null
[15:31:31.061] true
--
[15:31:37.985] false !== undefined
[15:31:37.989] true
--
[15:32:59.934] null != null
[15:32:59.937] false
--
[15:33:05.221] undefined != null
[15:33:05.225] false
--
[15:35:12.231] "" != null
[15:35:12.235] true
--
[15:35:19.214] "" !== undefined
[15:35:19.218] true

ฉันไม่สามารถคิดออกกรณีที่data !== undefined หลังจากที่ data != nullอาจจะมีการใช้งานใด ๆ

เป็น“ตัวแปรไม่ได้กำหนด” undefinedจะแตกต่างจากค่า

ตัวแปรที่ไม่ได้กำหนด:

var a;
alert(b); // ReferenceError: b is not defined

ตัวแปรที่มีค่าundefined:

var a;
alert(a); // Alerts “undefined”

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

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

var a = null;
alert(a === null); // true

@rynah พูดถึงว่า "undefined" ค่อนข้างสับสนใน JavaScript อย่างไรก็ตามจะปลอดภัยเสมอที่จะทดสอบว่าtypeof(x)สตริงนั้นเป็น "undefined" หรือไม่แม้ว่า "x" จะไม่ใช่ตัวแปรที่ประกาศไว้:

alert(typeof(x) === 'undefined'); // true

นอกจากนี้ตัวแปรอาจมี "ค่าที่ไม่ได้กำหนด" หากไม่ได้เตรียมข้อมูลเบื้องต้น

var y;
alert(typeof(y) === 'undefined'); // true

เช็คทั้งหมดของคุณควรมีลักษณะดังนี้:

if ((typeof(data) !== 'undefined') && (data !== null)) {
  // ...

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

function(data) {
  if ((data !== undefined) && (data !== null)) {
    // ...

ตัวอย่างนี้จะบอกว่า "ถ้าฟังก์ชั่นนั้นถูกเรียกด้วยอาร์กิวเมนต์ที่ถูกกำหนดและไม่เป็นโมฆะ ... "

ในกรณีของคุณใช้data==null(ซึ่งเป็นจริงเฉพาะสำหรับโมฆะและไม่ได้กำหนด - ในโฟกัสภาพที่สองในแถว / คอลัมน์ null- ไม่ได้กำหนด)

function test(data) {
    if (data != null) {
        console.log('Data: ', data);
    }
}

test();          // the data=undefined
test(null);      // the data=null
test(undefined); // the data=undefined

test(0); 
test(false); 
test('something');

ที่นี่คุณมีทั้งหมด ( src ):

ถ้า

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

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

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

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

ถาม:ฟังก์ชั่นนี้ถูกเรียกใช้เป็นพิเศษด้วย null (หรือไม่ได้กำหนด) เป็นอาร์กิวเมนต์ในกรณีที่ data! = null ได้ปกป้องโค้ดภายในการเรนเดอร์ && data! == undefined ไร้ประโยชน์

ถาม:ฟังก์ชั่นถูกเรียกใช้พร้อมอาร์กิวเมนต์ที่ไม่เป็นโมฆะซึ่งในกรณีนี้จะส่งผ่านข้อมูลทั้งสองเล็กน้อย! = null และ data! == undefined

ตอบ:ถูกต้อง โปรดทราบว่าการทดสอบต่อไปนี้เทียบเท่า:

data != null
data != undefined
data !== null && data !== undefined

ดูส่วนที่ 11.9.3 อัลกอริทึมการเปรียบเทียบความเท่าเทียมกันที่เป็นนามธรรมและส่วนที่ 11.9.6 อัลกอริทึมการเปรียบเทียบความเท่าเทียมกันอย่างเข้มงวดของสเป็ค

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

function (data) {
  if (data != null && data !== undefined) {
    // some code here
    // but what if data === false?
    // or data === '' - empty string?
  }
}

ทำอะไรแบบนี้:

function (data) {
  if (typeof data === 'string' && data.length) {
    // consume string here, it is here for sure
    // cleaner, it is obvious what type you expect
    // safer, less error prone due to implicit coercion
  } 
}

typeof foo === "undefined"ต่างจากfoo === undefinedอย่าสับสน typeof foo === "undefined"คือสิ่งที่คุณต้องการจริงๆ นอกจากนี้ยังใช้!==แทน!=

ดังนั้นคำสั่งสามารถเขียนเป็น

function (data) {
  if (typeof data !== "undefined" && data !== null) {
    // some code here
  }
}

แก้ไข:

คุณไม่สามารถใช้foo === undefinedสำหรับตัวแปรที่ไม่ได้ประกาศ

var t1;

if(typeof t1 === "undefined")
{
  alert("cp1");
}

if(t1 === undefined)
{
  alert("cp2");
}

if(typeof t2 === "undefined")
{
  alert("cp3");
}

if(t2 === undefined) // fails as t2 is never declared
{
  alert("cp4");
}

วิธีง่ายๆในการทำแบบทดสอบของคุณคือ:

function (data) {
    if (data) { // check if null, undefined, empty ...
        // some code here
    }
}

var a;
alert(a); //Value is undefined

var b = "Volvo"; 
alert(b); //Value is Volvo

var c = null;
alert(c); //Value is null