เมธอดอาร์เรย์ JavaScript จะดูองค์ประกอบเดียวในอาร์เรย์ JavaScript ได้อย่างไร Masivi ใน JavaScript

ด้วยอาร์เรย์ คุณสามารถทำงานกับวิธีการต่างๆ ที่อาศัยตัวสร้างอาร์เรย์ได้

วิธีป๊อป/ดันและเปลี่ยน/ยกเลิกการเปลี่ยน

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

ลองหันมาดูเมธอด push() และ pop() เมธอด push() เพิ่มองค์ประกอบใหม่อย่างน้อยหนึ่งรายการต่อท้ายอาร์เรย์และหมุนองค์ประกอบใหม่ วิธี pop() - แสดงองค์ประกอบที่เหลือของอาร์เรย์ เปลี่ยนอาร์เรย์ที่สอง และหมุนค่าต่อไป Varto ให้ความเคารพต่อผู้ที่ขุ่นเคืองด้วยวิธีการและเปลี่ยนอาร์เรย์ในฟิลด์และไม่สร้างสำเนาที่แก้ไข

วาร์ฟู=; // foo: foo.push(1,2); // foo: หมุน 2 foo.pop(); // foo: กด 2 foo.push(3); // foo: หมุน 2 foo.pop(); // foo: กด 3 foo.push(); // foo: ] เลี้ยว 2 foo.pop() // foo: เปิด foo.pop(); // foo: หมุนผลไม้ 1 ผล = ["ลูกแพร์", "กล้วย", "แอปเปิ้ล"]; var เลือก = fruits.pop(); document.write("คุณได้ของฉัน" + เลือก); พยายาม

เมธอด shift() และ unshift() ทำได้หลายอย่าง เช่น pop() และ push() ยกเว้นว่าจะแทรกและลบองค์ประกอบบน cob ของอาร์เรย์ วิธีการ unshift() แทนที่องค์ประกอบที่สำคัญของดัชนีขนาดใหญ่สำหรับการเปลี่ยนตำแหน่งขององค์ประกอบใหม่ เพิ่มองค์ประกอบอย่างน้อยหนึ่งรายการในอาร์เรย์บน cob และหมุนอาร์เรย์ใหม่ไปยังอีกองค์ประกอบหนึ่ง วิธี shift() จะมองเห็นองค์ประกอบแรกของอาร์เรย์และหมุนค่าที่สอง โดยเปลี่ยนองค์ประกอบถัดไปทั้งหมดให้ครอบครอง ที่ว่างที่จุดเริ่มต้นของอาร์เรย์

วาร์ ฉ =; // f: f.unshift(1); // f: หมุน: 1 f.unshift(22); // f: Shift: 2 f.shift(); // f: หมุน: 22 f.unshift(3,); // f:,1] หมุน: 3 f.shift(); // f:[,1] หมุน: 3 f.shift(); // f: เลี้ยว: f.shift(); // f: เทิร์น: 1

เข้าร่วมวิธี

Array.join() เป็นสิ่งที่ชั่วร้ายในการรวมองค์ประกอบในอาร์เรย์ในแถวเดียว วิธีการสามารถส่งผ่านอาร์กิวเมนต์แถวที่ไม่มีผลผูกพัน ซึ่งสามารถใช้สำหรับองค์ประกอบย่อยในแถว หากไม่มีการกำหนด วิธีการนี้จะเป็นอาการโคม่าที่มีการแยกสัญลักษณ์สำหรับล็อคเป็นเวลาหนึ่งชั่วโมง

Var a = ["ลม", "น้ำ", "ไฟ"]; var myVar1 = a.join(); //"น้ำ น้ำ ไฟ" var myVar2 = a.join(", "); //"ลม ฝน ไฟ" var myVar3 = a.join(" + "); //"ลม + ไม้ + ไฟ" document.write(myVar1 + "
" + myVar2 + "
+ myVar3); พยายาม "

วิธีการ Array.join() คือวิธีการส่งคืนวิธีการ String.split() ซึ่งสร้างอาร์เรย์โดยแยกแถวออกเป็นแฟรกเมนต์

วิธีย้อนกลับ

Array.reverse() วิธีการเปลี่ยนลำดับขององค์ประกอบในอาร์เรย์เพื่อขยายและหมุนอาร์เรย์ด้วยองค์ประกอบที่จัดเรียงใหม่ เมธอดนี้ไม่ได้สร้างอาร์เรย์ใหม่จากการเรียงลำดับองค์ประกอบใหม่ แต่จะจัดลำดับใหม่จากอาร์เรย์ที่มีอยู่แล้ว

