เป็นวิธีที่ดีที่สุดในการตรวจสอบว่าทรัพย์สินของวัตถุใน JavaScript คือundefinedอะไร?

วิธีปกติในการตรวจสอบว่ามูลค่าของทรัพย์สินเป็นค่าพิเศษundefinedหรือไม่คือ:

if(o.myProperty === undefined) {
  alert("myProperty value is the special value `undefined`");
}

ในการตรวจสอบว่าวัตถุไม่มีคุณสมบัติเช่นนั้นจริง ๆ หรือไม่และจะส่งกลับเป็นundefinedค่าเริ่มต้นเมื่อคุณลองและเข้าถึง:

if(!o.hasOwnProperty('myProperty')) {
  alert("myProperty does not exist");
}

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

if(typeof myVariable === 'undefined') {
  alert('myVariable is either the special value `undefined`, or it has not been declared');
}

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

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

หากคุณกังวลเกี่ยวกับกรณีขอบ (ไม่น่า) นี้คุณสามารถใช้ตัวดำเนินการ voidเพื่อรับundefinedค่าพิเศษเอง:

if(myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}

ฉันเชื่อว่ามีคำตอบที่ไม่ถูกต้องสำหรับหัวข้อนี้ ขัดกับความเชื่อทั่วไป "undefined" ไม่ใช่คำหลักใน JavaScript และในความเป็นจริงสามารถมีค่าที่กำหนดให้

รหัสที่ถูกต้อง

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

if (typeof myVar === "undefined")

นี่จะส่งคืนผลลัพธ์ที่ถูกต้องเสมอและยังจัดการกับสถานการณ์ที่myVarไม่ได้ประกาศ

รหัสเสื่อม ไม่ได้ใช้.

var undefined = false;  // Shockingly, this is completely legal!
if (myVar === undefined) {
    alert("You have been misled. Run away!");
}

นอกจากนี้myVar === undefinedจะเพิ่มข้อผิดพลาดในสถานการณ์ที่ myVar ไม่ได้ประกาศ

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

var snapshot = …;

if (typeof snaposhot === 'undefined') {
    //         ^
    // misspelled¹ – this will never run, but it won’t throw an error!
}

var foo = …;

if (typeof foo === 'undefned') {
    //                   ^
    // misspelled – this will never run, but it won’t throw an error!
}

ดังนั้นหากคุณกำลังตรวจจับคุณสมบัติ²ซึ่งมีความไม่แน่นอนว่าชื่อที่กำหนดจะอยู่ในขอบเขต (เช่นการตรวจสอบtypeof module !== 'undefined'ขั้นตอนในรหัสเฉพาะสำหรับสภาพแวดล้อม CommonJS) typeofเป็นตัวเลือกที่อันตรายเมื่อใช้กับตัวแปรและตัวเลือกที่ถูกต้องคือ เพื่อเปรียบเทียบค่าโดยตรง:

var foo = …;

if (foo === undefined) {
    ⋮
}

ความเข้าใจผิดที่พบบ่อยเกี่ยวกับสิ่งนี้รวมถึง:

• การอ่านตัวแปร“ uninitialized” ( var foo) หรือพารามิเตอร์ ( function bar(foo) { … }เรียกว่าbar()) จะล้มเหลว สิ่งนี้ไม่จริง - ตัวแปรที่ไม่มีการกำหนดค่าเริ่มต้นอย่างชัดเจนและพารามิเตอร์ที่ไม่ได้รับค่าจะกลายเป็นเสมอundefinedและอยู่ในขอบเขตเสมอ

• ที่undefinedสามารถเขียนทับได้ ยังมีอะไรอีกมากมายสำหรับเรื่องนี้ undefinedไม่ใช่คำหลักใน JavaScript มันเป็นคุณสมบัติของออบเจ็กต์ทั่วโลกแทนค่าที่ไม่ได้กำหนด อย่างไรก็ตามเนื่องจาก ES5 คุณสมบัตินี้อ่านได้อย่างเดียวและไม่สามารถกำหนดค่าได้ ไม่มีเบราว์เซอร์ที่ทันสมัยจะอนุญาตให้undefinedมีการเปลี่ยนแปลงคุณสมบัติและ ณ วันที่ 2017 กรณีนี้เป็นเวลานาน การขาดโหมดเข้มงวดไม่ส่งผลกระทบต่อundefinedพฤติกรรมของมันเช่นกัน - มันแค่สร้างข้อความเหมือนundefined = 5ไม่ทำอะไรเลยแทนที่จะโยน แม้ว่าจะไม่ใช่คำหลัก แต่คุณสามารถประกาศตัวแปรด้วยชื่อundefinedและตัวแปรเหล่านั้นสามารถเปลี่ยนแปลงได้ทำให้รูปแบบที่พบบ่อยครั้งนี้:

  (function (undefined) {
      // …
  })()

  เพิ่มเติมundefinedอันตรายกว่าการใช้ทั่วโลก หากคุณต้องรองรับ ES3 ให้แทนที่undefinedด้วยvoid 0- อย่าหันไปtypeofใช้ ( voidเป็นโอเปอเรเตอร์ unary ที่ประเมินเป็นค่าไม่ได้กำหนดสำหรับตัวถูกดำเนินการใด ๆ )

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

นี้:

if (typeof foo.bar === 'undefined') {
    ⋮
}

เทียบเท่ากับสิ่งนี้เสมอ ³:

if (foo.bar === undefined) {
    ⋮
}

และคำนึงถึงคำแนะนำข้างต้นเพื่อหลีกเลี่ยงความสับสนของผู้อ่านว่าทำไมคุณถึงใช้typeofเพราะเหมาะสมที่สุดที่จะใช้===เพื่อตรวจสอบความเท่าเทียมกันเพราะมันสามารถ refactored การตรวจสอบค่าของตัวแปรในภายหลังและเพราะมันเป็นธรรมดา รูปลักษณ์ที่ดีกว่าที่คุณควรใช้=== undefined ³ที่นี่เช่นกัน

สิ่งอื่นที่ควรพิจารณาเมื่อพูดถึงคุณสมบัติของวัตถุคือคุณต้องการตรวจสอบundefinedจริงหรือไม่ ชื่อคุณสมบัติที่กำหนดสามารถหายไปบนวัตถุ (สร้างมูลค่าundefinedเมื่ออ่าน) นำเสนอบนวัตถุเองด้วยค่าที่undefinedมีอยู่บนต้นแบบของวัตถุที่มีค่าundefinedหรืออยู่ในอย่างใดอย่างหนึ่งที่มีundefinedค่าที่ไม่ใช่ 'key' in objจะบอกคุณว่ามีกุญแจอยู่ที่ใดที่หนึ่งบนโซ่ต้นแบบของวัตถุหรือไม่และObject.prototype.hasOwnProperty.call(obj, 'key')จะบอกคุณว่ามันอยู่บนวัตถุโดยตรงหรือไม่ ฉันจะไม่ลงรายละเอียดในคำตอบนี้เกี่ยวกับต้นแบบและการใช้วัตถุเป็นแผนที่แบบสตริง - สตริงเพราะส่วนใหญ่มีจุดประสงค์เพื่อตอบโต้คำแนะนำที่ไม่ดีทั้งหมดในคำตอบอื่น ๆ โดยไม่คำนึงถึงการตีความที่เป็นไปได้ของคำถามต้นฉบับ อ่านต่อไปต้นแบบวัตถุบน MDNมากขึ้น!

_{choice ตัวเลือกที่ผิดปกติของชื่อตัวแปรตัวอย่าง? นี่เป็นโค้ดที่ตายจริงจากส่วนขยาย NoScript สำหรับ Firefox
²ไม่คิดว่าการไม่รู้ว่าอะไรอยู่ในขอบเขตก็โอเคโดยทั่วไปแล้ว ช่องโหว่ของโบนัสที่เกิดจากการละเมิดขอบเขตแบบไดนามิก: โครงการศูนย์ 1225 Zero
อีกครั้งโดยสมมติว่ามีสภาพแวดล้อม ES5 + และที่undefinedอ้างถึงundefinedทรัพย์สินของวัตถุระดับโลก แทนvoid 0อย่างอื่น}

ใน JavaScript มีnullและมีไม่ได้กำหนด พวกเขามีความหมายต่างกัน

• ไม่ได้กำหนดหมายความว่าค่าตัวแปรไม่ได้ถูกกำหนดไว้ ไม่ทราบว่าค่าคืออะไร
• nullหมายความว่าค่าตัวแปรถูกกำหนดและตั้งค่าเป็น null (ไม่มีค่า)

Marijn Haverbeke กล่าวในหนังสือออนไลน์ฟรี " Eloquent JavaScript " ของเขา (เน้นที่เหมือง):

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

ดังนั้นฉันเดาวิธีที่ดีที่สุดในการตรวจสอบว่ามีบางสิ่งที่ไม่ได้กำหนดจะเป็น:

if (something == undefined)

หวังว่านี่จะช่วยได้!

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

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

สิ่งนี้หมายความว่า: "คุณสมบัติวัตถุที่ไม่ได้กำหนด" ?

จริงๆแล้วมันอาจหมายถึงสองสิ่งที่แตกต่างกันมาก! ประการแรกมันอาจหมายถึงทรัพย์สินที่ไม่เคยมีการกำหนดไว้ในวัตถุและสองก็สามารถหมายถึงทรัพย์สินที่มีค่าไม่ได้กำหนด ลองดูรหัสนี้:

var o = { a: undefined }

คือo.aไม่ได้กำหนด? ใช่ ค่าของมันคือไม่ได้กำหนด คือo.bไม่ได้กำหนด? แน่นอน! ไม่มีคุณสมบัติ 'b' เลย! ตกลงดูตอนนี้วิธีการทำงานที่แตกต่างกันในทั้งสองสถานการณ์:

typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false

เราสามารถเห็นได้อย่างชัดเจนtypeof obj.prop == 'undefined'และobj.prop === undefinedเท่าเทียมกันและพวกเขาไม่แยกแยะสถานการณ์ที่แตกต่างเหล่านั้น และ'prop' in objสามารถตรวจจับสถานการณ์เมื่อทรัพย์สินไม่ได้ถูกกำหนดเลยและไม่ใส่ใจกับมูลค่าทรัพย์สินซึ่งอาจไม่ได้กำหนด

แล้วจะทำอย่างไรดี?

1) คุณต้องการทราบว่าคุณสมบัติไม่ได้ถูกกำหนดโดยความหมายแรกหรือที่สอง (สถานการณ์ทั่วไป)

obj.prop === undefined // IMHO, see "final fight" below

2) คุณต้องการที่จะรู้ว่าวัตถุมีคุณสมบัติบางอย่างและไม่สนใจคุณค่าของมัน

'prop' in obj

หมายเหตุ:

• คุณไม่สามารถตรวจสอบวัตถุและคุณสมบัติของวัตถุในเวลาเดียวกัน ตัวอย่างเช่นสิ่งนี้x.a === undefinedหรือสิ่งนี้typeof x.a == 'undefined'จะเพิ่มขึ้นReferenceError: x is not definedหากไม่ได้กำหนด x
• ตัวแปรundefinedเป็นตัวแปรทั่วโลก (จริง ๆ แล้วมันอยู่window.undefinedในเบราว์เซอร์) มันได้รับการสนับสนุนตั้งแต่ ECMAScript ฉบับที่ 1 และตั้งแต่ ECMAScript 5 มันจะอ่านเท่านั้น ดังนั้นในเบราว์เซอร์ที่ทันสมัยไม่สามารถนิยามใหม่เป็นจริงได้เนื่องจากผู้เขียนหลายคนชอบที่จะทำให้เราตกใจ แต่นี่ก็ยังเป็นจริงสำหรับเบราว์เซอร์รุ่นเก่า

การต่อสู้ครั้งสุดท้าย: obj.prop === undefinedvstypeof obj.prop == 'undefined'

ข้อดีของobj.prop === undefined:

• มันสั้นกว่าเล็กน้อยและดูดีกว่า
• เอ็นจิ้น JavaScript จะให้ข้อผิดพลาดแก่คุณหากคุณสะกดผิด undefined

ข้อเสียของobj.prop === undefined:

• undefined สามารถแทนที่ได้ในเบราว์เซอร์เก่า

ข้อดีของtypeof obj.prop == 'undefined':

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

