ชิ้นส่วนวัตถุ JavaScript
1: ส่วนพื้นฐาน
1. ตัวแปรทั้งหมดใน JavaScript เป็นวัตถุโดยมีข้อยกเว้นสองข้อและไม่ได้กำหนด
2.JScript รองรับวัตถุสี่ประเภท: วัตถุภายในวัตถุที่สร้างขึ้นวัตถุที่ได้รับโฮสต์ (วัตถุ BOM และ DOM ทั้งหมดเป็นวัตถุโฮสต์) และวัตถุ ActiveX (ส่วนประกอบภายนอก)
3. Microsoft JScript จัดเตรียมวัตถุภายใน 11 (หรือ "ในตัว") พวกเขาคืออาร์เรย์, บูลีน, วันที่, ฟังก์ชั่น, ทั่วโลก, คณิตศาสตร์, ตัวเลข, วัตถุ, regexp, ข้อผิดพลาดและวัตถุสตริง
4. วัตถุเป็นเพียงข้อมูลพิเศษ วัตถุมีคุณสมบัติและวิธีการ JavaScript เป็นภาษาที่มุ่งเน้นวัตถุ แต่ JavaScript ไม่ได้ใช้คลาส JavaScript ขึ้นอยู่กับต้นแบบไม่ใช่คลาส
5. แอตทริบิวต์: เป็นตัวแปรในเครือกับวัตถุเฉพาะ วิธีการ: มันเป็นฟังก์ชั่นที่สามารถเรียกได้โดยวัตถุเฉพาะ
6. วัตถุ JScript เป็นคอลเลกชันของคุณสมบัติและวิธีการ วิธีการคือฟังก์ชั่นซึ่งเป็นสมาชิกของวัตถุ แอตทริบิวต์คือค่าหรือชุดของค่า (ในรูปแบบของอาร์เรย์หรือวัตถุ) ที่เป็นสมาชิกของวัตถุ
7. วัตถุ JavaScript ขึ้นอยู่กับฟังก์ชั่นตัวสร้าง เมื่อใช้ฟังก์ชั่นคอนสตรัคเตอร์เพื่อสร้างวัตถุใหม่อาจกล่าวได้ว่าวัตถุใหม่เป็นอินสแตนซ์ คุณสมบัติเป็นตัวแปรภายในฟังก์ชันตัวสร้าง
วัตถุอินสแตนซ์โดยใช้ฟังก์ชั่นคอนสตรัคเตอร์:
แมว = สัตว์ใหม่ ();
8. JavaScript เป็นภาษาที่ใช้วัตถุและเกือบทุกอย่างที่คุณพบคือวัตถุ อย่างไรก็ตามมันไม่ใช่ภาษาการเขียนโปรแกรมเชิงวัตถุ (OOP) ที่แท้จริงเนื่องจากไม่มีคลาส (คลาส) ในไวยากรณ์
การคัดลอกรหัสมีดังนี้:
<script type = "text/javascript">
// Object เป็นคอลเลกชันของคู่ชื่อ/ค่า
VAR BROWSER = {// วัตถุถูกล้อมรอบในวงเล็บปีกกา
ชื่อ: "Firefox",
เคอร์เนล: "Gecko"
-
</script>
การคัดลอกรหัสมีดังนี้:
// เข้าถึงคุณสมบัติของวัตถุผ่าน dot (.) หรือ "[]"
Browser.name // "Firefox"
เบราว์เซอร์ ["เคอร์เนล"] // "ตุ๊กแก"
วัตถุ (OBJCT) เป็นคอลเลกชันของคุณสมบัติแต่ละคุณสมบัติประกอบด้วย "คู่ชื่อ/ค่าคู่" JS ยังกำหนดวัตถุพิเศษ - อาร์เรย์ซึ่งเป็นชุดที่สั่งซื้อของค่าหมายเลข JS ยังกำหนดฟังก์ชันวัตถุพิเศษฟังก์ชั่นเป็นวัตถุที่มีรหัสปฏิบัติการที่เกี่ยวข้อง มันดำเนินการรหัสโดยเรียกใช้ฟังก์ชันและส่งคืนผลการดำเนินการ
ชี้แจงแนวคิด:
"Object-based = Object-oriented" ใน JS 4 ไม่มีคลาส (คลาส) ใน JS แต่ใช้ชื่อใหม่ที่เรียกว่า "วัตถุต้นแบบ" ดังนั้น "class = วัตถุต้นแบบ"
2: ความแตกต่างและการเชื่อมต่อระหว่างคลาส (วัตถุต้นแบบ) และวัตถุ (อินสแตนซ์) ###
1. คลาส (วัตถุต้นแบบ) เป็นนามธรรม, แนวคิด, แสดงถึงประเภทของสิ่งต่าง ๆ
2. วัตถุเป็นคอนกรีตปฏิบัติและแสดงถึงสิ่งที่เฉพาะเจาะจง
3. คลาส (วัตถุต้นแบบ) เป็นเทมเพลตสำหรับอินสแตนซ์วัตถุและอินสแตนซ์วัตถุเป็นบุคคลของคลาส
ความเข้าใจผิดทั่วไปคือค่าตัวอักษรของตัวเลขไม่ใช่วัตถุ นี่เป็นเพราะข้อผิดพลาดในตัวแยกวิเคราะห์ JavaScript ที่พยายามแยกวิเคราะห์ตัวดำเนินการจุดเป็นส่วนหนึ่งของค่าตัวเลขตัวเลขลอยตัว
มีวิธีแก้ปัญหามากมายที่จะทำให้ค่าตามตัวอักษรของตัวเลขดูเหมือนวัตถุ
2..Tostring (); // จุดที่สองสามารถแยกวิเคราะห์ได้ตามปกติ
2.tostring (); // ให้ความสนใจกับช่องว่างก่อน DOT
(2) .tostring (); // 2 คำนวณก่อน
ลบแอตทริบิวต์
วิธีเดียวที่จะลบคุณสมบัติคือการใช้ตัวดำเนินการลบ การตั้งค่าคุณสมบัติเป็น undefined หรือ null ไม่ได้ลบคุณสมบัติ แต่เพียงลบความสัมพันธ์ระหว่างคุณสมบัติและค่า
คุณสมบัติหลักสามประการของวัตถุ JavaScript
encapsulation: ไม่มีการพิจารณาการใช้งานภายในจะพิจารณาเฉพาะการใช้งานที่ใช้งานได้
มรดก: สืบทอดวัตถุใหม่จากวัตถุที่มีอยู่
Polymorphism: polymorphism ที่เรียกว่าหมายถึงหลายรัฐที่อ้างถึงในสถานการณ์ที่แตกต่างกัน
1. บรรจุภัณฑ์
การห่อหุ้มหมายถึงการจัดกลุ่ม commonalities (รวมถึงคุณลักษณะและพฤติกรรม) ของสิ่งต่าง ๆ ที่อยู่ในหมวดหมู่เดียวกันในชั้นเรียนเพื่อใช้งานง่าย ตัวอย่างเช่นสิ่งที่มนุษย์สามารถห่อหุ้มด้วยวิธีต่อไปนี้:
ประชากร{
อายุ (แอตทริบิวต์ 1)
ความสูง (แอตทริบิวต์ 2)
เพศ (แอตทริบิวต์สาม)
ทำสิ่งต่างๆ (หนึ่งในพฤติกรรม)
เดิน (พฤติกรรม 2)
การพูด (กิจการ 3)
-
ประโยชน์ของการห่อหุ้ม:
การห่อหุ้มปกป้องความสมบูรณ์ของข้อมูลภายใน
Encapsulation ทำให้การปรับเปลี่ยนวัตถุง่ายขึ้น
การมีเพศสัมพันธ์ที่อ่อนตัวลงระหว่างโมดูลและปรับปรุงความสามารถในการใช้ซ้ำของวัตถุ
ช่วยหลีกเลี่ยงความขัดแย้งของเนมสเปซ
ดูตัวอย่างต่อไปนี้:
การคัดลอกรหัสมีดังนี้:
<script type = "text/javascript">
var boy = {}; // สร้างวัตถุเปล่า
boy.name = "Xiao Ming"; // กำหนดค่าตามคุณสมบัติของวัตถุต้นแบบ
boy.age = 12;
var girl = {};
girl.name = "Xiaohong";
girl.age = 10;
</script>
นี่คือการห่อหุ้มที่ง่ายที่สุดห่อหุ้มคุณลักษณะสองอย่างในวัตถุเดียว อย่างไรก็ตามวิธีการเขียนนี้มีสองข้อเสีย หนึ่งคือถ้าคุณสร้างอินสแตนซ์มากขึ้นมันจะลำบากมากในการเขียน อีกอย่างคือไม่มีวิธีที่จะบอกได้ว่ามีการเชื่อมต่อระหว่างอินสแตนซ์และต้นแบบหรือไม่
โหมดตัวสร้าง
เพื่อแก้ปัญหาการสร้างอินสแตนซ์จากวัตถุต้นแบบ JavaScript ให้รูปแบบตัวสร้าง
"ตัวสร้าง" ที่เรียกว่าจริง ๆ แล้วเป็นฟังก์ชันธรรมดา แต่ตัวแปรนี้ใช้ภายใน การใช้ตัวดำเนินการใหม่สำหรับตัวสร้างสามารถสร้างอินสแตนซ์และตัวแปรนี้จะถูกผูกไว้กับวัตถุอินสแตนซ์
ตัวอย่างเช่นวัตถุต้นแบบของเด็กชายและเด็กหญิงสามารถเขียนได้เช่นนี้: ตอนนี้:
การคัดลอกรหัสมีดังนี้:
<script type = "text/javascript">
ฟังก์ชั่นบุคคล (ชื่ออายุ) {
this.name = ชื่อ;
this.age = อายุ;
-
</script>
ตอนนี้เราสามารถสร้างวัตถุอินสแตนซ์
การคัดลอกรหัสมีดังนี้:
<script type = "text/javascript">
var boy = คนใหม่ ("Xiao Ming", "12");
var girl = คนใหม่ ("Xiaohong", "10");
การแจ้งเตือน (boy.name); // Xiao Ming
การแจ้งเตือน (boy.age); // 12
</script>
ในเวลานี้เด็กชายและเด็กหญิงจะมีแอตทริบิวต์ตัวสร้างโดยอัตโนมัติชี้ไปที่ตัวสร้างของพวกเขา
การคัดลอกรหัสมีดังนี้:
การแจ้งเตือน (boy.constructor == บุคคล); // จริง
การแจ้งเตือน (girl.constructor == บุคคล); //จริง
รูปแบบต้นแบบ JavaScript กำหนดว่าแต่ละตัวสร้างมีแอตทริบิวต์ต้นแบบที่ชี้ไปยังวัตถุอื่น คุณสมบัติและวิธีการทั้งหมดของวัตถุนี้จะได้รับการสืบทอดโดยอินสแตนซ์ตัวสร้าง
ซึ่งหมายความว่าเราสามารถกำหนดคุณสมบัติและวิธีการที่ไม่เปลี่ยนแปลงเหล่านั้นโดยตรงบนวัตถุต้นแบบ
การคัดลอกรหัสมีดังนี้:
<script type = "text/javascript">
ฟังก์ชั่นบุคคล (ชื่ออายุ) {
this.name = ชื่อ;
this.age = อายุ;
-
person.protype.type = "มนุษย์";
person.proterype.eat = function () {
แจ้งเตือน ("กินข้าว");
-
</script>
จากนั้นสร้างอินสแตนซ์:
การคัดลอกรหัสมีดังนี้:
<script type = "text/javascript">
var boy = คนใหม่ ("Xiao Ming", "12");
var girl = คนใหม่ ("Xiaohong", "10");
แจ้งเตือน (boy.type); // มนุษย์
boy.eat (); // กิน
</script>
ในเวลานี้วิธีการประเภทและวิธีการ EAT () ของทุกกรณีเป็นที่อยู่หน่วยความจำเดียวกันโดยชี้ไปที่วัตถุต้นแบบซึ่งจะช่วยปรับปรุงประสิทธิภาพการทำงาน
การแจ้งเตือน (boy.eat == girl.eat); //จริง
คุณสมบัติต้นแบบเป็นคุณสมบัติในตัวที่ระบุฟังก์ชันตัวสร้างที่วัตถุขยาย
รหัสต่อไปนี้เพิ่มขนาดแอตทริบิวต์ใหม่ให้กับฟังก์ชันตัวสร้างสัตว์ซึ่งเป็นแอตทริบิวต์ต้นแบบของวัตถุ CAT โดยใช้คุณสมบัติต้นแบบวัตถุทั้งหมดที่ขยายฟังก์ชั่นตัวสร้างสัตว์สามารถเข้าถึงคุณสมบัติขนาด
CAT = สัตว์ใหม่ ("Feline", "Meow", "Walk/Run");
cat.prototype.size = "fat";
ในกรณีนี้คุณลักษณะขนาดของวัตถุสัตว์ทั้งหมดคือ "ไขมัน" ต้นแบบเริ่มต้นเป็นอินสแตนซ์ใหม่ของวัตถุ เนื่องจากมันยังคงเป็นวัตถุจึงสามารถเพิ่มแอตทริบิวต์ใหม่ลงในวัตถุได้ เช่นเดียวกับสไตล์เป็นวัตถุใน JavaScript คุณยังสามารถเพิ่มคุณสมบัติตามสไตล์ได้
การคัดลอกรหัสมีดังนี้:
<script type = "text/javascript">
/*กำหนดคลาสบุคคล*/
คนฟังก์ชั่น (_name, _age, _salary) {
// คุณลักษณะสาธารณะของคลาสบุคคลคุณลักษณะสาธารณะของชั้นเรียนถูกกำหนดเป็น: "ชื่อแอตทริบิวต์นี้"
this.name = _name;
// แอตทริบิวต์ส่วนตัวของคลาส Person แอตทริบิวต์ส่วนตัวของคลาสถูกกำหนดเป็น: "ชื่อแอตทริบิวต์ VAR"
var อายุ = _age;
var salary = _salary;
// กำหนดวิธีการสาธารณะ (วิธีการที่ได้รับการยกเว้น) ของคลาสบุคคล, คำจำกัดความของวิธีการสาธารณะของชั้นเรียน
ใช่: "this.functionName = function () {...... }"
this.show = function () {
การแจ้งเตือน ("อายุ ="+อายุ+"/t"+"เงินเดือน ="+เงินเดือน); // การเข้าถึงคุณสมบัติส่วนตัวของชั้นเรียนในวิธีการสาธารณะได้รับอนุญาต
-
</script>
เมื่อวัตถุมองหาคุณสมบัติบางอย่างมันจะสำรวจคุณสมบัติของตัวเองก่อน หากไม่เป็นเช่นนั้นมันจะยังคงค้นหาวัตถุที่อ้างอิงโดย [[ต้นแบบ]] ถ้าไม่มันจะยังคงค้นหาวัตถุที่อ้างอิงโดย [[ต้นแบบ]]] [[ต้นแบบ]] และต่อไปจนกระทั่ง [[[ต้นแบบ]]] …. [[ต้นแบบ]] ไม่ได้กำหนด ([[ต้นแบบ]] ไม่ได้กำหนด))
พูดง่ายๆก็คือการบันทึกการอ้างอิงไปยังวัตถุอื่นผ่าน [[ต้นแบบ] ของวัตถุ] และค้นหาแอตทริบิวต์ผ่านการอ้างอิงนี้ นี่คือห่วงโซ่ต้นแบบ
วัตถุหน้าต่างทั่วโลก
ฟังก์ชั่นหรือตัวแปรส่วนกลางใน JavaScript เป็นคุณสมบัติของหน้าต่าง
วัตถุตนเองนั้นเหมือนกับวัตถุหน้าต่าง ตัวเองมักจะใช้เพื่อยืนยันว่าอยู่ในรูปแบบปัจจุบัน
วัตถุหลักหลักของหน้าต่างมีดังนี้:
วัตถุเอกสาร JavaScript
วัตถุ JavaScript Frames
วัตถุประวัติ JavaScript
วัตถุตำแหน่ง JavaScript
วัตถุ JavaScript Navigator
วัตถุหน้าจอ JavaScript
วิธีการทั่วไปหลายวิธี
วิธีการ (): ส่งคืนค่าดั้งเดิมของวัตถุที่ระบุ
วิธีการแยก () แยกสตริงออกเป็นอาร์เรย์สตริงและส่งคืนอาร์เรย์นี้
เมธอดดัชนี () ส่งคืนการเกิดขึ้นครั้งแรกของค่าสตริงที่ระบุในสตริง
เมธอด substring () ใช้เพื่อแยกอักขระในสตริงระหว่างสองตัวห้อยที่ระบุ
เมธอด substr () แยกจำนวนสตริงที่ระบุเริ่มต้นจากตำแหน่ง startPOS จากสตริง
วิธีการเข้าร่วม () ใช้เพื่อวางองค์ประกอบทั้งหมดในอาร์เรย์ลงในสตริง
arrayobject.oin (คั่น)
วิธีการย้อนกลับ () ใช้เพื่อย้อนกลับลำดับขององค์ประกอบในอาร์เรย์
เมธอด slice () ส่งคืนองค์ประกอบที่เลือกจากอาร์เรย์ที่มีอยู่
วัตถุ
ตัวอักษรวัตถุเป็นกระบวนการที่ใช้ในการสร้างแอตทริบิวต์จำนวนมาก
การคัดลอกรหัสมีดังนี้:
<script type = "text/javascript">
Var Company = {
ชื่อ: "Microsoft",
อายุ: 39,
พนักงาน: 99000
CEO: "Nadella"
-
</script>
ควรสังเกตที่นี่ว่าแอตทริบิวต์และค่าแอตทริบิวต์จะถูกคั่นด้วย colons (:); แอตทริบิวต์หลายตัวจะคั่นด้วยเครื่องหมายจุลภาค (,) วัตถุที่แท้จริงยังสามารถกำหนดวิธีการ เพียงแค่เขียนฟังก์ชั่นบนแอตทริบิวต์ของวัตถุนี้ นี่เป็นฟังก์ชั่นที่ไม่ระบุชื่อ คุณจะต้องเขียนชื่อวิธี () เพื่อเรียกมัน
การคัดลอกรหัสมีดังนี้:
<script type = "text/javascript">
var dog = {
ชื่อ: "ฮัสกี้",
อายุ: 2,
Run: function () {
กลับ "123";
-
-
Alert (dog.run ()); // ถ้าคุณป้อน dog.run รหัสของส่วนฟังก์ชั่นหลังจากมันจะปรากฏขึ้น
</script>
ส่วนอาร์เรย์ JavaScript
1. วัตถุอาร์เรย์
อาร์เรย์วัตถุ: ให้การสนับสนุนสำหรับการสร้างอาร์เรย์ของประเภทข้อมูลใด ๆ
การคัดลอกรหัสมีดังนี้:
arrayobj = อาร์เรย์ใหม่ ()
arrayobj = อาร์เรย์ใหม่ ([ขนาด])
arrayobj = อาร์เรย์ใหม่ ([องค์ประกอบ 0 [, องค์ประกอบ 1 [, ... [, elementn]]]])
คำจำกัดความ: var arr = [2,3,45,6]; var arr = อาร์เรย์ใหม่ (2,4,5,7)
ไม่มีความแตกต่างในคำจำกัดความระหว่างทั้งสอง [] มีประสิทธิภาพสูงเนื่องจากรหัสสั้น
ใช้อาร์เรย์และตัวอักษรวัตถุ: var atest = []; เมื่อสร้างอาร์เรย์การใช้ตัวอักษรอาร์เรย์เป็นตัวเลือกที่ดี ในทำนองเดียวกันตัวอักษรวัตถุยังสามารถใช้เพื่อประหยัดพื้นที่ สองบรรทัดต่อไปนี้เท่ากัน แต่ใช้ตัวอักษรวัตถุที่สั้นกว่า:
var otest = วัตถุใหม่; // พยายามอย่าใช้มัน
var otest = {}; // ตัวเลือกที่ดีที่สุดหรือ var 0test = [];
Traversal เพื่อให้ได้ประสิทธิภาพที่ดีที่สุดของอาร์เรย์ Traversing ขอแนะนำให้ใช้แบบคลาสสิกสำหรับการวนรอบ
การคัดลอกรหัสมีดังนี้:
var list = [1, 2, 3, 4, 5, ...... 100000000];
สำหรับ (var i = 0, l = list.length; i <l; i ++) {
console.log (รายการ [i]);
-
รหัสด้านบนมีการประมวลผลซึ่งคือแคชความยาวของอาร์เรย์ผ่าน l = list.length
ตัวสร้างอาร์เรย์
เนื่องจากตัวสร้างของอาเรย์ค่อนข้างคลุมเครือเล็กน้อยเมื่อพูดถึงวิธีการจัดการอาร์กิวเมนต์จึงแนะนำให้ใช้ไวยากรณ์ของอาร์เรย์ตามตัวอักษร - [] - เพื่อสร้างอาร์เรย์
ดังนั้นรหัสต่อไปนี้จะทำให้เกิดความสับสน:
อาร์เรย์ใหม่ (3, 4, 5); // ผลลัพธ์: [3, 4, 5]
อาร์เรย์ใหม่ (3) // ผลลัพธ์: [] ความยาวของอาร์เรย์นี้คือ 3
พยายามหลีกเลี่ยงการใช้ตัวสร้างอาร์เรย์เพื่อสร้างอาร์เรย์ใหม่ ขอแนะนำให้ใช้ไวยากรณ์ตัวอักษรของอาร์เรย์ พวกเขาสั้นลงและกระชับมากขึ้นซึ่งจะเป็นการเพิ่มความสามารถในการอ่านของรหัส
คุณสมบัติของอาร์เรย์อาร์เรย์
3 คุณสมบัติของอาร์เรย์อาร์เรย์: แอตทริบิวต์ความยาว, แอตทริบิวต์ต้นแบบ, แอตทริบิวต์ตัวสร้าง
1. แอตทริบิวต์ความยาว
แอตทริบิวต์ความยาวแสดงถึงความยาวของอาร์เรย์นั่นคือจำนวนองค์ประกอบในนั้น เนื่องจากดัชนีของอาร์เรย์เริ่มต้นจาก 0 เสมอขีด จำกัด บนและล่างของอาร์เรย์คือ: 0 และความยาว -1 ตามลำดับ ซึ่งแตกต่างจากภาษาอื่น ๆ ส่วนใหญ่คุณสมบัติความยาวของอาร์เรย์ JavaScript นั้นไม่แน่นอนซึ่งต้องการความสนใจเป็นพิเศษ
2. แอตทริบิวต์ prototype
ส่งคืนการอ้างอิงไปยังต้นแบบประเภทวัตถุ แอตทริบิวต์ต้นแบบเป็นเรื่องปกติของวัตถุ
สำหรับวัตถุอาร์เรย์อาร์เรย์ให้ใช้ตัวอย่างต่อไปนี้เพื่อแสดงวัตถุประสงค์ของแอตทริบิวต์ต้นแบบ
เพิ่มวิธีการลงในวัตถุอาร์เรย์เพื่อส่งคืนค่าองค์ประกอบสูงสุดในอาร์เรย์ ในการทำสิ่งนี้ให้สำเร็จประกาศฟังก์ชั่นเพิ่มลงใน Array.prototype และใช้งาน
การคัดลอกรหัสมีดังนี้:
ฟังก์ชั่น array_max ()
-
var i, max = this [0];
สำหรับ (i = 1; i <this.length; i ++)
-
ถ้า (สูงสุด <this [i])
สูงสุด = สิ่งนี้ [i];
-
กลับมาสูงสุด;
-
array.prototype.max = array_max;
var x = อาร์เรย์ใหม่ (1,2,3,4,5,6);
var y = x.max ();
หลังจากดำเนินการรหัสนี้แล้ว Y จะบันทึกค่าสูงสุดในอาร์เรย์ X หรือ 6
3. แอตทริบิวต์ของตัวสร้าง
ฟังก์ชั่นที่แสดงถึงการสร้างวัตถุ คำอธิบาย: แอตทริบิวต์ตัวสร้างเป็นสมาชิกของวัตถุทั้งหมดที่มีต้นแบบ พวกเขารวมวัตถุดั้งเดิมของ JScript ยกเว้นวัตถุทั่วโลกและคณิตศาสตร์ คุณสมบัติตัวสร้างมีการอ้างอิงถึงฟังก์ชั่นที่สร้างอินสแตนซ์วัตถุเฉพาะ
ตัวอย่างเช่น:
การคัดลอกรหัสมีดังนี้:
x = สตริงใหม่ ("สวัสดี");
if (x.constructor == สตริง) // กระบวนการ (เงื่อนไขเป็นจริง)
//หรือ
ฟังก์ชั่น myfunc {
// ฟังก์ชั่นร่างกาย
-
y = ใหม่ myfunc;
ถ้า (y.constructor == myfunc) // กระบวนการ (เงื่อนไขเป็นจริง)
สำหรับอาร์เรย์:
y = new Array ();
วิธีอาร์เรย์:
แนบแผนที่ความคิด: