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

push ใน JavaScript คืออะไร — เข้าใจเมธอดเพิ่มข้อมูลลงอาเรย์แบบถูกวิธี

push ใน JavaScript คือเมธอดที่ใช้เพิ่มข้อมูลตั้งแต่หนึ่งรายการเข้าไปที่ "ท้ายสุด" ของอาเรย์ แล้วคืนค่ากลับมาเป็นความยาวใหม่ของอาเรย์นั้น

ฟังดูง่ายใช่ไหม แต่เชื่อผมเถอะว่าเมธอดตัวนี้เป็นหนึ่งในตัวที่นักพัฒนามือใหม่ใช้ผิดบ่อยที่สุด เพราะหลายคนคิดว่ามันคืนค่าอาเรย์กลับมา ทั้งที่จริงมันคืนค่าเป็นตัวเลขจำนวนเต็ม ผมเจอบั๊กแบบนี้มานับไม่ถ้วนตอนช่วยตรวจโค้ดของทีม โค้ดที่เขียนว่า `const newArr = arr.push(item)` แล้วคาดหวังว่า newArr จะเป็นอาเรย์ แต่กลับได้ตัวเลขมาแทน

ตัวอย่างการใช้งานพื้นฐาน

const fruits = ['แอปเปิล', 'กล้วย']; const newLength = fruits.push('ส้ม');

console.log(fruits); // ['แอปเปิล', 'กล้วย', 'ส้ม'] console.log(newLength); // 3

จุดสำคัญคือ push เปลี่ยนแปลงอาเรย์ต้นฉบับโดยตรง (mutate) ไม่ได้สร้างอาเรย์ใหม่ ซึ่งแตกต่างจากเมธอดอย่าง concat หรือ spread operator ที่คืนอาเรย์ใหม่โดยไม่แตะต้องตัวเดิม ความแตกต่างนี้สำคัญมากในยุคที่เราทำงานกับ React หรือ state management ที่ต้องการความไม่เปลี่ยนแปลง (immutability) ของข้อมูล

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

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

ไวยากรณ์ของ push ง่ายมาก `arr.push(element1, element2, ..., elementN)` คุณส่งค่าได้ไม่จำกัดจำนวน

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

ไวยากรณ์ของ push ง่ายมาก `arr.push(element1, element2, ..., elementN)` คุณส่งค่าได้ไม่จำกัดจำนวน และแต่ละค่าจะถูกเพิ่มเข้าไปท้ายอาเรย์ตามลำดับที่ส่งเข้ามา ค่าที่ส่งได้ไม่ได้จำกัดแค่ชนิดเดียว อาเรย์เดียวสามารถมีทั้งตัวเลข ข้อความ วัตถุ ฟังก์ชัน หรือแม้แต่ undefined ปนกันได้ เพราะ JavaScript เป็นภาษาที่อาเรย์ไม่บังคับชนิดข้อมูล

ตารางสรุปคุณสมบัติของ push

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

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

const a = [1, 2]; const b = [3, 4]; a.push(b); console.log(a); // [1, 2, [3, 4]] — ได้อาเรย์ซ้อน!

ถ้าต้องการเพิ่มค่าของอีกอาเรย์แบบแยกรายการ ต้องใช้ spread operator แทน `a.push(...b)` ซึ่งจะได้ผลลัพธ์เป็น [1, 2, 3, 4] ตามที่ต้องการ หรือถ้าข้อมูลมีขนาดใหญ่มาก ผมแนะนำ concat หรือ spread ในการสร้างอาเรย์ใหม่เลย เพราะการ push ทีละค่าในลูปใหญ่อาจมีต้นทุนด้านประสิทธิภาพที่ควรพิจารณา

การเลือกเมธอดผิดเป็นสาเหตุของบั๊กเงียบ ๆ ที่กว่าจะเจอก็หลายวัน ผมจึงอยากให้เทียบ push กับตัวเลือกอื่นให้ชัดเจนตั้งแต่ต้น

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

push เทียบกับเมธอดเพิ่มข้อมูลอื่น ๆ — เลือกใช้ให้เหมาะกับงาน

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

ตารางเปรียบเทียบเมธอดยอดนิยม

