splice javascript คือ — คู่มือฉบับสมบูรณ์ 2026 | SiamCafe Blog

splice ในภาษาจาวาสคริปต์คืออะไร ทำไมทุกคนที่เขียนโค้ดต้องรู้

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

และที่สำคัญคือมันเปลี่ยนแปลงอาร์เรย์ต้นฉบับโดยตรง เรียกว่าการกระทำแบบ mutat­e นั่นเอง ฟังดูเรื่องเล็ก แต่ผมทำงานกับโค้ดมาหลายปีทั้งด้านระบบซิกแนลเทรดและเว็บไซต์ของตัวเอง พบว่าบั๊กจำนวนไม่น้อยเกิดจากการใช้ splice ผิดวิธีหรือเข้าใจผิดว่ามันทำงานอย่างไร

รูปแบบการเรียกใช้งานคือ `array.splice(start, deleteCount, item1, item2, ...)` โดย start คือตำแหน่งดัชนีที่เริ่มทำงาน deleteCount คือจำนวนข้อมูลที่ต้องการลบออก ส่วน item ต่าง ๆ คือข้อมูลใหม่ที่จะแทรกเข้าไปในตำแหน่งนั้น ทุกพารามิเตอร์ยกเว้นตัวแรกเป็นแบบตัวเลือกได้ ถ้าระบุแค่ start เดียว มันจะลบข้อมูลจากตำแหน่งนั้นจนถึงท้ายอาร์เรย์ทั้งหมด

สิ่งที่มือใหม่มักสับสนคือ splice จะคืนค่าเป็นอาร์เรย์ใหม่ที่ประกอบด้วยข้อมูลที่ถูกลบออก ไม่ใช่อาร์เรย์ที่เหลืออยู่หลังการลบ ดังนั้นถ้าเขียนโค้ดแบบ `let result = arr.splice(1, 2)` ตัวแปร result จะเก็บข้อมูลที่ถูกตัดออก ไม่ใช่ข้อมูลที่เหลือ ต้องเข้าถึงข้อมูลที่เหลือผ่านตัวแปร arr เดิมที่ถูกแก้ไขไปแล้ว

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

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

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

เพื่อความชัดเจน มาดูพารามิเตอร์ทั้งหมดของ splice ทีละตัวกัน พารามิเตอร์แรกชื่อ start เป็นตัวเลขบังคับระบุดัชนีที่การทำงานเริ่มต้น

ถ้าค่าที่ใส่เกินความยาวของอาร์เรย์ splice จะเริ่มทำงานจากท้ายอาร์เรย์ ถ้าใส่ค่าติดลบ จะนับจากท้าย และถ้าค่าติดลบมากเกินความยาวอาร์เรย์ จะเริ่มจากดัชนีศูนย์เสมอ

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

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

ตารางนี้สรุปกรณีการใช้งานที่พบบ่อยพร้อมผลลัพธ์

กรณีการใช้งาน	โค้ดตัวอย่าง	ผลลัพธ์ที่ได้
ลบ 1 ตัวตำแหน่งที่ 2	`arr.splice(2, 1)`	อาร์เรย์เดิมเหลือ 4 ตัว คืนค่าเป็นตัวที่ถูกลบ
ลบตั้งแต่ตำแหน่ง 1 จนจบ	`arr.splice(1)`	ลบตัวที่ 1 ถึงท้าย คืนค่าตัวที่ลบทั้งหมด
แทรกโดยไม่ลบ	`arr.splice(1, 0, 'ใหม่')`	แทรก 'ใหม่' ที่ตำแหน่ง 1 คืนค่าเป็นอาร์เรย์ว่าง
แทนที่ 1 ตัว	`arr.splice(1, 1, 'ทดแทน')`	ลบตัวที่ 1 แล้วแทรกตัวใหม่แทน
ลบจากท้าย	`arr.splice(-1, 1)`	ลบตัวสุดท้ายออก
ล้างอาร์เรย์ทั้งหมด	`arr.splice(0)`	อาร์เรย์เดิมว่างเปล่า คืนค่าข้อมูลที่ลบทุกตัว

ลองยกตัวอย่างโค้ดจริง สมมติเรามีรายชื่อหุ้นที่เฝ้าดูอยู่ แล้วต้องการถอดหุ้นตัวหนึ่งออกเมื่อผู้ใช้กดปุ่มยกเลิก

