ความเข้าใจที่ครอบคลุมเกี่ยวกับวัตถุจาวาสคริปต์ขั้นสูง

เพื่อทำความเข้าใจวัตถุ JavaScript เราสามารถเริ่มต้นจากการสร้างวัตถุการดำเนินการคุณสมบัติและวิธีการวัตถุ เพื่อสรุปจะมีโมดูลต่อไปนี้:

1. สร้างวัตถุ

1.1 การวัดวัตถุโดยตรง

ปริมาณโดยตรงของวัตถุเป็นวิธีที่ง่ายที่สุดในการสร้างวัตถุและประกอบด้วยคู่ชื่อ/ค่าหลายคู่:

 var point = {x: 0, y: 0};

ไม่มีการ จำกัด ชื่อแอตทริบิวต์ พวกเขาสามารถเป็นคำหลัก JS หรือสตริงใด ๆ หากสถานการณ์ทั้งสองนี้แอตทริบิวต์จะต้องถูกปิดล้อมในคำพูดสองครั้ง:

 var empty = {}; va point = {x: 0, y: 0}; var book = {"ชื่อหลัก": "javascript", "sub-title": "คู่มือขั้นสุดท้าย", "สำหรับ": "ผู้ชมทั้งหมด", ผู้แต่ง: {firstname: "Davide", นามสกุล: "Flanagan"}};

มันง่ายมากในการสร้างวัตถุโดยตรง แต่โดยทั่วไปไม่ได้ใช้ในลักษณะนี้ รหัสสามารถใช้ซ้ำได้ต่ำ หากคุณต้องการใช้วัตถุที่อื่นและค่าแอตทริบิวต์แตกต่างกันแล้วทำสิ่งนี้? คุณต้องสร้างรหัสอื่นใหม่หรือไม่?

1.2 สร้างวัตถุผ่านใหม่

