5. การสืบทอดปรสิต
เช่นเดียวกับตัวสร้างกาฝากและรูปแบบโรงงานสร้างฟังก์ชั่นที่ใช้เพื่อห่อหุ้มกระบวนการสืบทอดซึ่งจะช่วยเพิ่มวัตถุภายในบางวิธีและในที่สุดก็ส่งคืนวัตถุ
ฟังก์ชั่น createAnother (ต้นฉบับ) {var clone = object.create (ต้นฉบับ); // สร้างวัตถุใหม่โดยเรียกฟังก์ชั่น clone.sayhi = function () {// ปรับปรุงวัตถุนี้ในบางวิธีการแจ้งเตือน ("hi"); - กลับโคลน; // ส่งคืนวัตถุนี้} var person = {ชื่อ: "Bob", เพื่อน: ["Shelby", "Court", "Van"]}; var otherperson = createAnother (บุคคล); อีกคนหนึ่ง Sayhi ();ในตัวอย่างข้างต้นฟังก์ชั่น CreateAnother ได้รับพารามิเตอร์นั่นคือวัตถุที่จะใช้เป็นพื้นฐานของวัตถุใหม่
อีกคนหนึ่งเป็นวัตถุใหม่ที่สร้างขึ้นตามบุคคล วัตถุใหม่ไม่เพียง แต่มีคุณสมบัติและวิธีการทั้งหมดของบุคคลเท่านั้น แต่ยังรวมถึงวิธี Sayhi () ของตัวเอง
6. การสืบทอดการรวมกันของปรสิต
การสืบทอดการรวมกันเป็นรูปแบบการสืบทอดที่ใช้กันมากที่สุดใน JS ปัญหาที่ใหญ่ที่สุดของการสืบทอดการรวมกันคือตัวสร้างจะถูกเรียกสองครั้งในทุกกรณี: หนึ่งครั้งเมื่อสร้างต้นแบบชนิดย่อยและเวลาอื่น ๆ ภายในตัวสร้างชนิดย่อย
ฟังก์ชั่น supertype (ชื่อ) {this.name = name; this.colors = ["red", "blue", "green"];} supertype.prototype.sayname = function () {alert (this.name);} ฟังก์ชั่นย่อย (ชื่อ, อายุ) {supertype.call (นี่, ชื่อ); // การเรียกครั้งที่สองไปยัง superType () this.age = age;} subtype.prototype = new supertype (); // การเรียกครั้งแรกไปยัง superType () subtype.prototype.sayage = function () {Alert (this.age);}เมื่อตัวสร้าง Supertype ถูกเรียกเป็นครั้งแรกประเภทย่อย prototype จะได้รับสองคุณสมบัติ: ชื่อและสี; พวกเขาทั้งสองคุณสมบัติอินสแตนซ์ของ Supertype แต่ตอนนี้พวกเขาอยู่ในต้นแบบชนิดย่อย
เมื่อมีการเรียกตัวสร้างชนิดย่อยตัวสร้าง Supertype จะถูกเรียกอีกครั้งและในครั้งนี้ชื่อแอตทริบิวต์อินสแตนซ์จะถูกสร้างขึ้นบนวัตถุใหม่
ดังนั้นคุณลักษณะทั้งสองนี้บล็อกแอตทริบิวต์สองชื่อของชื่อเดียวกันในต้นแบบ
การสืบทอดการรวมกันของกาฝากคือการแก้ปัญหานี้
สืบทอดคุณลักษณะโดยการยืมตัวสร้าง;
สืบทอดวิธีการผ่านห่วงโซ่ต้นแบบ
ไม่จำเป็นต้องเรียกตัวสร้าง Supertype เพื่อระบุต้นแบบของชนิดย่อย
ฟังก์ชั่นสืบต่อมรดก (ชนิดย่อย, supertype) {var prototype = object.create (supertype.prototype); // สร้างวัตถุต้นแบบ object.constructor = ชนิดย่อย; // ปรับปรุงประเภทย่อยของวัตถุ prototype = ต้นแบบ; // ระบุวัตถุ} ฟังก์ชั่น superType (ชื่อ) {this.name = name; this.colors = ["red", "blue", "green"];} supertype.prototype.sayname = function () {alert (this.name);} ฟังก์ชั่นย่อย (ชื่อ, อายุ) {supertype.call (นี่, ชื่อ); // การเรียกครั้งที่สองไปยัง superType () this.age = age;} ermeritPrototype (subtype, supertype) subtype.prototype.sayage = function () {Alert (this.age);} var อินสแตนซ์ = ชนิดย่อยใหม่ ("bob", 18);ฟังก์ชั่นการสืบทอดข้อมูลมรดกได้รับสองพารามิเตอร์: ตัวสร้างชนิดย่อยและตัวสร้าง Supertype
1. สร้างสำเนาของต้นแบบ supertype
2. เพิ่มแอตทริบิวต์ตัวสร้างให้กับสำเนาที่สร้างขึ้นเพื่อชดเชยแอตทริบิวต์เริ่มต้นเริ่มต้นเนื่องจากการเขียนต้นแบบใหม่
3. กำหนดวัตถุที่สร้างขึ้นใหม่ (เช่นคัดลอก) ให้กับต้นแบบของชนิดย่อย วิธีนี้เรียกใช้ตัวสร้าง Supertype เพียงครั้งเดียวและอินสแตนซ์ของและ isprototypeof () สามารถใช้งานได้ตามปกติ
บทความข้างต้นพูดสั้น ๆ เกี่ยวกับการสืบทอดมรดก js _parasitic มรดกและปรสิตการรวมกันเป็นเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่าคุณจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น