Var myArr = ["หนึ่ง", "สอง", "สาม"]; document.write(myArr.reverse()); พยายาม

วิธีการต่อเชื่อม

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

วาร์ =; a.concat(4, 5) // เปลี่ยน a.concat(); // เหมือนกัน - หมุน a.concat(,) // หมุน

วิธีการเรียงลำดับ

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

Var a = ["Kiv", "Oranges", "Pears"]; ก.sort(); vars = a.join(", "); //ส้ม แพร์ กีวี document.write(s); //ปุ่มที่มีตัวเลข var myArr = ; myArr.sort(); document.write(myArr); ///1,10,2 ลอง »

คุณทำคะแนนได้สามคะแนนหรือมากกว่านั้น การเรียงลำดับดังกล่าวเกิดจากการที่เมธอด sort() ทำการเรียงลำดับองค์ประกอบ เปลี่ยนเป็นแถว นั่นเป็นเหตุผลที่พวกเขามีลำดับแถว - อาจ "10"

ในการเรียงลำดับอื่น ๆ ตามลำดับตัวอักษร คุณสามารถส่งเมธอด sort() เป็นอาร์กิวเมนต์ไปยังฟังก์ชัน sort ได้ Prote sled vrahuvati, scho function por_vnyannya เกิดขึ้นเพื่อเขียนด้วยตัวเอง ฟังก์ชั่นนี้จะต้องถูกตำหนิในพารามิเตอร์สองตัวของแม่ หินจะไม่ถูกติดตั้ง ซึ่งในสองอาร์กิวเมนต์จะถูกตำหนิในปัจจุบันก่อนหน้าในรายการที่จัดเรียง เพื่อให้ง่ายต่อการพัฒนาและเขียนฟังก์ชันดังกล่าว มีกฎสองสามข้อซึ่งกำหนดลำดับขององค์ประกอบ:

• เนื่องจากอาร์กิวเมนต์แรกสามารถกำหนดใหม่ให้กับอาร์กิวเมนต์อื่นได้ ฟังก์ชันเท่ากันจึงหมุนจำนวนลบ (เช่น a
• หากอาร์กิวเมนต์แรกสามารถติดตามอาร์กิวเมนต์อื่นได้ ฟังก์ชันสมมูลจะหมุนจำนวนบวก (ดังนั้น a > b)
• เนื่องจากค่าทั้งสองมีค่าเท่ากัน (ดังนั้นลำดับการหมุนจึงไม่สำคัญ) ฟังก์ชันการจัดตำแหน่งจะหมุน 0 (ดังนั้น a == b)

เพื่อให้ตรงกับอาร์กิวเมนต์ของคุณ ฟังก์ชันจะจับคู่กับองค์ประกอบของอาร์เรย์:

ฟังก์ชัน foo(a,b) ( //กำหนดฟังก์ชัน reverb ถ้า (a b) คืนค่า 1; return 0; // ดังนั้น a == b ) var a = ; ก.sort(foo); // ถ้าอาร์กิวเมนต์ไม่ถูกส่งไปยังฟังก์ชัน document.write(a.join(", ")); //อาจจะสั้นกว่าด้วย var a = ; a.sort(function(a,b) ( //ฟังก์ชั่นที่ไม่ระบุตัวตนเสมือนคืนค่า a - b; //ฟังก์ชั่นเพื่อหมุนค่า 0)); document.write(ก); ///1,2,5,10 ลอง »

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

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

วิธีสไลซ์

วิธีการ Array.slice() ถูกเขียนใหม่เพื่อคัดลอกสไลซ์ที่กำหนดไปยังอาร์เรย์ และหมุนอาร์เรย์ใหม่เพื่อลบองค์ประกอบที่คัดลอก อาร์เรย์ภายนอกไม่ได้เปลี่ยนแปลงด้วยตัวมันเอง

ไวยากรณ์วิธีการ:

im_array. slice(เริ่มต้น, สิ้นสุด);

Im'ya_array ควรแทนที่อาร์เรย์ im'yam ซึ่งจำเป็นต้องแยกองค์ประกอบชุดเดียวกันสำหรับอาร์เรย์ใหม่ วิธีการยอมรับสองอาร์กิวเมนต์ กล่าวคือ พวกเขากำหนด cob และจุดสิ้นสุดของพล็อตของอาร์เรย์ที่จะเปิด วิธีการคัดลอกไฟล์ไปยังอาร์เรย์ ตั้งแต่ต้นจนจบ ไม่รวมจุดสิ้นสุด หากมีการระบุอาร์กิวเมนต์มากกว่าหนึ่งอาร์กิวเมนต์ อาร์เรย์ที่หมุนจะแทนที่องค์ประกอบทั้งหมดในตำแหน่งที่กำหนดจนถึงจุดสิ้นสุดของอาร์เรย์ คุณสามารถเอาชนะดัชนีเชิงลบได้ - กลิ่นเหม็นจะขยายตัวจากส่วนท้ายของอาร์เรย์

วาร์ arr=; arr ชิ้น(0,3); //หมุน arr.slice(3); //หมุน arr.slice(1,-1); //หมุน arr.slice(-3,-2); //เปลี่ยน

วิธีประกบ

วิธีการ Array.splice() เป็นวิธีการทั่วไปสำหรับการทำงานกับอาร์เรย์ มันเปลี่ยนอาร์เรย์เป็นสถานที่ แทนที่จะหมุนการเปลี่ยนแปลงอาร์เรย์ใหม่ เช่นเดียวกับที่ทำกับเมธอด slice() และ concat() วิธีการต่อสามารถลบองค์ประกอบออกจากอาร์เรย์ แทรกองค์ประกอบใหม่ แทนที่องค์ประกอบ - ทุกชั่วโมง หมุนอาร์เรย์ที่ประกอบขึ้นจากองค์ประกอบที่ถูกลบออกไป ราวกับว่ามันถูกค้นพบจากองค์ประกอบที่มองไม่เห็น ให้เปิดอาร์เรย์ที่ว่างเปล่า

ไวยากรณ์วิธีการ:

array_name.splice(ดัชนี, y, elem1, ..., elemN);

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

Var ผลไม้ = ["ส้ม", "แอปเปิ้ล", "ลูกแพร์", "องุ่น"]; var ลบ = fruits.splice (2,2); //เปิด ["ลูกแพร์", "องุ่น"] document.write (ลบแล้ว); วาร์ อาร์ =; arr.splice(4); //เปลี่ยน; อาร์เรย์กลายเป็น: arr.splice(1,2); //เปลี่ยน; อาร์เรย์กลายเป็น: arr.splice(1,1); //เปลี่ยน; อาร์เรย์กลายเป็น: ลอง »

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

Var ผลไม้ = ["ส้ม", "แอปเปิ้ล"]; fruit.splice(2,0, "kavuni"); //เปิด document.write(ผลไม้); //กลายเป็น ["ส้ม", "แอปเปิ้ล", "kavuni"] var arr =; arr.splice(2,0,"a","b"); //เปลี่ยน; กลายเป็น arr.splice(2,2,); //หมุน ["a","b"]; กลายเป็น ,3,4,5] ลอง »

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

วิธี toString

toString() วิธีการจัดเรียงองค์ประกอบของอาร์เรย์เป็นแถว บิดเหมือนแยกอักขระ

Var arr = ["นม", "ขนมปัง", "ตับ"]; var อาหาร = arr.toString(); document.write(อาหาร); // นม ขนมปัง ลอง Pechivo »

ด้วยความเคารพ เมธอดจะหมุนเวียนในลำดับเดียวกันกับเมธอด join() เมื่อเรียกโยคะโดยไม่มีข้อโต้แย้ง

indexOf และสุดท้ายIndexOf

เมธอด indexOf หมุนดัชนีขององค์ประกอบ ค่าของค่าใดก็ตามที่ส่งผ่านไปยังเมธอดเป็นอาร์กิวเมนต์

ไวยากรณ์ของเมธอด indexOf() และ lastIndexOf() คือ:

im_array.indexOf(องค์ประกอบ hoo ดัชนี) im_array.lastIndexOf (องค์ประกอบ hoo ดัชนี)

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

วาร์ =; ก.ดัชนีของ(3) //เปิด 2 a.indexOf(3,4); //เปิด 6 a.indexOf(35); //Vernet -1: ไม่มีองค์ประกอบที่มีค่าดังกล่าว a.indexOf(2); // หนึ่ง

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

วาร์ =; ก.lastIndexOf(3); //เปลี่ยน 7 a.lastIndexOf(35); //Vernet -1: ไม่มีองค์ประกอบที่มีค่าดังกล่าว a.lastIndexOf(2); // 6

วิธีการวนซ้ำ

p align="justify"> วิธีการที่อธิบายไว้ด้านล่างเป็นตัววนซ้ำ ทั้งหมด เบราว์เซอร์ปัจจุบันสำหรับการทำงานกับอาร์เรย์ มีวิธีการที่รู้จักสำหรับการแจงนับองค์ประกอบและ vikonannya raznomanіtnyh dіy เหนือพวกเขา นี่คือวิธีการ forEach(), map(), filter(), every(), some, reduce() and reduceRight()

วนซ้ำองค์ประกอบของอาร์เรย์โดยเริ่มจาก 0 ถึงความยาว - 1 และหากมีองค์ประกอบอยู่ ให้ส่งผ่านไปยังฟังก์ชันเรียกกลับ

แต่ละ

ไวยากรณ์วิธีการ:

im_array.forEach(โทรกลับ, thisArg)

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

วาร์ arr=; ฟังก์ชั่น foo(ค่า) ( ​​var sum = ค่า * this; return document.write(sum + "
"); ) arr.forEach(foo, 5); // อาร์กิวเมนต์อื่นจะถูกส่งต่อเป็นค่า //app พร้อมพารามิเตอร์สามตัว var a = ; a.forEach(function(el, idx, a) ( document.write( " a["+idx+"] = "+el+" y ["+a+"]
"); )); พยายาม "

กรอง

ไวยากรณ์วิธีการ:

im_array.filter (โทรกลับ, thisObject)

เมธอด filter() สร้างและหมุนอาร์เรย์ใหม่ แล้วแต่จำนวนใดจะตรงกับองค์ประกอบเหล่านั้นของอาร์เรย์ ซึ่งฟังก์ชันเรียกกลับกลายเป็นจริง

ฟังก์ชั่น isBig(องค์ประกอบ ดัชนี อาร์เรย์) ( //เปลี่ยนตัวเลขให้มากกว่าหรือเท่ากับ 10 ผลตอบแทน (องค์ประกอบ >= 10); // ถ้าค่าขององค์ประกอบมากกว่าหรือเท่ากับ 10 - เป็นจริง ) var กรอง = .filter(isBig) ; //กรองแล้ว

แผนที่

เมธอด map() สร้างและหมุนอาร์เรย์ใหม่ที่เพิ่มโดยผลลัพธ์ของฟังก์ชันการเรียกกลับ (รายการ, idx, ar) สำหรับอาร์เรย์องค์ประกอบสกิน

วาร์ =; var b = a.map(ฟังก์ชัน(รายการ, idx, arr) ( รายการที่ส่งคืน * รายการ; )); // ข =

ทุก ๆ อย่าง

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

วิธี some() กลายเป็นจริง ซึ่งหมายความว่ามีเวลาตรวจสอบค่าฟังก์ชันเพียงชั่วโมงเดียว หรือองค์ประกอบบางอย่างกลายเป็นจริง

วาร์ =; a.every(function(x) ( return x 10; )) //true: one number > 10

ลดและลดขวา

ไวยากรณ์ของวิธีการ:

im'ya_array.reduce(โทรกลับ, initialValue) im'i_array.reduceRight (โทรกลับ, initialValue)

วิธีลด () ถูกกำหนดให้กับฟังก์ชันหยุด (เรียกกลับ) เพื่อแยกค่าอาร์เรย์สองค่า วนซ้ำองค์ประกอบทางด้านขวา โดยนำผลลัพธ์ที่อยู่ระหว่างกลาง

อาร์กิวเมนต์ของฟังก์ชันเรียกกลับ: (PreviousValue, currentItem, index, array)

• PreviousValue - หมุนผลลัพธ์ของฟังก์ชันการโทรกลับ (ในผลลัพธ์ระดับกลางเดียวกัน)
• รายการปัจจุบัน - องค์ประกอบการไหลไปยังอาร์เรย์ (องค์ประกอบจะถูกย้ายตามบรรทัดซ้ายมือขวา)
• ดัชนี – ดัชนีขององค์ประกอบการไหล
• array - อาร์เรย์ที่จะประมวลผล

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

วาร์ =; ฟังก์ชั่น foo(prevNum,curNum) ( sum = prevNum + curNum; alert(sum); return sum; ) var result = a.reduce (foo, 0); เอกสาร.เขียน(ผลลัพธ์); พยายาม

Rozberemo วิธีการทำงานของก้น อาร์กิวเมนต์แรกของฟังก์ชัน foo คือ:

• prevNum = 0 (ชาร์ด initialValue - 0)
• curNum = 1 (องค์ประกอบการไหลเป็นองค์ประกอบแรกในอาร์เรย์)

1 ถูกเพิ่มเป็น 0 ผลลัพธ์ (ผลรวม: 1) จะถูกส่งผ่านเป็น prevNum เมื่อ การเปิดตัวที่น่ารังเกียจฟังก์ชั่น. ยังไปไม่ถึงธาตุที่เหลือ ผลการหมุนคือผลรวมของการวิ่งที่เหลือ เราได้ 15 (1+2+3+4+5)

วิธี reduceRight ทำงานในลักษณะเดียวกับวิธีลด แต่ในอาร์เรย์ที่ถนัดขวามือซ้าย:

Var a = ["h", "o", "m", "e"]; แถบฟังก์ชัน (prevStr, curItem) ( return prevStr + curItem; ) document.write (a.reduceRight(bar)); // อีโม

ที่ องค์ประกอบการแสดงผลจาวาสคริปต์ไปยังอาร์เรย์สามารถkіlkomวิธีการ ก่อนหน้านั้น เราจะเห็นวิธีการป๊อปและชิฟต์ วิธีป๊อปเห็นองค์ประกอบแรกผ่าน ให้อาร์เรย์. วิธี shift จะลบองค์ประกอบที่เหลือออกจากอาร์เรย์ที่กำหนด

คุณสามารถแทรกอาร์เรย์ 0 เดิมได้ ซึ่งคุณจะต้องลบองค์ประกอบทั้งหมดออกจากอาร์เรย์นั้น แต่คุณต้องดูองค์ประกอบการร้องเพลงอะไร?

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

Array_name.splice(ดัชนี);

Array_name.delete

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

ดูการสาธิตเพื่อเรียนรู้วิธีแฮ็ควิธีการต่อ JavaScript และวิธีอื่นๆ ในการลบองค์ประกอบเดียวกัน

การสาธิตการแสดงภาพองค์ประกอบเฉพาะที่อยู่เบื้องหลังความช่วยเหลือของวิธีการต่อเชื่อม

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

Elementi อาร์เรย์ตัวเลขไปที่จุดนั้นหลังจากเรียกเมธอด JavaScript splice ในลำดับที่จะมาถึง:

โค้ด JavaScript ด้วยวิธี splice:

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

รุ่นสาธิตที่กำลังจะมีขึ้นจะแสดง vypadok หากเรามีพารามิเตอร์อื่น

พารามิเตอร์อื่นที่ไม่ใช่คำสั่งของวิธีการประกบ JavaScript มีประสิทธิภาพเพียงใด

รูปแบบในโค้ดเดียวกัน แต่ไม่มีพารามิเตอร์อื่น วิธีการต่อ:

Arr_Numbers.splice(2);

รหัสและผลลัพธ์:

ตรวจสอบการสาธิตออนไลน์และรหัส

เช่นเดียวกับ bachite คุณเห็นองค์ประกอบทั้งหมดก่อนหมายเลขดัชนีที่นี่ แน่นอนว่าวิธีการต่อจะหมุนอาร์เรย์ขององค์ประกอบที่อยู่ห่างไกลออกไป

รหัสจาวาสคริปต์:

ฟังก์ชันลบทางเลือกสำหรับการลบองค์ประกอบออกจากอาร์เรย์

ดังนั้น เพื่อลบองค์ประกอบออกจากอาร์เรย์ใน JavaScript คุณสามารถใช้ฟังก์ชันลบได้ เบียร์จะไม่บันทึกพื้นที่ว่าง และหากคุณหมุนอาร์เรย์นี้หลังจากใช้ฟังก์ชันอื่น องค์ประกอบที่นำออกจะแสดงเป็น undefined

มาดูเวอร์ชั่นเดโมซึ่งมีฟังก์ชั่นลบกันบ้าง:

ตรวจสอบการสาธิตออนไลน์และรหัส

รหัสจาวาสคริปต์:

โปรดทราบว่าองค์ประกอบที่สามจะแสดง undefined หลังจากการลบครั้งที่สองหลังจากฟังก์ชันตัวช่วยลบ

ในบรรดาผู้ค้าปลีก JavaScript มีความเข้าใจที่กว้างขึ้นเกี่ยวกับความแตกต่างระหว่างสองวิธี คุณรู้ในสิ่งที่คุณรู้ ชิ้นดู ประกบ?

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

Slice - ใช้ชีวิตและสร้าง

ภาษาอังกฤษ ชิ้น perekladaetsya เช่น "rіzati" พูดตามตรง ฉันไม่เข้าใจว่าผู้ระบุกำลังพูดอะไร แต่เป็นไปไม่ได้ที่จะพึ่งพาการแปลคำใน JS นำไปใช้กับข้อกำหนด ECMAScript 5.1 วิธีการ ชิ้นยอมรับสองอาร์กิวเมนต์: cob และ end index มาสร้างอาร์เรย์ใหม่ซึ่งจะแทนที่องค์ประกอบของดัชนี cob เก่าเป็นดัชนีสิ้นสุด ที่สำคัญที่สุด - มีการสร้างอาร์เรย์ใหม่เสมอ tobto อาร์เรย์ของการอุดตันบางประเภทเป็นวิธีกำจัดมันด้วยตัวเอง ดังนั้นอย่าลืมว่าพารามิเตอร์อื่นไม่ได้ระบุจำนวนขององค์ประกอบ แต่ดัชนีสุดท้าย พารามิเตอร์อื่นมักจะตำหนิสำหรับตัวแรก มิฉะนั้นอาร์เรย์ที่ว่างเปล่าจะถูกหมุน ลองมาดูที่มัน

วาร์ =; บันทึกคอนโซล (a); // varb = ก. ชิ้น(3, 5); บันทึกคอนโซล (a); // บันทึกคอนโซล (b); // var c = ก. ชิ้น(4, 2); บันทึกคอนโซล (a); // console.log(c);//

วิธีเริ่มต้นใน JS คุณเพียงแค่ต้องจำสิ่งที่ ชิ้นเปลี่ยนองค์ประกอบจากดัชนี cob ที่ระบุ ( รวมองค์ประกอบด้วยตัวมันเอง ) ฉันไปยังดัชนีสิ้นสุดที่กำหนด ale ไม่มีองค์ประกอบสิ้นสุด .

Splice - rіzhemo i dilimo

จากอังกฤษ ประกบ- ตะโกนออกไป. Znovu ยังไม่เห็นความเชื่อมโยงระหว่างวิธีดีเซลกับวิธี คุณสมบัติหลักของ splice คือสิ่งที่เปลี่ยนอาร์เรย์เอาต์พุต วิธีการนี้ยอมรับ cob และ end index ดังนั้นจึงเป็นสิ่งสำคัญที่ต้องจำไว้ว่า output array ของคุณจะถูกตัดโดยองค์ประกอบ

วาร์ =; บันทึกคอนโซล (a); //varb = a.splice(3, 5); บันทึกคอนโซล (a); // บันทึกคอนโซล (b); // var c = a.splice(4, 2); บันทึกคอนโซล (a); // บันทึกคอนโซล (c); //

ฉันต้องจำไว้อีกครั้งว่า ประกบอาร์เรย์เอาต์พุตที่ต่ำกว่าจากดัชนี cob ที่กำหนด ( รวมองค์ประกอบด้วยตัวมันเอง ) ฉันไปยังดัชนีสิ้นสุดที่กำหนด ( รวมถึงองค์ประกอบด้วย ). ด้วยวิธีนี้ องค์ประกอบทั้งหมดจะถูกหมุน และคุณสามารถบันทึกได้ okremo

นอกจากนี้ คุณยังสามารถปรับแต่งวิธีการต่อเข้าด้วยกันเพื่อลบองค์ประกอบออกจากอาร์เรย์ได้อีกด้วย ฉันจะเดาว่าอะไรดีที่สุด ลบ a; อย่าลบองค์ประกอบเอง แต่ตั้งค่าเป็นไม่ได้กำหนด เพื่อให้เห็นภาพองค์ประกอบ วิธีที่ดีที่สุดคือ a.splice(1, 1);

วาร์ =; ลบ; บันทึกคอนโซล (a); // วาร์ a =; a.splice(1, 1); บันทึกคอนโซล (a); //

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

ความชั่วร้ายทั้งหมดในวิธี JavaScript สามารถประเมินได้อย่างถูกต้องในความเข้าใจเท่านั้นเช่นกลิ่นเหม็น pratsyuyut มีสามวิธีในบทความนี้: ชิ้น(), ประกบ ()і แยก(). การค้นหาผู้ค้าปลีกที่รู้จักมักสร้างความสับสน: เป็นไปได้เพราะทั้งสามชื่อมีความคล้ายคลึงกันมาก

ถึงนักเรียนและผู้ค้าปลีก-pochatkіvtsam: อ่านบทความ tsyu ด้วยความเคารพเกี่ยวกับวิธีการสามวิธีและคุณสามารถเติมพลังให้กับspіvbesіdі

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

Masivi ใน JavaScript

ที่ด้านหลัง คุณต้องขยาย เช่น ฝึกอาร์เรย์ JavaScript เช่นเดียวกับในภาษาอื่น ๆ การเขียนโปรแกรม อาร์เรย์ได้รับชัยชนะในการกอบกู้ความเหงา ความแตกต่างก็คือ อาร์เรย์ของ JavaScript สามารถกำจัดจำนวนประเภทข้อมูลได้ในครั้งเดียว.

ในการทำงานกับอาร์เรย์ดังกล่าว เราจำเป็นต้องใช้เมธอด JavaScript เช่น ชิ้น() & ประกบ (). คุณสามารถสร้างอาร์เรย์ดังนี้:

ให้ arrayDefinition = ; // การประกาศอาร์เรย์ใน JS

มาสร้างอาร์เรย์ข้อมูลประเภทอื่นกัน:

ให้อาร์เรย์=;

JavaScript สามารถสร้างอาร์เรย์ด้วย ประเภทต่างๆข้อมูล: ด้วยตัวเลข แถว และค่าตรรกะ

ชิ้น()

วิธี ชิ้น()สำเนาของส่วนที่กำหนดของอาร์เรย์ แล้วเปลี่ยนสำเนาของส่วนที่คัดลอกจากอาร์เรย์ใหม่ อาร์เรย์ภายนอกไม่ได้เปลี่ยนแปลงด้วยตัวมันเอง.

อาร์เรย์สไลซ์(จาก จนถึง);

• พิมพ์: Narizuєอาร์เรย์ pochinayus ชม.องค์ประกอบใด
• จนกระทั่ง:กำหนดอาร์เรย์จนถึงองค์ประกอบแรก

ตัวอย่างเช่น ฉันต้องการบรรยายสามองค์ประกอบแรกของอาร์เรย์ที่ฉันเดาได้ องค์ประกอบแรกของอาร์เรย์ถูกกำหนดเป็น 0 เสมอ ดังนั้นพารามิเตอร์ จากฉันป้อน 0

อาร์เรย์ -> 1 // รวมอาร์เรย์ -> 2 // รวมอาร์เรย์ -> 3 // รวมอาร์เรย์ -> "สวัสดีชาวโลก" // ไม่รวม

ที่นี่คุณสามารถหลงทางได้! แกนว่าทำไมฉันถึงลงคะแนน "จนกระทั่ง".

ให้ newArray = array.slice(0, 3); // ค่าที่ส่งคืนยังเป็นอาร์เรย์

Nareshti ฉันสร้างอาร์เรย์ใหม่และผูกโยคะกับการเปลี่ยนแปลง newArray. เราดูผลลัพธ์:

บรรยายอาร์เรย์และเพิ่มองค์ประกอบในอาร์เรย์ใหม่

Change newArray กลายเป็นอาร์เรย์ใหม่ อาร์เรย์เดิมจะถูกปล่อยทิ้งไว้โดยไม่มีการเปลี่ยนแปลง

หมายเหตุสำคัญ: วิธีการ ชิ้น()คุณสามารถชนะใน แถว

ประกบ()

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

มุมมองขององค์ประกอบ

หากต้องการดูองค์ประกอบ ให้ป้อนองค์ประกอบที่จำเป็นต้องขยาย ( ดัชนี)จำนวนขององค์ประกอบนั้นจำเป็นต้องเห็น (จำนวนองค์ประกอบ):

Array Splice(ดัชนี จำนวนองค์ประกอบ);

พารามิเตอร์ ดัชนี- ce จุดซังองค์ประกอบที่ถูกลบ องค์ประกอบจากเลขลำดับ น้อยพารามิเตอร์ดัชนีที่ระบุจะไม่ถูกลบ:

ประกบอาร์เรย์(2); // ทุกองค์ประกอบที่เริ่มต้นจากดัชนี 2 จะถูกลบออก

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

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

Array Splice(2, 1);

Array ก่อน splice() method

Splice() ค้างหนึ่งครั้ง:

ลบองค์ประกอบ 3: แล้วตอนนี้องค์ประกอบ "สวัสดีชาวโลก" มีเลขอะตอม 2

ประกบ()

คราวนี้มองเห็นองค์ประกอบ "สวัสดีชาวโลก" ดังนั้นหมายเลขซีเรียลจึงเป็น 2

ดังนั้นคุณสามารถดำเนินการจุดต่อได้ ด็อคจะไม่หมดองค์ประกอบจากหมายเลขซีเรียล 2

การเพิ่มองค์ประกอบ

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

Array.splice(ดัชนี จำนวนองค์ประกอบ องค์ประกอบ องค์ประกอบ);

ก้นจามรี dodamo elementi เอі ขบนอาร์เรย์ cob:

Array Splice(0, 0, "a", "b");

องค์ประกอบ a และ b ถูกเพิ่มลงในอาร์เรย์บน cob

แยก()

วิธีการ ชิ้น()і ประกบ () vikoristovuyutsya สำหรับอาร์เรย์ วิธี แยก()ชัยชนะสำหรับ rowkiv. ในแถวpodіlyaєบนpіryadkiแล้วหมุนเมื่อเห็นอาร์เรย์ วิธีใดมี 2 พารามิเตอร์ และ 2 พารามิเตอร์ ไม่จำเป็น.

การแยกสตริง (ตัวคั่น, ขีด จำกัด );

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

วิธี แยก()อย่าฝึกเล่นๆ อาร์เรย์. Tim ไม่เล็กกว่าบน cob คุณสามารถเปลี่ยนองค์ประกอบของอาร์เรย์เป็นแถวและหลังจากแก้ไขวิธีการแล้ว แยก().

เรามาดูกันว่ามันทำงานอย่างไร

บน cob เราสามารถเปลี่ยนอาร์เรย์ในแถวเพื่อขอความช่วยเหลือจากเมธอด toString():

ให้ myString = array.toString();

มาแบ่งแถวกัน myString โคมามิและจำนวนสัญญาต่อเนื่องได้ถึง สาม.มาเปลี่ยนรูปร่างแถวเป็นอาร์เรย์กัน:

ให้ newArray = myString.split(",", 3);

เมื่อเห็นอาร์เรย์ 3 องค์ประกอบแรกจะเปลี่ยนไป

ในอันดับนี้ องค์ประกอบของอาร์เรย์ myStringแยกจากกันด้วยอาการโคม่า เราสร้างรั้วเป็น 3 แถว ดังนั้น 3 องค์ประกอบแรกจึงกลายเป็นอาร์เรย์

บันทึก:ทีมชัยชนะ อาร์เรย์แยก ("");คุณสามารถแบ่งสัญลักษณ์ทั้งหมดในแถวเป็นสตริงย่อยได้

สตริงย่อยหนวดในสตริงย่อย

เชิงนามธรรม:

ชิ้น()

• คัดลอกองค์ประกอบจากอาร์เรย์
• หมุนอาร์เรย์ใหม่
• อย่าเปลี่ยนอาร์เรย์เดิม
• สร้างอาร์เรย์สำหรับพารามิเตอร์เพิ่มเติมตั้งแต่และจนถึง: array.slice (ตั้งแต่ จนถึง)
• ไม่รวมค่าพารามิเตอร์ งานมี "จนกระทั่ง"
• Vikoristovuєtsyaและในอาร์เรย์และแถว

ประกบ()

• เพิ่มและแสดงภาพองค์ประกอบไปยังอาร์เรย์
• หมุนอาร์เรย์ขององค์ประกอบที่อยู่ห่างไกล
• เปลี่ยนอาร์เรย์
• การเพิ่มองค์ประกอบ: array.splice(ดัชนี จำนวนองค์ประกอบ องค์ประกอบ)
• มุมมองขององค์ประกอบ: array.splice (ดัชนี จำนวนองค์ประกอบ)
• Vykoristovuetsya น้อยกว่าในอาร์เรย์

แยก()

• แบ่งแถวเป็นแถวย่อย
• หมุนเมื่อเห็นอาร์เรย์
• 2 พารามิเตอร์และการดูถูกของพวกเขาไม่มีผลผูกพัน: string.split (ตัวคั่น, ขีด จำกัด )
• ห้ามเปลี่ยนแถวเดิม
• Vykoristovuetsya น้อยลงในแถว

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

แทรก ดู หรือแทนที่องค์ประกอบของอาร์เรย์

ไวยากรณ์

Array.splice(เริ่ม, deleteCount, element1, element2, ..., elementN)

พารามิเตอร์

ความสำคัญที่เปลี่ยนไป

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

คำอธิบาย

วิธี ประกบ ()ดูจำนวนองค์ประกอบที่ระบุในอาร์เรย์โดยเริ่มจากองค์ประกอบซึ่งตำแหน่งที่ระบุโดยอาร์กิวเมนต์เริ่มต้นรวมถึงซึ่งจะถูกแทนที่ด้วยค่าที่แสดงในรายการอาร์กิวเมนต์ (element1, ..., องค์ประกอบN) องค์ประกอบของอาร์เรย์ที่จัดเรียงตามองค์ประกอบที่แทรกหรือลบออก zsuvayutsya และสร้างลำดับอย่างต่อเนื่องด้วยตาข่ายของอาร์เรย์

บันทึก:หน้าเมธอดที่มีชื่อคล้ายกันคือ slice() เมธอด splice() จะแก้ไขอาร์เรย์โดยตรง

นำมาใช้

วิธี ประกบ ()เห็น 0 องค์ประกอบตามดัชนี 2 และใส่ "มะนาว":

หนึ่งองค์ประกอบโดยดัชนี 3 :

ที่ก้นที่น่ารังเกียจจะเห็นวิธีการประกบ () หนึ่งองค์ประกอบโดยดัชนี 2 เธอใส่ "กีวี"