การสร้างรหัสเพิ่มคุณภาพของรหัสหรือไม่


12

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

เราใช้ไฟล์ XML เพื่ออธิบายความสัมพันธ์เอนทิตีในสคีมาฐานข้อมูลของเราดังนั้นพวกเขาจึงช่วยให้เราสร้างกรอบ ORM และรูปแบบ HTML ซึ่งสามารถใช้ในการเพิ่มลบและแก้ไขเอนทิตี

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

ตั้งแต่ผมก็ถามว่าสำหรับความหมายของคุณภาพรหัสให้ฉันชี้แจงนี้สิ่งที่ฉันหมายถึงเป็นซอฟต์แวร์ที่มีคุณภาพ

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


3
คำจำกัดความของคุณภาพของรหัสของคุณคืออะไร
NoChance

@EmmadKareem ฉันได้เพิ่มคำจำกัดความสั้น ๆ ไว้ในคำถามเดิม
platzhirsch

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

คำตอบ:


38

ตัวสร้างรหัสไม่สามารถสร้างรหัสที่ดีกว่าคนที่เขียนตัวสร้าง

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

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


6
+ ส่วนที่เอียงแล้วพันครั้ง ผู้สร้างโค้ดควรทำหน้าที่เหมือนคอมไพเลอร์ของคุณหรือกลไกเท็มเพลต C ++: คุณไม่ควรแก้ไขเอาต์พุตด้วยตนเอง ครั้งเดียวที่คุณควรอ่านเอาต์พุตคือถ้าคุณสงสัยว่ามีบั๊ก
anon

1
มันเป็นความอัปยศที่ฉันไม่สามารถลงคะแนนเพิ่มเติม ...
Fabricio Araujo

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

... ยังอัปเดตซอร์สโค้ดให้ตรงกับซีแมนทิกส์ของรหัสวัตถุที่แก้ไขด้วยมือ
supercat

20

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


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

1
Ooh, +1 หรือ -1 .... ในการสร้างรหัสมือเดียวมีประโยชน์อย่างมากในการลบรหัสซ้ำ ๆ ที่น่าเบื่อซึ่งคุณมีคำจำกัดความที่ถูกขยายเข้าไปในโค้ดอย่างง่ายดาย ความซับซ้อนของ 'การประหยัดเวลา' ซึ่งจะกลายเป็นรูปแบบการต่อต้านในตัวเอง
gbjbaanb

13

ฉันคิดว่าการสร้างโค้ดอัตโนมัติและคุณภาพของโค้ดค่อนข้างจะเป็นฉากและไม่จำเป็นต้องสัมพันธ์กัน

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

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

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

เพื่อสร้างข้อสรุปการสร้างรหัสอัตโนมัติสามารถช่วยเพิ่มคุณภาพของรหัสเมื่อใช้อย่างถูกต้อง


11

รหัสรุ่นไม่ได้ส่งผลกระทบต่อรหัสที่มีคุณภาพต่อ se มากเป็นรหัสความสอดคล้อง

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

รหัสรุ่นนอกจากนี้ยังอาจถูกนำมาใช้ในการสร้างรหัสได้เร็วขึ้น อย่างไรก็ตามเร็วกว่านั้นไม่ได้หมายความว่าดีกว่า ... มันอาจหมายความว่าคุณได้รับโค้ดที่มีคุณภาพไม่ดีซึ่งเร็วกว่ามาก


6

การสร้างรหัสนั้นดีถ้า:

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

เมื่อเป็นกรณีนี้รหัสที่มีคุณภาพที่คุณต้องพิจารณาคือรหัสที่ป้อนไปยังเครื่องกำเนิด

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


และรหัสที่สร้างขึ้นจะแมปกลับไปเป็นต้นฉบับอย่างชัดเจนดังนั้นคุณไม่จำเป็นต้องดีบักรหัสที่สร้างขึ้น

@ Thorbjørn: ฉันเห็นด้วย ในหนึ่งแอพที่ฉันต้องดูแลนั่นก็คือการสร้าง Fortran จำเป็นที่จะต้องสามารถแก้ไขข้อบกพร่องมันหายไปตลอดหลายปีที่ผ่านมาและฉันเป็นคนเดียวที่โง่พอที่จะยังคงอยู่รอบ ๆ เพื่อให้บริการโทรศัพท์ :)
Mike Dunlavey

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

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

