เมื่อสร้างวัตถุผ่านตัวสร้างวัตถุหรือตัวอักษรวัตถุเมื่อสร้างวัตถุจำนวนมากด้วยอินเทอร์เฟซเดียวกันจะมีการสร้างรหัสซ้ำจำนวนมาก เพื่อความเรียบง่ายแบบจำลองโรงงานได้รับการแนะนำ
รูปแบบโรงงาน
ฟังก์ชั่น createperson (ชื่อ, อายุ, งาน) {var obj = วัตถุใหม่ (); obj.name = ชื่อ; obj.age = อายุ; obj.job = โยบ; obj.sayhello () {แจ้งเตือน (this.name); - return obj;} var p1 = createperson ("xxyh", 19, "โปรแกรมเมอร์"); var p2 = createperson ("จางซาน", 18, "นักเรียน");วิธีการสร้างวัตถุนี้ทำให้รหัสง่ายขึ้นอย่างมาก แต่ก็มีข้อบกพร่องนั่นคือประเภทของวัตถุไม่สามารถกำหนดได้ เพื่อแก้ปัญหานี้รูปแบบต่อไปนี้จะปรากฏขึ้น
โหมดตัวสร้าง
สร้างตัวสร้างที่กำหนดเองเพื่อกำหนดคุณสมบัติและวิธีการของประเภทวัตถุที่กำหนดเอง
ฟังก์ชั่นบุคคล (ชื่อ, อายุ, งาน) {this.name = name; this.age = อายุ; this.job = งาน; this.sayName = function () {Alert (this.name); };} var p1 = บุคคลใหม่ ("xxyh", 19, "โปรแกรมเมอร์"); var p2 = บุคคลใหม่ ("แจ็ค", 18, "นักเรียน");ในตัวอย่างข้างต้นบุคคล () แทนที่ createperson () นอกจากนี้ยังมีความแตกต่างหลายประการ:
•สร้างวัตถุโดยไม่แสดง
•กำหนดแอตทริบิวต์และวิธีการโดยตรงให้กับวัตถุนี้
•ไม่มีคำสั่งคืน
ในการสร้างวัตถุบุคคลคุณต้องใช้ตัวดำเนินการใหม่ แบ่งออกเป็น 4 ขั้นตอน:
•สร้างวัตถุใหม่
•กำหนดขอบเขตของตัวสร้างให้กับวัตถุใหม่
•เรียกใช้รหัสในตัวสร้าง
•ส่งคืนวัตถุใหม่
P1 และ P2 ตามลำดับบันทึกตัวอย่างของบุคคล
การแจ้งเตือน (P1.Constructor == บุคคล); // truealert (p2.constructor == บุคคล); // จริง
เป็นการดีที่สุดที่จะใช้อินสแตนซ์ของเมื่อตรวจจับประเภท:
การแจ้งเตือน (วัตถุอินสแตนซ์ P1); // truealert (p1 instanceof person); // truealert (วัตถุอินสแตนซ์ p2); // truealert (p2 instanceof person); // truealert (p2 instanceof person); // จริง
P1 และ P2 เป็นอินสแตนซ์ของวัตถุเนื่องจากวัตถุทั้งหมดได้รับการสืบทอดมาจากวัตถุ
2.1 ปฏิบัติต่อตัวสร้างเป็นฟังก์ชั่น
// ใช้ var person = บุคคลใหม่ ("xxyh", 19, "โปรแกรมเมอร์"); Person.SayName (); // "xxyh" // ใช้เป็นคนฟังก์ชั่นปกติ ("จาง", 18, "นักเรียน"); // เพิ่มลงใน windowwindow.sayname (); // "Zhangsan" // เรียก var obj ในขอบเขตของวัตถุอื่น obj = วัตถุใหม่ (); person.call (obj, "Jack", 29, "Manager"); obj.sayname (); // "Jack", OBJ มีคุณสมบัติและวิธีการทั้งหมด2.2 ปัญหาตัวสร้าง
ปัญหาเกี่ยวกับการใช้ตัวสร้างคือแต่ละวิธีจะต้องสร้างใหม่ในแต่ละอินสแตนซ์ P1 และ P2 ทั้งคู่มีวิธี Sayname () แต่พวกเขาไม่ใช่อินสแตนซ์ของฟังก์ชัน ใน JavaScript ฟังก์ชั่นเป็นวัตถุดังนั้นทุกครั้งที่มีการกำหนดฟังก์ชั่นวัตถุจะถูกสร้างอินสแตนซ์
ตัวสร้างยังสามารถกำหนดเช่นนี้:
ฟังก์ชั่นบุคคล (ชื่อ, อายุ, งาน) {this.name = name; this.age = อายุ; this.job = งาน; this.sayname = ฟังก์ชันใหม่ ("Alert (this.name)");}ดังนั้นฟังก์ชั่นของชื่อเดียวกันในอินสแตนซ์ที่แตกต่างกันจึงไม่เท่ากัน:
การแจ้งเตือน (P1.SayName == P2.SayName); // เท็จ
อย่างไรก็ตามการสร้างฟังก์ชั่นสองฟังก์ชั่นที่มีฟังก์ชั่นเดียวกันนั้นซ้ำซ้อนและไม่จำเป็นต้องผูกฟังก์ชันกับวัตถุเฉพาะก่อนที่จะดำเนินการรหัส
ฟังก์ชั่นบุคคล (ชื่อ, อายุ, งาน) {this.name = name; this.age = อายุ; this.job = งาน; this.sayname = sayname;} ฟังก์ชั่น sayname () {alert (this.name);} var p1 = บุคคลใหม่ ("xxyh", 19, "โปรแกรมเมอร์"); var p2 = บุคคลใหม่ ("แจ็ค", 18, "นักเรียน");ข้างต้นย้ายคำจำกัดความของ sayname () นอกคอนสตรัคเตอร์จากนั้นตั้งค่าแอตทริบิวต์บอกว่าชื่อเป็นฟังก์ชัน Sayname ทั่วโลกภายในคอนสตรัคเตอร์ ด้วยวิธีนี้ Sayname มีตัวชี้ไปยังฟังก์ชันและ P1 และ P2 แบ่งปันฟังก์ชั่น Sayname () เดียวกันที่กำหนดไว้ในขอบเขตทั่วโลก
อย่างไรก็ตามมีปัญหาใหม่เกี่ยวกับสิ่งนี้: ฟังก์ชั่นที่กำหนดไว้ในขอบเขตทั่วโลกสามารถเรียกได้โดยวัตถุบางอย่างเท่านั้น และหากวัตถุกำหนดวิธีการหลายวิธีประเภทการอ้างอิงจะสูญเสียการห่อหุ้ม
โหมดลูกโซ่ต้นแบบ
แต่ละฟังก์ชั่นมีคุณสมบัติต้นแบบซึ่งเป็นตัวชี้ชี้ไปที่วัตถุ วัตถุประสงค์ของวัตถุนี้คือ การรวมคุณสมบัติและวิธีการที่สามารถแบ่งปันได้โดยทุกกรณีของประเภทเฉพาะ ต้นแบบเป็นวัตถุต้นแบบของอินสแตนซ์ของวัตถุที่สร้างขึ้นโดยเรียกตัวสร้าง ข้อได้เปรียบของการใช้วัตถุต้นแบบคืออินสแตนซ์วัตถุทั้งหมดสามารถแบ่งปันคุณสมบัติและวิธีการที่มีอยู่ ซึ่งหมายความว่าแทนที่จะกำหนดข้อมูลของอินสแตนซ์วัตถุในตัวสร้างข้อมูลนี้จะถูกเพิ่มลงในวัตถุต้นแบบ
ฟังก์ชั่นบุคคล () {} person.prototype.name = "xxyh"; person.prototype.age = 19; person.prototype.job = "โปรแกรมเมอร์"; person.prototype.sayname = function () {Alert (this.name); person1.SayName (); // "xxyh" var person2 = คนใหม่ (); person2.sayname (); // "xxyh" แจ้งเตือน (person1.sayname == person2.sayname); // จริง3.1 การทำความเข้าใจวัตถุต้นแบบ
เพียงสร้างฟังก์ชั่นใหม่คุณสมบัติต้นแบบจะถูกสร้างขึ้นสำหรับฟังก์ชั่นซึ่งชี้ไปที่วัตถุต้นแบบของฟังก์ชั่น โดยค่าเริ่มต้นวัตถุต้นแบบทั้งหมดจะได้รับคุณสมบัติตัวสร้างโดยอัตโนมัติ คุณสมบัตินี้มีตัวชี้ไปยังฟังก์ชั่นที่คุณสมบัติของต้นแบบตั้งอยู่ person.prototype.constructor ชี้ไปที่บุคคล
เมื่อตัวสร้างถูกเรียกให้สร้างอินสแตนซ์ด้านในของอินสแตนซ์จะมีตัวชี้ (คุณสมบัติภายใน) ไปยังวัตถุต้นแบบของตัวสร้างที่เรียกว่า [[ต้นแบบ]] เข้าถึงผ่าน _proto ใน Firefox, Safari และ Chrome การเชื่อมต่อนี้มีอยู่ระหว่างอินสแตนซ์และวัตถุต้นแบบของตัวสร้างไม่ใช่ระหว่างอินสแตนซ์และตัวสร้าง
รูปต่อไปนี้แสดงความสัมพันธ์ระหว่างแต่ละวัตถุ:
person.prototype ชี้ไปที่วัตถุต้นแบบและ person.prototype.constructor ชี้ไปที่บุคคล นอกเหนือจากแอตทริบิวต์ตัวสร้างแล้วยังมีคุณลักษณะอื่น ๆ ที่เพิ่มเข้ามาในต้นแบบ อินสแตนซ์ของบุคคลทั้งหมดมีทรัพย์สินภายในที่ชี้ไปที่บุคคลเฉพาะและพวกเขาไม่มีความสัมพันธ์โดยตรงกับตัวสร้าง
แม้ว่า [[ต้นแบบ]] ไม่สามารถเข้าถึงได้ แต่วิธีการ isprototypeof () สามารถใช้เพื่อตรวจสอบว่าความสัมพันธ์ระหว่างวัตถุดังกล่าวมีความสัมพันธ์ระหว่างวัตถุหรือไม่
การแจ้งเตือน (person.prototype.isprototypeof (person1)); // truealert (person.prototype.isprototypeof (person2)); // จริง
เมื่ออ่านคุณสมบัติของวัตถุการค้นหาจะดำเนินการ โดยมีเป้าหมายของแอตทริบิวต์ด้วยชื่อที่กำหนด การค้นหาเริ่มต้นด้วยอินสแตนซ์ของวัตถุเอง การค้นหาเริ่มต้นจากอินสแตนซ์ของวัตถุเอง หากพบแอตทริบิวต์ที่มีชื่อที่กำหนดในอินสแตนซ์ค่าของแอตทริบิวต์จะถูกส่งคืน หากไม่พบให้ค้นหาต่อไปเพื่อค้นหาวัตถุต้นแบบที่ชี้ไปที่ตัวชี้และค้นหาแอตทริบิวต์ที่มีชื่อที่กำหนดในวัตถุต้นแบบ หากพบคุณสมบัตินี้ในวัตถุต้นแบบค่าของคุณสมบัติจะถูกส่งคืน
ค่าที่บันทึกไว้ในต้นแบบสามารถเข้าถึงได้ผ่านอินสแตนซ์ของวัตถุ แต่ ค่าที่เก็บไว้ในต้นแบบไม่สามารถเขียนใหม่ผ่านอินสแตนซ์ของวัตถุ หากคุณเพิ่มแอตทริบิวต์ลงในอินสแตนซ์ที่มีชื่อเดียวกันกับแอตทริบิวต์ในต้นแบบอินสแตนซ์แอตทริบิวต์จะบล็อกแอตทริบิวต์ในต้นแบบ
ฟังก์ชั่นบุคคล () {} person.prototype.name = "xxyh"; person.prototype.age = "20"; person.prototype.job = "โปรแกรมเมอร์"; person.prototype.sayname = function () {alert (this.name); "oooo"; แจ้งเตือน (person1.name); // "oooo" การแจ้งเตือน (person2.name); // "xxyh"ในตัวอย่างข้างต้นแอตทริบิวต์ชื่อใน person1 บล็อกแอตทริบิวต์ชื่อในต้นแบบ
เมื่อมีการเพิ่มแอตทริบิวต์ลงในอินสแตนซ์ของวัตถุแอตทริบิวต์นี้จะบล็อกแอตทริบิวต์ของชื่อเดียวกันที่บันทึกไว้ในวัตถุต้นแบบ ซึ่งหมายความว่าการมีอยู่ของคุณสมบัตินี้จะป้องกันการเข้าถึงคุณสมบัตินั้นในต้นแบบ ใช้ลบเพื่อลบคุณสมบัติอินสแตนซ์
ฟังก์ชั่นบุคคล () {} person.prototype.name = "xxyh"; person.prototype.age = "20"; person.prototype.job = "โปรแกรมเมอร์"; person.prototype.sayname = function () {alert (this.name); "oooo"; แจ้งเตือน (person1.name); // "oooo" การแจ้งเตือน (person2.name); // "xxyh" ลบ person1.name; แจ้งเตือน (person1.name); // "xxyh"HasownProperty () สามารถตรวจจับได้ว่ามีคุณสมบัติอยู่ในอินสแตนซ์หรือในต้นแบบ
person function () {} person.prototype.name = "xxyh"; person.prototype.age = "20"; person.prototype.job = "โปรแกรมเมอร์"; person.prototype.sayname = function () {alert (this.name); บุคคล (); แจ้งเตือน (person1.hasownproperty ("ชื่อ")); // falseperson1.name = "oooo"; แจ้งเตือน (person1.hasownproperty ("ชื่อ")); // จริงรูปต่อไปนี้แสดงความสัมพันธ์ระหว่างการใช้งานและต้นแบบในสถานการณ์ที่แตกต่างกัน:
3.2 ต้นแบบและในโอเปอเรเตอร์
วิธีการใช้ตัวดำเนินการใน: ใช้เพียงอย่างเดียวในลูปสำหรับสำหรับ เมื่อใช้เพียงอย่างเดียวตัวดำเนินการในตัวดำเนินการ จะส่งคืนจริงเมื่อเข้าถึงคุณสมบัติที่กำหนดผ่านวัตถุ ไม่ว่าจะมีอยู่ในอินสแตนซ์หรือในต้นแบบ
person function () {} person.prototype.name = "xxyh"; person.prototype.age = "20"; person.prototype.job = "โปรแกรมเมอร์"; person.prototype.sayname = function () {alert (this.name); // trueperson1.name = "oooo"; แจ้งเตือน ("ชื่อ" ในบุคคล 1); // จริงเมื่อรวมกับคุณสมบัติ HASOWNPROPERTY () ก่อนหน้านี้สามารถพิจารณาได้ว่าคุณสมบัติเป็นคุณสมบัติในต้นแบบหรือคุณสมบัติในอินสแตนซ์ หากผู้ให้บริการส่งคืน TRUE และ HASOWNPROPERTY ส่งคืน FALSE คุณสมบัติเป็นคุณสมบัติในต้นแบบ
ฟังก์ชั่น hasprototypeproperty (วัตถุ, ชื่อ) {return! object.hasownproperty (ชื่อ) && (ชื่อในวัตถุ);}ถัดไปมาดูการใช้งาน HASPROTOTYPEPROPERTY ():
ฟังก์ชันบุคคล () {} person.prototype.name = "xxyh"; person.prototype.age = "20"; person.prototype.job = "โปรแกรมเมอร์"; person.prototype.sayname = function () {alert); // trueperson.name = "oooo"; แจ้งเตือน (HasPrototypeProperty (บุคคล, "ชื่อ")); // เท็จเมื่อใช้ลูปสำหรับการใช้งานคุณสมบัติทั้งหมดที่สามารถเข้าถึงได้ทั้งหมดที่สามารถเข้าถึงได้ผ่านวัตถุรวมถึงคุณสมบัติในอินสแตนซ์และคุณสมบัติในต้นแบบ แอตทริบิวต์อินสแตนซ์ที่บล็อกข้อมูลที่ไม่สามารถสรุปได้ในต้นแบบ (เช่นแอตทริบิวต์ที่ทำเครื่องหมายว่าเป็นเท็จโดย [[enumerable]]) จะถูกส่งกลับใน For-in เนื่องจากตามกฎระเบียบคุณลักษณะทั้งหมดที่กำหนดโดยนักพัฒนา
ในการรับคุณสมบัติอินสแตนซ์ที่สามารถระบุได้ทั้งหมดบนวัตถุคุณสามารถใช้วิธีการ Object.keys ()
ฟังก์ชันบุคคล () {} person.prototype.name = "xxyh"; person.prototype.age = "20"; person.prototype.job = "โปรแกรมเมอร์"; person.prototype.sayname = function () {alert (this.name); // ชื่อ, อายุ, งาน, saynamevar p1 = บุคคลใหม่ (); p1.name = "oooo"; p1.age = 15; var p1_keys = object.keys (p1); แจ้งเตือน (p1_keys); // ชื่ออายุหากคุณต้องการรับคุณสมบัติอินสแตนซ์ทั้งหมดคุณสามารถใช้ method.getownpropertyNames () Method
var keys = object.getOwnPropertyNames (person.prototype); แจ้งเตือน (ปุ่ม); // "ตัวสร้างชื่ออายุงาน sayname"
3.3 ไวยากรณ์ต้นแบบที่ง่ายกว่า
ในการปรับปรุงอินพุตให้แทนที่วัตถุต้นแบบแบบรวมด้วยวัตถุที่มีคุณสมบัติและวิธีการทั้งหมด
ฟังก์ชันบุคคล () {} person.prototype = {ชื่อ: "xxyh", อายุ: 18, งาน: "โปรแกรมเมอร์", sayname: function () {alert (this.name); -ชุดข้างต้น person.prototype เท่ากับวัตถุใหม่ที่สร้างขึ้นในรูปแบบตัวอักษรวัตถุ ผลลัพธ์จะเหมือนกัน แต่ แอตทริบิวต์ตัวสร้างจะไม่ชี้ไปที่บุคคลอีกต่อไป
ผลลัพธ์ที่ถูกต้องสามารถส่งคืนผ่านอินสแตนซ์ของตัวสร้างไม่สามารถกำหนดประเภทของวัตถุ:
var boy = คนใหม่ (); แจ้งเตือน (วัตถุของเด็กของวัตถุ); // TrueAlert (คนอินสแตนซ์ของเด็ก); // truealert (boy.constructor == บุคคล); // falsealert (boy.constructor == วัตถุ); // จริง
ค่าตัวสร้างสามารถตั้งค่าได้ในรูปแบบต่อไปนี้:
ฟังก์ชันบุคคล () {} person.prototype = {constructor: บุคคล, ชื่อ: "xxyh", อายุ: 18, งาน: "โปรแกรมเมอร์", sayname: function () {alert (this.name); -3.4 ไดนามิกของโซ่ต้นแบบ
เนื่องจากกระบวนการค้นหาค่าในต้นแบบคือการค้นหาการดัดแปลงใด ๆ ที่ทำกับวัตถุต้นแบบจะสะท้อนให้เห็นในอินสแตนซ์ แต่ถ้าวัตถุต้นแบบทั้งหมดเขียนใหม่ผลลัพธ์จะแตกต่างกัน เมื่อเรียกตัวสร้างตัวชี้ [[ต้นแบบ]] ไปยังต้นแบบต้นแบบดั้งเดิมจะถูกเพิ่มเข้าไปในอินสแตนซ์และการปรับเปลี่ยนต้นแบบไปยังวัตถุอื่นจะเทียบเท่ากับการตัดการเชื่อมต่อระหว่างตัวสร้างและต้นแบบดั้งเดิม ตัวชี้ในอินสแตนซ์ชี้ไปที่ต้นแบบเท่านั้นไม่ใช่ไปยังตัวสร้าง
ฟังก์ชั่นบุคคล () {} var boy = บุคคลใหม่ (); person.prototype = {constructor: บุคคล, ชื่อ: "xxyh", อายุ: 29, งาน: "โปรแกรมเมอร์", sayname: function () {Alert (this.name); }}; boy.sayname (); // ข้อผิดพลาดกระบวนการเฉพาะมีดังนี้:
ดังที่เห็นได้จากด้านบนวัตถุต้นแบบใหม่จะตัดการเชื่อมต่อระหว่างต้นแบบที่มีอยู่และอินสแตนซ์วัตถุที่มีอยู่ก่อนหน้านี้ พวกเขาอ้างถึงต้นแบบดั้งเดิม
3.5 ต้นแบบของวัตถุดั้งเดิม
ประเภทอ้างอิงดั้งเดิมทั้งหมดกำหนดวิธีการบนต้นแบบของตัวสร้าง ผ่านต้นแบบของวัตถุดั้งเดิมไม่เพียง แต่จะได้รับวิธีเริ่มต้นเท่านั้น แต่ยังสามารถกำหนดวิธีการใหม่ได้
string.prototype.startswith = function (text) {return this.indexof (text) == 0;}; var msg = "สวัสดีตอนเช้า"; แจ้งเตือน (msg.startswith ("ดี")); // จริง3.6 ปัญหาเกี่ยวกับวัตถุต้นแบบ
มีสองปัญหาเกี่ยวกับรูปแบบต้นแบบ:
•ทุกอย่างเป็นค่าแอตทริบิวต์เดียวกันโดยค่าเริ่มต้น
•แอตทริบิวต์ทั้งหมดในต้นแบบจะถูกแชร์โดยอินสแตนซ์
มาดูตัวอย่างด้านล่าง:
ฟังก์ชั่นบุคคล () {} person.prototype = {constructor: บุคคล, ชื่อ: "xxyh", อายุ: 18, งาน: "โปรแกรมเมอร์", เพื่อน: ["จางซาน", "li si"], sayname: function () {Alert (this.name); }}; var p1 = บุคคลใหม่ (); var p2 = บุคคลใหม่ (); p1.friends.push ("wang wu"); แจ้งเตือน (p1.friends); // Zhang San, Li Si, Wang Wu Alert (P2.Friends); // Zhang San, Li Si, Wang Wu Alert (P1.Friends == P2.Friends); // จริงมีการเพิ่มรายการด้านบนผ่าน P1.Friends เนื่องจากอาเรย์ของเพื่อนมีอยู่ในตัวเอง prototype มันก็สะท้อนให้เห็นใน P2 อย่างไรก็ตามโดยทั่วไปอินสแตนซ์มีคุณลักษณะทั้งหมดของตัวเอง
ใช้โหมดตัวสร้างและโหมดต้นแบบร่วมกัน
โหมดคอนสตรัคเตอร์ใช้เพื่อกำหนดคุณสมบัติอินสแตนซ์และโหมดต้นแบบใช้เพื่อกำหนดวิธีการและคุณสมบัติที่ใช้ร่วมกัน ด้วยวิธีนี้แต่ละอินสแตนซ์จะมีสำเนาของแอตทริบิวต์อินสแตนซ์ของตัวเอง แต่ในเวลาเดียวกันแบ่งปันการอ้างอิงไปยังวิธีการ
ฟังก์ชั่นบุคคล (ชื่อ, อายุ, งาน) {this.name = name; this.age = อายุ; this.job = งาน; this.friends = ["Zhang San", "Li Si"];} person.prototype = {constructor: person, sayname: function () {alert (this.name); }} var p1 = บุคคลใหม่ ("Xiao Xiao Yihan", 18, "โปรแกรมเมอร์"); var p2 = บุคคลใหม่ ("kuiba", 10, "การล่าสัตว์ประหลาด"); p1.friends.push ("วังวู"); Alert (p1.friends); // Zhang San, Li Si, การแจ้งเตือนของวังวู (P2.Friends); // Zhang San, Li Si Alert (P1.Friends == P2.Friends); // falsealsealert (p1.sayname == p2.sayname); // จริงในตัวอย่างข้างต้นคุณสมบัติอินสแตนซ์ถูกกำหนดไว้ในตัวสร้างในขณะที่ตัวสร้างคุณสมบัติที่ใช้ร่วมกันและวิธีการ sayname () ถูกกำหนดไว้ในต้นแบบ การดัดแปลง P1.Friends จะไม่ส่งผลกระทบต่อผลลัพธ์ของ P2.Friends
โหมดต้นแบบไดนามิก
รูปแบบต้นแบบแบบไดนามิกห่อหุ้มข้อมูลทั้งหมดในคอนสตรัคเตอร์และโดยการเริ่มต้นต้นแบบในคอนสตรัคเตอร์จะรักษาข้อได้เปรียบของการใช้ทั้งตัวสร้างและต้นแบบ กล่าวคือมันเป็นไปได้ที่จะตรวจสอบว่าต้นแบบจะต้องเริ่มต้นโดยการตรวจสอบว่าวิธีการที่ควรมีอยู่นั้นมีประสิทธิภาพหรือไม่
ฟังก์ชั่นบุคคล (ชื่อ, อายุ, งาน) {// คุณสมบัติ this.name = ชื่อ; this.age = อายุ; this.job = งาน; // เมธอดถ้า (typeof this.sayname! = "function") {person.prototype.sayname = function () {alert (this.name); -สิ่งนี้จะถูกเพิ่มลงในต้นแบบเมื่อไม่มีเมธอด sayname () และจะดำเนินการเฉพาะเมื่อตัวสร้างถูกเรียกเป็นครั้งแรก
รูปแบบตัวสร้างกาฝาก
แนวคิดของรูปแบบนี้คือการสร้างฟังก์ชั่นที่มีฟังก์ชั่นที่จะห่อหุ้มรหัสที่สร้างวัตถุแล้วส่งคืนวัตถุที่สร้างขึ้นใหม่
ฟังก์ชั่นบุคคล (ชื่ออายุ) {var obj = วัตถุใหม่ (); obj.name = ชื่อ; obj.age = อายุ; obj.sayname = function () {Alert (this.name); } return obj;} var boy = บุคคลใหม่ ("xxyh", 19, "โปรแกรมเมอร์"); boy.sayname ();ควรสังเกต: ก่อนอื่นวัตถุที่ส่งคืนไม่มีความสัมพันธ์กับตัวสร้างหรือคุณลักษณะต้นแบบของตัวสร้าง; วัตถุที่ส่งคืนโดยตัวสร้างไม่แตกต่างจากวัตถุที่สร้างขึ้นนอกคอนสตรัคเตอร์ ตัวดำเนินการอินสแตนซ์ของไม่สามารถพึ่งพาเพื่อกำหนดประเภทวัตถุ
รูปแบบตัวสร้างที่มั่นคง
วัตถุที่ปลอดภัยหมายถึงวัตถุที่ไม่มีคุณลักษณะสาธารณะและวิธีการของมันไม่ได้อ้างถึงสิ่งนี้ ตัวสร้างที่เสถียรเป็นไปตามรูปแบบที่คล้ายกันกับตัวสร้างกาฝาก แต่มีความแตกต่างสองประการ:
•วิธีการอินสแตนซ์ของวัตถุที่สร้างขึ้นใหม่ไม่ได้อ้างถึงสิ่งนี้
•ตัวสร้างไม่ได้ถูกเรียกใช้โดยใช้ตัวดำเนินการใหม่
เขียนตัวสร้างบุคคลใหม่ดังนี้:
ฟังก์ชั่นบุคคล (ชื่อ, อายุ, งาน) {var obj = วัตถุใหม่ (); obj.sayname = function () {Alert (ชื่อ); - ส่งคืน obj;} ฟังก์ชั่นบุคคล (ชื่อ, อายุ, งาน) {var obj = วัตถุใหม่ (); obj.sayname = function () {Alert (ชื่อ); - ส่งคืน obj;}บทความข้างต้นพูดสั้น ๆ เกี่ยวกับการสร้างวัตถุ JavaScript เป็นเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่ามันจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น