const watchlist = ['ทองคำ', 'น้ำมัน', 'ดัชนีสหรัฐ', 'บิตคอยน์']; const removed = watchlist.splice(1, 1); console.log(removed); // ['น้ำมัน'] console.log(watchlist); // ['ทองคำ', 'ดัชนีสหรัฐ', 'บิตคอยน์']

สังเกตว่า watchlist เปลี่ยนไปถาวรแล้ว ส่วน removed เก็บข้อมูลที่ถูกลบ เราสามารถนำ removed ไปแสดงข้อความแจ้งผู้ใช้ว่าลบรายการอะไรออกไปได้เลยโดยไม่ต้องหาข้อมูลซ้ำ

กรณีแทรกข้อมูลกลางรายการ เช่น มีคิวสัญญาณแล้วอยากแทรกสัญญาณเร่งด่วนไว้ตำแหน่งแรกสุดหรือตำแหน่งที่สอง

const queue = ['สัญญาณก', 'สัญญาณข', 'สัญญาณค']; queue.splice(1, 0, 'สัญญาณด่วน'); console.log(queue); // ['สัญญาณก', 'สัญญาณด่วน', 'สัญญาณข', 'สัญญาณค']

คู่ตัวร้ายที่มือใหม่สับสนกันมากที่สุดคือ splice กับ slice ชื่อคล้ายกันมาก ต่างกันแค่ตัวอักษรตัวเดียว แต่พฤติกรรมต่างกันคนละเรื่อง splice

แก้ไขอาร์เรย์ต้นฉบับและใช้กับอาร์เรย์เท่านั้น ส่วน slice ไม่แก้ไขต้นฉบับเลย มันคัดลอกช่วงข้อมูลที่ระบุออกมาเป็นอาร์เรย์ใหม่ และยังใช้กับข้อความได้ด้วย

ความแตกต่างระหว่าง splice กับ slice และวิธีเลือกใช้ให้ถูก

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

ข้อต่างที่สองคือพารามิเตอร์ slice รับตำแหน่งเริ่มและตำแหน่งจบ โดยตำแหน่งจบไม่ถูกรวมอยู่ในผลลัพธ์ แต่ splice รับตำแหน่งเริ่มกับจำนวนที่จะลบ การตีความตัวเลขตัวที่สองจึงคนละความหมายกันโดยสิ้นเชิง เช่น `arr.slice(1, 3)` คืนข้อมูลตำแหน่ง 1 ถึง 2 รวมสองตัว แต่ `arr.splice(1, 3)` จะลบสามตัวเริ่มจากตำแหน่ง 1

เมื่อไรควรใช้ตัวไหน ผมมีเกณฑ์ง่าย ๆ จากประสบการณ์ตรง ถ้าภารกิจคือการลบ แทรก หรือแทนที่ข้อมูลจริง ๆ ให้ใช้ splice ถ้าภารกิจคือการดึงช่วงข้อมูลมาใช้โดยไม่กระทบต้นฉบับ ให้ใช้ slice ยิ่งในโปรเจคที่มีสถาปัตยกรรมแบบไม่เปลี่ยนแปลงข้อมูลเดิม เช่น การจัดการสเตตในไลบรารีสมัยใหม่ slice จะปลอดภัยกว่าเพราะไม่สร้างผลข้างเคียงกับข้อมูลเดิม

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

จากประสบการณ์เขียนระบบจัดการสัญญาณเทรดและเว็บแดชบอร์ดของผมเองมากว่าทศวรรษ ผมขอแบ่งข้อผิดพลาดที่เจอบ่อยที่สุดเป็นสี่ข้อ ข้อแรกคือคิดว่า splice

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

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

กรณีศึกษาการใช้ splice ในงานจริงและข้อผิดพลาดที่พบบ่อย

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

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

// วิธีที่ถูกต้อง — วนย้อนกลับ for (let i = orders.length - 1; i >= 0; i--) { if (orders[i].สถานะ === 'ปิดแล้ว') { orders.splice(i, 1); } }

เมื่อพื้นฐานแน่นแล้ว splice จะกลายเป็นเครื่องมือที่ต่อยอดได้อีกมาก เทคนิคแรกที่อยากแนะนำคือการแบ่งอาร์เรย์เป็นชุด ๆ

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

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

และอีกจุดที่อยากย้ำสำหรับทีมพัฒนา คือเรื่องการทำงานร่วมกับฟังก์ชันแบบไม่รู้ผลข้างเคียง ในโค้ดเบสที่หลายคนแก้ไฟล์เดียวกัน การมีเมธอดที่เปลี่ยนข้อมูลเดิมกระจายอยู่ทั่วทำให้ตามสาเหตุบั๊กยาก ทีมผมจึงมีข้อตกลงว่าการใช้ splice ที่แก้ต้นฉบับต้องมีชื่อฟังก์ชันบอกชัดว่าเปลี่ยนข้อมูล เช่น ขึ้นต้นด้วยคำว่าลบหรือแทรก เพื่อให้คนอ่านโค้ดคาดหวังพฤติกรรมได้ถูกต้องตั้งแต่แรก

เทคนิคขั้นสูง การประกอบ splice เข้ากับเมธอดอาร์เรย์อื่น

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

function แบ่งชุด(ข้อมูล, ขนาดชุด) { const ผลลัพธ์ = []; const สำเนา = [...ข้อมูล]; while (สำเนา.length > 0) { ผลลัพธ์.push(สำเนา.splice(0, ขนาดชุด)); } return ผลลัพธ์; }

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

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

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

เทคนิคที่สี่เกี่ยวกับการควบคุมประสิทธิภาพ การลบข้อมูลจากตำแหน่งหน้าของอาร์เรย์ใหญ่ด้วย splice จะทำให้ระบบต้องเลื่อนข้อมูลที่เหลือทั้งหมด ถ้าอาร์เรย์มีสิบหมื่นตัวและลบที่ดัชนีศูนย์ ต้องเลื่อนเกือบหมื่นตัวทุกครั้ง ถ้างานลักษณะนี้เกิดซ้ำ ๆ ควรพิจารณาโครงสร้างข้อมูลอื่น เช่น คิวสองหัวที่ออกแบบมาเพื่อเพิ่มและลบข้อมูลที่หัวและท้ายได้เร็ว ผมเคยเจอระบบที่ช้ามากจนสืบสาเหตุแล้วพบว่าลบหัวคิวด้วย splice ในลูปตลอดทั้งวัน พอเปลี่ยนโครงสร้างข้อมูลแล้วความเร็วดีขึ้นหลายเท่าตัว

สุดท้าย เทคนิคการทำให้ splice ปลอดภัยขึ้นด้วยการห่อหุ้มในฟังก์ชันของตัวเอง รับพารามิเตอร์ ตรวจสอบขอบเขตดัชนี แล

คำถามที่พบบ่อย

splice คืนค่าอะไรกลับมา ทำไมถึงเขียนโค้ดผิดบ่อย?

splice คืนค่าเป็นอาร์เรย์ใหม่ที่ประกอบด้วยข้อมูลที่ถูกลบออกไป ไม่ใช่อาร์เรย์ที่เหลืออยู่หลังการลบ ซึ่งเป็นจุดที่มือใหม่มักสับสนและเกิดบั๊กบ่อยที่สุด เช่น ถ้าเขียน `let result = arr.splice(1, 2)` ตัวแปร result จะเก็บข้อมูลที่ถูกตัดออก ไม่ใช่ข้อมูลที่เหลืออยู่ ถ้าต้องการข้อมูลที่เหลือ ต้องเข้าถึงผ่านตัวแปร arr เดิมซึ่งถูกแก้ไขไปแล้ว กรณีที่ใช้ splice เพื่อแทรกข้อมูลโดยไม่ลบอะไรเลย (deleteCount เป็นศูนย์) ค่าที่คืนกลับมาจะเป็นอาร์เรย์ว่าง ดังนั้นก่อนใช้งานควรกำหนดให้ชัดเจนว่าต้องการข้อมูลที่ถูกลบหรืออาร์เรย์ที่ถูกแก้ไข เพื่อเลือกวิธีเข้าถึงข้อมูลให้ถูกต้อง

splice ต่างจากการแก้ไขอาร์เรย์แบบอื่นอย่างไร และควรระวังอะไรบ้าง?

