ทุกคนพบคลาสการตั้งชื่อและวิธีการหนึ่งในส่วนที่ยากที่สุดในการเขียนโปรแกรม? [ปิด]

ดังนั้นฉันกำลังทำงานกับคลาสนี้ที่ควรจะขอเอกสารความช่วยเหลือจากผู้ขายผ่านบริการบนเว็บ ฉันพยายามที่จะตั้งชื่อDocumentRetriever, VendorDocRequester, DocGetterแต่พวกเขาก็ไม่ได้เสียงที่เหมาะสม ฉันจบการสืบค้นผ่านdictionary.comครึ่งชั่วโมงเพื่อพยายามหาคำที่เพียงพอ

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

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

บริบท + กริยา + อย่างไร

ฉันใช้วิธีนี้เพื่อตั้งชื่อฟังก์ชั่น / วิธี, SQL ที่เก็บไว้ procs, ฯลฯ โดยการรักษาด้วยไวยากรณ์นี้มันจะทำให้ Intellisense / บานหน้าต่างโค้ดของคุณเรียบร้อยมากขึ้น ดังนั้นคุณต้องการ EmployeeGetByID () EmployeeAdd (), EmployeeDeleteByID () เมื่อคุณใช้ไวยากรณ์ที่ถูกต้องทางไวยากรณ์มากขึ้นเช่น GetEmployee (), AddEmployee () คุณจะเห็นว่าสิ่งนี้ยุ่งเหยิงจริงๆถ้าคุณมีหลายตัวรับในคลาสเดียวกันกับสิ่งที่ไม่เกี่ยวข้องจะถูกจัดกลุ่มเข้าด้วยกัน

ฉันคล้ายกับการตั้งชื่อไฟล์ที่มีวันที่คุณต้องการบอกว่า 2009-01-07.log ไม่ใช่ 1-7-2009.log เพราะหลังจากที่คุณมีกลุ่มไฟล์เหล่านี้แล้วคำสั่งจะไร้ประโยชน์โดยสิ้นเชิง

บทเรียนหนึ่งที่ฉันได้เรียนรู้คือถ้าคุณไม่สามารถหาชื่อของชั้นเรียนได้มักจะมีบางอย่างผิดปกติกับชั้นเรียนนั้น:

• คุณไม่ต้องการมัน
• มันมากเกินไป

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

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

ในกรณีของคุณดูเหมือนว่าคลาสของคุณแปลง Url เป็นเอกสาร มันค่อนข้างแปลกที่จะคิดแบบนั้น แต่ถูกต้องสมบูรณ์แบบและเมื่อคุณเริ่มมองหารูปแบบนี้คุณจะเห็นมันทุกที่

เมื่อฉันได้พบกับรูปแบบนี้ฉันมักจะตั้งชื่อฟังก์ชั่นx YFrom

เนื่องจากฟังก์ชั่นของคุณแปลง Url เป็นเอกสารฉันจะตั้งชื่อมัน

DocumentFromUrl

รูปแบบนี้เป็นเรื่องธรรมดาอย่างน่าทึ่ง ตัวอย่างเช่น:

atoi -> IntFromString
GetWindowWidth -> WidthInPixelsFromHwnd // or DxFromWnd if you like Hungarian
CreateProcess -> ProcessFromCommandLine

คุณสามารถใช้UrlToDocumentถ้าคุณพอใจกับคำสั่งนั้น ไม่ว่าคุณจะพูดว่าx Fromyหรือy Toxอาจเป็นเรื่องของรสนิยม แต่ฉันชอบการFromสั่งซื้อเพราะวิธีนั้นจุดเริ่มต้นของชื่อฟังก์ชั่นจะบอกคุณว่ามันจะกลับมาแบบไหน

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

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

หัวข้อที่ 1:

function programming_job(){
    while (i make classes){
         Give each class a name quickly; always fairly long and descriptive.
         Implement and test each class to see what they really are. 
         while (not satisfied){
            Re-visit each class and make small adjustments 
         }
    }
}

หัวข้อที่ 2:

while(true){
      if (any code smells bad){
           rework, rename until at least somewhat better
      }
}

ไม่มี Thread.sleep (... ) ที่นี่ทุกที่

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

VendorHelpDocRequesterสำหรับชั้นเรียนของคุณผมขอแนะนำให้