เมธอด	ตำแหน่งที่เพิ่ม	คืนค่า	เปลี่ยนต้นฉบับ	กรณีที่ควรใช้
push	ท้ายสุด	ความยาวใหม่	ใช่	เพิ่มรายการท้ายอาเรย์ทั่วไป
unshift	หน้าสุด	ความยาวใหม่	ใช่	เพิ่มหัวคิว เช่น ข่าวใหม่สุด
concat	ท้ายสุด	อาเรย์ใหม่	ไม่	รวมอาเรย์โดยรักษาต้นฉบับ
splice	ตำแหน่งใดก็ได้	รายการที่ลบ	ใช่	แทรกตรงกลางอาเรย์
spread [...]	ตำแหน่งใดก็ได้	อาเรย์ใหม่	ไม่	เขียนโค้ดแบบไม่เปลี่ยนแปลงข้อมูล

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

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

กันหลายแบบ ซึ่งถ้าจำแบบเหล่านี้ได้ จะเขียนโค้ดได้เร็วและมั่นใจขึ้นมาก

สำหรับคนที่ทำงานกับ TypeScript push ยังตรวจสอบชนิดข้อมูลให้อัตโนมัติตามชนิดที่ประกาศไว้ ถ้าประกาศ `number[]` แล้ว push ข้อความเข้าไป คอมไพเลอร์จะเตือนทันที ช่วยลดบั๊กตั้งแต่ก่อนรันโค้ด ซึ่งเป็นเหตุผลว่าทำงานจริงปัจจุบันผมเขียน TypeScript เป็นหลัก

กรณีใช้งานจริงของ push — จากงานเล็กจนถึงระบบใหญ่

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

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

const prices = [100, 105, 98, 102]; const signals = []; for (const price of prices) { if (price > 100) { signals.push({ price, action: 'ขาย' }); } } console.log(signals); // [{price:105,...}, {price:102,...}]

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

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

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

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

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

ข้อผิดพลาดที่พบบ่อยกับ push และวิธีหลีกเลี่ยง

จากการช่วยแก้บั๊กให้นักพัฒนาหลายสิบคน ผมจัดกลุ่มข้อผิดพลาดกับ push ได้เป็นไม่กี่ข้อหลัก ซึ่งทุกข้อป้องกันได้ถ้ารู้ตั้งแต่ก่อนเขียนโค้ด

ข้อแรก การคิดว่า push คืนค่าอาเรย์ อย่างที่กล่าวไว้ตอนต้น push คืนความยาวใหม่ โค้ดที่เขียนว่า `const result = arr.push(item).map(x => x * 2)` จะพังทันทีเพราะตัวเลขไม่มีเมธอด map แก้ไขโดยแยกขั้นตอน คือ push ก่อน แล้วค่อยเรียกใช้กับอาเรย์เดิม

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

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

ข้อสี่ การ push undefined โดยไม่ตั้งใจ เกิดจากตัวแปรที่ยังไม่มีค่า อาเรย์จะมีช่องว่างที่ทำให้การคำนวณความยาวหรือการวนลูปให้ผลคลาดเคลื่อน ป้องกันได้ด้วยการตรวจสอบค่าก่อนเพิ่มเสมอ หรือใช้ default parameter ในฟังก์ชัน

ข้อห้า การใช้ push กับออบเจ็กต์ที่ไม่ใช่อาเรย์ เช่น เรียก `obj.push(x)` ทั้งที่ obj เป็นวัตถุธรรมดา จะได้ข้อผิดพลาดว่า push ไม่ใช่ฟังก์ชัน ตรวจก่อนด้วย `Array.isArray(obj)` เพื่อความปลอดภัย โดยเฉพาะข้อมูลที่รับมาจากภายนอก เช่น คำตอบจากเซิร์ฟเวอร์ที่โครงสร้างอาจเปลี่ยนไปได้ตลอด

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

ตัวอย่างการใช้งานจริง — จากโปรเจกต์ที่ผมทำเอง

อยากให้เห็นภาพใกล้ตัวขึ้น เล่าให้ฟังจากงานจริงที่ผมทำอยู่ ระบบแจ้งเตือนสัญญาณราคาของผม ซึ่งรันอยู่บน Node.js ทุกวัน มีส่วนที่ใช้ push เป็นหัวใจของการคัดกรองรายการแจ้งเตือน โครงหลักประมาณนี้

function คัดกรองสัญญาณ(ราคาทั้งหมด, เกณฑ์) { const ผลลัพธ์ = []; for (const ข้อมูล of ราคาทั้งหมด) { const คะแนน = คำนวณคะแนน(ข้อมูล); if (คะแนน >= เกณฑ์) { ผลลัพธ์.push({ คู่เงิน: ข้อมูล.pair, ราคา: ข้อมูล.close, คะแนน: คะแนน, เวลา: new Date().toISOString() }); } } return ผลลัพธ์.sort((a, b) => b.คะแนน - a.คะแนน); }

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

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

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

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

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

เมธอด push ใน JavaScript คืนค่าอะไรกลับมา?

