รู้เบื้องต้นเกี่ยวกับ ecmascript5
ก่อนอื่นเราต้องคิดออกว่า ecmascript เป็นพระเจ้า-มา เรารู้ว่า JavaScript หรือ Livescript ถูกสร้างขึ้นโดย NetScape และต่อมา Microsoft ก็ติดตามเพื่อสร้าง JScript ScriptEase ยังมี Cenvi ของตัวเอง ด้วยวิธีนี้มีสคริปต์เบราว์เซอร์สามเวอร์ชันที่ทำเอง ทุกคนเข้าใจความวุ่นวายนี้ดังนั้นปัญหาของการกำหนดมาตรฐานจึงอยู่ในวาระการประชุม ในปี 1997 ข้อเสนอที่ใช้ JavaScript1.1 ถูกส่งไปยังสมาคมผู้ผลิตคอมพิวเตอร์ในยุโรป (คอมพิวเตอร์ยุโรป M anufacturers ภาค) ในที่สุดทุกคนพัฒนา ECMA-262 ซึ่งเป็นมาตรฐานภาษาสคริปต์ใหม่ที่เรียกว่า ecmascript ในปีต่อไปนี้ ISO/IEC (องค์การระหว่างประเทศเพื่อการสร้างมาตรฐานและคณะกรรมาธิการ Electrotechnical นานาชาติ) ยังใช้ ECMASCRIPT เป็นมาตรฐาน หลังจากนั้นโลกจะสงบสุข ผู้ผลิตเบราว์เซอร์รายใหญ่ใช้ ECMAScript เป็นพื้นฐานสำหรับการใช้งาน JavaScript แน่นอนว่ามันเป็นเพียงรากฐานและยังไม่ได้รับการติดตามอย่างสมบูรณ์ มิฉะนั้นเราจะไม่มีปัญหาความเข้ากันได้ของเบราว์เซอร์มากมาย
ecmascript5 คืออะไร? ตามชื่อที่แนะนำมันเป็นเวอร์ชันที่ห้าของสิ่งแปลก ๆ นี้เช่น iPhone 5. Ecmascript3 ซึ่งเรามักจะใช้ตอนนี้ถือว่าเป็นภาษาการเขียนโปรแกรมที่แท้จริงมากกว่าของเล่นและได้รับความนิยมมาก
ข้อความ:
ฉันมักจะมีความเข้าใจที่ผิดเกี่ยวกับ Get/Set มาก่อนและฉันคิดว่า Get Set เป็นวิธีแอตทริบิวต์วัตถุ ฉันยังมีคำถามมากมายหลังจากอ่านบล็อกของคนอื่น วันนี้ระบบทำการทดสอบจำนวนมากและในที่สุดก็คิดออก (หากคุณผ่านการอ่านและการเขียนการทดสอบการทดสอบตัวเองหากมีไม่ถูกต้องคุณสามารถวิพากษ์วิจารณ์และแก้ไขฉันได้)
Accessor Get/Set ไม่ใช่คุณสมบัติของวัตถุ แต่เป็นคุณสมบัติของคุณสมบัติ ทุกคนต้องแยกแยะอย่างชัดเจน มีการใช้คุณสมบัติภายในเท่านั้นดังนั้นจึงไม่สามารถเข้าถึงได้โดยตรงใน JavaScript เพื่อระบุว่าลักษณะเป็นค่าภายในจะถูกล้อมรอบในวงเล็บระหว่างทั้งสองทีมเช่น [[ค่า]]
1. ให้ฉันแนะนำคุณลักษณะเหล่านี้สั้น ๆ (นี่คือการรับรองอย่างง่าย ๆ )
(1) แอตทริบิวต์ข้อมูล - ตำแหน่งที่มีค่าข้อมูล ตำแหน่งนี้สามารถอ่านและเขียนค่า
คุณลักษณะข้อมูลมีคุณสมบัติสี่ประการที่อธิบายพฤติกรรมของพวกเขา:
[[กำหนดค่า]]: สามารถกำหนดค่าได้หรือไม่?
[[enumerable]]: มันเป็นสิ่งที่พิสูจน์ได้หรือไม่?
[[เขียนได้]]: อ่านได้หรือไม่
[[ค่า]]: ค่าแอตทริบิวต์
(2) แอตทริบิวต์แอตทริบิวต์ accessor - ไม่มีค่าข้อมูลมีฟังก์ชัน getter และ setter (ไม่จำเป็นต้องใช้ฟังก์ชั่นทั้งสองนี้)
คุณสมบัติของอุปกรณ์เสริมยังมีคุณสมบัติสี่ประการที่อธิบายพฤติกรรมของพวกเขา:
[[กำหนดค่า]]: สามารถกำหนดค่าได้หรือไม่?
[[enumerable]]: มันเป็นสิ่งที่พิสูจน์ได้หรือไม่?
[[GET]]: ฟังก์ชั่นที่เรียกว่าเมื่ออ่านแอตทริบิวต์ค่าเริ่มต้นจะไม่ได้กำหนดไว้
[[SET]]: ฟังก์ชั่นที่เรียกว่าเมื่อเขียนแอตทริบิวต์ค่าเริ่มต้นจะไม่ได้กำหนดไว้
2. ที่นี่เรามุ่งเน้นไปที่การแนะนำ [[get]]/[[set]] คือสิ่งที่เราเรียกว่า get/set accessor
ก่อนอื่นมาพูดคุยเกี่ยวกับลักษณะพฤติกรรมของผู้เข้าร่วมรับ/ชุดที่กล่าวถึงในหนังสือ: Accessor Get/Set สามารถอ่านและเขียนได้โดยไม่ต้องมีคำจำกัดความ คุณสามารถกำหนดได้เพียงหนึ่งเดียว หากได้รับการกำหนดเท่านั้นแอตทริบิวต์ที่อธิบายสามารถอ่านได้และไม่สามารถเขียนได้ หากมีการกำหนดชุดเท่านั้นแอตทริบิวต์ที่อธิบายไว้สามารถเขียนได้เท่านั้นและไม่สามารถอ่านได้
(1) วิธีการตั้งค่าดั้งเดิมของเรามีดังนี้:
ฟังก์ชัน foo (val) {var value = val; this.getValue = function () {ค่าคืน;}; this.setValue = ฟังก์ชั่น (val) {value = val;};} var obj = new foo ("hello"); Alert (obj.getValue ();รหัสด้านบนเป็นเพียงวิธีการตั้งค่าที่ใช้งานโดยใช้ขอบเขตการปิด โปรดทราบว่าวิธีการเป็นวิธีการใช้แอตทริบิวต์ของวัตถุอินสแตนซ์ไม่ใช่คุณสมบัติแอตทริบิวต์ หากไม่ได้กำหนดค่าจะไม่สามารถเข้าถึงได้
ฟังก์ชัน foo (val) {var value = val;/* this.getValue = function () {ค่าคืน;}; this.setValue = function (val) {value = val;};*/} var obj = new foo ("hello"); Alert (obj.value); // undefinedตัวอย่างต่อไปนี้เป็นวิธีการใช้งานของวัตถุไม่ใช่คุณสมบัติของแอตทริบิวต์
var obj = {ชื่อ: "john", get: function () {return this.age;} // เท่านั้นที่ได้รับการกำหนดไม่ได้กำหนดไว้ แต่มันยังสามารถอ่านเขียนและแอตทริบิวต์ชื่อแม้ว่าจะเป็นอายุ // วิธีที่กำหนดไว้ที่นี่จะไม่ส่งผลกระทบต่อการตั้งค่าของแอตทริบิวต์ เพียงแค่แอตทริบิวต์วัตถุปกติ}; แจ้งเตือน (obj.name); // John อ่านได้ obj.name = "jack"; // การแจ้งเตือนที่เขียนได้ (obj.name); // jack(2) รับ/ตั้งค่า accessor เป็นคุณสมบัติของแอตทริบิวต์ accessor
อีกครั้งไม่ใช่แอตทริบิวต์ของวัตถุพวกเขาตัดสินใจว่าแอตทริบิวต์สามารถอ่านและเขียนได้หรือไม่ หากไม่ได้ตั้งค่าก็โอเคเช่นเดียวกับการอ่านและการเขียนตามปกติ (คุณสมบัติสามารถอ่านหรืออ่านได้
เขียนอ่านและเขียนการเข้าถึงคุณสมบัติเอง)
มีสองวิธีในการเปลี่ยนแอตทริบิวต์ Get /Set:
. ใช้ Object.defineProperty ()
var object = {_ ชื่อ: "Daisy"}; Object.defineProperty (Object, "Name", {// ชื่อวิธีที่นี่หมายความว่าคุณสมบัติชื่อถูกกำหนด (ดังนั้นสามารถเข้าถึงได้ผ่าน Object.name) เฉพาะผู้ที่ได้รับการอ่านเท่านั้น this._name;}}); Alert (Object.name); // "daisy" object.name = "jack"; // เฉพาะผู้ที่ได้รับ getter เท่านั้นโปรดทราบว่าชื่อคุณสมบัติใน Object.defineProperty (Object, Pro, {}) จะต้องสอดคล้องกับคุณสมบัติที่เข้าถึงโดย Object.pro
ข. ใช้คำหลัก GET SET:
var object = {_ ชื่อ: "เดซี่", รับชื่อ () {// ชื่อเมธอดที่นี่หมายความว่ามีการกำหนดแอตทริบิวต์ชื่อ (ดังนั้นจึงสามารถเข้าถึงได้ผ่าน Object.name) มีการกำหนดค่า getter accessor เท่านั้นไม่มีการกำหนดค่า [[ค่า]] ส่งคืนสิ่งนี้ _name;} // get, วิธีการตั้งค่าเป็นเพียงคุณสมบัติของแอตทริบิวต์ไม่ใช่วิธีวัตถุซึ่งกำหนดว่าแอตทริบิวต์สามารถอ่านและเขียน}; การแจ้งเตือน (object.name); // daisy วิธีการลบขีดล่างที่นี่คือเดซี่; นอกจากนี้ยังมีการกำหนด undefinedObject.name = "jack"; // เฉพาะ accessor getter เท่านั้นที่กำหนดไว้ดังนั้นจึงสามารถอ่านได้ แต่ไม่ได้เขียนการแจ้งเตือน (Object.name); // Daisyสองวิธีข้างต้นเทียบเท่า โปรดทราบว่าทั้งสองวิธีข้างต้นจะมีสองแอตทริบิวต์ในวัตถุวัตถุ: _name (ที่มีค่าเริ่มต้น) (ไม่มีค่าเริ่มต้น) ซึ่งสามารถมองเห็นได้ผ่านคอนโซลเบราว์เซอร์
ดังนั้นแอตทริบิวต์ชื่อนี้กำหนดไว้เมื่อใด เรารู้ว่า Object.defineProperty (Object, Pro, {}) สามารถกำหนดคุณสมบัติ Pro ใหม่สำหรับวัตถุ เนื่องจาก get pro () {}/set pro () {} และ object.defineProperty (Object, Pro, {}) มีค่าเทียบเท่า Pro Proper Pro ใหม่จะถูกกำหนด นี่คือเหตุผลที่มีคุณสมบัติสองประการในวัตถุ
(3) รหัสการใช้งานของ Get และ Set Accessor ใน JavaScript ในบทความนี้: เกี่ยวข้องกับการใช้งานของ Get and Set Accessors ของมาตรฐานมาตรฐาน: ความคิดที่สมเหตุสมผล
ฉันเขียนตัวอย่างด้วยตัวเอง
ฟังก์ชั่น foo (val) {this.value = val; // แอตทริบิวต์ค่าถูกกำหนดและไม่มี _value} foo.prototype = {set value (val) {// โปรดทราบว่าชื่อเมธอดและชื่อแอตทริบิวต์เหมือนกันแอตทริบิวต์ค่าจะถูกกำหนดไว้ รับแอตทริบิวต์ถูกกำหนดในต้นแบบส่งคืนสิ่งนี้ _value;}}; // accessor ส่งคืนและตั้งค่าเป็นทั้ง _name และไม่มีคำจำกัดความที่นี่ ทำไมสามารถอ่านหรือเขียนได้? - - - var obj = new foo ("สวัสดี"); การแจ้งเตือน (obj.value); // "สวัสดี" obj.value = "yehoo"; การแจ้งเตือน (obj.value); // "yehoo"เพื่อที่จะแก้ปัญหาข้างต้นได้ทำการทดสอบจำนวนมากลองดูทีละรายการ:
ก่อนอื่นดูตัวอย่างนี้ เฉพาะคุณสมบัติ GET เท่านั้นที่กำหนดไว้ในต้นแบบ เมื่ออ่านแอตทริบิวต์ค่าใน obj.value ให้มองหามันในอินสแตนซ์โดยไม่มีมันแล้วค้นหาในต้นแบบ วิธีการรับเรียกว่าซึ่งสามารถอ่านได้ แต่ไม่ได้เขียน
ฟังก์ชั่น foo (val) {this._value = val; // แอตทริบิวต์ที่นี่ขีดเส้นใต้เริ่มต้นแอตทริบิวต์ _value ของวัตถุอินสแตนซ์แอตทริบิวต์ _value สามารถอ่านได้และเขียนได้} foo.prototype = {// set value (val) {// หมายเหตุ this._value = val; //}, รับ value () {// ชื่อเมธอดเหมือนกันกับชื่อแอตทริบิวต์กำหนดแอตทริบิวต์ค่าและแอตทริบิวต์รับในต้นแบบส่งคืนสิ่งนี้ _value;}}; var obj = new foo ("hello"); แจ้งเตือน (obj.value); // สวัสดีเข้าถึงค่าในต้นแบบแอตทริบิวต์ obj.value = "yehoo"; // กำหนดเฉพาะแอตทริบิวต์ของแอตทริบิวต์ชื่อเท่านั้น การเขียนนั้นไม่ถูกต้องแจ้งเตือน (obj.value); // สวัสดีหาก this._value ถูกลบออกจากขีดล่างในคอนสตรัคเตอร์แอตทริบิวต์ค่าที่กำหนดไว้ในต้นแบบจะกำหนดแอตทริบิวต์ Get คุณยังสามารถควบคุมการอ่านและเขียนแอตทริบิวต์ค่าได้ กล่าวอีกนัยหนึ่งเมื่อ obj.value เข้าถึงแอตทริบิวต์วิธีการรับจะถูกเรียกก่อนการค้นหาในวัตถุตัวเองถ้าไม่ให้ค้นหาในต้นแบบ หากไม่มีอะไรจะไม่ได้รับการพิจารณาว่าไม่ได้กำหนด ค่าเริ่มต้นนั้นสามารถอ่านได้และเขียนได้
ฟังก์ชัน foo (val) {this.value = val; // เฉพาะคุณสมบัติรับของค่าถูกกำหนดไว้ในต้นแบบดังนั้นการเขียนที่นี่ไม่ถูกต้อง} foo.prototype = {// ค่าตั้งค่า (val) {// โปรดทราบว่าชื่อวิธีและชื่อแอตทริบิวต์เดียวกัน this._value = val; //}, // value: "hah", // แม้ว่าค่าของค่าจะถูกเขียนด้วยตนเองเนื่องจากวิธีการรับส่งคืนสิ่งนี้ _value ค่าจะไม่สามารถอ่านได้อย่างถูกต้อง: "hah" // ตราบใดที่ได้รับการใช้งานที่ถูกต้อง value () {// ชื่อเมธอดเหมือนกับชื่อแอตทริบิวต์ แอตทริบิวต์ค่าและแอตทริบิวต์ GET ถูกกำหนดไว้ในต้นแบบ ส่งคืนสิ่งนี้ _value;}}; var obj = new foo ("hello"); // "hello" ไม่ได้รับการแจ้งเตือนการเขียนสำเร็จ (obj.value); // undefined obj.value = "yehoo"; // กำหนดเฉพาะแอตทริบิวต์ดังนั้นมันสามารถอ่านได้เพื่อพิสูจน์ว่าตัวอย่างข้างต้นสามารถอ่านได้และไม่สามารถเขียนได้: เขียนด้วยตนเอง _value: "hah" คุณสามารถอ่านค่า แต่ไม่สามารถเขียนได้
ฟังก์ชัน foo (val) {this.value = val; // เฉพาะคุณสมบัติรับของค่าถูกกำหนดไว้ในต้นแบบดังนั้นการเขียนที่นี่ไม่ถูกต้อง} foo.prototype = {// ค่าตั้งค่า (val) {// โปรดทราบว่าชื่อวิธีและชื่อแอตทริบิวต์เดียวกัน this._value = val; //}, _ value: "hah", // แม้ว่าค่าของค่าจะถูกเขียนด้วยตนเองเนื่องจากวิธีการรับส่งคืนสิ่งนี้ _value ค่าจะไม่สามารถอ่านได้อย่างถูกต้อง: "hah" // ตราบใดที่ได้รับการใช้งานที่ถูกต้อง value () {// ชื่อเมธอดเหมือนกับชื่อแอตทริบิวต์ แอตทริบิวต์ค่าและแอตทริบิวต์ GET ถูกกำหนดไว้ในต้นแบบ ส่งคืนสิ่งนี้ _value;}}; var obj = new foo ("hello"); // "hello" ไม่ได้รับการแจ้งเตือนการเขียนสำเร็จ (obj.value); // "hah" obj.value = "yehoo"; // เฉพาะแอตทริบิวต์ที่กำหนดไว้หากค่า: "hah" เขียนด้วยตนเองฉันสามารถพยายามอ่านค่าของค่าได้หรือไม่? เนื่องจากไม่ได้กำหนดวิธีการที่ได้รับการส่งคืนโดยวิธี GET, OBJ.Value จึงอ่านค่าค่าและการโทร Get Value () {} วิธีการล้มเหลว แต่ค่ายังไม่สามารถเขียนได้
ฟังก์ชัน foo (val) {this.value = val; // เฉพาะคุณสมบัติรับของค่าถูกกำหนดไว้ในต้นแบบดังนั้นการเขียนที่นี่ไม่ถูกต้อง} foo.prototype = {// ค่าตั้งค่า (val) {// โปรดทราบว่าชื่อวิธีและชื่อแอตทริบิวต์เดียวกัน this._value = val; //}, ค่า: "hah", // แม้ว่าค่าของค่าจะถูกเขียนด้วยตนเองเนื่องจากวิธีการรับส่งคืนสิ่งนี้ _value ค่าไม่สามารถอ่านได้อย่างถูกต้อง: "hah" // ตราบใดที่ได้รับการกำหนดการที่ถูกต้อง value () {// ชื่อเมธอดและชื่อแอตทริบิวต์เหมือนกัน แอตทริบิวต์ค่าและคุณสมบัติ GET ถูกกำหนดไว้ในต้นแบบ ส่งคืนสิ่งนี้ _value;}}; var obj = new foo ("hello"); // "hello" ไม่ได้เขียนไว้อย่างประสบความสำเร็จ (obj.value); // undefined อ่านไม่ถูกต้องเพราะตราบใดที่ obj.value รับผลตอบแทนนี้ _value และไม่มีค่าที่ไม่ได้อ่าน การแจ้งเตือน (obj.value); // undefinedดูที่ตัวอย่างนี้ตั้งค่าตั้งค่า แต่ส่งคืนสิ่งนี้ _Value ที่ไม่ได้กำหนด คุณสามารถพบว่าค่าสามารถอ่านและเขียนได้ ลบวิธีการตั้งค่าในต้นแบบและยังสามารถอ่านหรือเขียนได้
ฟังก์ชั่น foo (val) {this.value = val;} foo.prototype = {set value (val) {this._value = val;}, รับค่า () {return this._value;}}; var obj = new foo ("hello"); แจ้งเตือน (obj.value); // hello obj.value = "yehoo"; แจ้งเตือน (obj.value); // ฟังก์ชั่น yehoo foo (val) {this.value = val;} // foo ("hello"); แจ้งเตือน (obj.value); // hello obj.value = "yehoo"; แจ้งเตือน (obj.value); // yehooสรุป
เฉพาะแอตทริบิวต์ get pro () {} สามารถอ่านได้และไม่สามารถเขียนได้
เฉพาะแอตทริบิวต์ Set Pro () {} ที่จะเขียนได้และไม่สามารถอ่านได้
หากไม่มีการประกาศการประกาศคุณลักษณะจะสามารถอ่านและเขียนได้
หากมีการประกาศทั้งหมดให้อ่านและเขียนตามวิธีที่กำหนดโดย GET Set;
หากมีการประกาศทั้งหมด แต่วิธีการอ่านและการเขียนที่กำหนดไม่สามารถอ่านและเขียนได้อย่างถูกต้อง GET/SET จะล้มเหลว กลายเป็นค่าเริ่มต้นที่อ่านได้และเขียนได้
แอตทริบิวต์ค่าที่กำหนดไว้ในต้นแบบกำหนดแอตทริบิวต์ GET คุณยังสามารถควบคุมการอ่านและเขียนแอตทริบิวต์ค่าได้ กล่าวอีกนัยหนึ่งเมื่อ obj.value เข้าถึงแอตทริบิวต์วิธีการรับจะถูกเรียกก่อนการค้นหาในวัตถุตัวเองแล้วค้นหาต้นแบบ หากไม่มีสิ่งใดมันจะถูกพิจารณาว่าไม่ได้กำหนด ค่าเริ่มต้นนั้นสามารถอ่านได้และเขียนได้
เติมเต็ม:
ไม่ว่าจะใช้ get pro () {}/set pro () {} หรือ object.defineProperty (Object, Pro, {get: function () {return this._name;}});PRO ไม่สามารถเป็นเช่นเดียวกับการส่งคืนสิ่งนี้มิฉะนั้นจะมีการรายงานข้อผิดพลาดต่อไปนี้: (ฉันไม่รู้ว่าทำไมดูเหมือนว่าจะเป็นสแต็กล้นที่เกิดจากการโทรของฉันเอง)
หลังจากการแก้ไขของอาจารย์ฉันเข้าใจว่าทำไมข้อผิดพลาดที่รายงานไว้ที่นี่: ถ้าสิ่งนี้จะถูกส่งคืนในค่า Get Value () {} วิธีการรับค่าจะถูกเรียกอีกครั้งดังนั้นจึงตกอยู่ในห่วงที่ตายแล้ว