วิธีการคัดลอกหรือขยายอาร์เรย์?

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

ทำความเข้าใจกับความจำเป็นในการคัดลอกหรือขยายอาร์เรย์

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

ในทางกลับกัน มันคุ้มค่า mencionar que อาร์เรย์ใน Java เป็นวัตถุที่ไม่เปลี่ยนรูปนั่นคือเมื่อสร้างอาร์เรย์แล้ว ขนาดของอาร์เรย์จะไม่สามารถเปลี่ยนแปลงได้ หากต้องการ "ขยาย" อาร์เรย์ใน Java เราจะต้องสร้างอาร์เรย์ที่ใหญ่ขึ้นใหม่ จากนั้นคัดลอกองค์ประกอบของอาร์เรย์ดั้งเดิมไปยังอาร์เรย์ใหม่ นี่อาจจะค่อนข้างน่าเบื่อ แต่ก็มีวิธีการต่างๆ ที่สร้างไว้ในไลบรารีมาตรฐาน Java เช่น System.arraycopy() y Arrays.copyOf() ที่สามารถอำนวยความสะดวกได้ กระบวนการนี้. สำหรับภาษาที่จัดการโครงสร้างข้อมูลไดนามิก เช่น JavaScript หรือ Python กระบวนการจะง่ายกว่ามากและมีวิธีการดังนี้ push() y append() ที่อนุญาตให้เพิ่มองค์ประกอบลงในอาร์เรย์ที่มีอยู่โดยไม่ต้องสร้างใหม่

เจาะลึกวิธีการคัดลอกอาร์เรย์ใน Javascript

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


let arrayOriginal = ['a', 'b', 'c', 'd', 'e'];
let arrayCopia = arrayOriginal.slice();


Si lo que necesitas es ขยายอาร์เรย์, JavaScript มันมอบให้เรา หลายวิธีที่จะทำ วิธีหนึ่งคือการใช้ตัวดำเนินการสเปรด โอเปอเรเตอร์นี้ช่วยให้คุณสามารถขยายองค์ประกอบที่ทำซ้ำได้ภายในอาร์เรย์ เพื่อสร้าง อาร์เรย์ใหม่ที่มีองค์ประกอบของอาร์เรย์ดั้งเดิมและองค์ประกอบเพิ่มเติม อีกวิธีหนึ่งคือวิธี concat() ซึ่งส่งคืนอาร์เรย์ใหม่ซึ่งเป็นผลลัพธ์ของการเข้าร่วมอาร์เรย์ดั้งเดิมกับอาร์เรย์หรือค่าตั้งแต่หนึ่งรายการขึ้นไป สุดท้ายนี้ คุณยังสามารถใช้เมธอด push() ซึ่งจะเพิ่มองค์ประกอบตั้งแต่หนึ่งรายการขึ้นไปที่ส่วนท้ายของอาร์เรย์และส่งกลับความยาวใหม่ของอาร์เรย์ ที่นี่คุณมี ตัวอย่างบางส่วน:


let array1 = [1, 2, 3];
let array2 = [...array1, 4, 5, 6]; // array2 ahora es [1, 2, 3, 4, 5, 6]



let array3 = [1, 2, 3];
let array4 = array3.concat([4, 5, 6]); // array4 ahora es [1, 2, 3, 4, 5, 6]



let array5 = [1, 2, 3];
array5.push(4, 5, 6); // array5 ahora es [1, 2, 3, 4, 5, 6]


การขยายอาร์เรย์: เทคนิคที่แนะนำและตัวเลือกอื่นๆ

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

let array1 = [1, 2, 3];
let array2 = [4, 5, 6];
let newArray = array1.concat(array2);

// newArray ahora es [1, 2, 3, 4, 5, 6]

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

let array1 = [1, 2, 3];
let newArray = [...array1, 4, 5, 6];

// newArray ahora es [1, 2, 3, 4, 5, 6]

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

การจัดการอาร์เรย์ที่มีประสิทธิภาพ: ผลกระทบต่อประสิทธิภาพของโค้ด

เมื่อจัดการอาร์เรย์ a ของหุ้น สิ่งที่พบบ่อยที่สุดคือการคัดลอกหรือส่วนขยายของสิ่งเหล่านี้ อย่างไรก็ตาม จำเป็นต้องทราบวิธีดำเนินการเหล่านี้ อย่างมีประสิทธิภาพ เพื่อให้แน่ใจว่าโค้ดมีประสิทธิภาพดี ดังนั้นเราจะวิเคราะห์สองวิธีหลัก: Array.prototype.slice() y Array.prototype.concat().

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

var ดั้งเดิม = [1, 2, 3, 4, 5]; var copy = original.slice();

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

สำหรับการขยายอาร์เรย์ เราแนะนำให้ใช้ฟังก์ชันนี้ concat(). วิธีการนี้ใช้ในการรวมอาร์เรย์สองตัวขึ้นไปและส่งกลับอาร์เรย์ใหม่ ลองจินตนาการว่าเรามีอาร์เรย์ 'array1' และ 'array2' สองตัวที่เราต้องการรวมเข้าด้วยกัน ดังนั้นเราจึงสามารถใช้ concat ได้ดังนี้:

var array1 = [1, 2, 3]; var array2 = [4, 5, 6]; var ขยาย = array1.concat (array2);

สิ่งนี้จะส่งกลับอาร์เรย์ 'ขยาย' ด้วยค่า [1, 2, 3, 4, 5, 6] อย่าลืมจำไว้ว่าในขณะที่ concat เหมาะอย่างยิ่งสำหรับการรวมอาร์เรย์ขนาดเล็ก โดยสามารถใช้หน่วยความจำได้มากเมื่อต้องจัดการกับอาร์เรย์ขนาดใหญ่