เมธอด push คืนค่ากลับมาเป็นตัวเลขจำนวนเต็ม ซึ่งก็คือความยาวใหม่ของอาเรย์หลังจากเพิ่มข้อมูลเข้าไปแล้ว ไม่ใช่อาเรย์ตามที่นักพัฒนามือใหม่หลายคนเข้าใจผิด นี่เป็นจุดที่ทำให้เกิดบั๊กบ่อยที่สุด เช่น การเขียนโค้ดว่า `const newArr = arr.push(item)` แล้วคาดหวังว่า newArr จะเป็นอาเรย์ แต่กลับได้ตัวเลขมาแทน ทำให้โค้ดที่เรียกใช้ newArr ต่อด้วยเมธอดของอาเรย์เกิด error ทันที วิธีที่ถูกต้องคือเรียก push บนอาเรย์ต้นฉบับก่อน แล้วใช้อาเรย์ตัวนั้นต่อ เพราะ push เปลี่ยนแปลงอาเรย์เดิมโดยตรง (mutate) ไม่ได้สร้างอาเรย์ใหม่ ถ้าต้องการอาเรย์ใหม่โดยไม่แตะต้องต้นฉบับ ควรใช้ concat หรือ spread operator แทน ซึ่งเหมาะมากในงานที่ต้องการ immutability เช่น React หรือ state management

push กับ concat ต่างกันอย่างไร ควรใช้ตัวไหน?

ความแตกต่างสำคัญคือ push จะเปลี่ยนแปลงอาเรย์ต้นฉบับโดยตรง และคืนค่าเป็นความยาวใหม่ของอาเรย์ ส่วน concat จะสร้างอาเรย์ใหม่ขึ้นมาโดยไม่แตะต้องอาเรย์เดิมเลย ถ้างานของคุณเป็นการรวบรวมผลลัพธ์จากการวนลูป การสร้างรายการแจ้งเตือน หรือการเก็บ log ชั่วคราวในหน่วยความจำ การใช้ push จะเร็ว ง่าย และได้รับการปรับปรุงประสิทธิภาพดีในทุกเอนจิน JavaScript ร่วมสมัยทั้ง V8, SpiderMonkey และ JavaScriptCore แต่ถ้าคุณทำงานกับ React หรือ state management ที่ต้องการความไม่เปลี่ยนแปลง (immutability) ของข้อมูล ควรใช้ concat หรือ spread operator เพราะจะคืนอาเรย์ใหม่โดยรักษาต้นฉบับไว้ นอกจากนี้ถ้าข้อมูลมีขนาดใหญ่มาก การ push ทีละค่าในลูปใหญ่อาจมีต้นทุนด้านประสิทธิภาพ การใช้ concat หรือ spread สร้างอาเรย์ใหม่ครั้งเดียวอาจเหมาะกว่า

ทำไม push อาเรย์หนึ่งเข้าไปในอีกอาเรย์แล้วได้อาเรย์ซ้อนอาเรย์?

เพราะ push จะถือว่าพารามิเตอร์แต่ละตัวเป็น "ข้อมูลหนึ่งรายการ" เสมอ ไม่ว่าข้อมูลนั้นจะเป็นชนิดใดก็ตาม ดังนั้นเมื่อคุณเขียน `a.push(b)` โดยที่ b เป็นอาเรย์ ทั้งอาเรย์ b จะถูกเพิ่มเข้าไปเป็นสมาชิกหนึ่งตัวที่ท้ายอาเรย์ a ทำให้ได้ผลลัพธ์เป็น [1, 2, [3, 4]] แทนที่จะเป็น [1, 2, 3, 4] ตามที่ต้องการ วิธีแก้คือใช้ spread operator ร่วมกับ push เขียนเป็น `a.push(...b)` ซึ่งจะกระจายสมาชิกของ b ออกมาเป็นพารามิเตอร์แยกรายการก่อนเพิ่มเข้าไป จึงได้ค่าแยกตามที่ต้องการ ข้อดีเพิ่มเติมคือ push รับได้หลายค่าพร้อมกันไม่จำกัดจำนวน เช่น `arr.push(1, 2, 3)` จะเพิ่มทั้งสามค่าเรียงต่อกันที่ท้ายอาเรย์ ทำให้ไม่ต้องเรียกเมธอดหลายรอบ ประหยัดทั้งบรรทัดโค้ดและเวลาประมวลผล

push กับ unshift ควรเลือกใช้ตัวไหน และมีข้อควรระวังด้านประสิทธิภาพหรือไม่?

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

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

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

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

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

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

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