คำก่อนหน้านี้
มี 22 วิธีในอาร์เรย์ บทความนี้แบ่งออกเป็นวิธีการสืบทอดวัตถุวิธีการแปลงอาร์เรย์วิธีการสแต็กและคิววิธีการเรียงลำดับอาร์เรย์วิธีการประกบอาร์เรย์วิธีการสร้าง subarray วิธีการลบอาร์เรย์วิธีการตำแหน่งอาร์เรย์วิธีการผสานอาเรย์และวิธีการทำซ้ำอาเรย์ในรายละเอียด
วิธีการสืบทอดวัตถุ
อาร์เรย์เป็นวัตถุพิเศษที่สืบทอดวิธี toString (), tolocalestring () และ valueof () วิธีการของวัตถุวัตถุ
【 ToString () 】
วิธี TOSTRING () ส่งคืนสตริงที่แยกออกจากเครื่องหมายจุลภาคจากรูปแบบสตริงของแต่ละค่าในอาร์เรย์
[หมายเหตุ] ค่าส่งคืนของวิธีนี้เหมือนกับสตริงที่ส่งคืนโดยการเรียกใช้วิธีการเข้าร่วม () โดยไม่มีพารามิเตอร์ใด ๆ
[1,2,3] .tostring (); // '1,2,3' ['A', 'B', 'C']. TOSTRING (); // 'A, B, C' [1, [2, 'C']]. TOSTRING (); // '1,2, C'
เนื่องจาก Alert () ต้องการรับพารามิเตอร์สตริงมันจะเรียกวิธี ToString () ในพื้นหลังและจะได้รับผลลัพธ์เช่นเดียวกับวิธี ToString ()
การแจ้งเตือน ([1,2,3]); // '1,2,3'
【 tolocalestring () 】
Tolocalestring () เป็นรุ่นที่แปลเป็นภาษาท้องถิ่นของวิธี TOSTRING () ซึ่งมักจะส่งคืนค่าเท่ากับวิธี TOSTRING () แต่มันไม่ได้เป็นเช่นนั้นเสมอไป เพราะมันเรียกองค์ประกอบเมธอด tolocalestring () แปลงแต่ละองค์ประกอบอาร์เรย์เป็นสตริง
var person1 = {tolocalestring: function () {return 'nikolaos';}, toString: function () {return 'nikolas';}}; var person2 = {tolocalestring: function () {return 'grigorios'; [person1, person2]; console.log (people.toString ()); // 'nikolas, greg'console.log (people.tolocalestring ()); //' nikolas, grigorios 'หากค่าของรายการในอาร์เรย์เป็นโมฆะหรือไม่ได้กำหนดค่าจะถูกแสดงเป็นสตริงว่างในผลลัพธ์ที่ส่งคืนโดยวิธี tolocalestring () และ toString ()
สี var = [1, undefined, 2, null, 3]; console.log (colors.toString ()); // '1,, 2 ,, 3'console.log (colors.tolocalestring ()); //' 1, 2, 3 '
【ค่าของ () 】
เมธอด valueof () ส่งคืนวัตถุอาร์เรย์เอง
var a = [1, 2, 3]; console.log (a.valueof ()); // [1, 2, 3] console.log (a.valueof () อาร์เรย์อินสแตนซ์); // true
วิธีการแปลงอาร์เรย์
【เข้าร่วม()】
เมธอด array.join () เป็นการทำงานแบบผกผันของเมธอด string.split () ซึ่งแยกสตริงออกเป็นหลายบล็อกเพื่อสร้างอาร์เรย์
วิธี tolocalestring () และ toString () ที่สืบทอดโดยอาร์เรย์จะส่งคืนรายการอาร์เรย์ในอักขระที่คั่นด้วยเครื่องหมายจุลภาคโดยค่าเริ่มต้น; วิธีการเข้าร่วม () สามารถใช้ตัวคั่นที่แตกต่างกันเพื่อสร้างสตริงนี้ วิธีการเข้าร่วม () ได้รับเพียงหนึ่งพารามิเตอร์ซึ่งใช้เป็นตัวคั่นแล้วส่งคืนสตริงที่มีรายการอาร์เรย์ทั้งหมด
หากไม่มีค่าผ่านไปยังวิธีการเข้าร่วม () ให้ใช้เครื่องหมายจุลภาคเป็นตัวคั่น
var a = [1,2,3]; console.log (a.join ()); // '1,2,3'console.log (a.join (')); // '1 2 3'console.log (a.join (' ')); //' 123'var b = ใหม่ Array (10); B.Join ('-'); // '---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -หากพารามิเตอร์ของวิธีการเข้าร่วม () ไม่ได้กำหนดเบราว์เซอร์มาตรฐานจะส่งคืนสตริงด้วยเครื่องหมายจุลภาคเป็นตัวคั่นและเบราว์เซอร์ IE7-browser ส่งคืนสตริงด้วย 'ไม่ได้กำหนด' เป็นตัวคั่น
// เบราว์เซอร์มาตรฐานคือ '1,2,3'; IE7-the Browser คือ '1Undefined2undefined3'var a = [1,2,3]; console.log (a.join (undefined));
หากค่าของรายการในอาร์เรย์เป็นโมฆะหรือไม่ได้กำหนดค่าจะถูกแสดงเป็นสตริงว่างในผลลัพธ์ที่ส่งคืนโดยวิธีการเข้าร่วม ()
var colours = [1, undefined, 2, null, 3]; console.log (colors.oin ()); // '1,, 2,, 3'
วิธีนี้ยังสามารถใช้กับวัตถุอาร์เรย์คลาส
console.log (array.prototype.join.call ('สวัสดี', '-')); // "สวัสดี" var obj = {0: 'a', 1: 'b', ความยาว: 2}; console.log (array.prototype.join.call (obj, '-');[หมายเหตุ] หากวัตถุไม่มีแอตทริบิวต์ความยาวมันไม่ใช่อาร์เรย์คลาสและวิธีการอาร์เรย์ไม่สามารถเรียกได้
var obj = {0: 'a', 1: 'b'}; console.log (typeof array.prototype.join.call (obj, '-')); // ''วิธีการสแต็กและคิว
วิธีการ push () และ pop () อนุญาตให้ใช้อาร์เรย์เป็นสแต็ค พฤติกรรมของวิธี unshift () และ shift () นั้นคล้ายกับ push () และ pop () มาก ความแตกต่างคืออดีตแทรกและลบองค์ประกอบที่หัวของอาร์เรย์มากกว่าที่หาง
สแต็คเป็นโครงสร้างข้อมูล LIFO (ครั้งสุดท้าย-ออกในภายหลังในภายหลัง) นั่นคือรายการเพิ่มเติมล่าสุดจะถูกลบออกอย่างเร็วที่สุด การแทรก (เรียกว่าการผลัก) และการลบ (เรียกว่าป๊อปอัพ) ของรายการในสแต็กจะเกิดขึ้นในที่เดียว - ด้านบนของสแต็ก JavaScript ให้วิธีการ push () และ pop () โดยเฉพาะสำหรับอาร์เรย์เพื่อให้ได้พฤติกรรมเหมือนสแต็ก
กฎการเข้าถึงสำหรับโครงสร้างข้อมูลคิวคือ FIFO (ครั้งแรกในการออกอันดับแรก, ครั้งแรก, แรก) คิวเพิ่มรายการในตอนท้ายของรายการและลบรายการออกจากส่วนหน้าของรายการ การใช้วิธีการ shift () และ push () ร่วมกันคุณสามารถใช้อาร์เรย์เช่นคิว
【ดัน()】
เมธอด push () สามารถรับพารามิเตอร์จำนวนใดก็ได้เพิ่มทีละหนึ่งไปยังจุดสิ้นสุดของอาร์เรย์และส่งคืนความยาวของอาร์เรย์ที่แก้ไข ดังนั้นอาร์เรย์จะเปลี่ยนอาร์เรย์ดั้งเดิม
var a = []; console.log (a, a.push (1)); // [1] 1console.log (a, a.push ('a')); // [1, 'a'] 2console.log (a, a.push (จริง, {}); 4console.log (a, a.push ([5,6])); // [1, 'a', true, {}, [5,6]] 5หากคุณต้องการรวมสองอาร์เรย์คุณสามารถใช้วิธีการสมัคร
var a = [1, 2, 3]; var b = [4, 5, 6]; console.log (a, array.prototype.push.apply (a, b)); // [1,2,3,4,5,6] 6] 6] 6] 6
[หมายเหตุ] หากคุณใช้วิธีการโทรอาร์เรย์ B จะถือเป็นพารามิเตอร์โดยรวม
var a = [1, 2, 3]; var b = [4, 5, 6]; console.log (a, array.prototype.push.call (a, b)); // [1,2,3, [4,5,6]
วิธีการกด () ยังสามารถเพิ่มองค์ประกอบลงในวัตถุและวัตถุที่เพิ่มเข้ามาจะกลายเป็นวัตถุอาร์เรย์นั่นคือดัชนีของอาร์เรย์ที่สอดคล้องกันของคีย์ขององค์ประกอบที่เพิ่มใหม่และวัตถุมีแอตทริบิวต์ความยาว
var obj = {a: 1}; console.log (obj, []. push.call (obj, 2)); // {a: 1, 0: 2, ความยาว: 1} console.log (obj, []. push.call (obj, [3]);【โผล่()】
เมธอด POP () จะลบรายการสุดท้ายออกจากจุดสิ้นสุดของอาร์เรย์ลดค่าความยาวของอาร์เรย์และส่งคืนรายการที่ถูกลบ ดังนั้นอาร์เรย์จะเปลี่ยนอาร์เรย์ดั้งเดิม
var a = ['a', 'b', 'c']; console.log (a, a.pop ()); // ['A', 'B'] 'C'
การใช้วิธี POP () สำหรับอาร์เรย์ว่างจะไม่รายงานข้อผิดพลาด แต่จะส่งคืนที่ไม่ได้กำหนด
var a = []; console.log (a, a.pop ()); // [] ไม่ได้กำหนด
【กะ()】
เมธอด shift () ลบรายการแรกในอาร์เรย์และส่งคืนรายการในขณะที่ความยาวของอาร์เรย์ลดลง 1 ดังนั้นอาร์เรย์จะเปลี่ยนอาร์เรย์ดั้งเดิม
var a = ['a', 'b', 'c']; console.log (a, a.shift ()); // ['b', 'c'] 'a'
ใช้วิธีการ Shift () สำหรับอาร์เรย์ที่ว่างเปล่าและจะไม่มีการรายงานข้อผิดพลาด แต่จะส่งคืนที่ไม่ได้กำหนด
var a = []; console.log (a, a.shift ()); // [] undefined
【 Unchift () 】
วิธี Unshift () เพิ่มรายการใด ๆ ในส่วนหน้าของอาร์เรย์และส่งคืนความยาวอาร์เรย์ใหม่ ดังนั้นอาร์เรย์จะเปลี่ยนอาร์เรย์ดั้งเดิม
var a = ['a', 'b', 'c']; console.log (a, a.unshift ('x')); // ['x', 'a', 'b', 'c'] 4เมื่อ unshift () ถูกเรียกด้วยพารามิเตอร์หลายพารามิเตอร์พารามิเตอร์จะถูกแทรกในครั้งเดียวแทนที่จะทีละครั้ง ซึ่งหมายความว่าลำดับขององค์ประกอบที่แทรกในอาร์เรย์สุดท้ายสอดคล้องกับคำสั่งของพวกเขาในรายการพารามิเตอร์
var a = ['a', 'b', 'c']; console.log (a, a.unshift ('x', 'y', 'z')); // ['x', 'y', 'z', 'a', 'b', 'c'] 6[หมายเหตุ] ใน IE7-Browser วิธี Unshift () จะส่งคืนที่ไม่ได้กำหนดไว้เสมอ
// ในเบราว์เซอร์มาตรฐานกลับ [1] 1; และใน IE7-Browser, return [1] undefinedvar a = []; console.log (a, a.unshift (1));
วิธีการเรียงลำดับอาร์เรย์
มีสองวิธีในอาร์เรย์ที่สามารถใช้ในการจัดลำดับใหม่ได้โดยตรง: reverse () และเรียงลำดับ ()
【ย้อนกลับ()】
วิธีการย้อนกลับ () ใช้เพื่อย้อนกลับลำดับของอาร์เรย์และส่งคืนอาร์เรย์ที่เรียงลำดับ และคำสั่งอาร์เรย์ดั้งเดิมก็เปลี่ยนไปเช่นกัน
var array = [1,2,4,3,5]; console.log (อาร์เรย์, array.reverse ()); // [5,3,4,2,1] [5,3,4,2,1] var array = ['str', true, 3]; console.log (Array, Array.Reverse ();
【เรียงลำดับ()】
โดยค่าเริ่มต้นวิธีการเรียงลำดับ () จัดเรียงรายการอาร์เรย์ตามลำดับจากน้อยไปมาก วิธีการเรียงลำดับจะเรียกวิธี ToString () ของแต่ละรายการอาร์เรย์จากนั้นเปรียบเทียบการเรียงลำดับสตริงผลลัพธ์เพื่อส่งคืนอาร์เรย์ที่เรียงลำดับและลำดับอาร์เรย์ดั้งเดิมก็เปลี่ยนไป
var array = [1,2,4,3,5]; console.log (Array, array.sort ()); // [1,2,3,4,5] [1,2,3,4,5] var array = ['3str', 3,2, '2']; console.log [1,5,10,50]; console.log (Array, Array.sort ()); // [1, 10, 5, 50]
หากอาร์เรย์มีองค์ประกอบที่ไม่ได้กำหนดไว้จะถูกวางไว้ที่ส่วนท้ายของอาร์เรย์
var array = ['3', 3, undefined, 2, '2']; console.log (Array, Array.sort ()); // ["2", 2, "3", 3, ไม่ได้กำหนด] ["2", 2, "3", 3, ไม่ได้กำหนด]
วิธีการเรียงลำดับ () สามารถยอมรับฟังก์ชั่นการเปรียบเทียบเป็นอาร์กิวเมนต์เพื่อระบุค่าที่นำหน้าด้วยค่าใด ฟังก์ชั่นการเปรียบเทียบได้รับพารามิเตอร์สองตัวจะส่งคืนหมายเลขลบหากพารามิเตอร์แรกควรเป็นก่อนพารามิเตอร์ที่สองจะส่งคืน 0 หากพารามิเตอร์ทั้งสองเท่ากันและส่งกลับหมายเลขบวกหากพารามิเตอร์แรกควรเป็นหลังจากพารามิเตอร์ที่สอง
ฟังก์ชั่นเปรียบเทียบ (ค่า 1, value2) {ถ้า (ค่า 1 <ค่า 2) {return -1;} else ถ้า (value1> value2) {return 1;} else {return 0;}} var array = ['5px', 50,1,10]; // เมื่อตัวเลขมีขนาดใหญ่กว่าสตริง seconsole.log (array.sort (เปรียบเทียบ)); // ["5px", 1, 10, 50]สำหรับประเภทตัวเลขหรือวิธีการ () ฟังก์ชันการเปรียบเทียบสามารถทำให้ประเภทวัตถุของประเภทตัวเลขง่ายขึ้น
ฟังก์ชั่นเปรียบเทียบ (ค่า 1, value2) {return value1 - value2;} var array = ['5px', 50,1,10]; console.log (array.sort (เปรียบเทียบ)); // ["5px", 1,10,50,50] var array = [5,50,1,10];หากอาร์เรย์ของสตริงดำเนินการเรียงลำดับตัวอักษรที่ไม่รู้สึกตัวฟังก์ชั่นการเปรียบเทียบจะแปลงพารามิเตอร์เป็นสตริงตัวพิมพ์เล็กก่อนแล้วจึงเริ่มการเปรียบเทียบ
a = ['ant', 'bug', 'cat', 'dog']; a.sort (); // ['bug', 'dog', 'ant', 'cat']; a.sort (ฟังก์ชั่น (s, t) {var a = s.toLowercase (); 0;}); // ['Ant', 'Bug', 'Cat', 'Dog']【เคล็ดลับ】สร้างอาร์เรย์แบบสุ่มโดยใช้วิธีการเรียงลำดับ ()
ฟังก์ชั่น Compare () {return math.random () - 0.5;} var array = [1,2,3,4,5]; console.log (array.sort (เปรียบเทียบ)); // [2,1,5,4,3]วิธีการเย็บอาร์เรย์
【 concat () 】
เมธอด concat () สร้างอาร์เรย์ใหม่ตามรายการทั้งหมดในอาร์เรย์ปัจจุบัน ก่อนอื่นสร้างสำเนาของอาร์เรย์ปัจจุบันจากนั้นเพิ่มพารามิเตอร์ที่ได้รับไปยังจุดสิ้นสุดของสำเนาและในที่สุดก็ส่งคืนอาร์เรย์ที่สร้างขึ้นใหม่ ดังนั้น concat () จะไม่ส่งผลกระทบต่ออาร์เรย์ดั้งเดิม
หากพารามิเตอร์ไม่ได้ส่งผ่านไปยังเมธอด concat () มันจะคัดลอกอาร์เรย์ปัจจุบัน หากพารามิเตอร์คือหนึ่งหรือมากกว่าหนึ่งอาร์เรย์วิธีการจะเพิ่มแต่ละรายการในอาร์เรย์เหล่านี้ไปยังอาร์เรย์ผลลัพธ์ หากค่าที่ผ่านไม่ใช่อาร์เรย์ค่าเหล่านี้จะถูกเพิ่มไปยังส่วนท้ายของอาร์เรย์ผลลัพธ์
หมายเลข var = [1,2]; console.log (ตัวเลข, ตัวเลข. concat (3,4)); // [1,2] [1,2,3,4] console.log (ตัวเลข, ตัวเลข concat ([5,4,3], [3,4,5], 1,2)); // [1,2] [1,2,5,4,3,3,4,4,5,1,2] console.log (ตัวเลข, ตัวเลข. concat (4, [5, [6,7]]))); // [1,2] [1,2,4,5, [6,7]]
หากไม่มีการให้พารามิเตอร์เมธอด concat () จะส่งคืนสำเนาตื้นของอาร์เรย์ปัจจุบัน สิ่งที่เรียกว่า "สำเนาตื้น" หมายความว่าหากสมาชิกอาร์เรย์มีค่าชนิดผสม (เช่นวัตถุ) อาร์เรย์ใหม่จะคัดลอกการอ้างอิงถึงค่า
// วิธีนี้จะคัดลอกมิติแรกของอาร์เรย์เท่านั้น มิติแรกของอาร์เรย์เก็บการอ้างอิงของมิติที่สองและมิติที่สองเก็บหมายเลขเนื้อหา var ของพวกเขา = [1,2]; var newnumbers = numbers.concat (); console.log (ตัวเลข, newnumbers); // [1,2] [1,2] ตัวเลข [0] = 0; [[1,2]]; var newnumbers = number.concat (); console.log (ตัวเลข, newnumbers); // [[1,2]] [[1,2]] ตัวเลข [0] [0] = 0; console.log (ตัวเลข, newnumbers);
วิธีการ concat () ยังสามารถใช้เพื่อรวมวัตถุเข้ากับอาร์เรย์ แต่ต้องทำด้วยวิธีการโทร ()
var newarray = array.prototype.concat.call ({a: 1}, {b: 2}) console.log (newarray); // [{a: 1}, {b: 2}] console.log (newarray [0]สร้างเมธอด subarray
【ชิ้น()】
เมธอด Slice () สร้างอาร์เรย์ใหม่ตามหนึ่งรายการขึ้นไปในอาร์เรย์ปัจจุบันยอมรับหนึ่งหรือสองพารามิเตอร์นั่นคือเพื่อส่งคืนตำแหน่งเริ่มต้นและสิ้นสุดของรายการและในที่สุดก็ส่งคืนอาร์เรย์ใหม่
เมธอดชิ้นส่วน (เริ่มต้น) ต้องใช้พารามิเตอร์สองพารามิเตอร์เริ่มต้นและสิ้นสุดซึ่งส่งคืน subarray ในอาร์เรย์นี้จากตำแหน่งเริ่มต้นไปยังตำแหน่งสิ้นสุด (แต่ไม่มี); หากปลายไม่ได้กำหนดหรือไม่มีอยู่จะส่งคืนรายการทั้งหมดจากตำแหน่งเริ่มต้นไปยังส่วนท้ายของอาร์เรย์
หากเริ่มต้นเป็นจำนวนลบให้เริ่ม = สูงสุด (ความยาว + เริ่ม, 0)
ถ้าสิ้นสุดเป็นจำนวนลบ, end = สูงสุด (ความยาว + end, 0)
เริ่มต้นและสิ้นสุดไม่สามารถเปลี่ยนตำแหน่งได้
หากไม่มีพารามิเตอร์ให้กลับไปที่อาร์เรย์ดั้งเดิม
หมายเลข var = [1,2,3,4,5]; console.log (numbers.slice (2)); // [3,4,5] console.log (numbers.slice (2, ไม่ได้กำหนด)); // [3,4,5] consol e.log (numbers.slice (2,3)); // [3] console.log (numbers.slice (2,1)); // [] console.log (numbers.slice (-3)); //-3+5 = 2 -> [3,4,5] console.log (numbers.slice (-8)); // สูงสุด (5 + -8,0) = 0 -> [1,2,3,4,5] console.log (numbers.slice (0, -3)); // 3 + 5 = 2 -> [1,2] console.log (numbers.slice (-2, -1)); //-2+5 = 3; -1+5 = 4; -> [4]
หากไม่มีการให้พารามิเตอร์เมธอด slice () จะส่งคืนสำเนาตื้นของอาร์เรย์ปัจจุบัน
// วิธีนี้จะคัดลอกมิติแรกของอาร์เรย์เท่านั้น มิติแรกของอาร์เรย์เก็บการอ้างอิงของมิติที่สองและมิติที่สองเก็บเนื้อหา var หมายเลขของพวกเขา = [1,2]; var newnumbers = numbers.slice (); console.log (ตัวเลข, newnumbers); // [1,2] [1,2] ตัวเลข [0] = 0; [[1,2]]; var newnumbers = number.slice (); console.log (ตัวเลข, newnumbers); // [[1,2]] [[1,2]] ตัวเลข [0] [0] = 0; console.log (ตัวเลข, newnumbers);
เมธอด slice () เกี่ยวข้องกับการแปลงประเภทโดยนัยของฟังก์ชันการแปลงตัวเลข () เมื่อเริ่มต้นถูกแปลงเป็น NAN มันจะเทียบเท่ากับ start = 0; เมื่อปลายถูกแปลงเป็น NAN (ยกเว้นปลายไม่ได้กำหนด) อาร์เรย์ที่ว่างเปล่าจะถูกส่งออก
หมายเลข var = [1,2,3,4,5]; console.log (numbers.slice (nan)); // [1,2,3,4,4,5] console.log (numbers.slice (0, nan)); // [] console.log (numbers.slice (จริง, [3]); // [2,3] sole.log (numbers.slice (null, undefined)); // [1,2,3,4,5] console.log (number.slice ({})); // [1,2,3,4,5] console.log (numbers.slice ('2', [5]));คุณสามารถใช้เมธอด slice () เพื่อเปลี่ยนวัตถุอาร์เรย์คลาสเป็นอาร์เรย์จริง
var arr = array.prototype.slice.call (arraylike); array.prototype.slice.call ({0: 'a', 1: 'b', ความยาว: 2}) // ['a', 'b'] array.prototype.slice.call (document.querySelectorall ("div")); array.prototype.slice.call (อาร์กิวเมนต์);วิธีการลบอาร์เรย์
【 splice () 】
Splice () และ slice () มีชื่อที่คล้ายกันมาก แต่ฟังก์ชั่นของพวกเขาแตกต่างกันเป็นหลัก วิธีการ Splice () ใช้เพื่อลบส่วนหนึ่งของอาร์เรย์ดั้งเดิมและสามารถเพิ่มสมาชิกอาร์เรย์ใหม่ได้ที่ตำแหน่งที่ถูกลบ วิธีนี้จะเปลี่ยนอาร์เรย์ดั้งเดิม
Splice () ส่งคืนอาร์เรย์ที่ประกอบด้วยองค์ประกอบที่ถูกลบหรืออาร์เรย์ที่ว่างเปล่าหากไม่มีการลบองค์ประกอบที่ถูกลบ
พารามิเตอร์แรกของ Splice () เริ่มระบุตำแหน่งเริ่มต้นสำหรับการแทรกหรือการลบ หากเริ่มต้นเป็นจำนวนลบให้เริ่ม = สูงสุด (ความยาว + เริ่มต้น, 0); หากเริ่มต้น NAN มันจะเทียบเท่ากับ start = 0
หากมีเพียงองค์ประกอบเดียวเท่านั้นมันจะเทียบเท่ากับการแยกอาร์เรย์ดั้งเดิมออกเป็นสองอาร์เรย์ที่ตำแหน่งที่ระบุ
var a = [1,2,3,4,5,6,7,7,8]; console.log (a, a.splice ()); // [1,2,3,4,5,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (4); = [1,2,3,4,5,6,7,7,8]; console.log (a, a.splice (-4)); //-4+8 = 4; [1,2,3,4] [5,6,7,8] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (-9)); // สูงสุด (-9+8,0) = 0 [] [1,2,3,4,5,6,7,7,8]; console.log (a, a.splice (nan)); // [] [1,2,3,4,5,6,7,8,8]
หมายเลขพารามิเตอร์ที่สองระบุจำนวนองค์ประกอบที่ควรลบออกจากอาร์เรย์ หากมีการละเว้นพารามิเตอร์ที่สององค์ประกอบทั้งหมดจากจุดเริ่มต้นถึงจุดสิ้นสุดของอาร์เรย์จะถูกลบ หากตัวเลขเป็นลบหรือ nan หรือไม่ได้กำหนดจำนวน = 0 ดังนั้นองค์ประกอบจะไม่ถูกลบ
var a = [1,2,3,4,5,6,7,7,8]; console.log (a, a.splice (0,2)); // [3,4,5,6,7,8] [1,2] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (10,2); [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1,100)); // [1] [2,3,4,5,6,7,7,8] var a = [1,2,3,4,5,6,7,7,8]; console.log (a, a.splice (1, -5)); // [1,2,3,4,5,6,7,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, nan)); // [1,2,3,4,5,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, undefined)); // [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,7,8]; console.log (a, a.splice (1, undefined)); // [1,2,3,4,5,6,7,8] []
หากมีพารามิเตอร์เพิ่มเติมในภายหลังหมายความว่าสิ่งเหล่านี้เป็นองค์ประกอบใหม่ที่จะแทรกลงในอาร์เรย์
var a = [1,2,3,4,5]; console.log (a, a.splice (2,0, 'a', 'b')); // [1,2, 'a', 'b', 3,4,5] [] console.log (a, a.splice (2,2, [1,2], 3); ['A', 'B']
วิธีการตำแหน่งอาร์เรย์
ES5 เพิ่มวิธีการสองตำแหน่งในอินสแตนซ์อาร์เรย์: indexof () และ lastindexof ()
【ดัชนี () 】
indexof (ค้นหา, เริ่มต้น) ได้รับการค้นหาพารามิเตอร์สองตัวและเริ่มต้นกลับตำแหน่งที่การค้นหาปรากฏขึ้นครั้งแรกและหากไม่พบจะส่งกลับ -1
พารามิเตอร์การค้นหาระบุรายการที่จะค้นหา ใช้ตัวดำเนินการความเท่าเทียมกันอย่างเข้มงวด (===) สำหรับการเปรียบเทียบ
var arr = [1,2,3, '1', '2', '3']; console.log (arr.indexof ('2')); // 4console.log (arr.indexof (3)); // 2console.log (arr.indexof (0);พารามิเตอร์เริ่มต้นระบุตำแหน่งเริ่มต้นของการค้นหา วิธีนี้เรียกใช้ฟังก์ชันการแปลงตัวเลข () โดยปริยายเพื่อแปลงค่าเริ่มต้นที่ไม่ใช่ตัวเลข (ยกเว้นไม่ได้กำหนด) เป็นตัวเลข หากพารามิเตอร์นี้ถูกละเว้นหรือหากพารามิเตอร์ไม่ได้กำหนดหรือ NAN ให้เริ่ม = 0
var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (arr.indexof ('a', ไม่ได้กำหนด)); // 0console.log (arr.indexof ('a', nan)); e.log (arr.indexof ('a', 1)); // 5console.log (arr.indexof ('a', true)); // 5console.log (arr.indexof ('a',-1)); // max (0, -1+7) = 6; -1console.log (arr.indexof ('a',-5)); // สูงสุด (0, -5+7) = 2; 5console.log (arr.indexof ('a',-50)); // สูงสุด (0, -50+7) = 0; 0 var person = {ชื่อ: 'nicholas'}; var people = [{ชื่อ: 'nicholas'}]; var morepeople = [person]; แจ้งเตือน (people.indexof (บุคคล)); //-1 เพราะแม้ว่าบุคคลและผู้คน [0] มีค่าเดียวกัน การแจ้งเตือน (morepeople.indexof ({ชื่อ: 'Nicholas'}))); //-1 เพราะพวกเขาไม่ได้เป็นข้อมูลอ้างอิงเดียวกันวิธีการเขียนที่เข้ากันได้ของ indexof () วิธีการ
if (typeof array.prototype.indexof! = "function") {array.prototype.indexof = function (searchElement, fromIndex) {var index = -1; fromIndex = fromIndex * 1 || 0; สำหรับ (var k = 0, length = this.length; k <length; k ++) {ถ้า (k> = fromindex && this [k] === searchelement) {index = k; break;}} return index;};};【 LastIndexof () 】
ไม่เหมือน indexof (), lastindexof () ดูจากขวาไปซ้าย
เมธอด LastIndexof (Search, start) ได้รับการค้นหาพารามิเตอร์สองตัวและเริ่มต้นกลับตำแหน่งที่การค้นหาปรากฏขึ้นครั้งแรกและหากไม่พบ
พารามิเตอร์การค้นหาระบุรายการที่จะค้นหา ใช้ตัวดำเนินการความเท่าเทียมกันอย่างเข้มงวด (===) สำหรับการเปรียบเทียบ
var arr = [1,2,3, '1', '2', '3']; console.log (arr.lastindexof ('2')); // 4console.log (arr.lastindexof (3)); // 2console.log (arr.lastindexof (0);การเริ่มต้นหมายถึงตำแหน่งเริ่มต้นของการค้นหาซึ่งเรียกใช้ฟังก์ชันการแปลงตัวเลข () โดยปริยายเพื่อแปลงค่าเริ่มต้นที่ไม่ใช่ตัวเลข (ยกเว้นที่ไม่ได้กำหนด) เป็นตัวเลข หากพารามิเตอร์นี้ถูกละเว้นหรือหากพารามิเตอร์ไม่ได้กำหนดหรือ NAN ให้เริ่ม = 0
ซึ่งแตกต่างจากวิธี LastIndexof () ของสตริงเมื่อวิธีการค้นหาเป็นจำนวนลบ, search = max (0, ความยาว+การค้นหา)
var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (arr.lastindexof ('b')); // 6console.log ndefined)); // 0console.log (arr.lastindexof ('b', nan)); //-1console.log (arr.lastindexof ('b', 1)); // 1console.log 6console.log (arr.AltIctIndexof ('B',-5)); // สูงสุด (0, -5+7) = 2; 1console.log (arr.lastindexof ('b',-50)); // สูงสุด (0, -50+7) = 0; -1【เคล็ดลับ】ส่งคืนค่าดัชนีทั้งหมดของรายการที่ตรงตามเกณฑ์
รายการที่ตรงกันทั้งหมดสามารถพบได้โดยการวนซ้ำเพื่อเรียกดัชนี () หรือ LastIndexof ()
ฟังก์ชั่น allindexof (อาร์เรย์, ค่า) {var result = []; var pos = array.indexof (ค่า); ถ้า (pos === -1) {return -1;} ในขณะที่ (pos> -1) {result.push (pos); pos = array.indexof (ค่า, pos+1); [1,2,3,3,2,1]; console.log (allindexof (อาร์เรย์, 1)); // [0,5]วิธีการเขียนที่เข้ากันได้ของวิธี LastIndexof ()
if (typeof array.prototype.lastindexof! = "function") {array.prototype.lastindexof = ฟังก์ชั่น (searchElement, fromIndex) {var index = -1, length = this.length; fromIndex = FromIndex * 1 || ความยาว - 1; สำหรับ (var k = ความยาว - 1; k> -1; k- = 1) {ถ้า (k <= fromIndex && this [k] === searchElement) {index = k; break;}} return index;};};วิธีการผสานอาเรย์
วิธีการรวมอาเรย์รวมถึงวิธีการลด () และ REDUCERIGHT () พวกเขาใช้ฟังก์ชั่นที่ระบุเพื่อรวมองค์ประกอบอาร์เรย์เพื่อสร้างค่าเดียว นี่คือการดำเนินการทั่วไปในการเขียนโปรแกรมที่ใช้งานได้หรือที่เรียกว่า "การฉีด" และ "ล่มสลาย"
【ลด()】
วิธีการลด () ต้องการสองพารามิเตอร์ อย่างแรกคือฟังก์ชั่นที่ดำเนินการง่ายๆ งานของฟังก์ชั่นการทำให้เข้าใจง่ายคือการใช้วิธีการบางอย่างเพื่อรวมหรือลบสองค่าเป็นค่าเดียวและส่งคืนค่าที่ง่ายขึ้น
ฟังก์ชั่นที่ง่ายขึ้นยอมรับสี่พารามิเตอร์คือ:
【 1 】ตัวแปรเริ่มต้นเริ่มต้นเป็นค่าองค์ประกอบแรกของอาร์เรย์ ค่าส่งคืนหลังจากการดำเนินการครั้งแรกของฟังก์ชั่นใช้เป็นตัวแปรเริ่มต้นสำหรับการดำเนินการครั้งที่สองของฟังก์ชันและอื่น ๆ
【 2 】ตัวแปรปัจจุบันหากมีการระบุพารามิเตอร์ที่สองตัวแปรคือค่าขององค์ประกอบแรกของอาร์เรย์มิฉะนั้นค่าขององค์ประกอบที่สองคือค่าขององค์ประกอบที่สอง
【 3 】ดัชนีขององค์ประกอบที่สอดคล้องกับตัวแปรปัจจุบันในอาร์เรย์ (เริ่มต้นจาก 0)
【 4 】วัตถุอาร์เรย์ดั้งเดิม
ในบรรดาพารามิเตอร์ทั้งสี่ของฟังก์ชั่นที่เรียบง่ายจำเป็นต้องใช้เพียงสองคนแรกเท่านั้นในขณะที่สองตัวสุดท้ายเป็นตัวเลือก
values.reduce (ฟังก์ชั่น (ก่อนหน้า, cur, cur, lep, array) {// toDo});พารามิเตอร์ที่สอง (เลือก) ของวิธีการลด () เป็นค่าเริ่มต้นที่ส่งผ่านไปยังฟังก์ชัน
var a = [1,2,3,4,5]; var sum = a.reduce (ฟังก์ชั่น (x, y) {return x+y}, 0); // ผลรวมของอาร์เรย์ var product = a.reduce (ฟังก์ชั่น (x, y) {return x*y}, 1); 2, 3, 4, 5] .Reduce (ฟังก์ชั่น (ก่อนหน้า, cur) {console.log (ก่อนหน้า, cur) return prev + cur;}); // 1 2 // 3 3 // 6 4 // 10 5 // ผลลัพธ์สุดท้าย: 15 [1, 2, 3, 4, 5] 3 // 6 4 // 10 5 // ผลลัพธ์สุดท้าย: 15[หมายเหตุ] ประเภทผลการส่งคืนของวิธีการลด () เหมือนกับค่าเริ่มต้นที่ผ่านเข้ามา
[1, 2, 3, 4, 5] .Reduce (ฟังก์ชั่น (ก่อนหน้า, cur) {console.log (prev.sum, cur); prev.sum = prev.sum + cur; return prev;}, {sum: 0}); // 0 1 // 1 2 // 3 3 // 6 4 // 10 5 //การใช้วิธีลด () คุณสามารถเขียนวิธีการรวมสำหรับผลรวมของอาร์เรย์
array.prototype.sum = function () {return this.reduce (ฟังก์ชั่น (ก่อนหน้า, cur) {return prev + cur;})}; [3,4,5,6,6,10] .sum (); // 28เนื่องจากวิธีการลดวิธีการแต่ละองค์ประกอบตามลำดับจึงสามารถใช้เพื่อค้นหาองค์ประกอบ ตัวอย่างเช่นค้นหาองค์ประกอบอาร์เรย์ที่ยาวที่สุด
ฟังก์ชั่น findlongest (รายการ) {return entries.reduce (ฟังก์ชั่น (ก่อนหน้า, cur) {return cur.length> prev.length? cur: prev;}, '');} console.log (findlongest ([1,2,3, 'ab', 4, 'bcd', 5,6785,4คุณสามารถใช้วิธีการลด () เพื่อให้ได้อาร์เรย์สองมิติที่แบนราบ
var matrix = [[1, 2], [3, 4], [5, 6]]; // 2d อาร์เรย์ flatten var flatten = matrix.reduce (ฟังก์ชั่น (ก่อนหน้า, cur) {return prev.concat (cur);}); console.log (flatten); // [1, 2, 3, 4, 5, 6]ในอาร์เรย์ที่ว่างเปล่าการเรียกลด () โดยไม่มีพารามิเตอร์ค่าเริ่มต้นจะส่งผลให้เกิดข้อผิดพลาดประเภทข้อผิดพลาด หากมีเพียงค่าเดียวเมื่อเรียกว่า - อาร์เรย์มีเพียงองค์ประกอบเดียวและไม่ระบุค่าเริ่มต้นหรือมีอาร์เรย์ว่างเปล่าและระบุค่าเริ่มต้น - ลด () ลด (เพียงส่งคืนค่านั้นโดยไม่ต้องเรียกฟังก์ชันที่ง่ายขึ้น
var arr = []; arr.reduce (function () {}); // uncaught typeError: ลดอาร์เรย์ที่ว่างเปล่าโดยไม่มี valuevar arr = []; arr.reduce (ฟังก์ชั่น () {}, 1); // 1วิธีการเขียนที่เข้ากันได้ของวิธีการลด ()
if (typeof array.prototype.Reduce! = "function") {array.prototype.Reduce = function (การเรียกกลับ, เริ่มต้น) {var previous = initialValue, k = 0, length = this.length; if (typeof initialValue === "undefined") {ก่อนหน้านี้ <length;【 reduceright () 】
Reduceright () ทำงานเช่นเดียวกับการลด () ความแตกต่างคือประมวลผลอาร์เรย์จากสูงถึงต่ำ (ขวาไปซ้าย) ตามดัชนีอาร์เรย์มากกว่าจากต่ำถึงสูง
ค่า var = [1,2,3,4,5]; var sum = values.reduceright (ฟังก์ชั่น (ก่อนหน้า, cur, ดัชนี, อาร์เรย์) {console.log (ก่อนหน้า, cur); return prev + cur;}); console.log (ผลรวม); // 5 4 // 9 3 // 12 2 // 14 1 // 15วิธีการเขียนที่เข้ากันได้
if (typeof array.prototype.reduceright! = "function") {array.prototype.reduceright = ฟังก์ชั่น (การเรียกกลับ, initialValue) {var length = this.length, k = ความยาว - 1, previous = initialValue; {สำหรับ (k; k> -1; k- = 1) {this.hasownproperty (k) && (ก่อนหน้า = การโทรกลับ (ก่อนหน้านี้ [k], k, k, this));}} return ก่อนหน้า;};};วิธีการวนซ้ำอาร์เรย์
ECMASCRIPT5 กำหนด 5 วิธีการวนซ้ำสำหรับอาร์เรย์ แต่ละวิธีได้รับสองพารามิเตอร์: ฟังก์ชันที่จะทำงานในแต่ละรายการและวัตถุขอบเขตที่ (ไม่บังคับ) เรียกใช้ฟังก์ชัน - ส่งผลกระทบต่อค่าของสิ่งนี้ ฟังก์ชั่นที่ส่งผ่านไปยังวิธีการเหล่านี้ได้รับสามพารามิเตอร์: ค่าของรายการอาร์เรย์ตำแหน่งของรายการในอาร์เรย์และวัตถุอาร์เรย์เอง ขึ้นอยู่กับวิธีที่ใช้ค่าส่งคืนหลังจากการดำเนินการของฟังก์ชันนี้อาจหรือไม่มีผลต่อค่าคืนที่เข้าถึงได้
ฟังก์ชั่น (รายการ, ดัชนี, อาร์เรย์) {// toDo}【แผนที่()】
เมธอดแผนที่ () เรียกใช้ฟังก์ชั่นที่กำหนดในแต่ละรายการของอาร์เรย์ส่งคืนอาร์เรย์ที่ประกอบด้วยผลลัพธ์ของการโทรแต่ละฟังก์ชัน
// f เป็นฟังก์ชั่นที่เรียกโดยแต่ละองค์ประกอบของอาร์เรย์ ค่าผลตอบแทนของมันกลายเป็นองค์ประกอบของอาร์เรย์ส่งคืน O เป็นตัวเลือกนี้ค่านี้เมื่อ f เรียกว่า array.map (f, o); [1,2,3] .map (ฟังก์ชั่น (รายการ, ดัชนี, arr) {return item*item}); // [1,4,9] [1,2,3] .map (ฟังก์ชั่น (รายการ, ดัชนี, arr) {return item*}); // [0,2,6]เมธอดแผนที่ () ยังสามารถยอมรับพารามิเตอร์ที่สองซึ่งระบุวัตถุที่ชี้ไปที่สิ่งนี้เมื่อฟังก์ชั่นการเรียกกลับถูกเรียกใช้งาน
var arr = ['a', 'b', 'c']; [1,2] .map (ฟังก์ชั่น (รายการ, ดัชนี, arr) {ส่งคืน [รายการ]}, arr); // ['b', 'c']เมื่อใช้ในทางปฏิบัติคุณสามารถใช้วิธีการ MAP () เพื่ออำนวยความสะดวกในการได้มาของค่าแอตทริบิวต์เฉพาะในอาร์เรย์วัตถุ
ผู้ใช้ var = [{ชื่อ: 't1', อีเมล:'[email protected] '}, {ชื่อ:' t2 ', อีเมล:'[email protected]'}, {ชื่อ: 't3', อีเมล:'[email protected] '}]; console.log (users.map (รายการ "[email protected]", "[email protected]"]MAP () สามารถใช้วิธีการสำหรับวัตถุอาร์เรย์คลาส
array.prototype.map.call ('abc', ฟังก์ชั่น (รายการ, ดัชนี, arr) {return item.touppercase ()}); // ["a", "b", "c"]สำหรับอาร์เรย์แบบเบาบางวิธี MAP () ไม่เรียกฟังก์ชั่นในหมายเลขลำดับที่องค์ประกอบไม่มีอยู่จริง
var a = [1 ,, 3]; console.log (a.map (ฟังก์ชัน (รายการ, ดัชนี, arr) {return item*2;})); // [2, 2: 6]MAP () วิธีการเขียนที่เข้ากันได้
if (typeof array.prototype.map! = "function") {array.prototype.map = function (fn, บริบท) {var arr = []; ถ้า (typeof fn === "function") {สำหรับ (var k = 0, length = this.length; arr;};}【 foreach () 】
วิธีการ foreach () เรียกใช้ฟังก์ชั่นที่กำหนดในแต่ละรายการในอาร์เรย์และวิธีนี้จะไม่ส่งคืนค่า เป็นหลักเช่นเดียวกับการวนซ้ำในอาร์เรย์สำหรับลูป หากคุณต้องการค่าส่งคืนคุณมักจะใช้เมธอดแผนที่
[1,2,3,4] .Foreach (ฟังก์ชั่น (รายการ, ดัชนี, arr) {console.log (รายการ)}); // 1 // 2 // 3 // 4คล้ายกับลูปด้านล่าง
var array = [1, 2, 3, 4]; สำหรับ (var k = 0, length = array.length; k <length; k ++) {console.log (array [k]);}ใช้วิธี foreach () เพื่อใช้งานง่าย ๆ
var sum = 0; [1, 2, 3, 4]. foreach (ฟังก์ชัน (รายการ, ดัชนี, อาร์เรย์) {sum += item;}); console.log (sum); // 10นอกเหนือจากการยอมรับพารามิเตอร์ฟังก์ชันการโทรกลับที่จำเป็นพารามิเตอร์ที่สองยังสามารถยอมรับพารามิเตอร์บริบททางเลือก (เปลี่ยนตัวชี้นี้ในฟังก์ชันการโทรกลับ)
var out = []; [1, 2, 3]. foreach (ฟังก์ชั่น (elem) {this.push (elem * elem);}, out); console.log (ออก); // [1, 4, 9]พารามิเตอร์ที่สองมีประโยชน์มากสำหรับหลายชั้นนี้เนื่องจากหลายชั้นซึ่งมักจะชี้ไม่สอดคล้องกันคุณสามารถใช้พารามิเตอร์ที่สองของวิธี foreach () เพื่อแก้ไขปัญหานี้
var obj = {ชื่อ: 'จางซาน', ครั้ง: [1, 2, 3], พิมพ์: ฟังก์ชั่น () {// นี่ชี้ไปที่ objconsole.log (นี่); this.times.foreach (ฟังก์ชั่น (n) {// นี่ชี้ไปที่ windowconsole.log (นี่);});}}; obj.print (); var obj = {ชื่อ: 'จางซาน', ครั้ง: [1, 2, 3], พิมพ์: ฟังก์ชั่น () {// นี่ชี้ไปที่ objconsole.log (นี่); this.times.foreach (ฟังก์ชั่น (n) {// สิ่งนี้ยังชี้ไปที่ objconsole.log (นี่);}, สิ่งนี้);}}; obj.print ();foreach () ลูปสามารถใช้สำหรับวัตถุอาร์เรย์คลาส
var str = 'abc'; array.prototype.foreach.call (str, ฟังก์ชัน (รายการ, ดัชนี, อาร์เรย์) {console.log (รายการ + ':' + ดัชนี);}); // a: 0 // b: 1 // c: 2ซึ่งแตกต่างจากลูปสำหรับอาร์เรย์กระจัดกระจายวิธี foreach () ไม่เรียกฟังก์ชั่นในหมายเลขคำสั่งซื้อที่องค์ประกอบไม่มีอยู่จริง
var a = [1,2,3]; ลบ a [1]; สำหรับ (var i = 0; i <a.length; i ++) {console.log (a [i]);} // 1 // undefined // 3 a.foreach (ฟังก์ชั่น (รายการ, ดัชนี, arr) {console.logวิธีการ foreach () ไม่สามารถยุติการสำรวจก่อนได้ก่อนที่องค์ประกอบทั้งหมดจะถูกส่งผ่านไปยังฟังก์ชันที่เรียกว่า นั่นคือไม่มีคำสั่งหยุดพักที่สอดคล้องกันเช่นที่ใช้ในการวนรอบ หากคุณต้องการยกเลิกก่อนกำหนดคุณต้องใส่วิธี foreach () ในบล็อกลองและโยนข้อยกเว้น
สำหรับ (var i = 0; i <5; i ++) {ถ้า (i == 2) break;} console.log (i); // 2 var a = [1,2,3,4,4,5]; console.log (a.foreach (รายการ (รายการ, ดัชนี, arr) {ถ้า (ดัชนี == 2) var a = [1,2,3,4,5]; a.foreach (ฟังก์ชั่น (รายการ, ดัชนี, arr) {ลอง {ถ้า (รายการ == 2) โยนข้อผิดพลาดใหม่;} catch (e) {console.log (รายการ);}});foreach () วิธีการเขียนที่เข้ากันได้
if (typeof array.prototype.foreach! = 'function') {array.prototype.foreach = function (fn, บริบท) {สำหรับ (var k = 0, length = this.length; k <length; k ++) {if (typeof fn === object.prototype.hasownproperty.call (this, k)) {fn.call (บริบท, [k], k, k, this);}}}}}【กรอง()】
เมธอดตัวกรอง () เรียกใช้ฟังก์ชั่นที่กำหนดในแต่ละรายการในอาร์เรย์และส่งคืนอาร์เรย์ของรายการที่จะส่งคืนจริง วิธีนี้มักจะใช้ในการสืบค้นรายการอาร์เรย์ทั้งหมดที่ตรงตามเกณฑ์
[1, 2, 3, 4, 5] .filter (ฟังก์ชั่น (elem) {return (elem> 3);}); // [4, 5] [0, 1, 'a', false] .filter (บูลีน); // [1, "a"] [1, 2, 3, 4, 5] 3, 5]เมธอดตัวกรอง () ยังสามารถยอมรับพารามิเตอร์ที่สองโดยระบุวัตถุบริบท (วัตถุนี้) โดยที่ฟังก์ชั่นการทดสอบอยู่
var obj = function () {this.max = 3;}; var myfilter = ฟังก์ชั่น (รายการ) {ถ้า (รายการ> this.max) {return true;}}; var arr = [2, 8, 3, 4, 1, 3, 2, 9]; arr.filterตัวกรอง () จะข้ามองค์ประกอบที่หายไปในอาร์เรย์กระจัดกระจาย อาร์เรย์ที่ส่งคืนนั้นมีความหนาแน่นสูงเสมอดังนั้นจึงสามารถบีบอัดช่องว่างในอาร์เรย์ได้
var a = [1,2 ,,,,, 3 ,,, 4]; console.log (A.length); // 10var ความหนาแน่น = a.filter (ฟังก์ชั่น () {return true;}) console.log (หนาแน่น, หนาแน่น); // [1,2,3,4] 4] 4หากคุณต้องการบีบอัดตำแหน่งงานว่างและลบองค์ประกอบที่ไม่ได้กำหนดและ NULL คุณสามารถใช้วิธีตัวกรอง () เช่นนี้
var a = [1,2 ,, undefined ,, 3 ,, null ,, 4]; console.log (a.length); // 10var ความหนาแน่น = a.filter (ฟังก์ชั่น (รายการ) {รายการส่งคืน! = undefined;}) คอนโซลล็อกวิธีการเขียนที่เข้ากันได้กับวิธีการ ()
if (typeof array.prototype.filter! = "function") {array.prototype.filter = function (fn, บริบท) {var arr = []; ถ้า (typeof fn === "function") {สำหรับ (var k = 0, ความยาว arr.push (นี่ [k]);}} return arr;};}【บาง()】
วิธีบางอย่าง () เรียกใช้ฟังก์ชั่นที่กำหนดในแต่ละรายการในอาร์เรย์และหากฟังก์ชั่นส่งคืนจริงสำหรับรายการใดรายการหนึ่งมันจะส่งกลับจริง และถ้าถ้าองค์ประกอบทั้งหมดในค่าเรียกใช้ฟังก์ชันการตัดสินใจจะส่งกลับเท็จก็จะส่งกลับเท็จ
a = [1,2,3,4,5]; a.some (ฟังก์ชั่น (elem, ดัชนี, arr) {return elem%2 === 0;}) // truea.some (isnan); // falseการโทรบางวิธี () ในอาร์เรย์ที่ว่างเปล่าจะส่งคืนเท็จ
[]. some (function () {}); // falseบางวิธี () วิธีการเขียนที่เข้ากันได้
if (typeof Array.prototype.some != "function") {Array.prototype.some = function (fn, context) {var passed = false;if (typeof fn === "function") {for (var k = 0, length = this.length; k < length; k++) {if (passed === true) break;passed = !!fn.call(context, this[k], k, this);}}return passed;};}【ทั้งหมด()】
every()方法对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true；只要有一项返回false，则返回false
a = [1,2,3,4,5];a.every(function(elem, index, arr){elem < 10;})//truea.every(function(elem, index, arr){return elem%2 ===0;});//false在空数组上调用every()方法会返回true
[].every(function(){});//trueevery()方法兼容写法
if (typeof Array.prototype.every != "function") {Array.prototype.every = function (fn, context) {var passed = true;if (typeof fn === "function") {for (var k = 0, length = this.length; k < length; k++) {if (passed === false) break;passed = !!fn.call(context, this[k], k, this);}}return passed;};}สรุป
วิธีการอาร์เรย์ JavaScript นั้นถูกกำหนดโดยเฉพาะเป็นเรื่องทั่วไปดังนั้นจึงทำงานได้อย่างถูกต้องไม่เพียง แต่ในอาร์เรย์จริง แต่ยังรวมถึงวัตถุอาร์เรย์คลาสด้วย Of these 22 methods, all methods except toString() and toLocaleString() are common
可以改变原数组的方法总共有7种：包括unshift()、shift()、push()、pop()这4种栈和队列方法，reverse()和sort()这2种数组排列方法，数组删改方法splice()
The above is the 22 must-learn methods of arrays in JavaScript introduced to you by the editor (recommended). ฉันหวังว่ามันจะเป็นประโยชน์กับคุณ หากคุณมีคำถามใด ๆ โปรดฝากข้อความถึงฉันและบรรณาธิการจะตอบกลับคุณทันเวลา ขอบคุณมากสำหรับการสนับสนุนเว็บไซต์ Wulin.com!