ข้อเสียของtypeof obj.prop == 'undefined':

• 'undefned'( สะกดผิด ) ที่นี่เป็นเพียงค่าคงที่สตริงดังนั้นเครื่องมือ JavaScript ไม่สามารถช่วยคุณได้หากคุณสะกดผิดเหมือนที่ฉันเพิ่งทำ

อัปเดต (สำหรับ JavaScript ฝั่งเซิร์ฟเวอร์):

Node.js รองรับตัวแปรโกลบอลundefinedในรูปแบบglobal.undefined(สามารถใช้งานได้โดยไม่ต้องใส่คำนำหน้า 'global') ฉันไม่รู้เกี่ยวกับการใช้งานอื่น ๆ ของ JavaScript ฝั่งเซิร์ฟเวอร์

ปัญหาเดือดลงไปสามกรณี:

1. undefinedวัตถุที่มีคุณสมบัติและความคุ้มค่าของมันไม่ได้
2. undefinedวัตถุที่มีคุณสมบัติและความคุ้มค่าของมันคือ
3. วัตถุไม่มีคุณสมบัติ

สิ่งนี้บอกสิ่งที่ฉันพิจารณาว่าสำคัญ:

มีความแตกต่างระหว่างสมาชิกที่ไม่ได้กำหนดและสมาชิกที่กำหนดด้วยค่าที่ไม่ได้กำหนด

แต่โชคtypeof obj.fooไม่ดีที่ไม่บอกเราว่ามีสามกรณีที่เรามี อย่างไรก็ตามเราสามารถรวมสิ่งนี้กับ"foo" in objเพื่อแยกความแตกต่างของเคส

                               |  typeof obj.x === 'undefined' | !("x" in obj)
1.                     { x:1 } |  false                        | false
2.    { x : (function(){})() } |  true                         | false
3.                          {} |  true                         | true

มันน่าสังเกตว่าการทดสอบเหล่านี้เหมือนกันสำหรับnullรายการด้วย

                               |  typeof obj.x === 'undefined' | !("x" in obj)
                    { x:null } |  false                        | false

ฉันยืนยันว่าในบางกรณีมันสมเหตุสมผลมากกว่า (และชัดเจนกว่า) เพื่อตรวจสอบว่ามีทรัพย์สินนั้นหรือไม่มากกว่าการตรวจสอบว่าไม่ได้กำหนดไว้หรือไม่และในกรณีเดียวที่การตรวจสอบนี้จะแตกต่างกันคือกรณีที่ 2 รายการจริงในวัตถุที่มีค่าไม่ได้กำหนด

ตัวอย่างเช่นฉันเพิ่งได้รับการเปลี่ยนรหัสเป็นจำนวนมากซึ่งมีการตรวจสอบจำนวนมากว่าวัตถุนั้นมีคุณสมบัติที่กำหนดหรือไม่

if( typeof blob.x != 'undefined' ) {  fn(blob.x); }

ซึ่งชัดเจนเมื่อเขียนโดยไม่ตรวจสอบเพื่อไม่ได้กำหนด

if( "x" in blob ) { fn(blob.x); }

แต่ดังที่ได้กล่าวมาสิ่งเหล่านี้ไม่เหมือนกันทุกประการ (แต่ดีเกินพอสำหรับความต้องการของฉัน)

if ( typeof( something ) == "undefined") 

สิ่งนี้ใช้ได้สำหรับฉันในขณะที่คนอื่นไม่ได้

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

