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

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

94 development-process  methods  initialization 

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

68 object-oriented  class  methods  static-methods  access-modifiers 

ดังนั้นก่อนหน้านี้ฉันสังเกตเห็นความคิดเห็นบางอย่างเกี่ยวกับวิธีการที่ยาวนานว่าเป็นการฝึกฝนที่ไม่ดี ฉันไม่แน่ใจว่าฉันเห็นด้วยเสมอว่าวิธีการที่ยาวนานนั้นไม่ดี (และต้องการความคิดเห็นจากผู้อื่น) ตัวอย่างเช่นฉันมีมุมมอง Django ที่ประมวลผลบางส่วนของวัตถุก่อนที่จะส่งไปยังมุมมองซึ่งเป็นวิธีการที่ยาวเป็นรหัส 350 บรรทัด ฉันได้เขียนโค้ดของฉันเพื่อให้เกี่ยวข้องกับพารามิเตอร์ - การเรียงลำดับ / กรองชุดสืบค้นจากนั้นการประมวลผลบางอย่างบนวัตถุที่แบบสอบถามของฉันส่งคืน ดังนั้นการประมวลผลส่วนใหญ่จะเป็นการรวมแบบมีเงื่อนไขซึ่งมีกฎที่ซับซ้อนพอที่จะไม่สามารถทำได้อย่างง่ายดายในฐานข้อมูลดังนั้นฉันจึงมีตัวแปรบางตัวที่ประกาศนอกลูปหลักจากนั้นจึงเปลี่ยนแปลงระหว่างลูป variable_1 = 0 variable_2 = 0 for object in queryset : if object.condition_condition_a and variable_2 > 0 : variable 1+= 1 ..... ... . more conditions to alter the variables return queryset, and context ตามทฤษฎีฉันควรแยกรหัสทั้งหมดออกเป็นวิธีที่เล็กลงเพื่อให้ฉันมีวิธีการดูว่ายาวที่สุดในหนึ่งหน้า อย่างไรก็ตามในอดีตเคยทำงานกับฐานรหัสหลาย …

64 readability  methods 

ฉันสับสนเล็กน้อยเกี่ยวกับ 'ฟังก์ชั่น' และ 'แลมบ์ดา' ฉันเคยเห็นตัวอย่างบางส่วนที่แสดงว่าคำหลักแบบแผนlambdaทำงานคล้ายกับคำหลัก JavaScript functionแต่ฉันไม่รู้ว่าเกี่ยวข้องกันอย่างไร ฉันบอกว่า 'function' และ 'method' สามารถใช้แทนกันได้เมื่อพูดถึงวัตถุใน. net ฉันสงสัยว่า 'แลมบ์ดา' และ 'ฟังก์ชั่น' ในทำนองเดียวกันหมายถึงสิ่งเดียวกัน ฉันสงสัยว่า 'แลมบ์ดา' มีความหมายลึกลับบางอย่างหรือไม่เนื่องจากเห็นว่าตัวอักษรกรีกแลมบ์ดา (λ) ปรากฏในอวตารมากมายในไซต์นี้ ในการทำให้สิ่งต่าง ๆ สับสนมากขึ้นใน. net ส่วนการทำงานของ C # หมายถึงนิพจน์ฟังก์ชันที่ส่งผ่านไปยังฟังก์ชันอื่นเป็น 'แลมบ์ดานิพจน์' ดังนั้นคำนี้ดูเหมือนจะอยู่ทั่วทุกแห่ง ฉันยังคุ้นเคยกับคำว่า 'lambda แคลคูลัส' ด้วย อะไรคือความแตกต่างระหว่างฟังก์ชั่นและแลมบ์ดา?

54 functional-programming  methods  lambda 

