คอฟฟี่เบรค #87 เหตุใดการทดสอบหน่วยจึงมีความสำคัญสำหรับนักพัฒนา 5 วิธีในการคัดลอกอาร์เรย์ใน Java

เหตุใดการทดสอบหน่วยจึงมีความสำคัญสำหรับนักพัฒนา

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

• ลดจำนวนข้อบกพร่องและระบุข้อบกพร่องในระยะแรกของวงจรการพัฒนา
• ปรับปรุงการอ่านโค้ด
• อนุญาตให้ใช้รหัสซ้ำ
• เพิ่มความเร็วในการปรับใช้

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

ประวัติความเป็นมาของการทดสอบหน่วย

ข้อผิดพลาดที่ตรวจพบตั้งแต่ระยะแรกช่วยประหยัดเวลาและความพยายาม ในช่วง 50 ปีแรกของประวัติศาสตร์คอมพิวเตอร์ การทดสอบหน่วยและการแก้ไขข้อบกพร่องเป็นสิ่งเดียวกันโดยพื้นฐานแล้ว แต่ในช่วงทศวรรษ 1990 รหัสมีความซับซ้อนมากจนเป็นไปไม่ได้เลยที่จะแบ่งระบบออกเป็นส่วนเล็กๆ เพื่อรันแยกกัน ในปี 1997 โปรแกรมเมอร์ชื่อ Kent Beck ได้สร้าง JUnit ซึ่งเป็นปลั๊กอินสภาพแวดล้อมการพัฒนาสำหรับทดสอบโค้ดชิ้นเล็กๆ รหัสทดสอบที่ประเมินซอร์สโค้ดเรียกว่าการทดสอบหน่วย การทดสอบหน่วยประเภทนี้กลายเป็นเรื่องหลักมาหลายปีแล้ว หลังจากที่ Beck สร้าง JUnit แล้ว Martin Fowler ได้เขียนหนังสือ Refactoring ซึ่งเขาเสนอวิธีในการแปลงโค้ดเพื่อให้แยกและทดสอบได้มากขึ้น การรวมกันของการปรับโครงสร้างโค้ดใหม่และการทดสอบหน่วยได้นำไปสู่การพัฒนาที่ขับเคลื่อนด้วยการทดสอบ ซึ่งการสร้างการทดสอบหน่วยมีความสำคัญต่อกระบวนการเขียนโปรแกรม ในนั้นโค้ดจะต้องสามารถทดสอบได้ก่อนที่จะถูกสร้างขึ้นด้วยซ้ำ ดังนั้น กระบวนการเขียนโปรแกรมจะไม่เสร็จสมบูรณ์จนกว่าจะรันการทดสอบหน่วย โครงการสามารถก้าวไปสู่ขั้นตอนการวิจัยในระดับระบบหรือระดับมนุษย์ได้

ตัวอย่างการทดสอบหน่วย

ตัวอย่างนี้แสดงให้เห็นถึงความสำคัญของการทดสอบหน่วย ที่นี่ JUnit จะประเมินฟังก์ชันง่ายๆ ที่แปลงอุณหภูมิจากฟาเรนไฮต์เป็นเซลเซียส สูตรการแปลง: C = (F-32) * 5/9 เพียงไม่กี่บรรทัด รวมถึงลายเซ็นของฟังก์ชันและเครื่องหมายปีกกา ก็สามารถนำไปใช้ในโค้ดเป็นฟังก์ชันไลบรารีได้ อย่างไรก็ตาม จากฟังก์ชันยังไม่ชัดเจนว่าสิ่งเหล่านี้เป็นเกณฑ์ ตัวเลือกเหล่านี้อาจรวมถึงการปัดเศษขึ้นหรือลง จำนวนจริง หรือขีดจำกัดบนและล่าง เรามาสร้างตัวอย่างการทดสอบหน่วยสำหรับฟังก์ชันการแปลงอุณหภูมิใน Perl โดยใช้โมดูล Test::More บรรทัดแรกคือความคิดเห็นที่บอกโปรแกรมเมอร์ถึงสิ่งที่คาดหวังจากโค้ดที่เหลือ

# is (input, expected result, comment)
is( FtoC(32),0,'Freezing point is F32, C 0');
is( FtoC(212),100,'Boiling point is F212, C 100');
is( FtoC(59038),32767, 'Upper limit of C is 32767');
is( FtoC(59039),undefined, 'One past upper limit is error');

กรอบงาน JUnit ขึ้นอยู่กับระบบเชิงอ็อบเจ็กต์และอ็อบเจ็กต์ทดสอบ แต่แนวคิดก็คล้ายกัน

การทดสอบหน่วยแยก

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

การปรับการทดสอบหน่วย

ซอฟต์แวร์รุ่นเก่าคือซอฟต์แวร์ที่ทำงานมาเป็นเวลานานและมีแนวโน้มว่าจะเขียนขึ้นโดยไม่มีการทดสอบหน่วย รหัสเดิมมีคุณค่าต่อบริษัท มันทำงานได้อย่างเสถียรเป็นเวลาหลายปี บางโปรแกรมที่สร้างขึ้นโดยไม่มีการทดสอบหน่วยจะประมวลผลธุรกรรมนับล้านดอลลาร์ต่อวัน แต่โค้ดที่ไม่มีการทดสอบหน่วยจะกลายเป็นเรื่องเลวร้ายเมื่อเวลาผ่านไป เนื่องจากโปรแกรมเมอร์บำรุงรักษาโค้ดจำนวนมากได้สัมผัสมันในช่วงหลายปีที่ผ่านมา การปรับโครงสร้างใหม่ช่วยให้โปรแกรมเมอร์ค่อยๆ เปลี่ยนแปลงระบบเพื่อให้สามารถทดสอบได้ อย่างไรก็ตาม การเปลี่ยนแปลงเหล่านี้ต้องใช้เวลา เมื่อหลายปีก่อน ฉันได้พูดคุยกับ Bob Reselman เพื่อนร่วมงานของฉันเกี่ยวกับปัญหาการใช้การทดสอบหน่วยสำหรับแอปพลิเคชันรุ่นเก่า Reselman แย้งว่าการนำการทดสอบหน่วยไปใช้ในแอปพลิเคชันที่สร้างขึ้นโดยไม่มีการทดสอบนั้นมีราคาแพงเกินไปและโง่เขลาด้วยซ้ำ แต่เขาแนะนำให้องค์กรเริ่มการพัฒนาใหม่ด้วยการทดสอบหน่วยและปล่อยให้แอปพลิเคชันรุ่นเก่าอยู่คนเดียว สิ่งนี้อาจเป็นจริงสำหรับ COBOL ตัวสร้างรายงาน และแอปพลิเคชันอื่นๆ แต่ฉันขอยืนยันว่าในแอปพลิเคชันที่เขียนด้วยภาษาสมัยใหม่ เช่น C++, C#, Java และ Ruby นั้นค่อนข้างง่ายที่จะเพิ่มการทดสอบหน่วยย้อนหลัง แทนที่จะเขียนไว้สำหรับแอปพลิเคชันทั้งหมด เพียงเพิ่มการทดสอบหน่วยลงในการเปลี่ยนแปลงปัจจุบันและปรับโครงสร้างใหม่ตามที่คุณดำเนินการ

ความเร็ว คุณภาพ และความสามารถในการทดสอบที่เพิ่มขึ้น

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

5 วิธีในการคัดลอกอาร์เรย์ใน Java

ที่มา: Dev.to ดังนั้น คุณมีสองอาร์เรย์ A และ B และคุณจำเป็นต้องคัดลอกองค์ประกอบจาก A ไป B มีวิธีที่แตกต่างกันในการทำเช่นนี้ใน Java และฉันจะแสดงให้คุณเห็นตอนนี้

วิธีที่หนึ่ง: ForLoop

นี่คือจุดที่ for loop รุ่นเก่ามาช่วยเหลือเรา:

int[] A = {1,2,4,4};
int[] B = new int[];

 for (int i = 0; i < A.length; i++){
      B[i] = A[i];
}

วิธีที่สอง: .clone()

วิธีการโคลนอาเรย์ยังสามารถช่วยให้บรรลุผลลัพธ์ที่ต้องการ:

int[] A = {1,2,4,4};
int[] B = A.clone();//the clone method copies the content of A into B;

วิธีที่สาม: System.arraycopy()

วิธีถัดไปคือใช้ เมธอด System.arraycopy ( )ซึ่งอยู่ใน แพ็คเกจ java.lang ก่อนที่เราจะพูดถึงการใช้งาน เรามาพูดถึงลายเซ็นของมันก่อน:

public static void arraycopy(
    Object src, //:source array, in this case A
    int srcPos, //:the start index for copy, typically 0
    Object dest, //:destination object in this case B.
    int destPos, //:the index to place the copied elements
    int length //:the length of the contents to be copied
);

แอปพลิเคชัน:

int[] A = {1,2,4,4};
int[] B = new int[];

System.arraycopy(A, 0, B, 0, A.length);

วิธีที่สี่: Arrays.copyOf()

ตัวเลือกการคัดลอกถัดไปที่เราจะกล่าวถึงคือคลาสArraysจาก แพ็คเกจ java.utils ให้ความสนใจกับลายเซ็นของเขา:

public static int[] copyOf(
    int[] original, // :source array in this case A
    int newLength // :the length of the contents to be copied
);

แอปพลิเคชัน:

int[] A = {1,2,4,4};
int[] B = Arrays.copyOf(A, 3);

วิธีที่ห้า: Arrays.copyOfRange()

นี่จะเป็นตัวเลือกสุดท้ายที่เราจะดูในโพสต์นี้ นอกจากนี้ยังมาจากคลาสArraysที่มีอยู่ใน แพ็คเกจ java.utils ลองดูลายเซ็นของเขาอีกครั้ง:

public static int[] copyOfRange​(
    int[] original, // :source array in this case A
    int from,  //:the start index for copy, typically 0
    int to // the end index exclusive
);

แอปพลิเคชัน:

int[] A = {1,2,3,4,5,6,7};
int[] B = Arrays.copyOfRange(A, 0, A.length);