JavaScript ไม่ใช่ภาษาที่มุ่งเน้นวัตถุและไม่ได้ให้วิธีการสืบทอดแบบดั้งเดิม แต่เป็นวิธีการสืบทอดต้นแบบโดยใช้คุณสมบัติต้นแบบที่ให้มาเพื่อให้ได้มรดก
ห่วงโซ่ต้นแบบเป็นวิธีหลักของการสืบทอดในจาวาสคริปต์
แนวคิดพื้นฐานของห่วงโซ่ต้นแบบคือ: ใช้ต้นแบบเพื่อให้ประเภทอ้างอิงหนึ่งประเภทเพื่อสืบทอดคุณสมบัติและวิธีการของประเภทอ้างอิงอื่น
ความสัมพันธ์ระหว่างตัวสร้าง, ต้นแบบและอินสแตนซ์: แต่ละตัวสร้างมีวัตถุต้นแบบวัตถุต้นแบบมีตัวชี้ไปยังตัวสร้างและอินสแตนซ์มีตัวชี้ภายในไปยังวัตถุต้นแบบ
หากวัตถุต้นแบบเท่ากับอินสแตนซ์ของวัตถุอื่นวัตถุต้นแบบจะมีตัวชี้ไปยังต้นแบบอื่นและดังนั้นต้นแบบอื่น ๆ ก็มีตัวชี้ไปยังตัวสร้างอื่น
โหมดพื้นฐานของการใช้งานห่วงโซ่ต้นแบบ:
ฟังก์ชั่น superType () {this.property = true;} supertype.prototype.getSuperValue = function () {return this.property;}; ฟังก์ชั่น subtype () {this.subproperty = talse;} // superType (); subtype.prototype.getSubValue = function () {return this.subproperty;}; var instance = new typepe (); Alert (instance.getSuperValue ()); // จริงชนิดย่อยสืบทอด supertype ซึ่งทำได้โดยการสร้างอินสแตนซ์ของ supertype และกำหนดอินสแตนซ์ให้กับชนิดย่อย. prototype สาระสำคัญของการใช้งานคือการเขียนวัตถุต้นแบบใหม่และแทนที่ด้วยอินสแตนซ์ของประเภทใหม่ ด้วยวิธีนี้คุณสมบัติและวิธีการที่มีอยู่เดิมในอินสแตนซ์ supertype ยังมีอยู่ใน subtype.prototype จากนั้นเพิ่มวิธีการลงใน subtype.prototype ซึ่งเพิ่มวิธีการอื่นตามการสืบทอดคุณสมบัติและวิธีการของ supertype
ความสัมพันธ์อินสแตนซ์ในตัวอย่างข้างต้นแสดงดังนี้:
ข้างต้นไม่ได้ใช้ต้นแบบที่จัดทำโดยชนิดย่อยโดยค่าเริ่มต้น แต่แทนที่ด้วยต้นแบบใหม่แทน ต้นแบบใหม่นี้เป็นตัวอย่างของ Supertype นอกจากนี้ยังมีตัวชี้ไปยังต้นแบบที่ดำเนินการ supertype ภายในต้นแบบใหม่ เป็นผลให้อินสแตนซ์ชี้ไปที่ต้นแบบของชนิดย่อยซึ่งชี้ไปที่ต้นแบบของ supertype วิธี getValue () ยังคงอยู่ใน supertype.prototype แต่ต้นแบบอยู่ในประเภทย่อย. prototype นี่เป็นเพราะคุณสมบัติเป็นคุณสมบัติอินสแตนซ์และ getSuperValue () เป็นวิธีต้นแบบ เนื่องจาก subtype.prototype เป็นอินสแตนซ์ของ supertype คุณสมบัติจึงตั้งอยู่ในอินสแตนซ์นั้นตามธรรมชาติ
หมายเหตุ: Instance.constructor ชี้ไปที่ Supertype เนื่องจากต้นแบบของคะแนนย่อยไปยังวัตถุอื่น - ต้นแบบของ Supertype และแอตทริบิวต์ตัวสร้างของวัตถุต้นแบบนี้ชี้ไปที่ Supertype
เมื่อเข้าถึงแอตทริบิวต์ในโหมดอ่านอินสแตนซ์จะถูกค้นหาครั้งแรกสำหรับแอตทริบิวต์นั้น หากไม่พบทรัพย์สิน จากนั้นการค้นหาต้นแบบของอินสแตนซ์จะดำเนินต่อไป เมื่อการสืบทอดประสบความสำเร็จผ่านห่วงโซ่ต้นแบบกระบวนการค้นหาสามารถเลื่อนขึ้นไปตามห่วงโซ่ต้นแบบได้
ต้นแบบเริ่มต้น
ประเภทการอ้างอิงทั้งหมดสืบทอดวัตถุโดยค่าเริ่มต้นและการสืบทอดนี้จะถูกนำไปใช้ผ่านห่วงโซ่ต้นแบบ ต้นแบบเริ่มต้นของฟังก์ชั่นทั้งหมดเป็นอินสแตนซ์ของวัตถุ ดังนั้นต้นแบบเริ่มต้นจะมีตัวชี้ภายในไปที่ Object.prototype นี่คือเหตุผลที่ประเภทที่กำหนดเองจะสืบทอดวิธีการเช่น toString (), valueof () ฯลฯ
ห่วงโซ่ต้นแบบที่สมบูรณ์:
ในระบบการสืบทอดข้างต้นชนิดย่อยสืบทอด supertype และ supertype สืบทอดวัตถุ เมื่อมีการเรียกอินสแตนซ์ toString () วิธีที่บันทึกไว้ใน Object.prototype เรียกจริง
กำหนดความสัมพันธ์ระหว่างอินสแตนซ์และต้นแบบ
มีสองวิธีในการกำหนดความสัมพันธ์ระหว่างต้นแบบและอินสแตนซ์:
ใช้อินสแตนซ์ของตัวดำเนินการ
การแจ้งเตือน (อินสแตนซ์อินสแตนซ์ของวัตถุ); การแจ้งเตือน (อินสแตนซ์อินสแตนซ์ของ supertype); การแจ้งเตือน (อินสแตนซ์อินสแตนซ์ของชนิดย่อย);
เนื่องจากความสัมพันธ์ระหว่างห่วงโซ่ต้นแบบทั้งหมดข้างต้นกลับมาเป็นจริง
ใช้วิธี isprototypeof ()
การแจ้งเตือน (object.prototype.isprototypeof (อินสแตนซ์)); การแจ้งเตือน (supertype.prototype.isprototypeof (อินสแตนซ์)); การแจ้งเตือน (subtype.prototype.isprototypeof (อินสแตนซ์)); การแจ้งเตือน (subtype.prototype.isprototypeof (อินสแตนซ์));
กำหนดวิธีการอย่างระมัดระวัง
รหัสเพื่อเพิ่มวิธีการลงในต้นแบบจะต้องวางหลังจากคำสั่งที่แทนที่ต้นแบบ
ฟังก์ชั่น supertype () {this.property = true;} supertype.prototype.getSuperValue = function () {return this.property;}; ฟังก์ชั่น subtype () {this.subproperty = talse; function () {return this.subproperty;}; // overwrite วิธี subtype.prototype.getSuperValue = function () {return this.subproperty;}; // overwrite วิธีย่อย subtype.prototype.getSuperValue subtype (); Alert (instance.getSuperValue ()); // เท็จในตัวอย่างด้านบนจะต้องสังเกตว่าหลังจากแทนที่ต้นแบบด้วยอินสแตนซ์ของ Supertype จากนั้นกำหนดวิธีการทั้งสองนั้น
นอกจากนี้เมื่อสืบทอดผ่านห่วงโซ่ต้นแบบคุณไม่สามารถใช้วัตถุตามตัวอักษรเพื่อสร้างวิธีการต้นแบบ เพราะการทำเช่นนั้นจะเขียนโซ่ต้นแบบใหม่:
ฟังก์ชั่น supertype () {this.property = true;} supertype.prototype.getSuperValue = function () {return this.property;}; ฟังก์ชั่น subtype () {this.subproperty = talse;} // บรรทัดก่อนหน้าของรหัส subtype.prototype = {getSubValue: function () {return this.subproperty;}, othermethod: function () {return false;}}; var instance = new type (); // ข้อผิดพลาดตัวอย่างข้างต้นกำหนดอินสแตนซ์ของ supertype ให้กับต้นแบบจากนั้นแทนที่ต้นแบบด้วยตัวอักษรวัตถุ ต้นแบบปัจจุบันมีอินสแตนซ์ของวัตถุไม่ใช่อินสแตนซ์ของ supertype และไม่มีความสัมพันธ์ระหว่างชนิดย่อยและ supertype
ปัญหาห่วงโซ่ต้นแบบ
ดังที่ได้กล่าวไว้ก่อนหน้านี้แอตทริบิวต์ต้นแบบที่มีประเภทอ้างอิงจะถูกแชร์โดยทุกกรณี นี่คือเหตุผลที่ควรกำหนดคุณลักษณะในตัวสร้างมากกว่าในวัตถุต้นแบบ
ฟังก์ชั่น superType () {this.colors = ["สีแดง", "สีน้ำเงิน", "เขียว"];} ฟังก์ชั่น subtype () {} subtype.prototype = new SuperType (); var instance1 = subtype ใหม่ (); // "สีแดง", "สีน้ำเงิน", "สีเขียว", "ดำ" var instance2 = new type (); แจ้งเตือน (อินสแตนซ์ 2.colors); // "สีแดง", "สีน้ำเงิน", "สีเขียว", "ดำ"ในตัวอย่างด้านบนคุณสมบัติสีถูกกำหนดไว้ในตัวสร้าง Supertype ซึ่งมีอาร์เรย์และแต่ละอินสแตนซ์ของ Supertype จะมีคุณสมบัติสีที่มีอาร์เรย์ของตัวเอง หลังจากชนิดย่อยสืบทอด supertype ผ่านห่วงโซ่ต้นแบบชนิดย่อย prototype กลายเป็นอินสแตนซ์ของ supertype ดังนั้นมันจึงมีแอตทริบิวต์สีของตัวเอง อย่างไรก็ตามอินสแตนซ์ทั้งหมดของชนิดย่อยแบ่งปันคุณสมบัติหนึ่งสีนี้
ปัญหาอีกประการหนึ่งคือไม่มีวิธีที่จะส่งผ่านพารามิเตอร์ไปยังตัวสร้างซูเปอร์คลาสโดยไม่ส่งผลกระทบต่ออินสแตนซ์ของวัตถุทั้งหมด
ข้างต้นเป็นความรู้ที่เกี่ยวข้องของ JavaScript ตามมรดกของห่วงโซ่ต้นแบบที่บรรณาธิการแนะนำให้คุณ ฉันหวังว่ามันจะเป็นประโยชน์กับคุณ หากคุณมีคำถามใด ๆ โปรดฝากข้อความถึงฉันและบรรณาธิการจะตอบกลับคุณทันเวลา ขอบคุณมากสำหรับการสนับสนุนเว็บไซต์ Wulin.com!