คำถามติดแท็ก refactoring

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

37 tdd  refactoring 

เราทุกคนทราบดีว่าเลขอาถรรพ์ (ค่าฮาร์ดโค้ด) สามารถสร้างความหายนะในโปรแกรมของคุณโดยเฉพาะเมื่อถึงเวลาที่จะแก้ไขส่วนของรหัสที่ไม่มีความคิดเห็น แต่คุณจะวาดเส้นที่ไหน ตัวอย่างเช่นหากคุณมีฟังก์ชันที่คำนวณจำนวนวินาทีระหว่างสองวันคุณจะเปลี่ยนหรือไม่ seconds = num_days * 24 * 60 * 60 กับ seconds = num_days * HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE ณ จุดใดที่คุณตัดสินใจว่ามันชัดเจนอย่างชัดเจนว่าค่าฮาร์ดโค้ดมีความหมายอย่างไรและทิ้งไว้คนเดียว?

36 refactoring  coding-standards  maintainability 

TD; DR: มีความสับสนเกี่ยวกับสิ่งที่ฉันถามดังนั้นนี่คือแนวคิดการขับขี่ที่อยู่เบื้องหลังคำถาม: ฉันมักจะตั้งคำถามว่ามันคืออะไร ฉันอาจไม่ได้พูดชัดแจ้ง แต่แรกเริ่ม แต่เจตนาได้เสมอ " เป็นโมดูลแยกแยกหลวมคู่ decoupled รหัส refactored " ช้าลงอย่างเห็นได้ชัดโดยธรรมชาติของตัวเองมากกว่า " เสาเดียวหน่วยทำทุกอย่างในที่เดียวหนึ่งไฟล์คู่แน่น " รหัส ส่วนที่เหลือเป็นเพียงรายละเอียดและอาการต่าง ๆ ของเรื่องนี้ที่ฉันเจอในตอนนี้หรือตอนนี้หรือจะในภายหลัง มันช้าลงอย่างแน่นอนในระดับหนึ่ง เช่นเดียวกับดิสก์ที่ไม่มีการดีแฟรกต์คุณต้องเลือกชิ้นส่วนจากทุกที่ มันช้ากว่า ได้อย่างแน่นอน แต่ฉันควรสนใจ และคำถามไม่ได้เกี่ยวกับ ... ไม่เกี่ยวกับการเพิ่มประสิทธิภาพขนาดเล็กการปรับให้เหมาะสมก่อนวัยและอื่น ๆ มันไม่เกี่ยวกับ "เพิ่มประสิทธิภาพส่วนนี้หรือส่วนที่ตาย" ถ้าเช่นนั้นจะเป็นอะไร เป็นเรื่องเกี่ยวกับระเบียบวิธีและเทคนิคโดยรวมและวิธีคิดเกี่ยวกับการเขียนโค้ดที่เกิดขึ้นเมื่อเวลาผ่านไป: "ฉีดรหัสนี้ในชั้นเรียนของคุณเป็นการพึ่งพา" "เขียนหนึ่งไฟล์ต่อคลาส" "แยกมุมมองของคุณออกจากฐานข้อมูลตัวควบคุมโดเมน" อย่าเขียน codeblock สปาเก็ตตี้ที่เป็นเนื้อเดียวกัน แต่เขียนส่วนประกอบแยกส่วนจำนวนมากที่ทำงานร่วมกัน มันเกี่ยวกับวิธีการและรูปแบบของรหัสที่ปัจจุบัน - ภายในทศวรรษนี้ - เห็นและสนับสนุนในกรอบการทำงานส่วนใหญ่ที่สนับสนุนการประชุมส่งต่อผ่านชุมชน มันเป็นการเปลี่ยนความคิดจาก 'monolithic blocks' เป็น …

35 object-oriented  performance  refactoring  dependency-injection 