typeof x;                      // some string literal "string", "object", "undefined"
if (typeof x === "string") {   // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") {    // sufficient

การข้ามคำตอบจากคำถามที่เกี่ยวข้องจะตรวจสอบ "undefined" ใน JavaScript ได้อย่างไร

someObject.<whatever>โดยเฉพาะกับคำถามนี้ให้ดูกรณีทดสอบด้วย

บางสถานการณ์แสดงภาพประกอบของคำตอบที่หลากหลาย: http://jsfiddle.net/drzaus/UVjM4/

(โปรดทราบว่าการใช้varสำหรับinการทดสอบสร้างความแตกต่างเมื่ออยู่ใน wrapper ที่กำหนดขอบเขต)

รหัสสำหรับการอ้างอิง:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.log(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

และผลลัพธ์:

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined

ถ้าคุณทำ

if (myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

มันจะล้มเหลวเมื่อmyvarไม่มีตัวแปรเนื่องจากไม่ได้กำหนด myvar ดังนั้นสคริปต์จึงขาดและการทดสอบไม่มีผล

เนื่องจากวัตถุหน้าต่างมีขอบเขตส่วนกลาง (วัตถุเริ่มต้น) นอกฟังก์ชั่นการประกาศจะถูก 'แนบ' กับวัตถุหน้าต่าง

ตัวอย่างเช่น:

var myvar = 'test';

ตัวแปรส่วนกลางmyvarเหมือนกับwindow.myvarหรือwindow ['myvar']

เพื่อหลีกเลี่ยงข้อผิดพลาดในการทดสอบเมื่อมีตัวแปรโกลบอลคุณควรใช้:

if(window.myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

คำถามหากตัวแปรมีอยู่จริงไม่สำคัญว่าเป็นค่าที่ไม่ถูกต้อง มิฉะนั้นจะเป็นการโง่ที่จะเริ่มต้นตัวแปรด้วย undefined และควรใช้ค่า false เพื่อเริ่มต้น เมื่อคุณรู้ว่าตัวแปรทั้งหมดที่คุณประกาศถูกเตรียมใช้งานด้วยเท็จคุณสามารถตรวจสอบประเภทของมันหรือพึ่งพา!window.myvarเพื่อตรวจสอบว่ามันมีค่าที่เหมาะสม / ถูกต้อง ดังนั้นแม้ในขณะที่ตัวแปรไม่ได้กำหนดไว้แล้ว!window.myvarเหมือนกันสำหรับmyvar = undefinedหรือหรือmyvar = falsemyvar = 0

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

if( !window.myvar || typeof window.myvar != 'string' )
{
    alert('var does not exists or is not type of string');
}

เมื่อเงื่อนไขแรกและเรียบง่ายเป็นจริงล่ามจะข้ามการทดสอบถัดไป

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

(y)

ฉันไม่เห็น (หวังว่าฉันจะไม่พลาด) ใครก็ตามที่ตรวจสอบวัตถุก่อนทรัพย์สิน ดังนั้นนี่คือสั้นและมีประสิทธิภาพมากที่สุด (แต่ไม่จำเป็นต้องชัดเจนที่สุด):

if (obj && obj.prop) {
  // Do something;
}

หาก obj หรือ obj.prop ไม่ได้กำหนดเป็นโมฆะหรือ "เท็จ" คำสั่ง if จะไม่ดำเนินการบล็อกรหัส นี่คือมักจะพฤติกรรมที่ต้องการในงบป้องกันรหัสมากที่สุด (ใน JavaScript)

ในบทความExploring the Abyss of Null และ Undefined ใน JavaScriptฉันอ่านเฟรมเวิร์กอย่างUnderscore.jsใช้ฟังก์ชั่นนี้:

function isUndefined(obj){
    return obj === void 0;
}

ทุกอย่างไม่ได้ถูกกำหนดใน JavaScript คือไม่ได้กำหนดไม่สำคัญว่าจะเป็นคุณสมบัติภายในObject / Arrayหรือเป็นเพียงตัวแปรอย่างง่าย ...

JavaScript typeofช่วยให้ตรวจจับตัวแปรที่ไม่ได้กำหนดได้ง่าย

เพียงตรวจสอบว่าtypeof whatever === 'undefined'มันจะส่งคืนบูลีนหรือไม่

นั่นคือวิธีที่ฟังก์ชันที่มีชื่อเสียงisUndefined()ใน AngularJs v.1x ถูกเขียน:

function isUndefined(value) {return typeof value === 'undefined';} 

ดังนั้นตามที่คุณเห็นฟังก์ชั่นได้รับค่าถ้าค่าที่กำหนดไว้ก็จะกลับมิฉะนั้นค่าที่ไม่ได้กำหนดผลตอบแทนfalsetrue

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

var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;

และเราตรวจสอบพวกเขาตามด้านล่างคุณสามารถเห็นผลลัพธ์ต่อหน้าพวกเขาเป็นความคิดเห็น:

isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true

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

อีกสิ่งหนึ่งสำหรับการตรวจสอบคุณสมบัติบนวัตถุในแอปพลิเคชันจริงซึ่งคุณไม่แน่ใจว่ามีวัตถุอยู่หรือไม่ให้ตรวจสอบว่าวัตถุนั้นมีอยู่ก่อนหรือไม่

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

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

ง่ายมากที่คุณสามารถสรุปคำสั่ง if ด้านล่าง:

if(typeof x !== 'undefined') {
  //do something
}

ซึ่งยังเท่ากับ isDefined ใน Angular 1.x ...

function isDefined(value) {return typeof value !== 'undefined';}

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

ฉันยังเพิ่มส่วนนี้จาก MDN ซึ่งได้รับข้อมูลที่เป็นประโยชน์เกี่ยวกับ typeof, undefined และ void (0)

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

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

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

Typeof operator และ undefined
อีกทางเลือกหนึ่ง typeof สามารถใช้:

var x;
if (typeof x === 'undefined') {
   // these statements execute
}

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

// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

if (x === undefined) { // throws a ReferenceError

}

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

ผู้ประกอบการโมฆะและไม่ได้กำหนด

ตัวดำเนินการ void เป็นทางเลือกที่สาม

var x;
if (x === void 0) {
   // these statements execute
}

// y has not been declared before
if (y === void 0) {
   // throws a ReferenceError (in contrast to `typeof`)
}

เพิ่มเติม> ที่นี่

' if (window.x) {} ' มีข้อผิดพลาดที่ปลอดภัย

if (window.x)ส่วนใหญ่มีแนวโน้มที่คุณต้องการ การตรวจสอบนี้ปลอดภัยแม้ว่า x จะไม่ถูกประกาศ ( var x;) - เบราว์เซอร์ไม่ได้เกิดข้อผิดพลาด

ตัวอย่าง: ฉันต้องการทราบว่าเบราว์เซอร์ของฉันรองรับ History API หรือไม่

if (window.history) {
    history.call_some_function();
}

มันทำงานอย่างไร:

windowเป็นวัตถุที่เก็บตัวแปรส่วนกลางทั้งหมดในฐานะสมาชิกและเป็นกฎหมายที่พยายามเข้าถึงสมาชิกที่ไม่มีอยู่ ถ้าxยังไม่ได้รับการประกาศหรือยังไม่ได้รับการตั้งค่าแล้วwindow.xกลับไม่ได้กำหนด ไม่ได้กำหนดจะนำไปสู่falseเมื่อif ()ประเมินค่า

การอ่านผ่านสิ่งนี้ฉันประหลาดใจที่ฉันไม่เห็นสิ่งนี้ ฉันพบอัลกอริทึมหลายอย่างที่สามารถใช้ได้กับสิ่งนี้

ไม่เคยกำหนด

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

if(obj.prop === void 0) console.log("The value has never been defined");

กำหนดเป็นไม่ได้กำหนดหรือไม่เคยกำหนด

หากคุณต้องการให้ผลลัพธ์เป็นtrueค่าที่กำหนดด้วยค่าundefinedหรือไม่เคยกำหนดไว้คุณสามารถใช้=== undefined

if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");

กำหนดเป็นค่าที่ไม่ถูกต้องไม่ได้กำหนดเป็นโมฆะหรือไม่เคยกำหนดไว้

โดยทั่วไปผู้คนถามฉันถึงอัลกอริทึมที่จะเข้าใจว่าค่านั้นผิดพลาดundefinedหรือnullไม่ ผลงานดังต่อไปนี้

if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}

"propertyName" in obj //-> true | false

เปรียบเทียบกับvoid 0เพื่อความกระชับ

if (foo !== void 0)

มันไม่ได้เป็นอย่าง verbose if (typeof foo !== 'undefined')

วิธีแก้ไขไม่ถูกต้อง ในจาวาสคริปต์

null == undefined

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

if (something === undefined)

ซึ่งเป็นผู้ประกอบการประจำตัว ...

คุณสามารถรับอาเรย์ทั้งหมดที่ไม่ได้กำหนดด้วยพา ธ โดยใช้รหัสต่อไปนี้

 function getAllUndefined(object) {

        function convertPath(arr, key) {
            var path = "";
            for (var i = 1; i < arr.length; i++) {

                path += arr[i] + "->";
            }
            path += key;
            return path;
        }


        var stack = [];
        var saveUndefined= [];
        function getUndefiend(obj, key) {

            var t = typeof obj;
            switch (t) {
                case "object":
                    if (t === null) {
                        return false;
                    }
                    break;
                case "string":
                case "number":
                case "boolean":
                case "null":
                    return false;
                default:
                    return true;
            }
            stack.push(key);
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    v = getUndefiend(obj[k], k);
                    if (v) {
                        saveUndefined.push(convertPath(stack, k));
                    }
                }
            }
            stack.pop();

        }

        getUndefiend({
            "": object
        }, "");
        return saveUndefined;
    }

ลิงก์jsFiddle

นี่คือสถานการณ์ของฉัน:

ฉันกำลังใช้ผลการโทร REST ควรแยกวิเคราะห์ผลลัพธ์จาก JSON ไปยังวัตถุ JavaScript

มีข้อผิดพลาดประการหนึ่งที่ฉันต้องปกป้องคือ หาก args ไปยังการโทรที่เหลือไม่ถูกต้องเท่าที่ผู้ใช้ระบุ args ผิดการโทรที่เหลือจะกลับมาว่างเปล่าโดยทั่วไป

ในขณะที่ใช้โพสต์นี้เพื่อช่วยฉันป้องกันสิ่งนี้ฉันพยายามทำสิ่งนี้

if( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }

สำหรับสถานการณ์ของฉันถ้า restResult.data [0] === "วัตถุ" จากนั้นฉันสามารถเริ่มตรวจสอบสมาชิกที่เหลือได้อย่างปลอดภัย หากไม่ได้กำหนดให้โยนข้อผิดพลาดดังกล่าวข้างต้น

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

มีวิธีที่ดี & สวยงามในการกำหนดคุณสมบัติที่กำหนดให้กับตัวแปรใหม่หากมีการกำหนดหรือกำหนดค่าเริ่มต้นให้กับมันเป็นทางเลือกหากไม่ได้กำหนด

var a = obj.prop || defaultValue;

มันเหมาะสมถ้าคุณมีฟังก์ชั่นซึ่งได้รับคุณสมบัติการกำหนดค่าเพิ่มเติม:

var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.log(this.yourConfigValue);

}