4

เพิ่มคุณภาพของรหัสเนื่องจากDRY (อย่าทำซ้ำตัวเอง)

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


นอกจากว่าคุณจะต้องแก้ไขรหัสที่สร้างขึ้น - ซึ่งไม่ใช่ DRY เลย .... ฉันต้องทำอย่างนั้นเมื่อเร็ว ๆ นี้ - มันไม่น่าพอใจเลย หากฉันต้องแก้ไขฐานรหัสที่สร้างอัตโนมัติอีกครั้งด้วยตนเองฉันจะเรียกเก็บเงินสามครั้ง !!!
Fabricio Araujo

1
คุณไม่ควรต้องแก้ไขรหัสนั้น แก้ไขรหัสที่สร้างขึ้นเองและเพิ่มด้วยกฎเพิ่มเติมหากจำเป็น การแก้ไขโค้ดที่สร้างควรเป็นทางเลือกสุดท้าย
earlNameless

1
ฉันอยากได้ตัวเลือกนั้น .. ฉันไม่ได้ทำ
Fabricio Araujo

2

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

ป้อนคำอธิบายรูปภาพที่นี่

ฉันคิดว่ามันสามารถพิสูจน์ได้ว่ากราฟโหนดในพิมพ์เขียวนั้นง่ายต่อการบำรุงรักษาและมีข้อผิดพลาดน้อยกว่ารหัส GLSL / HLSL ที่มันสร้างขึ้น

นอกจากนี้ยังมีประสิทธิภาพมากขึ้นที่จะเกิดขึ้นกับเฉดสีใหม่เนื่องจากคุณได้รับข้อเสนอแนะภาพเรียลไทม์ของวิธีการที่ผลดูเหมือนว่าเมื่อคุณเปลี่ยนกราฟ แน่นอนว่าฉันต้องการรักษาเฉดสีหลายพันตัวที่แสดงด้วยกราฟปมด้วยวิธีนี้แทนที่จะเป็นรหัส GLSL / HLSL และจริง ๆ แล้วฉันคุ้นเคยกับการเขียน GLSL / HLSL มากกว่าการใช้พิมพ์เขียว ฉันคิดว่ามันเป็นไปไม่ได้จริงที่จะทำให้เกิดข้อผิดพลาดที่สำคัญนอกเหนือจากความผิดพลาดทางสายตาบางอย่างที่คุณอาจจับได้ทันทีเพราะ "ภาษาภาพ" กำหนดข้อ จำกัด ที่สมเหตุสมผลด้วยรูปแบบการทำงานที่บริสุทธิ์ซึ่งไม่อนุญาตให้คุณพูด crash a shader อย่างน้อย AFAIK (ฉันยอมรับว่าไม่ใช่ผู้เชี่ยวชาญด้านพิมพ์เขียว)

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

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

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


1

ฉันจะบอกว่าในกรณีของคุณมันอาจเพิ่มคุณภาพเล็กน้อย แต่ลดเวลาในการพัฒนาลงได้มาก บางครั้งรหัสที่สร้างขึ้นนั้นเป็นขุยไม่เรียบหรือไม่ดีหรือเปล่า ในกรณีดังกล่าวรหัสที่สร้างขึ้นสามารถลดคุณภาพและเพิ่มเวลาการทดสอบ / แก้ไข / การถดถอยเพิ่มเติมลงในโครงการ และงานบางอย่างก็ซับซ้อนเกินกว่าที่จะสร้างได้ง่าย - เครื่องกำเนิดไฟฟ้าจะกลายเป็นระบบที่แยกจากกันทั้งหมด (อาจใหญ่กว่าและซับซ้อนกว่าโครงการหลัก) แก่ตัว

ตัวสร้างรหัสนั้นใช้ได้ แต่ระวังด้วย!


1

ฉันเคยทำงานในร้านที่ต้องพึ่งพาการสร้างรหัสอย่างมาก ในใจของฉันมันทำให้รหัสสำหรับโครงการเหมือนกันมาก และในแง่นั้นคุณภาพก็โอเค

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

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