ฉันแน่ใจว่ามีคำศัพท์สำหรับการรีแฟคเตอร์ต่อไปนี้ แต่ฉันจำไม่ได้และ Google-fu ของฉันกำลังทำให้ฉันล้มเหลว! refactor จะย้ายถ้าข้อความไปยังตำแหน่งที่พวกเขาจะได้รับผลกระทบมากที่สุดเช่นการเปลี่ยนแปลง $test = someFunctionThatReturnsABool(); for($x = 0; $x < 10000; $x++) { if ($test) { echo $x; } } สำหรับสิ่งนี้ $test = someFunctionThatReturnsABool(); if ($test) { for($x = 0; $x < 10000; $x++) { echo $x; } }

33 terminology  refactoring 

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

33 design-patterns  refactoring  clean-code 

ตามคำตอบที่ยอมรับได้ใน " เหตุผลที่ต้องการตัวแปรท้องถิ่นมากกว่าตัวแปรอินสแตนซ์? " ตัวแปรควรอยู่ในขอบเขตที่เล็กที่สุดเท่าที่จะเป็นไปได้ ลดความซับซ้อนของปัญหาในการตีความของฉันซึ่งหมายความว่าเราควรปรับโครงสร้างโค้ดประเภทนี้อีกครั้ง: public class Main { private A a; private B b; public ABResult getResult() { getA(); getB(); return ABFactory.mix(a, b); } private getA() { a = SomeFactory.getA(); } private getB() { b = SomeFactory.getB(); } } เป็นอะไรเช่นนี้: public class Main { public ABResult getResult() { …

32 refactoring  scope  local-variable 

ตัวอย่างเช่นฉันเคยเห็นรหัสบางอย่างที่สร้างชิ้นส่วนเช่นนี้: Fragment myFragment=new MyFragment(); ซึ่งประกาศตัวแปรเป็นชิ้นส่วนแทน MyFragment ซึ่ง MyFragment เป็นคลาสย่อยของ Fragment ฉันไม่พอใจรหัสบรรทัดนี้เพราะฉันคิดว่ารหัสนี้ควรเป็น: MyFragment myFragment=new MyFragment(); ข้อไหนเจาะจงกว่ากันจริงหรือ? หรือโดยทั่วไปของคำถามเป็นการใช้งานไม่ถูกต้อง: Parent x=new Child(); แทน Child x=new Child(); หากเราสามารถเปลี่ยนคนที่เคยเป็นคนหลังได้โดยไม่ผิดพลาด

32 object-oriented  coding-style  refactoring  inheritance 

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

32 refactoring 

นี่เป็นหัวข้อที่ถกเถียงกันอยู่และฉันคิดว่ามีความคิดเห็นมากเท่ากับที่มีโปรแกรมเมอร์ แต่เพื่อประโยชน์ของมันฉันต้องการทราบว่าการปฏิบัติทั่วไปในธุรกิจคืออะไร (หรือในที่ทำงานของคุณ) ในที่ทำงานของฉันเรามีแนวทางการเข้ารหัสที่เข้มงวด ส่วนหนึ่งของนั้นจะทุ่มเทให้กับสายอักขระ / หมายเลข มันระบุ (สำหรับ C #): อย่าใช้ค่าตัวอักษรตัวเลขหรือสตริงในรหัสของคุณนอกเหนือจากการกำหนดค่าคงที่เชิงสัญลักษณ์ ใช้รูปแบบต่อไปนี้เพื่อกำหนดค่าคงที่: public class Whatever { public static readonly Color PapayaWhip = new Color(0xFFEFD5); public const int MaxNumberOfWheels = 18; } มีข้อยกเว้นคือค่า 0, 1 และ null สามารถใช้ได้อย่างปลอดภัยเกือบตลอดเวลา บ่อยครั้งที่ค่า 2 และ -1 ก็โอเคเช่นกัน สตริงที่มีไว้สำหรับการบันทึกหรือการติดตามได้รับการยกเว้นจากกฎนี้ อนุญาตให้ใช้ตัวอักษรเมื่อความหมายชัดเจนจากบริบทและไม่ขึ้นอยู่กับการเปลี่ยนแปลงในอนาคต mean = (a + b) …

31 coding-style  refactoring  coding-standards  readability  maintainability 

ฉันพบว่าตัวเองอยู่ในจุดที่ยากลำบากของสาย เคยทำงานในเกมกับเพื่อนเขียนโปรแกรมมาเกือบ 8 เดือนแล้ว เราทั้งคู่เริ่มต้นในฐานะผู้มาใหม่ในการเขียนโปรแกรมประมาณเดือนสิงหาคมของปีที่แล้วเขาเป็นนักเรียน CS ปีที่ 2 ฉันเป็นผู้ให้การสนับสนุนด้านเทคโนโลยีโดยการค้าและเป็นโปรแกรมเมอร์ที่สอนตัวเองด้วยหนังสือมากมายและการสมัครสมาชิกออนไลน์ ปัญหาที่ฉันเห็นอยู่ตลอดเวลาคือเมื่อเราเขียนโค้ดจำนวนหนึ่งบ่อยครั้งที่มันจะถูกแฮ็กเข้าด้วยกันมีความล้มเหลวมากมายและหากเป็นแนวคิดใหม่เอี่ยมสำหรับเราหนึ่งคนที่เต็มไปด้วยโซลูชั่นไร้เดียงสา นี่เป็นสิ่งที่ดีเรากำลังเรียนรู้ฉันคาดหวังว่าโค้ดทั้งสองของเราจะถูกแฮ็กเข้าด้วยกันในภาคเรียนหรือรอบที่สอง ปัญหานำเสนอตัวเองเมื่อมันมาถึงการแก้ไขและ refactoring พฤติกรรมที่แฮ็กด้วยกัน คู่ของฉันจะยึดติดกับก้อนกรวดที่สดใหม่ของเขาด้วยกันอย่างโจ๋งครึ่มปฏิเสธที่จะเห็นข้อผิดพลาดใด ๆ ในขณะที่มันเริ่มทำงาน การอ้างถึงความสมบูรณ์แบบจากชิ้นส่วนของโครงสร้างฉันไม่สามารถแม้แต่จะใช้แม้ว่ามันจะมีความคิดเห็นและวิธีการและฟิลด์ที่ตั้งชื่อไว้อย่างเหมาะสมก็ตาม ไม่ว่าฉันจะพยายามแค่ไหนฉันก็ไม่สามารถทำให้เขาเห็นข้อบกพร่องที่เห็นได้ชัดซึ่งจะป้องกันไม่ให้เกิดการเปลี่ยนแปลงหรือการขยายตัวของพฤติกรรมโดยไม่ทำลายมันและทุกอย่างที่มันเชื่อมโยงกับพวกเขาอาจจะอยู่ในชั้นเดียวกัน โซลูชันที่ถูกแฮ็กตลอดเวลาจะถูกแฮ็กอยู่ตลอดและคิดว่าการออกแบบที่ไม่ดีจะยังคงอยู่ในแบบที่พวกเขาคิด ฉันใช้เวลาไปกับการดูแลรหัสใหม่ให้มากขึ้นเพราะฉันเขียนด้วยตัวเองฉันเสียสิ่งที่ต้องทำ คู่ของฉันสูญเสียมันไปคืนนี้และทำให้ชัดเจนว่าไม่ว่าอะไรก็ตามไม่ว่าจะเป็นมาตรฐานไม่ว่าจะเป็นเรื่องธรรมดาการปฏิบัติไม่ว่าจะเป็นข้อพิสูจน์ที่หักล้างไม่ได้ก็ตามรหัสของเขาจะยังคงอยู่ในแบบที่เขาทำ แม้ว่าหนังสือทั้งเล่มจะถูกเขียนขึ้นเกี่ยวกับสาเหตุที่คุณต้องการหลีกเลี่ยงการทำอะไรเขาจะปฏิเสธที่จะยอมรับความถูกต้องของพวกเขาโดยอ้างว่าเป็นเพียงความเห็นของใครบางคน ฉันมีความสนใจในโครงการของเรา แต่ฉันไม่แน่ใจว่าฉันจะสามารถทำงานร่วมกับคู่ค้าของฉันได้หรือไม่ ฉันดูเหมือนจะมีสามตัวเลือกให้ฉันเปิด หยุดการดูแลเกี่ยวกับการทำงานของ codebase ที่ผ่านจุดรวบรวมและเพียงจัดการกับการพยายามที่จะรักษาและแยกวิเคราะห์พฤติกรรมที่แทบจะไม่คลานไปมา หวังว่าเมื่อสิ่งต่าง ๆ เริ่มสลายอย่างจริงจังเขาจะเห็นและพยายามทำมากกว่าแค่ใส่ bandaid เหนือการออกแบบที่มีข้อบกพร่องพื้นฐาน ติดตามข้อถกเถียงที่ไม่รู้จบเกี่ยวกับปัญหาที่เกิดขึ้นเมื่อทศวรรษที่แล้วโดยบุคคลที่มีความสามารถมากกว่า หยุดเขียนโปรแกรมในโครงการนี้ทิ้งโค้ดของฉันเกือบ 10,000 บรรทัดและใช้เวลาหลายชั่วโมงในการออกแบบและลองหาโปรเจคใหม่ด้วยตัวเอง ฉันจะใช้วิธีการใดเพื่อตรวจสอบว่าโครงการนี้ดำเนินต่อกับบุคคลนี้ได้หรือไม่ หรือปัจจัยใดที่ควรมีอิทธิพลต่อการตัดสินใจของฉัน เราได้เขียนโค้ดจำนวนมากและฉันไม่ต้องการยอมแพ้เว้นแต่จะจำเป็น

30 code-quality  refactoring  teamwork  maintenance 

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

29 code-quality  refactoring  clean-code  technical-debt 

ในอีกคำถามหนึ่งพบว่าหนึ่งในความเจ็บปวดกับ TDD กำลังรักษาชุดการทดสอบให้สอดคล้องกับรหัสฐานระหว่างและหลังการปรับโครงสร้างใหม่ ตอนนี้ฉันเป็นแฟนตัวยงของการฟื้นฟู ฉันจะไม่ยอมแพ้ที่จะทำ TDD แต่ฉันยังประสบปัญหาของการทดสอบที่เขียนในลักษณะที่การปรับเปลี่ยนเล็กน้อยทำให้เกิดความล้มเหลวในการทดสอบมากมาย คุณจะหลีกเลี่ยงการทำลายการทดสอบเมื่อทำการเปลี่ยนโครงสร้างใหม่ได้อย่างไร คุณเขียนแบบทดสอบ 'ดีกว่า' หรือไม่? ถ้าเป็นเช่นนั้นคุณควรมองหาอะไร คุณหลีกเลี่ยงการ refactoring บางประเภทหรือไม่ มีเครื่องมือทดสอบการปรับโครงสร้างใหม่หรือไม่? แก้ไข:ฉันเขียนคำถามใหม่ที่ถามสิ่งที่ฉันต้องการถาม (แต่เก็บไว้เป็นตัวแปรที่น่าสนใจ)

29 development-process  tdd  refactoring 

ฉันจะบันทึกส่วนของข้อมูลสตริงในฐานข้อมูล ฉันมีการกำหนดค่าระดับโลกสองแบบ: การเข้ารหัส การอัด สิ่งเหล่านี้สามารถเปิดใช้งานหรือปิดการใช้งานโดยใช้การกำหนดค่าในลักษณะที่เปิดใช้งานเพียงอย่างเดียวเท่านั้นทั้งสองถูกเปิดใช้งานหรือทั้งสองอย่างถูกปิดใช้งาน การใช้งานปัจจุบันของฉันคือ: if (encryptionEnable && !compressEnable) { encrypt(data); } else if (!encryptionEnable && compressEnable) { compress(data); } else if (encryptionEnable && compressEnable) { encrypt(compress(data)); } else { data; } ฉันกำลังคิดเกี่ยวกับลวดลายมัณฑนากร มันเป็นตัวเลือกที่ถูกต้องหรืออาจเป็นทางเลือกที่ดีกว่า

28 design  design-patterns  object-oriented-design  refactoring 

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

28 refactoring  switch-statement 

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

27 refactoring