เพื่อทำความเข้าใจวัตถุ 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.prototypeJavaScript ดำเนินการโดย 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 มากขึ้น