แค่ 2 เซ็นต์ของฉัน


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

@ MarkJ: บางครั้งการชุมนุมอาจดีกว่าภาษาที่คอมไพล์เพื่อความเท่าเทียมกัน ตัวอย่างเช่นในบางระบบฝังตัวมันมีประโยชน์ที่จะสามารถเขียนโค้ดเทียบเท่าx=someValue ^ 0xFF ^ 0xFF ^ 0xFF ^ 0xFF;และให้มันถูกเข้ารหัสด้วยคำแนะนำ XOR สี่ตัวอักษร หากสื่อจัดเก็บรหัสสามารถเขียนได้เฉพาะไบต์ที่ว่างเปล่า (0xFF) การสร้างด้านบนจะอนุญาตการเปลี่ยนแปลงค่าตามอำเภอใจสี่ประการ แม้ว่าผู้เขียนและนิพจน์x=someValue; x = x ^ 0xFF ^ 0xFF ^ 0xFF ^ 0xFF;และคอมไพเลอร์จะประเมิน xors ทั้งหมด ณ รันไทม์ แต่ก็อาจยังใช้ "complement all bits" ...
supercat

... การสอนมากกว่า xor-ทันที
supercat

1

นอกเหนือจากคำตอบของ Martin ฉันจะเพิ่มว่าการสร้างโค้ด SQL นั้นดีมากเมื่อคุณทำงานในแบบบันทึกทีละระเบียน (เลือก * จาก tab1 โดยที่ tab1.pkcolumn =: พารามิเตอร์, update tab1 set [จำนวนคอลัมน์ใด ๆ ] โดยที่ tab1.pkcolumn =: พารามิเตอร์ ฯลฯ ) และ ORM ของคุณจะเปล่งประกายในสถานการณ์นั้นเนื่องจาก SQL ที่จำเป็นต้องสร้างขึ้นนั้นซ้ำซ้อนแน่นอน

ความกังวลหลักของฉันคือ metaqueries - แบบสอบถามเกี่ยวกับคุณสมบัติของวัตถุที่ ORM แปลเป็น SQL โดยใช้อัลกอริทึมอะไรก็ได้ metaqueries ที่คล้ายกันมากสามารถสร้าง SQL ที่แตกต่างกันโดยสิ้นเชิง - และไม่รับประกันว่า SQL ที่สร้างขึ้นนี้เป็นแบบ performatic

ภาษา metaquery ที่แปลเป็นภาษาอื่น (SQL) ที่แปลเป็นแผนแบบสอบถามเพื่อดำเนินการรวบรวมข้อมูลได้อย่างมีประสิทธิภาพ และผลลัพธ์ที่สร้างขึ้นจะต้องเป็นวัตถุดังนั้น ORM จะต้องสร้างอินสแตนซ์ของวัตถุที่ได้รับผลกระทบดังนั้นจึงสามารถกระตุ้นการสืบค้นอีกครั้งเพื่อเติมคุณสมบัติของวัตถุที่ไม่ได้นำมาด้วย metaquery ...


0

ฉันเห็นด้วยกับผู้ที่บอกว่าการสร้างโค้ดนั้นดีตราบใดที่คุณไม่ต้องแก้ไข (โดยเฉพาะอย่างยิ่งไม่ต้องมอง) โค้ดที่สร้างขึ้น

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


ภาคผนวก: แน่นอนปัจจัยอื่น ๆ เช่นเวลาดำเนินการอาจมีบทบาท

โดยส่วนตัวฉันได้เขียนตัวสร้างโค้ดค่อนข้างน้อย แต่ไม่เคยเป็นวิธีเริ่มต้น

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

ในระดับนั้นรหัสที่ฉันสร้างขึ้นนั้นเกือบจะเหมือนกับโค้ดที่เขียนด้วยมือที่มีอยู่ (ยกเว้นว่ามันมีแนวโน้มที่จะวางโครงสร้างทางสายตาที่ดีขึ้นและมีความเหมือนกันมากขึ้น

Btw ฉันแนะนำให้ใส่ความคิดเห็นเปิด / ปิดซึ่งระบุว่ารหัสถูกสร้างขึ้นรวมถึงรายละเอียดของเครื่องมือและผู้ดูแล

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.