รหัสหนังสือที่สมบูรณ์โดย Steve Mcconnellมีบทที่ดีในการตั้งชื่อตัวแปร / คลาส / ฟังก์ชั่น / ...

ฉันคิดว่านี่เป็นผลข้างเคียง

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

ที่จริงฉันเพิ่งได้ยินคำพูดนี้เมื่อวานนี้ผ่านบล็อกสัญญาณกับเสียงที่ 37 สัญญาณและแน่นอนฉันเห็นด้วยกับ:

"มีเพียงสองสิ่งที่ยากในวิทยาการคอมพิวเตอร์คือ: การทำให้ใช้ไม่ได้แคชและการตั้งชื่อสิ่ง" - ฟิลคาร์ลตัน

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

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

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

ฉันเพิ่งเขียนการประชุมการตั้งชื่อเมื่อเดือนที่แล้ว: http://caseysoftware.com/blog/useful-naming-conventions

ส่วนสำคัญของมัน:

verbAdjectiveNounStructure - มีโครงสร้างและคำคุณศัพท์เป็นส่วนเสริม

สำหรับคำกริยาฉันใช้คำกริยา action: เซฟลบแจ้งเตือนอัพเดตหรือสร้าง นาน ๆ ครั้งฉันใช้ "กระบวนการ" แต่เพื่ออ้างถึงคิวหรือ backlogs งานโดยเฉพาะ

สำหรับคำนามฉันใช้คลาสหรือวัตถุที่ถูกโต้ตอบด้วย ใน web2project นี่มักจะเป็นงานหรือโครงการ หาก Javascript โต้ตอบกับหน้าเว็บนั้นอาจเป็นเนื้อหาหรือตาราง ประเด็นก็คือรหัสจะอธิบายวัตถุที่โต้ตอบด้วยอย่างชัดเจน

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

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

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

พิจารณาเค้าโครงของแอปของคุณตอนนี้:

• App
  • VendorDocRequester (อ่านจากเว็บเซอร์วิสและให้ข้อมูล)
  • VendorDocViewer (ใช้ผู้ร้องขอเพื่อให้เอกสารผู้ขาย)

ฉันจะลองเดาดูว่ามีอะไรเกิดขึ้นมากมายในบางวิชา หากคุณต้องปรับเปลี่ยนวิธีการนี้ให้เป็นวิธี MVC-ified ที่มากขึ้นและอนุญาตให้ชั้นเรียนขนาดเล็กจัดการกับหน้าที่ของแต่ละบุคคลคุณอาจจะจบลงด้วยสิ่งต่อไปนี้:

• App
  • VendorDocs
    • แบบ
      • เอกสาร (วัตถุธรรมดาที่เก็บข้อมูล)
      • WebServiceConsumer (จัดการกับ nitty gritty ในบริการเว็บ)
    • ตัวควบคุม
      • DatabaseAdapter (จัดการการคงอยู่โดยใช้ ORM หรือวิธีอื่น)
      • WebServiceAdapter (ใช้ Consumer เพื่อคว้าเอกสารและติดไว้ในฐานข้อมูล)
    • ดู
      • HelpViewer (ใช้ DBAdapter เพื่อคายเอกสาร)

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

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

Leo Brodie ในหนังสือ "Thinking Forth" เขียนว่างานที่ยากที่สุดสำหรับโปรแกรมเมอร์คือการตั้งชื่อสิ่งต่าง ๆ ได้ดีและเขากล่าวว่าเครื่องมือการเขียนโปรแกรมที่สำคัญที่สุดคืออรรถาภิธาน

ลองใช้พจนานุกรมที่http://thesaurus.reference.com/

นอกเหนือจากนั้นอย่าใช้เครื่องหมายฮังการีเคยหลีกเลี่ยงตัวย่อและสอดคล้องกัน

ด้วยความปรารถนาดี

กล่าวโดยย่อ:
ฉันยอมรับว่าชื่อที่ดีมีความสำคัญ แต่ฉันไม่คิดว่าคุณจะต้องค้นหาชื่อเหล่านั้นก่อนดำเนินการทั้งหมด

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

ยาว:
โดยทั่วไปมักจะไม่คุ้มค่าที่จะคิดถึงชื่อนานเกินไปก่อนนำไปใช้ หากคุณใช้คลาสของคุณให้ตั้งชื่อเป็น "Foo" หรือ "Dsnfdkgx" ในขณะที่ใช้งานคุณจะเห็นสิ่งที่คุณควรตั้งชื่อ

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

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