จุดสำคัญคือ splice เปลี่ยนแปลงอาร์เรย์ต้นฉบับโดยตรง เรียกว่าการกระทำแบบ mutate ไม่ได้สร้างอาร์เรย์ใหม่กลับมาให้ นั่นหมายความว่าถ้าคนอื่นในทีมยังอ้างอิงอาร์เรย์เดียวกันนี้อยู่ ข้อมูลที่เขาเห็นจะเปลี่ยนตามด้วยทันที อาจทำให้เกิดบั๊กที่ตามหายาก ในงานจริงผู้เขียนบทความพบว่าบั๊กจำนวนไม่น้อยเกิดจากการใช้ splice ผิดวิธีหรือเข้าใจผิดว่ามันทำงานอย่างไร แนวทางที่ปลอดภัยคือถ้าไม่แน่ใจ ให้คัดลอกอาร์เรย์ด้วย spread operator หรือใช้เมธอดแบบไม่แก้ต้นฉบับก่อน แล้วค่อยเรียกใช้ splice กับสำเนานั้น จะช่วยให้อาร์เรย์ต้นฉบับไม่ถูกกระทบโดยไม่ตั้งใจ

ถ้าใส่ค่าติดลบหรือค่าที่เกินความยาวอาร์เรย์ในพารามิเตอร์ start จะเกิดอะไรขึ้น?

splice รองรับกรณีพิเศษเหล่านี้ไว้แล้ว ถ้าใส่ค่าติดลบในพารามิเตอร์ start เมธอดจะนับย้อนกลับจากท้ายอาร์เรย์ เช่น -1 หมายถึงข้อมูลตัวสุดท้าย ซึ่งมีประโยชน์มากเวลาต้องการจัดการข้อมูลจากด้านท้ายโดยไม่ต้องคำนวณดัชนีเอง เช่น `arr.splice(-1, 1)` จะลบตัวสุดท้ายออก แต่ถ้าค่าติดลบมากเกินความยาวของอาร์เรย์ splice จะเริ่มทำงานจากดัชนีศูนย์เสมอ ส่วนถ้าใส่ค่าที่เกินความยาวของอาร์เรย์ splice จะเริ่มทำงานจากท้ายอาร์เรย์ การเข้าใจพฤติกรรมเหล่านี้ช่วยให้เขียนโค้ดได้ยืดหยุ่นขึ้นและลดโอกาสเกิดข้อผิดพลาดเวลาทำงานกับขนาดอาร์เรย์ที่ไม่แน่นอน

จะใช้ splice แทรกข้อมูลเข้าไปในอาร์เรย์โดยไม่ลบข้อมูลเดิมได้อย่างไร?

ทำได้โดยตั้งค่าพารามิเตอร์ deleteCount เป็นศูนย์หรือค่าติดลบ ซึ่งจะทำให้ splice ไม่ลบข้อมูลใดออกเลย แล้วระบุข้อมูลใหม่ที่ต้องการแทรกในพารามิเตอร์ตัวที่สามขึ้นไป โดยใส่ได้กี่ตัวก็ได้ ข้อมูลจะถูกแทรกเรียงกันเริ่มจากตำแหน่ง start เช่น `arr.splice(1, 0, 'ใหม่')` จะแทรก 'ใหม่' ที่ตำแหน่ง 1 โดยข้อมูลเดิมจะถูกเลื่อนไปท้ายอัตโนมัติ และค่าที่คืนกลับมาจะเป็นอาร์เรย์ว่างเพราะไม่มีการลบ นี่เป็นเทคนิคที่ใช้บ่อยในงานจริง เช่น การแทรกออเดอร์ใหม่เข้าคิวที่เรียงลำดับตามเวลาอยู่แล้ว เพราะ splice จัดการให้ในบรรทัดเดียวโดยไม่ต้องเขียนลูปคัดลอกอาร์เรย์ใหม่ทั้งหมดซึ่งเปล

แนะนำเพิ่มเติม

🎯 เปิดบัญชี XM Forex → สมัคร

📱 แอป iCafeFX → ดาวน์โหลด

📊 สัญญาณฟรี → รับสัญญาณ

📚 คู่มือเทรด → SiamCafeBook

🤝 สมัคร Partner XM → pipaffiliates.com/c?c=72816&l=th&p=6