บทนำเกี่ยวกับอินสแตนซ์ของตัวดำเนินการ
ใน JavaScript การตัดสินประเภทของตัวแปรคุณจะใช้ตัวดำเนินการ Typeof เมื่อใช้ตัวดำเนินการ typeof คุณจะมีปัญหาโดยใช้ประเภทการอ้างอิงเพื่อจัดเก็บค่า ไม่ว่าจะมีการอ้างอิงวัตถุประเภทใดมันจะกลับ "วัตถุ" Ecmascript แนะนำอินสแตนซ์ของผู้ให้บริการ Java อื่นเพื่อแก้ปัญหานี้ ตัวดำเนินการอินสแตนซ์ของมีความคล้ายคลึงกับตัวดำเนินการ typeof และใช้เพื่อระบุประเภทของวัตถุที่ถูกประมวลผล ซึ่งแตกต่างจากวิธี typeof วิธีการอินสแตนซ์ของนักพัฒนาต้องการให้ผู้พัฒนายืนยันอย่างชัดเจนว่าวัตถุนั้นเป็นประเภทเฉพาะ ตัวอย่างเช่น:
รายการ 1. ตัวอย่างของตัวอย่าง
var ostringObject = สตริงใหม่ ("Hello World"); console.log (สตริงอินสแตนซ์ OstringObject ของสตริง); // เอาต์พุต "จริง"รหัสนี้ถามว่า "ตัวแปร OstringObject เป็นอินสแตนซ์ของวัตถุสตริงหรือไม่" OstringObject เป็นอินสแตนซ์ของวัตถุสตริงดังนั้นผลลัพธ์คือ "จริง" แม้ว่าจะไม่ยืดหยุ่นเท่ากับวิธี typeof แต่วิธีการอินสแตนซ์ของวิธีการมีประโยชน์เมื่อวิธีการ typeof ส่งคืน "วัตถุ"
การใช้งานทั่วไปของผู้ดำเนินการอินสแตนซ์:
โดยทั่วไปแล้วการใช้อินสแตนซ์ของการตรวจสอบว่าอินสแตนซ์เป็นของบางประเภทหรือไม่ ตัวอย่างเช่น:
รายการ 2. การใช้งานทั่วไปของอินสแตนซ์
// ตรวจสอบว่า foo เป็นอินสแตนซ์ของฟังก์ชันคลาส foo foo () {} var foo = new foo (); console.log (foo instanceof foo) // trueนอกจากนี้จุดที่หนักกว่าคืออินสแตนซ์ของสามารถใช้ในความสัมพันธ์การสืบทอดเพื่อตรวจสอบว่าอินสแตนซ์เป็นของประเภทหลักหรือไม่ ตัวอย่างเช่น:
รายการ 3. การใช้อินสแตนซ์ของความสัมพันธ์ในการสืบทอด
// ตรวจสอบว่า foo เป็นอินสแตนซ์ของคลาส foo และไม่ว่าจะเป็นอินสแตนซ์ของฟังก์ชั่นประเภทหลัก aoo () {} function foo () {} foo.prototype = new aoo (); // javascript ต้นแบบ console.log (foo instanceof foo) // true console.log (foo instanceof aoo) // trueในรหัสข้างต้นชั้นพาเรนต์ในเลเยอร์ของความสัมพันธ์การสืบทอดจะถูกตัดสิน ในความสัมพันธ์การสืบทอดหลายชั้นผู้ประกอบการอินสแตนซ์ของตัวดำเนินการก็ใช้ได้เช่นกัน
คุณเข้าใจตัวดำเนินการอินสแตนซ์ของตัวดำเนินการจริงหรือ?
หลังจากอ่านตัวอย่างโค้ดด้านบนคุณคิดว่าตัวดำเนินการอินสแตนซ์ของง่ายมากหรือไม่? มาดูการใช้งานที่ซับซ้อน
รายการ 4. อินสแตนซ์ของการใช้งานที่ซับซ้อน
console.log (วัตถุอินสแตนซ์ของวัตถุ); // จริง console.log (ฟังก์ชั่นอินสแตนซ์ของฟังก์ชัน); // จริง console.log (หมายเลขอินสแตนซ์ของหมายเลข); // เท็จคอนโซล. log (สตริงสตริงสตริง); // false console.log (ฟังก์ชันอินสแตนซ์ของวัตถุ);
คุณสับสนอีกครั้งหลังจากอ่านรหัสด้านบนหรือไม่? ทำไมวัตถุและฟังก์ชั่นอินสแตนซ์ของตัวเองเท่ากันในขณะที่อินสแตนซ์อื่น ๆ ของตัวเองไม่เท่ากับความจริง? จะอธิบายได้อย่างไร? เพื่อให้เข้าใจถึงความลึกลับของอินสแตนซ์ของเราต้องเริ่มต้นจากสองด้าน: 1. วิธีการกำหนดตัวดำเนินการนี้ในข้อกำหนดภาษา 2. กลไกการสืบทอดต้นแบบ JavaScript
รายการ 5. JavaScript อินสแตนซ์ของรหัสผู้ประกอบการ
ฟังก์ชั่นอินสแตนซ์ _of (l, r) {// l หมายถึงนิพจน์ด้านซ้าย r หมายถึงนิพจน์ที่ถูกต้อง var o = r.prototype; // ใช้ต้นแบบการแสดงผลของ r l = l .__ โปรโต __; // ใช้ต้นแบบโดยนัยของ l ในขณะที่ (จริง) {ถ้า (l === null) ถ้า (o === l) // นี่คือประเด็น: เมื่อ o มีค่าเท่ากับ l อย่างเคร่งครัดกลับจริง l = l .__ proto__; -รายการ 6. วัตถุอินสแตนซ์ของวัตถุ
// เพื่อความสะดวกในการแสดงออกก่อนแยกความแตกต่างระหว่างนิพจน์ด้านซ้ายและวัตถุนิพจน์ด้านขวา = วัตถุ, objectr = วัตถุ; // ต่อไปนี้คือการค่อยๆอนุมาน o = objectr.prototype = object.prototype l = objectl .__ proto__ = function.prototype // การตัดสินครั้งแรกคือ o! = l // loop เพื่อค้นหาว่า l ยังคงมี __proto__ l = function.prototype.
รายการ 7. ฟังก์ชั่นฟังก์ชั่นฟังก์ชั่น
// เพื่อความสะดวกในการแสดงออกก่อนแยกความแตกต่างระหว่างนิพจน์ด้านซ้ายและฟังก์ชั่นนิพจน์ด้านขวา = ฟังก์ชั่นฟังก์ชั่น = ฟังก์ชั่น; // ต่อไปนี้คือการค่อยๆอนุมาน o = functionr.prototype = function.prototype l = functionl .__ proto__ = function.prototype // การตัดสินครั้งแรก o == l // ส่งคืนจริง
รายการ 8. อินสแตนซ์ foo ของ foo
// เพื่อความสะดวกในการแสดงออกก่อนแยกความแตกต่างระหว่างการแสดงออกทางซ้ายและการแสดงออกที่ถูกต้อง fool = foo, foor = foo; // ต่อไปนี้คือการอนุมานตามข้อกำหนด o = foor.prototype = foo.prototype l = fool .__ proto__ = function.prototype // การตัดสินครั้งแรกคือ o! = l // การตัดสินครั้งแรกคือ o! o! = l // วัฏจักรคือการค้นหาว่า l ยังคงมี __proto__ l = object.prototype .__ proto__ = null // การตัดสินครั้งที่สาม l == null // return false
วิเคราะห์การประยุกต์ใช้อินสแตนซ์ของกลไกการสืบทอด Dojo สั้น ๆ
ใน JavaScript ไม่มีแนวคิดของการสืบทอดหลายอย่างเช่นเดียวกับ Java อย่างไรก็ตามเมื่อประกาศคลาสใน Dojo การสืบทอดจากหลายคลาสจะได้รับอนุญาต ลองใช้ Dojo 1.6.1 เป็นตัวอย่าง
รายการ 9. การสืบทอดหลายครั้งในโดโจ
dojo.declare ("aoo", null, {}); dojo.declare ("boo", null, {}); dojo.declare ("foo", [aoo, boo], {}); var foo = new foo (); console.log (foo instanceof aoo); // true console.log (foo instanceof boo); // false console.log (foo.isinstanceof (aoo)); // true console.log (foo.isinstanceof (boo));ในตัวอย่างด้านบน Foo สืบทอดจากทั้ง AOO และ BOO แต่เมื่อใช้ตัวดำเนินการอินสแตนซ์ของตัวดำเนินการเพื่อตรวจสอบว่า FOO เป็นอินสแตนซ์ของ BOO มันจะกลับมาเป็นเท็จหรือไม่ ในความเป็นจริงภายใน Dojo, Foo ยังคงสืบทอดเฉพาะจาก AOO และใช้กลไก MixIn เพื่อคัดลอกวิธีการและคุณสมบัติในคลาส Boo to Foo ดังนั้นเมื่อใช้ตัวดำเนินการอินสแตนซ์ของตัวดำเนินการเพื่อตรวจสอบว่าเป็นอินสแตนซ์ของ BOO หรือไม่ FALSE จะถูกส่งคืน ดังนั้น Dojo จึงเพิ่มวิธีการใหม่ที่เรียกว่า isinstanceof สำหรับแต่ละอินสแตนซ์คลาสและใช้วิธีนี้เพื่อตรวจสอบการสืบทอดหลายครั้ง