ไวยากรณ์
วัตถุอินสแตนซ์ของตัวสร้าง
พารามิเตอร์
วัตถุ:
วัตถุที่จะตรวจพบ
ตัวสร้าง:
ตัวสร้าง
อธิบาย:
ตัวดำเนินการอินสแตนซ์ของตัวดำเนินการเพื่อตรวจจับว่าตัวสร้างโปรเซสเซอร์มีอยู่ในห่วงโซ่ต้นแบบของวัตถุพารามิเตอร์หรือไม่
// กำหนดฟังก์ชั่นคอนสตรัคเตอร์ c () {} ฟังก์ชัน d () {} var o = new c (); // true เพราะ object.getPrototypeof (o) === c.prototypeo อินสแตนซ์ของ C; // false เนื่องจาก d.prototype ไม่ได้อยู่ในห่วงโซ่ต้นแบบของ O Instanceof d; o อินสแตนซ์ของวัตถุ; // true เนื่องจาก object.prototype.isprototypeof (o) ส่งคืน trueec.prototype อินสแตนซ์ของวัตถุ // true เหมือนกับข้างต้น c.prototype = {}; var o2 = new c (); o2 instanceof c; // trueo instanceof c; // false, c.prototype ชี้ไปที่วัตถุเปล่าซึ่งไม่ได้อยู่ในห่วงโซ่ต้นแบบของ O.D.Prototype = ใหม่ C (); // สืบทอด var o3 = new d (); O3 instanceof d; // trueO3 instanceof c; // จริงควรสังเกตว่าหากนิพจน์ OBJ อินสแตนซ์ของ foo ส่งคืนจริงมันไม่ได้หมายความว่านิพจน์จะกลับมา ture ตลอดไปเนื่องจากค่าของคุณสมบัติ foo.prototype อาจเปลี่ยนแปลงและค่าที่เปลี่ยนแปลงอาจไม่มีอยู่ในห่วงโซ่ต้นแบบ OBJ และค่าของนิพจน์ดั้งเดิมจะกลายเป็นเท็จ ในอีกกรณีหนึ่งค่าของนิพจน์ดั้งเดิมจะเปลี่ยนไปเช่นกันซึ่งเป็นกรณีที่ห่วงโซ่ต้นแบบของวัตถุ OBJ เปลี่ยนไป แม้ว่าในข้อกำหนด ES ปัจจุบันเราสามารถอ่านต้นแบบของวัตถุเท่านั้นและไม่สามารถเปลี่ยนแปลงได้สามารถทำได้ด้วยความช่วยเหลือของแอตทริบิวต์เวทมนตร์ __proto__ ที่ไม่ได้มาตรฐาน ตัวอย่างเช่นหลังจากดำเนินการ obj .__ proto__ = {}, obj instanceof foo จะกลับมาเป็นเท็จ
อินสแตนซ์ของวัตถุและหลาย global (ปฏิสัมพันธ์ระหว่างหลายเฟรมหรือหลายหน้าต่าง)
ในเบราว์เซอร์สคริปต์ของเราอาจจำเป็นต้องโต้ตอบระหว่างหลายหน้าต่าง Windows หลายแห่งหมายถึงสภาพแวดล้อมทั่วโลกที่หลากหลายและสภาพแวดล้อมทั่วโลกที่แตกต่างกันมีวัตถุระดับโลกที่แตกต่างกันดังนั้นจึงมีตัวสร้างประเภทในตัวที่แตกต่างกัน สิ่งนี้อาจทำให้เกิดปัญหาบางอย่าง ตัวอย่างเช่นนิพจน์ [] อินสแตนซ์ของ window.frames [0] .Array จะกลับเท็จเพราะ array.prototype! == window.frames [0] .array.prototype ดังนั้นคุณต้องใช้ array.isarray (myobj) หรือวัตถุ
ตัวอย่าง
การใช้งานทั่วไปของอินสแตนซ์คือการตรวจสอบว่าเป็นประเภท B:
console.log (อินสแตนซ์จริงของบูลีน); // false console.log (หมายเลขใหม่ (1) หมายเลขอินสแตนซ์); // จริง
อินสแตนซ์ของสามารถกำหนดประเภทหลัก:
ฟังก์ชั่นพ่อ () {} ฟังก์ชั่นเด็ก () {} child.prototype = พ่อใหม่ (); var a = เด็กใหม่ (); console.log (เด็กอินสแตนซ์); // trueconsole.log (อินสแตนซ์ของพ่อ); // จริงตัวสร้างเด็กสืบทอดมาจากพ่อ อินสแตนซ์ A ถูกสร้างขึ้นโดยเด็กอย่างไม่ต้องสงสัย แต่ทำไมมันถึงเป็นตัวอย่างของพ่อ? ในความเป็นจริงเคอร์เนลของตัวดำเนินการอินสแตนซ์สามารถอธิบายได้ง่ายๆด้วยรหัสต่อไปนี้:
การตรวจสอบฟังก์ชั่น (a, b) {ในขณะที่ (a .__ proto__) {ถ้า (a .__ proto__ === b.prototype) กลับมาจริง; a = a .__ proto__; } return false;} function foo () {} console.log (วัตถุอินสแตนซ์ของวัตถุ === ตรวจสอบ (วัตถุ, วัตถุ)); // จริง console.log (ฟังก์ชั่นอินสแตนซ์ของฟังก์ชั่น === ตรวจสอบ (ฟังก์ชั่น, ฟังก์ชั่น)); // True Console.log (หมายเลขอินสแตนซ์ของหมายเลข === ตรวจสอบ (หมายเลข, หมายเลข)); // จริง console.log (สตริงอินสแตนซ์ของสตริง === ตรวจสอบ (สตริง, สตริง)); // จริง console.log (ฟังก์ชั่นอินสแตนซ์ของวัตถุ === ตรวจสอบ (ฟังก์ชั่น, วัตถุ)); // จริง console.log (foo instanceof function === ตรวจสอบ (foo, function)); // จริง console.log (foo instanceof foo === ตรวจสอบ (foo, foo)); // จริง console.log (foo instanceof foo === ตรวจสอบ (foo, foo)); // จริง console.log (foo instanceof foo === ตรวจสอบ (foo, foo)); // จริงพูดง่ายๆคือถ้า A เป็นอินสแตนซ์ของ B ดังนั้น A สามารถใช้วิธีการและคุณสมบัติที่กำหนดไว้ในต้นแบบของ B ได้อย่างแน่นอน จากนั้นในรหัสหมายความว่ามีวัตถุที่มีค่าเท่ากันในห่วงโซ่ต้นแบบที่มี b.prototype ดังนั้นเพียงทำตามห่วงโซ่ต้นแบบของ A เพื่อค้นหาเลเยอร์โดยเลเยอร์
นอกจากนี้ยังเป็นที่น่าสังเกตว่าบูลีนหมายเลขสตริงและฟังก์ชั่นเป็นฟังก์ชั่นและฟังก์ชั่นถูกสร้างขึ้นอย่างสม่ำเสมอจากฟังก์ชั่น พวกเขาเป็นเหมือนฟังก์ชั่นง่าย ๆ และพวกเขาสามารถใช้คุณสมบัติต้นแบบในฟังก์ชั่น:
function.prototype.a = 10; console.log (string.a); // 10
สุดท้ายเรามาพูดคุยสั้น ๆ เกี่ยวกับคำถามสองข้อแรก
// เพื่อความสะดวกในการแสดงออกก่อนแยกแยะนิพจน์ด้านซ้ายและฟังก์ชั่นนิพจน์ด้านขวา = ฟังก์ชั่น, functionr = function; // ด้านล่างจะค่อยๆอนุมานตามข้อกำหนด o = functionr.prototype = function.prototype l = functionl .__ proto__ = function.prototype // การตัดสินครั้งแรก o == l // ส่งคืนจริง // เพื่อความสะดวกของการแสดงออก // ด้านล่างจะค่อยๆอนุมานตามข้อกำหนด o = stringr.prototype = string.prototype l = stringl .__ proto__ = function.prototype // ครั้งแรกที่ตัดสิน o! ยังคงมี __proto__ l = string.prototype .__ proto__ = null // ครั้งที่สามผู้พิพากษา l == null // return false