ก่อนที่จะสร้างวัตถุผ่านใหม่คุณต้องสร้างฟังก์ชั่นก่อนและการปฏิบัติใหม่ฟังก์ชั่นนี้เป็นตัวสร้าง ตัวอย่างเช่นสร้างวัตถุบุคคลผ่านใหม่:

 ฟังก์ชันบุคคล () {// constructor} var person = บุคคลใหม่ ();

ประเภทดั้งเดิมในแกนกลางของภาษาจาวาสคริปต์ทั้งหมดมีตัวสร้างในตัว:

 var a = array ใหม่ (); var d = วันที่ใหม่ (); var r = ใหม่ regexp ("js");

1.3 Object.create ()

ก่อนที่เราจะเข้าใจวิธีการสร้างวัตถุเราต้องการดูว่าต้นแบบคืออะไร แต่ละวัตถุ JavaScript (ยกเว้น NULL) เชื่อมโยงกับวัตถุอื่น วัตถุ "อื่น" คือสิ่งที่เราเรียกว่าต้นแบบ แต่ละวัตถุสืบทอดคุณลักษณะจากต้นแบบ

วัตถุทั้งหมดที่สร้างผ่านปริมาณ Direct Object มีวัตถุต้นแบบวัตถุเดียวกัน prototype ต้นแบบวัตถุที่สร้างขึ้นโดยคำหลักใหม่และตัวสร้างเป็นค่าของคุณสมบัติต้นแบบของตัวสร้าง ต้นแบบของวัตถุที่สร้างขึ้นผ่าน array ใหม่ () คือ array.prototype และต้นแบบของวัตถุที่สร้างขึ้นผ่านวันที่ใหม่ () คือ date.prototype ต้นแบบได้รับการแนะนำที่นี่

วิธีการสร้างวัตถุมีสองพารามิเตอร์ พารามิเตอร์แรกคือต้นแบบของวัตถุและพารามิเตอร์ที่สองเป็นทางเลือกในการอธิบายคุณสมบัติของวัตถุ ใช้งานง่ายเพียงแค่ผ่านในวัตถุต้นแบบที่จำเป็น:

 var o1 = object.create ({x: 1, y: 2}); // ต้นแบบคือ Object.prototype

หากคุณต้องการสร้างวัตถุโดยไม่มีต้นแบบคุณสามารถส่ง Null เป็นพารามิเตอร์ วัตถุที่สร้างขึ้นด้วยวิธีนี้ไม่ได้รับคุณสมบัติใด ๆ และไม่มีวิธีใดเช่น ToString:

 var o2 = object.create (null); // ไม่มีต้นแบบ

หากคุณต้องการสร้างวัตถุเปล่าปกติให้ส่งผ่านไปยัง Object.prototype โดยตรง:

 var o3 = object.create (object.prototype);

หากเป็นวัตถุที่กำหนดเองมันก็เหมือนกับการสร้างวัตถุที่ว่างเปล่า ส่งชื่อวัตถุโดยตรง prototype:

 ฟังก์ชันบุคคล () {} var o4 = object.create (person.prototype);

2. การจัดการแอตทริบิวต์

2.1 แบบสอบถามและการตั้งค่าคุณสมบัติ

คุณสมบัติของวัตถุสามารถรับได้ผ่านตัวดำเนินการ DOT (.) หรือ square bracket ([]) หากคุณใช้จุดเพื่อรับแอตทริบิวต์ชื่อแอตทริบิวต์จะต้องเป็นตัวบ่งชี้อย่างง่าย มันไม่สามารถเป็นคำที่สงวนไว้เช่น o.for หรือ o.class

 AR Author = Book.Author; // ถูกต้องชื่อ var = uther.surname; // ถูกต้อง var title = book ["ชื่อหลัก"]; // แก้ไข var classname = book.class; //ข้อผิดพลาด

ไวยากรณ์ของวัตถุ ["คุณสมบัติ"] ดูเหมือนอาร์เรย์มากกว่ายกเว้นองค์ประกอบของอาร์เรย์นี้ถูกจัดทำดัชนีโดยสตริงมากกว่าตัวเลข อาร์เรย์ประเภทนี้เป็นสิ่งที่เราเรียกว่าอาร์เรย์ที่เชื่อมโยงกันหรือที่เรียกว่าแฮชแผนที่หรือพจนานุกรม วัตถุ JavaScript เป็นอาร์เรย์เชื่อมโยง

เนื่องจากวัตถุนั้นเป็นอาร์เรย์ที่เชื่อมโยงกัน JavaScript จึงให้วิธีการสำหรับ/in เพื่อสำรวจคุณสมบัติ ตัวอย่างต่อไปนี้ใช้สำหรับ/in เพื่อคำนวณค่ารวมของพอร์ตโฟลิโอ:

 ฟังก์ชั่น getValue (พอร์ตโฟลิโอ) {var total = 0.0; สำหรับ (หุ้นใน Portolio) {var Shares = portolio [หุ้น]; ราคา var = getquote (หุ้น); รวม += หุ้น * ราคา; } return total;}

การสืบทอด: วัตถุจาวาสคริปต์มีคุณสมบัติของตัวเองและคุณสมบัติบางอย่างได้รับการสืบทอดมาจากวัตถุต้นแบบ ก่อนอื่นให้ดูที่ฟังก์ชั่นที่สืบทอดซึ่งใช้การสืบทอด:

 ฟังก์ชั่นสืบทอด (p) {ถ้า (p == null) โยน typeError (); // p เป็นวัตถุมันไม่สามารถเป็นโมฆะได้ถ้า (object.create) {return object.create (p); // ใช้เมธอด object.create โดยตรง} var t = typeof p; if (t! == "Object" && t! == "ฟังก์ชั่น") โยน typeerror (); ฟังก์ชั่น f () {}; f.prototype = p; // ตั้งค่าแอตทริบิวต์ต้นแบบเป็น p return ใหม่ f ();}

สมมติว่าคุณต้องการสอบถามแอตทริบิวต์ x ของวัตถุ o หาก X ไม่มีอยู่ใน O คุณจะยังคงสืบค้นแอตทริบิวต์ x ในวัตถุต้นแบบของ O หากไม่มี X ในวัตถุต้นแบบ แต่วัตถุต้นแบบก็มีต้นแบบให้ดำเนินการค้นหาแบบสอบถามบนต้นแบบของวัตถุต้นแบบจนกว่าจะพบ X หรือพบวัตถุว่าง

 var o = {}; // oinherit วัตถุแอตทริบิวต์ ox = 1 จาก object.prototype; // กำหนดแอตทริบิวต์ x สำหรับ o var p = สืบทอด (O); // pinherit o และ object.prototypep.y = 2; // แอตทริบิวต์ pdefine yvar q = สืบทอด (p); // qinherit p, o และ object.prototypeq.z = 3; // กำหนดแอตทริบิวต์ zvar s = q.toString (); // ToString สืบทอดมาจาก Object.prototypeq.x + Qy // => 3: x และ y สืบทอดมาจาก O และ P ตามลำดับ

2.2 ลบแอตทริบิวต์

ตัวดำเนินการลบสามารถลบคุณสมบัติของวัตถุ:

 ลบ Book.author; ลบหนังสือ ["ชื่อหลัก"];

การลบสามารถลบแอตทริบิวต์ของตัวเองเท่านั้นและไม่สามารถลบแอตทริบิวต์ที่สืบทอดได้ ในการลบคุณสมบัติที่สืบทอดมานั้นจะต้องถูกลบออกจากวัตถุต้นแบบที่กำหนดคุณสมบัติและสิ่งนี้จะส่งผลกระทบต่อวัตถุทั้งหมดที่สืบทอดมาจากต้นแบบ การลบจะกลับมาเป็นจริง

 ar o = {x: 1}; ลบ ox; // ลบ x และกลับ truedelete ox; // x ไม่มีอยู่อีกต่อไปไม่มีอะไรทำกลับมาจริง ลบ O.Tostring; // ไม่ทำอะไรเลยกลับมาจริง ลบไม่สามารถลบแอตทริบิวต์ด้วยประเภทที่กำหนดค่าได้ คุณสมบัติของวัตถุในตัวบางตัวไม่สามารถกำหนดค่าได้เช่นคุณสมบัติของวัตถุทั่วโลกที่สร้างขึ้นผ่านการประกาศตัวแปรและการประกาศฟังก์ชั่น: ลบ object.prototype // ไม่สามารถลบได้คุณสมบัติไม่สามารถกำหนดค่า var x = 1; ลบ this.x; // คุณสมบัตินี้ไม่สามารถลบฟังก์ชัน f () {} ลบ this.f; // ฟังก์ชั่นทั่วโลกไม่สามารถลบได้

2.3 ตรวจจับคุณสมบัติ

เพื่อตรวจสอบว่ามีคุณสมบัติอยู่ในวัตถุสามารถตรวจพบได้โดยผู้ประกอบการในวิธีการ HasownProperty () และ Propertyisenumerable ()

ในตัวดำเนินการ: ผู้ประกอบการเป็นชื่อคุณสมบัติทางด้านซ้ายและวัตถุทางด้านขวา ส่งคืนจริงหากแอตทริบิวต์ของวัตถุหรือแอตทริบิวต์ที่สืบทอดมามีแอตทริบิวต์:

 var o = {x: 1}; "x" ใน o; // true: x เป็นแอตทริบิวต์ "y" ใน o; // false: y ไม่ใช่แอตทริบิวต์ "toString" ใน o; // true: o สืบทอดแอตทริบิวต์ ToString

วิธี HASOWNPROPERTY (): ตรวจพบชื่อที่กำหนดเป็นคุณสมบัติของวัตถุหรือไม่ สำหรับแอตทริบิวต์ที่สืบทอดมันจะส่งคืน FALSE:

 var o = {x: 1}; o.hasownproperty ("x"); // true: o มีคุณสมบัติฟรี xo.hasownproperty ("y"); // false: ไม่มีคุณสมบัติ yo.hasoenproperty ("ToString"); // false: ToString เป็นคุณสมบัติการสืบทอด

วิธีการ Propertyisenumerable (): เป็นรุ่นที่ได้รับการปรับปรุงของ HasownProperty มันจะส่งคืนจริงเฉพาะในกรณีที่ตรวจพบทรัพย์สินของตัวเองและคุณสมบัตินี้ถือเป็นจริง:

 var o = สืบทอด ({y: 2}); ox = 1; o.propertyisenumerable ("x"); // true: o มีคุณสมบัติที่ระบุได้ xo.propertyisenumerable ("y"); // false: y เป็น object.prototype.propertyisenumerable ("toString"); // false: ไม่สามารถระบุได้

2.4 คุณสมบัติการแจงนับ

โดยปกติแล้วจะใช้/ในการวนรอบคุณสมบัติของวัตถุและคุณสมบัติการสำรวจรวมถึงคุณสมบัติของตนเองและคุณสมบัติที่สืบทอดมา วิธีการในตัวของการสืบทอดวัตถุนั้นไม่สามารถระบุได้ แต่คุณสมบัติที่เพิ่มเข้ามาในวัตถุในรหัสนั้นสามารถระบุได้ ตัวอย่างเช่น:

 var o = {x: 1, y: 2, z: 3}; // สามคุณสมบัติที่ระบุได้ O.propertyisenumable ("ToString"); // false ไม่สามารถระบุได้สำหรับ (p ใน o) // โอนทรัพย์สินคอนโซล log (p); // output x, y และ z ไม่มีเอาต์พุต toString

บางครั้งเราแค่ต้องการทำซ้ำคุณสมบัติของเราเองและคุณสมบัติไม่ใช่ฟังก์ชั่น:

 สำหรับ (p ใน o) {ถ้า (! o.hasownproperty (p)) ดำเนินการต่อ; if (typeof o [p] === "function") ดำเนินการต่อ;}

เราสามารถคัดลอกแอตทริบิวต์ที่ระบุได้ผ่านฟังก์ชั่นการเดินทางข้าม

 /** คัดลอกแอตทริบิวต์ที่ระบุได้ใน P ลงใน O และ return O* หาก O และ P มีแอตทริบิวต์ของชื่อเดียวกันเขียนทับแอตทริบิวต์ใน o* ฟังก์ชั่นนี้ไม่ได้จัดการกับ getters และ setters และการคัดลอกแอตทริบิวต์*/ฟังก์ชันขยาย (o, p) {สำหรับ (prop ใน p) {// ถ่ายโอนแอตทริบิวต์ทั้งหมด // เพิ่มแอตทริบิวต์ไปยัง o} return o;}

ES5 กำหนดสองฟังก์ชั่นที่ระบุชื่อแอตทริบิวต์ ครั้งแรกคือ Object.keys () ซึ่งส่งคืนอาร์เรย์ที่ประกอบด้วยชื่อแอตทริบิวต์ที่ระบุในวัตถุ ฟังก์ชั่นการแจงนับที่สองคือ Object.TownPropertyNames () ซึ่งคล้ายกับ Object.keys () ซึ่งส่งคืนคุณสมบัติของวัตถุทั้งหมดไม่ใช่แค่คุณสมบัติที่ระบุได้

3. การห่อหุ้มคุณลักษณะ

3.1 แอตทริบิวต์ getter และ setter

แอตทริบิวต์วัตถุประกอบด้วยชื่อค่าค่าและชุดของแอตทริบิวต์ ใน ES5 ค่าแอตทริบิวต์สามารถแทนที่ด้วยหนึ่งหรือสองวิธีซึ่งเป็น getters และ setters แอตทริบิวต์ที่กำหนดโดย getters และ setters เรียกว่า "accessor attributes" ซึ่งแตกต่างจาก "แอตทริบิวต์ข้อมูล" คุณลักษณะข้อมูลมีค่าง่ายเพียงหนึ่งเดียว

แอตทริบิวต์ accessor ไม่สามารถเขียนได้ หากคุณสมบัติมีทั้งวิธี getter และ setter แสดงว่าเป็นคุณสมบัติการอ่าน/เขียน หากมีเพียงวิธีการ getter ก็จะเป็นคุณสมบัติแบบอ่านอย่างเดียวหากมีวิธีการตั้งค่าเท่านั้นมันจะเป็นคุณสมบัติการเขียนเท่านั้น การอ่านแอตทริบิวต์การเขียนอย่างเดียวจะกลับมาที่ไม่ได้กำหนดไว้เสมอ

ไวยากรณ์แอตทริบิวต์แอตทริบิวต์ของ Accessor นั้นค่อนข้างง่ายเช่นกัน นิยามฟังก์ชั่นไม่ได้ใช้คำหลักของฟังก์ชั่น แต่ใช้ GET หรือ SET:

 var o = {// แอตทริบิวต์ข้อมูลสามัญข้อมูล data_prop: 1, // แอตทริบิวต์ accessor เป็นฟังก์ชั่นที่กำหนดไว้คู่ทั้งหมดรับ accessor_prop () {/* นี่คือฟังก์ชันร่างกาย*/} ตั้งค่า accessor_prop (ค่า) {}};

คิดเกี่ยวกับวัตถุต่อไปนี้ที่แสดงถึงพิกัดของคะแนนคาร์ทีเซียน 2D มันมีคุณสมบัติปกติสองคุณสมบัติ x และ y แทน x พิกัดและพิกัด y ตามลำดับ นอกจากนี้ยังมีคุณสมบัติ accessor ที่เทียบเท่าสองตัวเพื่อเป็นตัวแทนพิกัดขั้วโลกของคะแนน:

 var p = {// x และ y เป็นแอตทริบิวต์ข้อมูลการอ่าน-เขียนธรรมดา x: 1.0, y: 1.0, // r เป็นแอตทริบิวต์ read-write accessor ซึ่งมี getter และ setter get r () {return math.sqrt (this.x * this.x + this.y * this.y); }, ตั้งค่า r (newValue) {var oldValue = math.sqrt (this.x * this.x + this.y * this); อัตราส่วน var = newValue / oldValue; this.x *= อัตราส่วน; this.y *= อัตราส่วน; }, // theta เป็นแอตทริบิวต์ accessor แบบอ่านอย่างเดียวมีเพียงวิธี getter เท่านั้นที่จะได้รับ theta () {return math.atan2 (this.y, this.x); -

เช่นเดียวกับแอตทริบิวต์ข้อมูลแอตทริบิวต์ accessor นั้นสืบทอดได้ดังนั้นวัตถุ P ในรหัสข้างต้นจึงถือได้ว่าเป็นต้นแบบของ "จุด" อื่น มันสามารถกำหนดคุณสมบัติ x และ y สำหรับวัตถุทางเพศ แต่คุณสมบัติ R และ theta ที่สืบทอดมาจาก:

 var q = สืบทอด (p); qx = 1, qy = 1; console.log (qr); cosole.log (q.theta);

3.2 คุณสมบัติแอตทริบิวต์

เราสามารถพิจารณาวิธีการ getter และ setter ของแอตทริบิวต์ accessor เป็นคุณสมบัติของแอตทริบิวต์ ตามตรรกะนี้เรายังสามารถดูคุณสมบัติของคุณสมบัติของคุณสมบัติได้เช่นกัน ดังนั้นจึงสามารถพิจารณาได้ว่าคุณสมบัติมีชื่อและ 4 แอตทริบิวต์

คุณสมบัติสี่ประการของคุณสมบัติตัวเลขคือค่าของมันเขียนได้จองได้และกำหนดค่าได้

แอตทริบิวต์ accessor ไม่มีลักษณะค่าและความสามารถในการเขียนดังนั้นจึงรวมถึง: อ่าน (รับ), เขียน (ชุด), การแจงนับและการกำหนดค่า

ES5 กำหนดวัตถุที่ชื่อว่า "แอตทริบิวต์ descriptor" ซึ่งแสดงถึงแอตทริบิวต์ 4 เหล่านั้น แอตทริบิวต์ของวัตถุ descriptor ของแอตทริบิวต์ข้อมูลรวมถึงค่า, เขียน, enumerable และกำหนดค่าได้ วัตถุ descriptor ของแอตทริบิวต์ accessor จะถูกแทนที่ด้วยแอตทริบิวต์ Get และแอตทริบิวต์ Set ในบรรดาพวกเขาการเขียน, การเขียนได้และกำหนดค่าได้คือค่าบูลีนและแอตทริบิวต์ Get และชุดคุณลักษณะเป็นค่าฟังก์ชั่น

คุณสามารถรับตัวบ่งชี้คุณสมบัติสำหรับคุณสมบัติเฉพาะของวัตถุโดยเรียก object.getownpropertydescriptor ()::

 // return {value: 1, writable: true, enumerable: true, configrable: true} object.getownproeprtydescriptor ({x: 1}, "x"); // การสืบค้นคุณสมบัติ octet ของวัตถุสุ่มที่กำหนดไว้ข้างต้น // "Octet"); // สำหรับแอตทริบิวต์ที่สืบทอดมาและแอตทริบิวต์ที่ไม่มีอยู่จริง, return undefinedobject.getownpropertydesciptor ({}, "x"); object.getownpropertydesciptor ({}, "ToString");

อย่างที่คุณเห็นจากชื่อฟังก์ชั่น Object.GetOwnPropertyDesciptor () สามารถรับคุณสมบัติของคุณสมบัติของตัวเองได้เท่านั้น เพื่อให้ได้คุณสมบัติของแอตทริบิวต์ที่สืบทอดมาคุณต้องสำรวจห่วงโซ่ต้นแบบ (Object.getPrototypeof ())

หากคุณต้องการตั้งค่าคุณสมบัติของคุณสมบัติหรือทำให้คุณสมบัติที่สร้างขึ้นใหม่มีคุณสมบัติบางอย่างคุณต้องเรียก Object.defineProperty () ซึ่งมีพารามิเตอร์สามตัว: วัตถุชื่อคุณสมบัติและวัตถุตัวบ่งชี้คุณสมบัติ: วัตถุ:

 // คุณสมบัติมีอยู่ แต่วัวไม่สามารถระบุได้ // => 1Object.keys (o) // => [] // ตอนนี้แก้ไขคุณสมบัติ x เพื่อให้เป็นวัตถุอ่านอย่างเดียว defineproperty (o, "x", {writable: true}); // มุมมองเปลี่ยนค่าของทรัพย์สินนี้ = 2; // การดำเนินการล้มเหลว แต่ไม่มีการรายงานข้อผิดพลาดและข้อผิดพลาดประเภทถูกโยนลงไปในโหมดที่เข้มงวด // คุณสมบัติยังคงสามารถกำหนดค่าได้ดังนั้นจึงสามารถแก้ไขได้ด้วยวิธีนี้: Object.defineProperty (o, "x", {ค่า: 2}); ox // => 2 // 0;}}); ox // => 0

หากคุณต้องการแก้ไขหรือสร้างคุณสมบัติหลายอย่างในเวลาเดียวกันคุณต้องใช้ Object.defineProperties () พารามิเตอร์แรกคือวัตถุที่จะแก้ไขและพารามิเตอร์ที่สองคือตารางการแมป ตัวอย่างเช่น:

 var p = object.defineproperties ({}, {x: {ค่า: 1, เขียน: จริง, enumerable: true, กำหนดค่าได้: true}, y: {ค่า: 2, เขียนได้: จริง จริง, กำหนดค่าได้: true}});

API แบบเก่าแก่สำหรับ getters และ setters: ก่อน ES5 การใช้งาน JavaScript ส่วนใหญ่สามารถรองรับการรับและตั้งค่าการเขียนในไวยากรณ์ปริมาณโดยตรงของวัตถุ การใช้งานเหล่านี้ให้ API แบบเก่าที่ไม่ได้มาตรฐานสำหรับการสืบค้นและการตั้งค่า getters และ setters API เหล่านี้ประกอบด้วยสี่วิธีและวัตถุทั้งหมดมีวิธีการเหล่านี้

__lookUpgetter __ () และ __lookupsetter __ () ใช้เพื่อส่งคืนแอตทริบิวต์ที่มีชื่อและวิธีการตั้งค่า

__definegetter __ () และ __definesetter __ () ใช้เพื่อกำหนด getters และ setters พารามิเตอร์แรกคือชื่อแอตทริบิวต์และพารามิเตอร์ที่สองคือวิธี getter และ setter

 var o = {}; o .__ defineGetter __ ("x", ฟังก์ชัน () {return 0;}); o .__ definesetter __ ("y", ฟังก์ชัน (ค่า) {console.log ("ค่าตั้งค่า:" + ค่า);});

4. สามคุณสมบัติของวัตถุ

แต่ละวัตถุมีต้นแบบคลาสและแอตทริบิวต์ที่ขยายได้ที่เกี่ยวข้อง ถัดไปเรามาพูดถึงสิ่งที่คุณลักษณะเหล่านี้ทำ

4.1 คุณสมบัติต้นแบบ

คุณลักษณะต้นแบบของวัตถุใช้เพื่อสืบทอดแอตทริบิวต์ เรามักจะเรียกว่า "คุณลักษณะต้นแบบของ O" โดยตรง "ต้นแบบของ O" ก่อนหน้านี้ "สร้างวัตถุ" แนะนำสามวิธีในการสร้างวัตถุ วัตถุที่สร้างโดยวัตถุถูกใช้เป็นต้นแบบโดยใช้ Object.prototype วัตถุที่สร้างขึ้นโดยใหม่ใช้แอตทริบิวต์ต้นแบบของตัวสร้างเป็นต้นแบบ วัตถุที่สร้างขึ้นด้วย Object.create () ใช้พารามิเตอร์แรกเป็นต้นแบบ

ใน ES5 ต้นแบบวัตถุสามารถสอบถามผ่าน Object.getPrototypeof () ใน ES3 ไม่มีฟังก์ชั่นที่เทียบเท่า แต่แทนที่จะใช้นิพจน์ o.constructor.prototype เพื่อตรวจสอบต้นแบบของวัตถุ

ในการตรวจสอบว่าวัตถุเป็นต้นแบบของวัตถุอื่น (หรืออยู่ในห่วงโซ่ต้นแบบ) ให้ใช้วิธี isprototypeof () ตัวอย่างเช่นคุณสามารถตรวจพบว่า P เป็นต้นแบบของ O โดย P.Isprototypeof (O):

 var p = {x: 1}; // กำหนดวัตถุต้นแบบ var o = object.create (p); // ใช้ต้นแบบนี้เพื่อสร้างวัตถุ p.isprototypeof (O); // => จริง o สืบทอดมาจาก pobject.prototype.isprototypeof (o) // => true, p สืบทอดจาก object.prototype

JavaScript ดำเนินการโดย Mozilla เผยให้เห็นแอตทริบิวต์เฉพาะชื่อ __proto__ เพื่อค้นหา/ตั้งต้นแบบวัตถุโดยตรง อย่างไรก็ตาม IE และ Opera ไม่สนับสนุนแอตทริบิวต์ __Proto__ ดังนั้นจึงไม่แนะนำให้ใช้แอตทริบิวต์ __Proto__ โดยตรง

4.2 แอตทริบิวต์คลาส

แอตทริบิวต์คลาสของวัตถุคือสตริงเพื่อแสดงข้อมูลประเภทของวัตถุ ทั้ง ES3 และ ES5 มีวิธีการตั้งค่าคุณสมบัตินี้และมีวิธีเดียวทางอ้อมในการสอบถาม เมธอด ToString () เริ่มต้นส่งคืนสตริงในรูปแบบนี้: [คลาสวัตถุ]

คุณสามารถเรียกวิธี ToString () จากนั้นแยกอักขระระหว่างแปดและตำแหน่งสุดท้ายของสตริงที่ส่งคืน แต่มีปัญหาที่วัตถุจำนวนมากที่สืบทอดมาด้วยวิธีการ ToString () ได้รับการเขียนใหม่ เพื่อให้สามารถเรียกใช้เวอร์ชัน toString () ที่ถูกต้องได้วิธีการเรียกใช้ () จะต้องเรียกว่าทางอ้อม ฟังก์ชั่นคลาสของตัวอย่างต่อไปนี้สามารถส่งคืนคลาสของวัตถุใด ๆ :

 ฟังก์ชั่นคลาสของ (o) {ถ้า (o === null) ส่งคืน "null"; ถ้า (o === ไม่ได้กำหนด) กลับ "undefined"; return object.prototype.toString.call (o) .slice (8, -1);}

4.3 ความสามารถในการปรับขนาด

ความสามารถในการขยายของวัตถุใช้เพื่อระบุว่าสามารถเพิ่มคุณสมบัติใหม่ลงในวัตถุได้หรือไม่ วัตถุในตัวและแบบกำหนดเองทั้งหมดสามารถขยายได้อย่างชัดเจน ใน ES5 วัตถุสามารถแปลงเป็นไม่สามารถลดขนาดได้

นอกเหนือจากการตั้งค่าวัตถุให้ไม่สามารถยืดเยื้อได้วิธีการ Object.seal () ยังสามารถตั้งค่าคุณสมบัติทั้งหมดของวัตถุให้ไม่สามารถกำหนดค่าได้ กล่าวคือไม่สามารถเพิ่มแอตทริบิวต์ใหม่ลงในวัตถุและไม่สามารถลบแอตทริบิวต์ที่มีอยู่ได้

วิธีการ Object.ISSELED () ใช้เพื่อตรวจสอบว่าวัตถุนั้นถูกปิดไว้หรือไม่

วิธีการ freeze () จะล็อควัตถุอย่างเคร่งครัดมากขึ้น นอกเหนือจากการมีฟังก์ชั่นของ method ของ Object.seal () แล้วยังสามารถตั้งค่าแอตทริบิวต์ข้อมูลทั้งหมดของตัวเองให้อ่านอย่างเดียว (หากแอตทริบิวต์ accessor ของวัตถุมีวิธีการตั้งค่าแอตทริบิวต์ accessor จะไม่ได้รับผลกระทบและคุณยังสามารถเรียกพวกเขาได้โดยกำหนดค่าให้กับแอตทริบิวต์)

Object.isfrozen () ใช้เพื่อตรวจสอบว่าวัตถุนั้นถูกแช่แข็งหรือไม่

5. วัตถุต่อเนื่อง

การทำให้เป็นอนุกรมวัตถุหมายถึงการแปลงสถานะของวัตถุเป็นสตริงหรือคุณสามารถกู้คืนสตริงเป็นวัตถุได้ ES5 จัดทำฟังก์ชั่นในตัว JSON.Stringify () และ JSON.parse () เพื่อทำให้เป็นอนุกรมและคืนค่าวัตถุ JavaScript วิธีการเหล่านี้ทั้งหมดใช้ JSON เป็นรูปแบบการแลกเปลี่ยนข้อมูล ตัวอย่างเช่น:

 o = {x: 1, y: {z: [false, null, ""]}}; // กำหนดวัตถุทดสอบ s = json.stringify (o); // {"x": 1, "y": {"z": [false, null, ""]}} p = json.parse (s); // P เป็นสำเนาลึกของ O

ไวยากรณ์ของ JSON เป็นชุดย่อยของไวยากรณ์ JavaScript และไม่สามารถแสดงค่าทั้งหมดใน JavaScript วัตถุ, อาร์เรย์, สตริง, หมายเลขอนันต์, จริง, เท็จและโมฆะได้รับการสนับสนุนและพวกเขาสามารถเป็นอนุกรมและฟื้นฟู NAN, Infinity และ -infinity Serialization ผลลัพธ์ล้วนเป็นโมฆะ ฟังก์ชั่น, regexp, วัตถุข้อผิดพลาดและค่าที่ไม่ได้กำหนดไม่สามารถเป็นอนุกรมและกู้คืนได้

ที่นี่ฉันจะเพิ่มวิธีการของวัตถุ:

วิธี TOSTRING (): มันจะส่งคืนสตริงที่แสดงถึงค่าของวัตถุที่เรียกวิธีนี้ วัตถุจำนวนมากได้เขียนวิธี toString () ใหม่เช่น array.toString (), date.toString () และ function.toString ()

วิธี TOJSON (): Object.prototype ไม่ได้กำหนดวิธี TOJSON () จริง ๆ แต่เนื่องจากความจำเป็นในการดำเนินการอนุกรมวิธี JSON.Stringify () จะเรียกวิธี TOJSON () หากวิธีนี้มีอยู่ในวัตถุที่เป็นอนุกรมจะเรียกว่า

วิธีการ (): วิธีการ Valueof () นั้นคล้ายกับวิธี ToString () แต่ JavaScript มักจะเรียกมันเมื่อแปลงวัตถุเป็นค่าดั้งเดิมที่แน่นอนแทนที่จะเป็นสตริงโดยเฉพาะอย่างยิ่งเมื่อมันถูกแปลงเป็นตัวเลข คลาสในตัวบางคลาสปรับแต่งวิธีการ () เช่น date.valueof ()

บทความข้างต้นเข้าใจถึงความก้าวหน้าของวัตถุ JavaScript อย่างครอบคลุมคือเนื้อหาทั้งหมดที่ฉันแบ่งปันกับคุณ ฉันหวังว่ามันจะให้ข้อมูลอ้างอิงและฉันหวังว่าคุณจะสนับสนุน wulin.com มากขึ้น