ทำไมไม่ HelpDocumentServiceClient ชนิดคำหนึ่งหรือ HelpDocumentClient ... มันไม่สำคัญว่ามันจะเป็นผู้ขายประเด็นก็คือมันเป็นลูกค้าของเว็บเซอร์ที่จัดการกับเอกสารช่วยเหลือ

และการตั้งชื่อใช่ยาก

มีชื่อที่สมเหตุสมผลเพียงหนึ่งชื่อสำหรับคลาสนั้น:

HelpRequest

อย่าให้รายละเอียดการใช้งานเบี่ยงเบนความสนใจของคุณจากความหมาย

ลงทุนในเครื่องมือซ่อมบำรุงที่ดี!

ฉันยึดติดกับพื้นฐาน: VerbNoun (อาร์กิวเมนต์) ตัวอย่าง: GetDoc (docID)

ไม่จำเป็นต้องได้รับแฟนซี มันจะง่ายต่อการเข้าใจปีนับจากนี้ไม่ว่าจะเป็นคุณหรือคนอื่น

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

Intelisense มีอยู่สำหรับภาษาหลักทั้งหมด ดังนั้นเมื่อใช้ API ของบุคคลที่สามฉันชอบใช้ intelisense สำหรับเอกสารซึ่งต่างจากการใช้เอกสาร 'จริง'

โดยที่ในใจฉันสบายดีที่จะสร้างชื่อวิธีเช่น

StevesPostOnMethodNamesBeingLongOrShort

ยาว - แต่อะไรนะ วันนี้ใครไม่ใช้หน้าจอ 24 นิ้ว!

ฉันต้องยอมรับว่าการตั้งชื่อเป็นศิลปะ มันจะง่ายขึ้นเล็กน้อยถ้าคลาสของคุณทำตาม "รูปแบบ desigh" (โรงงาน ฯลฯ )

นี่คือหนึ่งในเหตุผลที่มีมาตรฐานการเข้ารหัส การมีมาตรฐานมีแนวโน้มที่จะช่วยหาชื่อเมื่อจำเป็น ช่วยเพิ่มความคิดของคุณในการใช้สิ่งที่น่าสนใจอื่น ๆ ! (-:

ฉันขอแนะนำให้อ่านบทที่เกี่ยวข้องของ Code Complete ( ลิงก์ Amazon ) ของ Steve McConnell ซึ่งมีกฎหลายข้อเพื่อช่วยเหลือการอ่านและการบำรุงรักษา

HTH

เสียงเชียร์

ปล้น

ไม่การดีบั๊กเป็นสิ่งที่ยากที่สุดสำหรับฉัน! :-)

DocumentFetcher? มันยากที่จะพูดโดยไม่มีบริบท

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

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

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

หากมีข้อสงสัยนอนบนมันและเลือกชื่อที่ชัดเจนที่สุดก่อนเช้าวันรุ่งขึ้น :-)

หากคุณตื่นขึ้นมาในวันหนึ่งและรู้ว่าคุณผิดแล้วให้เปลี่ยนมันทันที

พอล

BTW: Document.fetch () ค่อนข้างชัดเจน

ฉันพบว่าฉันมีปัญหามากที่สุดในตัวแปรท้องถิ่น ตัวอย่างเช่นฉันต้องการสร้างวัตถุประเภท DocGetter ดังนั้นฉันรู้ว่ามันคือ DocGetter ทำไมฉันต้องให้ชื่ออื่นกับมัน? ฉันมักจะจบลงด้วยการให้ชื่อเช่น dg (สำหรับ DocGetter) หรือ temp หรือบางสิ่งบางอย่างที่ไม่บรรยาย

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

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

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

ข้อเสนอแนะอย่างหนึ่งที่ฉันมีคือปรึกษาอรรถาภิธาน Word มีรูปแบบที่ดีเช่นเดียวกับ Mac OS X ที่สามารถช่วยฉันให้พ้นจากกลุ่มเมฆและทำให้ฉันเป็นสถานที่เริ่มต้นที่ดีและมีแรงบันดาลใจ

หากชื่อจะอธิบายตัวเองกับโปรแกรมเมอร์วางแล้วก็ไม่จำเป็นต้องเปลี่ยนมัน