อาร์เรย์ใหม่ ()
ใหม่อาร์เรย์ (เลน)
อาร์เรย์ใหม่ ([item0, [item1, [item2, ... ]]]]]
วิธีการใช้วัตถุอาร์เรย์:
var objarray = new Array ();
objarray.concact ([item1 [, item2 [, ... ]] ----------------------------- ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------- และกลับมา อาร์เรย์ดั้งเดิมไม่ได้รับผลกระทบ
arr.concact ("d", "e");
จะส่งคืนอาร์เรย์ที่มีองค์ประกอบตัวอักษรจาก "A" ถึง "E" และ ARR นั้นไม่ได้รับผลกระทบ
objarray.join (ตัวแยก) -------------------------------------------------------- ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ---- )เดียวกัน.
objarray.pop () -------- ตามเงื่อนไขของคนธรรมดามันคือการปรากฏขึ้นเป็นองค์ประกอบสุดท้ายของอาร์เรย์ เมื่อรวมกับวิธีการผลักดันต่อไปนี้เป็นไปได้ที่จะใช้อาร์เรย์เป็นสแต็ค วิธีการป๊อปส่งคืนค่าขององค์ประกอบสุดท้ายของอาร์เรย์และลบแอตทริบิวต์ความยาวโดย 1 นั่นคือองค์ประกอบสุดท้ายจะหายไปทันทีหลังจากกลับมา
objarray.push ([value1 [, value2 [, ... ]]]) --------------------------- ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ตัวอย่างเช่น: [1,2,3, 4] .Push ("A", "B") จะได้รับ [1,2,3,4, "A", "B"]
Objarray.Reverse () จะกลับองค์ประกอบในอาร์เรย์ ตัวอย่างเช่น [1,2,3] .Reverse () จะได้รับ [3,2,1]
objarray.shift () ------------ ลบองค์ประกอบแรกของอาร์เรย์และส่งคืนค่าขององค์ประกอบนี้ ลักษณะของวิธีนี้คล้ายกับวิธีป๊อปมากซึ่งก็คือการลบองค์ประกอบสุดท้าย
Objarray.slice (เริ่มต้น) -------------- กลับมาชุดย่อยของวัตถุอาร์เรย์ อาร์เรย์ดั้งเดิมไม่ได้รับผลกระทบ ตัวอย่างเช่น: [1,2,3,4,5,6,6] .slice (1,4) จะได้รับ [2,3,4] เมื่อเริ่มต้นหรือสิ้นสุดเป็นลบพวกเขาจะใช้เพื่อเพิ่มค่าความยาว ตัวอย่างเช่น: [1,2,3,4,5,6,6] .slice (-4, -1) จะได้รับ [3,4,5] หากสิ้นสุดน้อยกว่าหรือเท่ากับเริ่มต้นอาร์เรย์ที่ว่างเปล่าจะถูกส่งคืน
objarray.sort (Comparefn) -------------------------------------------------------- ------------------------------------------------------ ------------------ ฟังก์ชั่นการเปรียบเทียบจะต้องยอมรับสองพารามิเตอร์ Element1 และ Element2 นั่นคือเก็บของต้นฉบับ) จะส่งคืน 0 เมื่อละเว้นเปรียบเทียบองค์ประกอบจะถูกจัดเรียงตามลำดับพจนานุกรม ตัวอย่างเช่น: สำหรับฟังก์ชั่นการเปรียบเทียบที่กำหนด CMP: ฟังก์ชั่น cmp (e1, e2) {return e1-e2;} จากนั้น [3,4,2,7] .sort (CMP) จะได้รับ [2,3,4,7 ].
objarray.splice (เริ่ม, deleteCount [, item1, item2 [, ... ]]])) นี่เป็นฟังก์ชันที่ซับซ้อนเพื่อให้การลบ, การทดแทนและการแทรกขององค์ประกอบอาร์เรย์ ในหมู่พวกเขาพารามิเตอร์เริ่มต้นระบุตำแหน่งดัชนีที่จะดำเนินการและ deleteCount หมายถึงจำนวนองค์ประกอบที่จะถูกลบตั้งแต่เริ่มต้น (รวมถึงตำแหน่งเริ่มต้น) ลบตั้งแต่ต้น [, item1 [, item2 [, ... ]]]] หมายถึงรายการเสริมขององค์ประกอบที่แทรกก่อนเริ่ม ชอบ:
var arr = [0,1,2,3,4,5,6];
arr.splice (1,1);
document.write (arr); // แสดง "0, 2, 3, 4, 5, 6"
arr = [0,1,2,3,4,5,6];
arr.splice (0,0, "a", "b");
document.write (arr); // show "a, b, 0,1,2,3,4,5,6"
arr = [0,1,2,3,4,5,6];
arr.splice (3,2, "c", "d");
document.write (arr); // แสดง "0,1,2, c, d, 5,6"
objarray.unshift (item1 [, item2 [, ... ]]]) ----------------------------- ------------------------------------------------------ ------------------- คุณสมบัติและประเภทวิธีการผลักดัน แต่วิธีการผลักดันคือการเพิ่มองค์ประกอบในตอนท้ายของอาร์เรย์ ตัวอย่างเช่น: [1,2,3,4] .unshift ("A", "B") จะได้รับ ["A", "B", 1,2,3,4]
การเพิ่มและการลบองค์ประกอบอาร์เรย์ของ JS นั้นทำให้เกิดความสับสนในวันนี้ฉันพบคำอธิบายโดยละเอียด
var arr = new Array ();
arr [0] = "AAA";
arr [1] = "bbb";
arr [2] = "CCC";
//alert(arr.length);//3
arr.pop ();
//alert(arr.length);//2
//alert(Arr.arr.length-1hat) ;//bbb
arr.pop ();
//alert(arrdarr.length-1hat
//alert(arr.length);//1
var arr2 = new Array ();
//alert(arr2.length);//0
arr2 [0] = "AAA";
arr2 [1] = "bbb";
//alert(arr2.length);//2
arr2.pop ();
//alert(arr2.length);//1
arr2 = arr2.slice (0, arr2.length-1);
//alert(arr2.length);//0
arr2 [0] = "AAA";
arr2 [1] = "bbb";
arr2 [2] = "CCC";
arr2 = arr2.slice (0,1);
การแจ้งเตือน (arr2.length); // 1
การแจ้งเตือน (arr2 [0]); // aaa
การแจ้งเตือน (arr2 [1]); // undefined
Shift: ลบรายการแรกของอาร์เรย์ดั้งเดิมและส่งคืนค่าขององค์ประกอบที่ถูกลบ
var a = [1,2,3,4,5];
var b = a.shift ();
Unshift: เพิ่มพารามิเตอร์ไปยังจุดเริ่มต้นของอาร์เรย์ดั้งเดิมและส่งคืนความยาวของอาร์เรย์
var a = [1,2,3,4,5];
var b = a.unshift (-2, -1);
หมายเหตุ: ค่าส่งคืนการทดสอบใน IE6.0 นั้นไม่ได้กำหนดไว้เสมอและค่าการทดสอบผลตอบแทนใน FF2.0 คือ 7 ดังนั้นค่าส่งคืนของวิธีนี้ไม่น่าเชื่อถือ ของวิธีนี้
ป๊อป: ลบรายการสุดท้ายของอาร์เรย์ดั้งเดิมและส่งคืนค่าขององค์ประกอบที่ถูกลบ
var a = [1,2,3,4,5];
var b = a.pop ();
Push: เพิ่มพารามิเตอร์ไปที่ส่วนท้ายของอาร์เรย์ดั้งเดิมและส่งคืนความยาวของอาร์เรย์
var a = [1,2,3,4,5];
var b = a.push (6,7);
CONCAT: ส่งคืนอาร์เรย์ใหม่ซึ่งประกอบด้วยการเพิ่มพารามิเตอร์ไปยังอาร์เรย์ดั้งเดิม
var a = [1,2,3,4,5];
var b = a.concat (6,7);
Splice (เริ่ม, deleteCount, val1, val2, ... ): รายการ deleteCount จากตำแหน่งเริ่มต้นและแทรก val1, val2, ...
เมื่อล้างอาร์เรย์เพียงแค่ผ่าน StartIndex
หากองค์ประกอบทั้งหมดไม่ถูกลบให้ส่งพารามิเตอร์ deleteCount
Splice ยังมีฟังก์ชั่นของการลบก่อนและเพิ่มนั่นคือลบองค์ประกอบหลายอย่างก่อนจากนั้นเพิ่มองค์ประกอบหลายอย่างที่ตำแหน่งที่ถูกลบ .
var a = [1,2,3,4,5];
var b = a.splice (2,2,7,8,9);
var b = a.splice (0,1);
A.Splice (0,0, -2, -1);
var b = a.splice (a.length-1,1); // ป๊อปเดียวกัน
A.Splice (A.Length, 0,6,7);
ย้อนกลับ: ผกผันอาร์เรย์
var a = [1,2,3,4,5];
var b = a.reverse ();
เรียงลำดับ (orderfunction): เรียงลำดับอาร์เรย์ตามพารามิเตอร์ที่ระบุ
var a = [1,2,3,4,5];
var b = a.sort ();
Slice (เริ่มต้นสิ้นสุด): ส่งคืนอาร์เรย์ใหม่ที่ประกอบด้วยรายการจากตัวห้อยเริ่มต้นที่ระบุไปยังตัวห้อยปลายในอาร์เรย์ดั้งเดิม
var a = [1,2,3,4,5];
var b = a.slice (2,5);
เข้าร่วม (ตัวคั่น): จัดกลุ่มองค์ประกอบของอาร์เรย์ลงในสตริงโดยมีตัวคั่นเป็นตัวคั่นถ้าละเว้นให้ใช้เครื่องหมายจุลภาคเริ่มต้นเป็นตัวคั่น
var a = [1,2,3,4,5];
var b = a.join ("|");
นี่เป็นอีกวิธีหนึ่งในการใช้อาร์เรย์เพื่อจำลอง JavastringBuffer เพื่อประมวลผลสตริง:
การคัดลอกรหัสมีดังนี้:
-
* ฟังก์ชั่นการประมวลผลสตริง
-
ฟังก์ชัน StringBuffer () {
var arr = อาร์เรย์ใหม่;
this.append = function (str) {
arr [arr.length] = str;
-
this.toString = function () {
return arr.join (""); // ping อาร์เรย์ที่ผนวกเข้ากับสตริง
-
-
วันนี้ฉันค้นพบทันทีว่าการเข้าร่วมเป็นวิธีที่ดีในการแปลงอาร์เรย์เป็นสตริงในแอปพลิเคชันดังนั้นฉันจึงห่อหุ้มพวกเขาไว้ในวัตถุและใช้:
การคัดลอกรหัสมีดังนี้:
-
*แปลงอาร์เรย์เป็นสตริงที่แยกตามสัญลักษณ์เฉพาะ
-
ฟังก์ชั่น ArrayToString (arr, ตัวคั่น) {
ถ้า (ตัวคั่น) ตัวคั่น = ""; // ถ้าตัวคั่นเป็นโมฆะมันจะว่างเปล่าโดยค่าเริ่มต้น
return arr.oin (ตัวคั่น);
-
-
* ค้นหาสตริงที่มีอยู่ในอาร์เรย์
-
ฟังก์ชั่น arrayfindstring (arr, string) {
var str = arr.oin ("");
return str.indexof (String);
-