ตอนนี้กำลังดำเนินการ

yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

คำตอบทั้งหมดไม่สมบูรณ์ นี่เป็นวิธีที่ถูกต้องในการรู้ว่ามีคุณสมบัติ 'กำหนดเป็นไม่ได้กำหนด':

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;

ตัวอย่าง:

var a = { b : 1, e : null } ;
a.c = a.d ;

hasUndefinedProperty(a, 'b') ; // false : b is defined as 1
hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined
hasUndefinedProperty(a, 'd') ; // false : d is undefined
hasUndefinedProperty(a, 'e') ; // false : e is defined as null

// And now...
delete a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined

น่าเสียดายที่คำตอบนี้ถูกฝังอยู่ในคำตอบที่ผิด> _ <

ดังนั้นสำหรับทุกคนที่ผ่านไปฉันจะให้คุณไม่ได้กำหนดฟรี !!

var undefined ; undefined ; // undefined
({}).a ;                    // undefined
[].a ;                      // undefined
''.a ;                      // undefined
(function(){}()) ;          // undefined
void(0) ;                   // undefined
eval() ;                    // undefined
1..a ;                      // undefined
/a/.a ;                     // undefined
(true).a ;                  // undefined

จะผ่านความคิดเห็นสำหรับผู้ที่ต้องการตรวจสอบทั้งสองมันไม่ได้กำหนดหรือค่าเป็นโมฆะ:

//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}

หากคุณกำลังใช้ jQuery Library jQuery.isEmptyObject()จะเพียงพอสำหรับทั้งสองกรณี

var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;

s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;

//Usage
if (jQuery.isEmptyObject(s)) {
    alert('Either variable:s is undefined or its value is null');
} else {
     alert('variable:s has value ' + s);
}

s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;

หากคุณใช้แองกูลาร์:

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

Underscore.js:

_.isUndefined(obj) 
_.isUndefined(obj.prop) 

ฉันใช้if (this.variable)เพื่อทดสอบว่ามีการกำหนดไว้หรือไม่ ที่เรียบง่ายif (variable), ที่แนะนำข้างต้นล้มเหลวสำหรับฉัน ปรากฎว่ามันทำงานเฉพาะเมื่อตัวแปรเป็นเขตข้อมูลของวัตถุบางอย่างobj.someFieldเพื่อตรวจสอบว่ามีการกำหนดไว้ในพจนานุกรม แต่เราสามารถใช้thisหรือwindowเป็นวัตถุพจนานุกรมเนื่องจากตัวแปรใด ๆ เป็นเขตข้อมูลในหน้าต่างปัจจุบันตามที่ฉันเข้าใจ ดังนั้นนี่คือการทดสอบ

if (this.abc) alert("defined"); else alert("undefined");