ฉันมักจะมีปัญหาในการหาว่าผมควรจะตั้งชื่อวิธีการบางอย่างที่เริ่มต้นด้วยเมื่อเทียบกับgetSomethingfindSomething ปัญหาอยู่ในการสร้างผู้ช่วยเหลือสำหรับ API ที่ออกแบบมาไม่ดี สิ่งนี้มักจะเกิดขึ้นเมื่อรับข้อมูลจากวัตถุซึ่งต้องการวัตถุเป็นพารามิเตอร์ นี่คือตัวอย่างง่ายๆ: public String getRevision(Item item) { service.load(item, "revision"); // there is usually more work to do before getting the data.. try { return item.get_revision(); } catch(NotLoadedException exception) { log.error("Property named 'property_name' was not loaded", exception); } return null; } วิธีการและเหตุผลในการตัดสินใจระหว่างการตั้งชื่อวิธีการนี้เป็นgetRevision()หรือfindRevision()?

47 naming  methods 

ฉันเห็นคำถามที่คล้ายกับเรื่องนี้เกี่ยวกับชื่อพารามิเตอร์ที่ตรงกับคุณสมบัติในคลาส แต่ฉันไม่พบสิ่งใดเกี่ยวกับการใช้ชื่อพารามิเตอร์ที่เหมือนกับชื่อประเภทพารามิเตอร์ยกเว้นการใส่ใน C # ดูเหมือนจะไม่เป็นการละเมิดที่ฉันสามารถหาได้ แต่มันถือว่าเป็นการปฏิบัติที่ไม่ดี ตัวอย่างเช่นฉันมีวิธีการดังต่อไปนี้ public Range PadRange(Range range) {} วิธีนี้ใช้ช่วงและส่งกลับช่วงใหม่ที่มีการเติมเต็มบางส่วน ดังนั้นด้วยบริบททั่วไปฉันไม่สามารถนึกถึงชื่อที่อธิบายเพิ่มเติมสำหรับพารามิเตอร์ได้ อย่างไรก็ตามฉันระลึกถึงปลายที่ฉันหยิบขึ้นมาเมื่ออ่านรหัสสมบูรณ์เกี่ยวกับ "ระยะทางทางจิตวิทยา" มันบอกว่า ระยะทางทางจิตวิทยาสามารถกำหนดได้ว่าเป็นความง่ายในการแยกความแตกต่างของสองรายการ ... เมื่อคุณดีบั๊กให้พร้อมสำหรับปัญหาที่เกิดจากระยะห่างทางจิตใจไม่เพียงพอระหว่างชื่อตัวแปรที่คล้ายกันและระหว่างชื่อรูทีนที่คล้ายกัน ในขณะที่คุณสร้างรหัสให้เลือกชื่อที่มีความแตกต่างมากเพื่อให้คุณสามารถหลีกเลี่ยงปัญหาได้ ลายเซ็นวิธีการของฉันมี "ช่วง" มากมายเกิดขึ้นดังนั้นจึงรู้สึกว่ามันอาจเป็นปัญหาเกี่ยวกับระยะห่างทางจิตวิทยานี้ ตอนนี้ฉันเห็นนักพัฒนาหลายคนทำต่อไปนี้ public Range PadRange(Range myRange) {} โดยส่วนตัวฉันมีความไม่พอใจที่แข็งแกร่งสำหรับการประชุมครั้งนี้ การเพิ่มคำนำหน้า "ของฉัน" ไปยังชื่อตัวแปรไม่มีบริบทเพิ่มเติม ฉันยังเห็นดังต่อไปนี้ public Range PadRange(Range rangeToPad) {} ฉันชอบสิ่งนี้ดีกว่าส่วนนำหน้า "ของฉัน" แต่ก็ยังไม่สนใจโดยรวม มันรู้สึก verbose มากเกินไปสำหรับฉันและอ่านอย่างเชื่องช้าเป็นชื่อตัวแปร สำหรับฉันมันเป็นที่เข้าใจกันดีว่าช่วงนั้นจะถูกเพิ่มเนื่องจากชื่อเมธอด ดังนั้นเมื่อทั้งหมดนี้ออกมาอุทรของฉันคือการได้ไปกับลายเซ็นแรก สำหรับฉันมันสะอาด ไม่จำเป็นต้องบังคับบริบทเมื่อไม่จำเป็น …

43 coding-standards  methods  parameters 

สมมติว่าในส่วนส่วนตัวของคลาสมีค่าที่ใช้โดยวิธีส่วนตัวหลายวิธี คนชอบมีการกำหนดนี้เป็นตัวแปรสมาชิกสำหรับชั้นเรียนหรือผ่านมันเป็นอาร์กิวเมนต์สำหรับแต่ละวิธี - และทำไม ในอีกด้านหนึ่งฉันสามารถเห็นการโต้เถียงที่จะทำให้การลดสถานะ (เช่นตัวแปรสมาชิก) ในชั้นเรียนโดยทั่วไปเป็นสิ่งที่ดีแม้ว่าค่าเดียวกันจะถูกใช้ซ้ำหลายครั้งตลอดทั้งวิธีการเรียนดูเหมือนว่าจะเหมาะ ผู้สมัครเพื่อเป็นตัวแทนของรัฐในชั้นเรียนเพื่อให้รหัสชัดเจนขึ้นถ้าไม่มีอะไรอื่น แก้ไข: เพื่ออธิบายความเห็น / คำถามบางอย่างที่ยกขึ้นฉันไม่ได้พูดถึงค่าคงที่และนี่ไม่ได้เกี่ยวข้องกับกรณีเฉพาะ แต่เป็นเพียงสมมติฐานที่ฉันได้พูดคุยกับคนอื่น ๆ ไม่สนใจมุม OOP สักครู่กรณีการใช้งานเฉพาะที่ฉันมีในใจคือต่อไปนี้ (สมมติว่าผ่านโดยการอ้างอิงเพียงเพื่อให้ตัวทำความสะอาดรหัสเทียม) int x doSomething(x) doAnotherThing(x) doYetAnotherThing(x) doSomethingElse(x) ดังนั้นสิ่งที่ฉันหมายถึงคือมีตัวแปรบางอย่างที่เป็นเรื่องธรรมดาระหว่างฟังก์ชั่นหลายอย่าง - ในกรณีที่ฉันจำได้ว่ามันเป็นเพราะการผูกมัดของฟังก์ชั่นขนาดเล็ก ในระบบ OOP หากวิธีการเหล่านี้เป็นวิธีการเรียน (พูดเนื่องจากการปรับโครงสร้างด้วยวิธีการแยกจากวิธีการขนาดใหญ่) ตัวแปรนั้นสามารถส่งผ่านไปรอบ ๆ พวกเขาทั้งหมดหรืออาจเป็นสมาชิกชั้นเรียน

39 java  code-quality  variables  class-design  methods 

หากมีวิธีการ bool DoStuff() { try { // doing stuff... return true; } catch (SomeSpecificException ex) { return false; } } มันควรจะถูกเรียกว่าค่อนข้างIsStuffDone()? ผู้ใช้ทั้งสองชื่ออาจตีความผิด: หากชื่อเป็นDoStuff()สาเหตุว่าทำไมจึงส่งคืนบูลีน หากชื่อIsStuffDone()ไม่ชัดเจนว่าวิธีการทำงานหรือตรวจสอบผลของมันเท่านั้น มีแบบแผนสำหรับกรณีนี้หรือไม่? หรือวิธีการอื่นเป็นวิธีนี้ถือว่ามีข้อบกพร่อง? ยกตัวอย่างเช่นในภาษาที่มีพารามิเตอร์ที่ส่งออกเช่น C # voidตัวแปรสถานะบูลีนอาจจะส่งผ่านไปยังวิธีการที่เป็นหนึ่งและประเภทผลตอบแทนของวิธีการที่จะเป็น แก้ไข: ในการจัดการข้อยกเว้นปัญหาเฉพาะของฉันไม่สามารถมอบหมายโดยตรงไปยังผู้โทรเพราะวิธีการเป็นส่วนหนึ่งของการใช้อินเตอร์เฟซ ดังนั้นผู้เรียกไม่สามารถเรียกเก็บเงินกับการจัดการกับข้อยกเว้นทั้งหมดของการใช้งานที่แตกต่างกัน ไม่คุ้นเคยกับข้อยกเว้นเหล่านั้น แต่โทรสามารถจัดการกับข้อยกเว้นที่กำหนดเองเช่นStuffHasNotBeenDoneForSomeReasonExceptionเป็นได้รับการแนะนำในคำตอบของ npinti และแสดงความคิดเห็น

33 naming  methods  naming-standards  parameters  return-type 

ภาษาการเขียนโปรแกรมกำหนดและบันทึกฟังก์ชัน / วิธีอย่างไร ฉันกำลังสร้างภาษาการเขียนโปรแกรมตีความใน Ruby และฉันพยายามคิดวิธีการประกาศใช้ฟังก์ชั่น แนวคิดแรกของฉันคือการบันทึกเนื้อหาของการประกาศในแผนที่ ตัวอย่างเช่นถ้าฉันทำสิ่งที่ชอบ def a() { callSomething(); x += 5; } จากนั้นฉันจะเพิ่มรายการลงในแผนที่ของฉัน: { 'a' => 'callSomething(); x += 5;' } ปัญหานี้คือว่ามันจะกลายเป็นแบบเรียกซ้ำเพราะฉันจะต้องเรียกparseวิธีการของฉันบนสตริงซึ่งจะโทรparseอีกครั้งเมื่อพบdoSomethingและจากนั้นฉันก็จะหมดพื้นที่สแต็คในที่สุด ดังนั้นภาษาที่ตีความจะจัดการกับสิ่งนี้ได้อย่างไร

28 programming-languages  language-design  functions  methods 

เมื่อฉันแยกวิธีการขนาดใหญ่ (หรือขั้นตอนหรือฟังก์ชั่น - คำถามนี้ไม่เฉพาะเจาะจงกับ OOP แต่เนื่องจากฉันทำงานในภาษา OOP 99% ของเวลามันเป็นคำศัพท์ที่ฉันรู้สึกสบายใจที่สุด) เป็นคำเล็ก ๆ ฉันมักจะพบว่าตัวเองไม่พอใจกับผลลัพธ์ มันยากที่จะให้เหตุผลเกี่ยวกับวิธีการขนาดเล็กเหล่านี้มากกว่าเมื่อพวกเขาเป็นเพียงบล็อกของรหัสในใหญ่เพราะเมื่อฉันแยกพวกเขาฉันสูญเสียสมมติฐานพื้นฐานมากมายที่มาจากบริบทของผู้โทร ต่อมาเมื่อฉันดูรหัสนี้และดูวิธีการต่าง ๆ ฉันไม่รู้ทันทีว่าพวกเขาจะเรียกจากที่ไหนและคิดว่าเป็นวิธีการส่วนตัวแบบธรรมดาที่สามารถเรียกได้จากทุกที่ในไฟล์ ตัวอย่างเช่นลองจินตนาการถึงวิธีการเริ่มต้น (ตัวสร้างหรืออื่น ๆ ) แบ่งออกเป็นชุดของตัวเล็ก: ในบริบทของวิธีการเองคุณรู้ชัดเจนว่าสถานะของวัตถุนั้นยังคงไม่ถูกต้อง แต่ในวิธีส่วนตัวปกติคุณอาจไปจากสมมติฐานว่าวัตถุนั้น เริ่มต้นแล้วและอยู่ในสถานะที่ถูกต้อง ทางออกเดียวที่ฉันเคยเห็นคือwhereclause ใน Haskell ซึ่งช่วยให้คุณกำหนดฟังก์ชันขนาดเล็กที่ใช้เฉพาะในฟังก์ชัน "parent" โดยทั่วไปดูเหมือนว่านี้: len x y = sqrt $ (sq x) + (sq y) where sq a = a * a แต่ภาษาอื่นที่ฉันใช้ไม่มีอะไรแบบนี้ - …

27 functions  methods 

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

23 c#  design-patterns  object-oriented  methods 

Java SE 8 มาพร้อมกับกลไกใหม่สำหรับวันที่แนะนำLocalDate, LocalTimeและLocalDateTimeชั้นเรียนเพื่อเป็นตัวแทนของจังหวะเวลา เพื่อจัดการกับจังหวะดังกล่าวเป็นชุดของวิธีการที่จะได้รับ: LocalDate.plusDays(...), LocalDate.minusDays(...)และอื่น ๆ ฉันคิดเสมอว่าวิธีปฏิบัติที่ดีคือการตั้งชื่อวิธีการหลังจากคำกริยาอธิบายถึงจุดประสงค์ของพวกเขาเช่นเดียวกับวิธีการที่เป็นจริงการดำเนินการที่จะดำเนินการสิ่งที่จะดำเนินการ เพียงแค่พูดถึงถ้าคุณพิจารณาการเรียนเหมือนStringBuilderเช่นชื่อวิธีการมีappend, insert, delete... นี่คือเหตุผลที่ฉันก็ไม่ได้เสียงที่เหมาะสมในการตั้งชื่อวิธีการplusDaysแทนsumDays, แทนminusDays subtractDaysฉันแค่พบว่ามันน่ารำคาญมาก? คุณคิดอย่างไร? เหตุผลเดียวที่ฉันนึกได้ก็คือวันที่นั้นเป็นวัตถุที่ไม่เปลี่ยนรูปดังนั้นโดยการโทรplusDaysคุณไม่ได้เพิ่มวันในวัตถุดั้งเดิม แต่สร้างวันใหม่ด้วยคุณสมบัติใหม่ แต่นั่นช่างลึกซึ้งมาก

21 java  methods  naming-standards 

ฉันใช้การวิพากษ์วิจารณ์อย่างมากจากโปรแกรมเมอร์คนอื่น ๆ เนื่องจากฉันใช้ตัวเรือนที่เหมาะสมกับตัวแปรทั้งหมดของฉัน ยกตัวอย่างเช่นโปรแกรมเมอร์ของคุณโดยทั่วไปจะใช้employeeCountชื่อตัวแปร EmployeeCountแต่ฉันจะใช้ ฉันใช้ตัวเครื่องที่เหมาะสมสำหรับทุกอย่างไม่ว่าจะเป็นวิธีที่เป็นโมฆะวิธีคืนค่าตัวแปรคุณสมบัติหรือค่าคงที่ ฉันยังทำตามอนุสัญญานี้ใน Javascript สิ่งสุดท้ายที่ทำให้เกิดความสับสนวุ่นวายของคนจริงๆ เหตุผลทั่วไปที่กำหนดว่าทำไมฉันไม่ควรทำตามกรอบ "ที่ไม่ได้มาตรฐาน" นี้เป็นเพราะกรณีที่เหมาะสมควรถูกสงวนไว้สำหรับคุณสมบัติและวิธีการโมฆะ int employeeCount = getEmployeeCount()ตัวแปรท้องถิ่นและวิธีการที่ส่งกลับค่าควรมีคำแรกเป็นตัวพิมพ์เล็กเช่น อย่างไรก็ตามฉันไม่เข้าใจว่าทำไม เมื่อผมถามนี้ก็ดูเหมือนว่าฉันเพิ่งได้รับคำตอบโดยพลการของที่มาตรฐาน อะไรก็ตามที่คำตอบคือมันมักจะเดือดลงไปที่นั่นเป็นเพียงวิธีที่มันเป็นและฉันไม่ได้ถามมัน ฉันแค่ติดตามมัน . คำตอบโดยพลการไม่เคยดีพอสำหรับฉัน นับตั้งแต่วันแรกของการเขียนโปรแกรมแมโคร Excel 97 กับ Office IDE ฉันไม่เคยต้องการรูปแบบการเขียนเพื่อบอกฉันว่ามีบางสิ่งที่เป็นตัวแปรหรือคุณสมบัติในตัวเครื่องหรือไม่ นี่เป็นเพราะฉันมักจะใช้รูปแบบการตั้งชื่อที่ใช้งานง่ายมาก ตัวอย่างเช่นGetNuggetCount()แนะนำวิธีการที่จะไปที่ไหนสักแห่งและนับจำนวนนักเก็ตทั้งหมด SetNuggetCount(x)แนะนำว่าคุณกำลังกำหนดค่าใหม่ให้กับจำนวนนักเก็ต NuggetCountโดยตัวมันเองแนะนำคุณสมบัติหรือตัวแปรท้องถิ่นที่เป็นเพียงการเก็บค่า สำหรับคนสุดท้ายนั้นอาจถูกล่อลวงให้พูดว่า "อ้าฮ่า! นั่นคือคำถามทรัพย์สินหรือตัวแปร? เพื่อที่ฉันจะตอบด้วย "มันเป็นเรื่องสำคัญจริง ๆ ?" ดังนั้นนี่คือ tl; dr ;: อะไรคือวัตถุประสงค์เหตุผลเหตุผลที่ไม่มีเหตุผลในการใช้ตัวพิมพ์เล็กสำหรับคำแรกในตัวแปรหรือวิธีการส่งคืนของคุณ แก้ไข: สำหรับ MainMa แทนที่รหัสนี้ด้วยตัวอย่างรหัสแรกในคำตอบของคุณและดูว่าอาร์กิวเมนต์ของคุณดีขึ้นเพียงใด: public …

20 variables  methods  naming-standards 

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

18 python  unit-testing  methods 

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

16 exceptions  methods  state