เมื่อเร็ว ๆ นี้เมื่อฉันเรียนรู้ JavaScript และเรียนรู้ต้นแบบของ JS Object-oriented ฉันมีข้อมูลเชิงลึกมากมาย หากมีบางอย่างผิดปกติฉันหวังว่ามันจะสามารถแก้ไขได้
ในฐานะที่เป็นภาษาที่มุ่งเน้นวัตถุ JS มีแนวคิดเกี่ยวกับการสืบทอด แต่ไม่มีแนวคิดของชั้นเรียนใน JS ดังนั้นจึงไม่มีการขยายคล้ายกับใน Java ดังนั้นฉันคิดว่าการสืบทอดใน JS ส่วนใหญ่ขึ้นอยู่กับต้นแบบ (โซ่) ใน JS
ดังนั้นต้นแบบคืออะไร? เรารู้ว่าฟังก์ชั่นใน JS ก็เป็นวัตถุเช่นกัน เมื่อเราสร้างฟังก์ชั่นฟังก์ชั่นจริง ๆ แล้วมีคุณสมบัติที่เรียกว่าต้นแบบ ประเภทประเภทนี้เรียกว่าคุณสมบัติต้นแบบ มันเป็นตัวชี้ที่ชี้ไปที่วัตถุต้นแบบของฟังก์ชันนี้ วัตถุต้นแบบนี้มีคุณสมบัติเริ่มต้นที่เรียกว่าตัวสร้าง ประเภทประเภทนี้ชี้ไปที่ฟังก์ชั่นที่มีประเภทต้นแบบ
ฟังก์ชันบุคคล () {} person.prototype = {// constructor: person; first_name: "guo", hair_color: "Black", City: "Zhengzhou", Act: function () {Alert ("Eatting");}};ยกตัวอย่างสิ่งนี้เป็นครั้งแรกที่เราสร้างคนฟังก์ชั่น ฟังก์ชั่นนี้มีต้นแบบแอตทริบิวต์เริ่มต้นชี้ไปที่วัตถุ PROPTTYPE วัตถุนี้มีแอตทริบิวต์เริ่มต้นที่สร้างสรรค์ (), person.prototype.constructor ---> บุคคล (อันที่จริงค่าเริ่มต้นที่นี่คือการชี้ไปที่วัตถุและการแก้ไขจะทำในภายหลัง)
จะเกิดอะไรขึ้นเมื่อเราสร้างอินสแตนซ์ผ่านตัวสร้าง
ฟังก์ชั่นบุคคล () {} person.prototype = {first_name: "guo", hair_color: "ดำ", เมือง: "Zhengzhou", Act: function () {Alert ("Eatting");}}; var boy = คนใหม่ (); var girl = คนใหม่ ();ในเวลานี้เราจำเป็นต้องรู้ว่าความแตกต่างระหว่างตัวสร้างและฟังก์ชั่นใน JS เป็นคำหลักใหม่และฟังก์ชั่นที่ใช้ตัวดำเนินการใหม่เป็นตัวสร้าง เมื่อเราสร้างวัตถุอินสแตนซ์ของบุคคลและบันทึกไว้ใน Boy, Girl วัตถุสองอินสแตนซ์นี้จะสร้างแอตทริบิวต์เริ่มต้นที่เรียกว่า _proto_ (ซึ่งสามารถแสดงได้ด้วย [[ต้นแบบ]] ใน ecmascript5) ประเภทประเภทนี้ชี้ไปที่วัตถุต้นแบบของตัวสร้างนั่นคือ boy._proto _--> person.prototype (ไม่มีส่วนเกี่ยวข้องกับตัวสร้าง) ในเวลานี้เด็กชายหรือเด็กหญิงสามารถใช้คะแนนเพื่อเรียกประเภทประเภทในวัตถุต้นแบบ ในเวลานี้คุณควรรู้ว่าเด็กชายและเด็กหญิงแบ่งปันประเภทประเภทของวัตถุต้นแบบ เราสามารถตรวจสอบข้อสรุปข้างต้นโดย isprotptypeof () หรือ object.getPrototypeof () (ค่าส่งคืนของฟังก์ชั่นนี้คือวัตถุต้นแบบนั่นคือค่าของ _proto_)
การแจ้งเตือน (person.prototype.isprototypeof (boy)); // การแจ้งเตือนจริง (Object.getPrototypeof (Boy) .first_name); // "guo"
ในเวลานี้เราสามารถทำการตรวจสอบเพิ่มเติมได้ ถ้าเราสร้างแอตทริบิวต์ที่ทำซ้ำกับแอตทริบิวต์วัตถุต้นแบบในอินสแตนซ์
var boy = คนใหม่ (); var girl = คนใหม่ (); boy.hair_color = "สีแดง"; การแจ้งเตือน (boy.hair_color); // การแจ้งเตือนสีแดง (girl.hair_color); // Black Alert (Object.getPrototypeof (Boy) .hair_color); //สีดำ
จะเห็นได้ว่าแอตทริบิวต์ที่ซ้ำกันที่ประกาศในอินสแตนซ์จะบล็อกคุณสมบัติในวัตถุต้นแบบ แต่มันจะถูกเขียนทับและจะไม่ส่งผลกระทบต่อประเภทประเภทของวัตถุต้นแบบ (Object.getPrototypeof (boy) .hair_color == สีดำ) ในเวลาเดียวกันคุณสามารถใช้ตัวดำเนินการลบเพื่อลบแอตทริบิวต์ที่ประกาศโดยวัตถุอินสแตนซ์เพื่อยกเลิกเอฟเฟกต์การปิดบัง เราสามารถใช้ HasownProperty () เพื่อตรวจสอบว่ามีสกุลอยู่ในอินสแตนซ์ (จริง) หรือในวัตถุต้นแบบ (เท็จ)
การแจ้งเตือน (boy.hasownproperty ("hair_color")); //จริงคุณสามารถใช้ Object.keys () เพื่อระบุคุณสมบัติ
var key = object.keys (person.prototype); การแจ้งเตือน (กุญแจ);
หลังจากเรียนรู้สิ่งเหล่านี้เราจะพบว่าการใช้วิธีการเขียนข้างต้นเพื่อประกาศวัตถุต้นแบบจะมีปัญหา ตัวสร้างไม่ชี้ไปที่บุคคลอีกต่อไปซึ่งตรงกันข้ามกับการชี้ไปที่ฟังก์ชั่นที่มีแอตทริบิวต์ต้นแบบ นี่เป็นเพราะ: ทุกครั้งที่มีการสร้างฟังก์ชั่นวัตถุต้นแบบจะถูกสร้างขึ้นโดยอัตโนมัติและวัตถุนี้จะสร้างตัวสร้างตามค่าเริ่มต้น ดังนั้นที่นี่สาระสำคัญของเราคือการเขียนต้นแบบเริ่มต้นใหม่ดังนั้นโครงสร้างใหม่จึงกลายเป็นจุดชี้ไปที่ฟังก์ชั่นวัตถุไม่ชี้ไปที่ฟังก์ชันบุคคลอีกต่อไป หากตัวสร้างมีความสำคัญจริง ๆ คุณต้องเขียนตัวสร้าง: บุคคล
หลังจากนั้นเราจำเป็นต้องรู้พลวัตของต้นแบบ การเปลี่ยนคุณสมบัติในวัตถุต้นแบบจะสะท้อนให้เห็นในอินสแตนซ์โดยไม่คำนึงว่าอินสแตนซ์จะถูกสร้างขึ้นก่อนหรือหลังการเปลี่ยนแปลงทั่วไปของวัตถุต้นแบบ
ฟังก์ชั่นบุคคล () {} person.prototype = {first_name: "guo", hair_color: "ดำ", เมือง: "Zhengzhou", Act: function () {Alert ("Eatation");}}; var boy = คนใหม่ (); person.prototype.hobby = "บาสเก็ตบอล"; var girl = คนใหม่ (); การแจ้งเตือน (boy.hobby); //บาสเกตบอลดังที่แสดงในรหัสข้างต้นแม้ว่าการดัดแปลงคุณสมบัติวัตถุต้นแบบจะเกิดขึ้นหลังจากการสร้างอินสแตนซ์อินสแตนซ์ของเด็กยังคงแบ่งปัน person.prototype.hobby
อย่างไรก็ตามสถานการณ์นี้จะเกิดขึ้นก็ต่อเมื่อแอตทริบิวต์วัตถุต้นแบบได้รับการแก้ไข เมื่อแอตทริบิวต์วัตถุต้นแบบมีการเขียนใหม่อย่างสมบูรณ์การสร้างอินสแตนซ์จะต้องวางหลังจากแอตทริบิวต์วัตถุต้นแบบเขียนใหม่มิฉะนั้นข้อผิดพลาดจะเกิดขึ้น
ฟังก์ชั่นบุคคล () {} var girl = คนใหม่ (); person.prototype = {first_name: "guo", hair_color: "Black", City: "Zhengzhou", Act: function () {Alert ("Eatation");}}; var boy = คนใหม่ (); person.prototype.hobby = "บาสเก็ตบอล"; การแจ้งเตือน (boy.hobby); // การแจ้งเตือนบาสเก็ตบอล (girl.first_name); // ไม่ได้กำหนดกลับไปที่ปัญหาของ "การบล็อก" เราได้เรียนรู้ก่อนหน้านี้ว่าการสร้างแอตทริบิวต์ของวัตถุอินสแตนซ์ (ชื่อเดียวกับแอตทริบิวต์บางอย่างในวัตถุต้นแบบ) จะบล็อกแอตทริบิวต์ของวัตถุต้นแบบ แต่จะไม่ส่งผลกระทบต่อวัตถุอินสแตนซ์อื่น ๆ มีข้อผิดพลาดที่นี่ สถานการณ์นี้ใช้กับชนิดข้อมูลพื้นฐานเท่านั้น เมื่อค่าของแอตทริบิวต์หมายถึงประเภทปัญหาใหญ่จะเกิดขึ้น ดูรหัสต่อไปนี้
ฟังก์ชั่นบุคคล () {} person.prototype = {first_name: "guo", hair_color: "ดำ", เพื่อน: ["nick", "John"], เมือง: "Zhengzhou", Act: function () {แจ้งเตือน ("Eatation");}}; var boy = คนใหม่ (); boy.friends.push ("ไมค์"); var girl = คนใหม่ (); การแจ้งเตือน (boy.friends); // Nick, John, Mike Alert (girl.friends); // Nick, John, Mikeจะเห็นได้ว่าประโยคข้างต้นไม่ได้ใช้เพราะเพื่อนมีอยู่ในวัตถุต้นแบบไม่ใช่ในเด็กดังนั้นการดัดแปลงจะส่งผลกระทบต่อสภาพแวดล้อมนี้ (เราสามารถสร้างคุณสมบัติของอินสแตนซ์ของเด็กชายผ่าน boy.frindes = []) จากนั้นเราต้องแนะนำการรวมกันของรูปแบบตัวสร้างและรูปแบบต้นแบบ
ฟังก์ชั่นบุคคล (hair_color, เมือง) {this.hair_color = hair_color; this.city = เมือง; this.friends = ["John", "Nick"]; } person.prototype = {constructor: person, first_name: "guo", act: function () {alert ("Eatation"); - var boy = คนใหม่ ("ดำ", "Zhengzhou"); var girl = คนใหม่ ("สีแดง", "Shenyang"); boy.friends.push ("Nick"); Alert (girl.friends); การแจ้งเตือน (boy.friends);โหมดนี้เป็นวิธีที่ใช้กันอย่างแพร่หลายและเป็นที่รู้จักมากที่สุดในการสร้างประเภทที่กำหนดเองใน ECMASCript และสามารถใช้เป็นโหมดเริ่มต้นได้
แต่สำหรับโปรแกรมเมอร์ที่ทำงานในภาษาที่มุ่งเน้นวัตถุอื่น ๆ รูปแบบนี้ดูแปลก ๆ เพื่อที่จะห่อหุ้มข้อมูลทั้งหมดลงในตัวสร้างรูปแบบต้นแบบแบบไดนามิกจะปรากฏขึ้น โหมดไดนามิกส่วนใหญ่ใช้คำสั่ง IF เพื่อตรวจสอบว่าวัตถุต้นแบบจะต้องเริ่มต้นเพื่อให้บรรลุวัตถุประสงค์ในการออมทรัพยากรหรือไม่
นอกจากนี้ยังมีโหมดการก่อสร้างที่ปลอดภัยเพื่อปรับให้เข้ากับสถานการณ์ที่ไม่มีแอตทริบิวต์ที่ใช้ร่วมกันและไม่มีการใช้งานนี้
การวิเคราะห์ต้นแบบข้างต้นใน JavaScript [แนะนำ] เป็นเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่าคุณจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น