abc = "abc";
if (this.abc) alert("defined"); else alert("undefined");

ก่อนตรวจพบว่าตัวแปรabcไม่ได้ถูกกำหนดและถูกกำหนดหลังจากการเริ่มต้น

ฉันให้สามวิธีที่นี่สำหรับผู้ที่คาดหวังคำตอบแปลก ๆ :

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}
function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
    const defaultVal={};
    return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
    console.group(`test start :`+func.name);
    console.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

isUndefined1:

ลองรับคุณสมบัติของค่าอินพุตตรวจสอบข้อความแสดงข้อผิดพลาดหากมีอยู่ หากค่าอินพุตไม่ได้กำหนดข้อความแสดงข้อผิดพลาดจะเป็น Uncaught TypeError: ไม่สามารถอ่านคุณสมบัติ 'b' ของไม่ได้กำหนด

isUndefined2:

แปลงค่าอินพุตเป็นสตริงเพื่อเปรียบเทียบ"undefined"และตรวจสอบให้แน่ใจว่าเป็นค่าลบ

isUndefined3:

ใน js, undefinedพารามิเตอร์ตัวเลือกทำงานเมื่อค่าเข้าเป็นว่า

function isUnset(inp) {
  return (typeof inp === 'undefined')
}

ส่งคืนเท็จถ้าตั้งค่าตัวแปรและเป็นจริงถ้าไม่ได้กำหนด

จากนั้นใช้:

if (isUnset(var)) {
  // initialize variable here
}

ฉันต้องการแสดงสิ่งที่ฉันใช้เพื่อปกป้องundefinedตัวแปร:

Object.defineProperty(window, 'undefined', {});

สิ่งนี้ห้ามมิให้ผู้ใดเปลี่ยนwindow.undefinedค่าดังนั้นการทำลายโค้ดตามตัวแปรนั้น หากใช้"use strict"สิ่งใดก็ตามที่พยายามเปลี่ยนค่าจะสิ้นสุดลงโดยผิดพลาดมิฉะนั้นจะถูกเพิกเฉย

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

function resolveUnknownProps(obj, resolveKey) {
  const handler = {
    get(target, key) {
      if (
        target[key] !== null &&
        typeof target[key] === 'object'
      ) {
        return resolveUnknownProps(target[key], resolveKey);
      } else if (!target[key]) {
        return resolveUnknownProps({ [resolveKey]: true }, resolveKey);
      }

      return target[key];
    },
  };

  return new Proxy(obj, handler);
}

const user = {}

console.log(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }

ดังนั้นคุณจะใช้มันเหมือน:

const { isUndefined } = resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else;
if (!isUndefined) {
  // do someting
}

จาก lodash.js

var undefined;
function isUndefined(value) {
  return value === undefined;
}

มันจะสร้างตัวแปรท้องถิ่นชื่อundefinedซึ่งจะเริ่มต้นได้ด้วยค่าเริ่มต้น - จริงundefinedแล้วเปรียบเทียบกับตัวแปรvalueundefined

อัปเดต 9/9/2019

ฉันพบว่า lodash ได้อัปเดตการใช้งาน ดูปัญหาของฉันและรหัส

เพื่อเป็นหลักฐานกระสุนเพียงใช้:

function isUndefined(value) {
  return value === void 0;
}