การปฏิบัติตามกฎคำนamingใน Go อย่างเชี่ยวชาญ: คู่มือที่แสดงให้เห็นถึงความเป็นปฏิบัติ

1. เข้าใจวิธีการตั้งชื่อ

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

1.1. ทำไมการตั้งชื่อสำคัญ

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

1.2. กฎทั่วไปสำหรับการตั้งชื่อ

กฎการตั้งชื่อใน Go เป็นไปอย่างชัดเจนและมีอำนาจ:

• ใช้ชื่อสั้นและกระชับ: Go สนับสนุนการใช้ชื่อที่สั้นโดยเฉพาะสำหรับตัวแปรที่มีขอบเขตเล็ก ตัวอย่างเช่น i อาจถูกใช้สำหรับตัวนับลูป แต่ index หรือ counter สามารถถูกใช้หากต้องการความชัดเจนมากขึ้น

• ใช้ CamelCase สำหรับชื่อที่มีหลายคำ: เมื่อชื่อประกอบด้วยหลายคำ ให้ใช้การบ่งบอก CamelCase Exported names (ชื่อที่ควรสามารถเข้าถึงนอกแพ็คเกจ) ควรเริ่มต้นด้วยตัวพิมพ์ใหญ่ (MyFunction) ในขณะที่ชื่อภายในควรเริ่มต้นด้วยตัวพิมพ์เล็ก (myFunction)

• ใช้ชื่อที่มีความหมาย: ชื่อควรมีคำบรรยายอย่างพอเพียงเพื่อสื่อสารวัตถุประสงค์หรือการใช้งานโดยไม่ต้องเป็นเกินไป ตัวอย่างเช่น CalculateNetIncome ควรได้รับการความพิจารณามากกว่า CNI

• หลีกเลี่ยงการใช้ under_scores: ในทางตรงข้ามกับบางภาษา แนวคิดของ Go หลีกเลี่ยงการใช้ขีดล่างในชื่อ แทนของ record_count คุณควรใช้ recordCount

• ตัวย่อควรเป็นแบบเดียวกัน: เมื่อใช้ตัวย่อในชื่อ ให้เก็บมันในตัวอักษรเดียวกัน สำหรับชื่อที่เข้าถึงได้ให้ใช้ตัวพิมพ์ใหญ่ทั้งหมด (HTTPServer) และสำหรับชื่อภายในให้ใช้ตัวพิมพ์เล็กทั้งหมด (httpServer) เป็นการปฏิบัติที่มีความสากล

• ชื่อแพ็คเกจควรเป็นอย่างง่าย: ชื่อแพ็คเกจใน Go ถืออยู่ระดับง่ายและเป็นตัวพิมพ์เล็ก โดยไม่มีขีดล่างหรือ mixedCaps พวกเขาควรเป็นคำเดียวที่แสดงเจตคติของแพ็คเกจอย่างชัดเจน (net, os, json)

• การตั้งชื่อตัวแปรขึ้นอยู่กับประเภท: สำหรับตัวแปรที่แทนตัวอย่างของ struct จะใช้ชื่อของ struct เป็นชื่อตัวแปรโดยใช้ตัวพิมพ์เล็ก (var user User)

ต่อไปนี้คือตัวอย่างของโค้ด Go พร้อมความคิดเห็นที่อธิบายเรื่องวิธีการตั้งชื่อ:

package main

import "fmt"

type User struct {
    FirstName string
    LastName  string
    Age       int
}

func main() {
    var currentUser User // ใช้ชื่อ struct ในตัวแปรที่เริ่มด้วยตัวพิมพ์เล็ก
    currentUser.FirstName = "John"
    currentUser.LastName = "Doe"
    currentUser.Age = 30

    fmt.Println(formatUserDetails(currentUser))
}

// formatUserDetails รับ struct User เป็นอินพุทและคืนค่าเป็นสตริงรูปแบบกลับ
// ชื่อฟังก์ชันเริ่มด้วยตัวพิมพ์เล็กเนื่องจากมันไม่ถูกส่งออก (เป็นส่วนตัว)
func formatUserDetails(u User) string {
    return fmt.Sprintf("Name: %s %s, Age: %d", u.FirstName, u.LastName, u.Age)
}

การปฏิบัติตามกฎการตั้งชื่อเหล่านี้จะทำให้คุณมีโค้ด Go ที่มีคุณภาพดีมาก โดยทำให้มันอ่านง่ายและสามารถบำรุงรักษาได้

2. ตัวระบุใน Go

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

2.1. กฎการตั้งชื่อตัวแปร

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

Best Practices:

• ใช้ชื่อที่สั้นและแจ่มแจ้ง
• ขึ้นต้นด้วยตัวพิมพ์เล็กสำหรับขอบเขตระดับแพ็คเกจ
• ใช้ CamelCase สำหรับชื่อที่มีหลายคำ ( เช่น totalAmount )
• สำหรับตัวแปรที่สามารถเข้าถึงได้ภายนอกแพ็คเกจ ให้ขึ้นต้นด้วยตัวพิมพ์ใหญ่

ตัวอย่าง:

var userName string // ตัวแปรที่ไม่ได้ส่งออก
var UserAge int     // ตัวแปรที่ส่งออก

ความเห็นในโค้ดอธิบายการแตกต่างระหว่างตัวแปรที่ส่งออกและไม่ส่งออก

2.2. มารยาทในการตั้งชื่อฟังก์ชัน

การตั้งชื่อใน Go ของฟังก์ชันจะเป็นตามกฎเดียวกันกับตัวแปร ชื่อควรสะท้อนวัตถุประสงค์ของฟังก์ชัน และขอบเขตของมันจะกำหนดตัวอักษรตัวแรก

Best Practices:

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

Example:

func calculateTotal(price int, quantity int) int { // ฟังก์ชันภายใน
    return price * quantity
}

func CalculateDiscount(totalPrice int) float64 { // ฟังก์ชันที่ส่งออก
    return totalPrice * 0.1
}

ความคิดเห็นอธิบายถึงความเข้าถึงของฟังก์ชันขึ้นอยู่กับเคสและให้ความคิดฉลาดสั้นๆ เกี่ยวกับวัตถุประสงค์ของมัน

2.3. มารยาทในการตั้งชื่อค่าคงที่

ค่าคงที่เป็นค่าที่ไม่เปลี่ยนแปลงได้เมื่อกำหนดรายละเอียดแล้ว ใน Go ค่าคงที่ถูกประกาศโดยใช้คีย์เวิร์ด const และสามารถเป็นตัวอักษร สตริง บูลีน หรือค่าตัวเลข

Best Practices:

• ใช้ตัวอักษรทั้งหมดเป็นตัวใหญ่พร้อมกับขีดล่างสำหรับการแยก (เช่น MAX_LIMIT)
• สำหรับค่าคงที่ที่เป็นเลขเรียง ให้ใช้ตัวกำหนด iota
• ค่าคงที่ที่ส่งออกควรขึ้นต้นด้วยตัวอักษรใหญ่

Example:

const MAX_RETRY_COUNT int = 3 // ค่าคงที่ที่ส่งออก

type ByteSize float64
const (
    _           = iota // ละเว้นค่าแรกโดยการกำหนดให้ตัวแปรเป็นชื่อไม่มีบทบาท
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
    TB
)

ตัวอย่างแสดงถึงการกำหนดค่าคงที่อย่างง่ายและชุดค่าคงที่ที่เกี่ยวข้องโดยใช้ iota สำหรับขนาดไบต์

3. มารยาทการตั้งชื่อสำหรับประเภทต่างๆ

บทนี้เน้นไปที่มาตรฐานในการตั้งชื่อประเภทต่างๆ เช่น สตรัคต์ และอินเทอร์เฟซ

3.1. แนวทางในการตั้งชื่อสำหรับสตรัคต์

ภาพรวม: สตรัคต์ใน Go แทนด้วยประเภทข้อมูลที่รวมกันตัวแปร ในขณะที่ตั้งชื่อสตรัคต์ให้ใช้ชื่อที่อธิบายสิ่งที่พวกมันแทนในรูปแบบ PascalCase ซึ่งเริ่มต้นด้วยตัวอักษรใหญ

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

// ดี
type Employee struct {
    ID        int
    FirstName string
    LastName  string
    Position  string
}

• ควรหลีกเลี่ยง: การใช้ชื่อที่กำกวมหรือทั่วไปซี่ไม่สื่อถึงวัตถุประสงค์ของสตรัคต์

// ควรหลีกเลี่ยง
type Data struct {
    ID        int
    FirstName string
    LastName  string
    Position  string
}

3.2. แนวทางในการตั้งชื่อสำหรับอินเทอร์เฟซ

ภาพรวม: อินเทอร์เฟซใน Go ระบุชุดของเมทอด และตั้งชื่อโดยใช้ชื่ออธิบายที่สุดท้ายด้วยคำส่งลงท้ายด้วย 'er' หากเหมาะสม

• การใช้จรรยาบรรณที่ดี: ตั้งชื่ออินเทอร์เฟซตามพฤติกรรมที่มันชื่นชอบ โดยทั่วไปถ้าอินเทอร์เฟซมีเพียงเมทอดเดียว ชื่อควรสะท้อนพฤติกรรมของเมทอดนั้นรวมทั้งเออร์เองลงท้ายด้วย '-er'

// ดี
type Reader interface {
    Read(p []byte) (n int, err error)
}

• การตั้งชื่อชุดของพฤติกรรม: หากอินเทอร์เฟซแทนชุดของพฤติกรรม ให้เลือกชื่อที่สะท้อนวัตถุประสงค์ของมันโดยไม่ต้องเออร์ลงท้ายด้วย 'er'

// ตัวอย่างของชุดของพฤติกรรม
type Filesystem interface {
    ReadFile(path string) ([]byte, error)
    WriteFile(path string, data []byte) error
}

4. ความอคติและการใช้ตัวบ่งชี้แบบตัวพิมพ์

4.1. ชื่อที่ส่งออกกับชื่อที่ไม่ส่งออก

ใน Go การเห็นขอบเขตของตัวบ่งชี้ของตัวเองอยู่ในแพ็คเกจของมันเองจะได้รับการกำหนดโดยตัวอักษรของตัวแรก ตัวบ่งชี้ที่ขึ้นต้นด้วยตัวอักษรใหญ่ถูกเรียกว่า 'ส่งออก' หมายความว่ามันสามารถเข้าถึงได้จากแพ็คเกจอื่น ๆ โดยการนำแพ็คเกจ 'geometry' มาใช้ ในขณะเดียวกัน ตัวบ่งชี้ที่ขึ้นต้นด้วยตัวอักษรเล็กถูกเรียกว่า 'ไม่ส่งออก' หรือส่วนตัว และพวกมันสามารถเข้าถึงได้เฉพาะในแพ็คเกจของมันเอง

ตัวอย่าง:

package geometry

// ตัวบ่งชี้ที่ส่งออก
type Rectangle struct {
    Length, Width float64
}

// ตัวบ่งชี้ที่ไม่ส่งออก
type point struct {
    x, y float64
}

ในตัวอย่างนี้ Rectangle เป็นชนิดที่ส่งออกเพราะเริ่มต้นด้วยตัวอักษรใหญ่และสามารถใช้ได้จากแพ็คเกจอื่นๆ ที่นำแพ็คเกจ geometry มาใช้ กลับกัน point เป็นชนิดที่ไม่ส่งออกและสามารถใช้ได้เฉพาะในแพ็คเกจ geometry เท่านั้น

4.2. ปฏิบัติที่ดีสำหรับตัวแสดงที่ส่งออก

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

• ความชัดเจนกว่าความกระชับ: เลือกใช้ชื่อที่ชัดเจนและเกรงกว่าชื่อที่สั้นและลับ ตัวอย่างเช่น CalculateArea นั้นถือว่าดีกว่า CalcA.
• คงเดิม: ทำให้รูปแบบการตั้งชื่อเหมือนกันไปทั่วทั้งรหัสของคุณ หากคุณเริ่มต้นตั้งชื่อสิ่งที่คล้ายคลึงกันด้วยรูปแบบบางตัว คงให้มัน.
• หลีกเลี่ยงความซ้ำซ้อน: อย่าทำซ้ำชื่อแพ็คเกจในชื่อตัวแสดง เช่น ใช้ geometry.Rectangle แทน geometry.GeometryRectangle.
• พิจารณาบริบท: ชื่อของตัวแสดงควรมีความหมายในบริบทที่พวกเขาถูกใช้ หลีกเลี่ยงชื่อที่อาจทำให้สับสนหรือกำกวม.
• คำอธิบายด้วยความคิด: ใช้คำอธิบายเพื่อเอกสารบันทึกตัวแสดงที่ส่งออก อธิบายว่าพวกเขาทำอะไรและควรถูกใช้อย่างไร.

ตัวอย่าง:

package geometry

// CalculateArea คืนค่าพื้นที่ของสี่เหลี่ยม.
func (r Rectangle) CalculateArea() float64 {
    return r.Length * r.Width
}

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

5. การตั้งชื่อตามประสบการณ์ในการใช้งาน

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

5.1. ข้อบกพร่องที่พบบ่อยและวิธีหลีกเลี่ยง

การตั้งชื่อตัวแปร ฟังก์ชัน และตัวแสดงอื่น ๆ มักถูกประมาณมูลค่าการใช้งานของมัน ข้อผิดพลาดที่พบบ่อยได้แก่:

• ใช้ชื่อที่ทั่วไป: ชื่อเช่น data หรือ info ไม่เป็นทางการและสามารถทำให้สับสน.
• ชื่อยาวเกินไป: ถึงแม้จะเป็นชื่อที่ให้คำอธิบายได้ดี ยาวมากเกินไปอาจทำให้ลำบาก ควรหาสมดุล.
• ขีดล่างในตัวแสดงหลายคำ: Go ชอบใช้ camelCase สำหรับชื่อตัวแปรและ PascalCase สำหรับฟังก์ชันที่ถูกส่งออก และประเภท.
• รูปแบบการตั้งชื่อที่ไม่สัมพันธ์กัน: ความสม่ำเสมอในรูปแบบการตั้งชื่อช่วยในการเข้าใจโค้ดโครงสร้างอย่างรวดเร็ว.

เคล็ดลับในการหลีกเลี่ยงข้อบกพร่องเหล่านี้:

• ใช้ชื่อที่กระชับและให้คำอธิบายได้ชัดเจน เช่น แทนที่จะใช้ data ให้ใช้ userData หากมีข้อมูลเกี่ยวกับผู้ใช้.
• ปฏิบัติตามแนวทางการใช้ไฟกโรของ Go สำหรับคำย่อ ให้เก็บไว้ในตัวพิมพ์ใหญ่ เช่น HTTPServer แทน HttpServer.
• สำหรับตัวแปรและค่าคงที่ในแพ็คเกจที่ไม่ได้ส่งออก ตั้งใช้ชื่อที่สั้นเพราะมันมีขอบเขตของความคาดหวัง.

5.2. การเปลี่ยนชื่อใหม่เพื่อปรับปรุง

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

1. ใช้ชื่อที่ให้คำอธิบายได้: เปลี่ยนชื่อให้ชัดเจนว่ามันแทนอะไรหรือทำอะไร ตัวอย่างเช่น เปลี่ยนชื่อฟังก์ชันจาก Process เป็น ProcessUserInput หากมันทำงานเช่นนั้น.
2. ใช้เครื่องมือ: ใช้เครื่องมือเช่น gorename ซึ่งช่วยในการเปลี่ยนชื่ออย่างปลอดภัยโดยการวิเคราะห์รหัส Go โดยการเขียนข้อความ.
3. ทบทวนกับเพื่อนร่วมงาน: บางครั้งสิ่งที่มันเข้าใจสำหรับคุณอาจไม่ชัดเจนสำหรับผู้อื่น การทบทวนด้วยเพื่อนร่วมงานสามารถช่วยในการระบุชื่อที่กำกวม.
4. เปลี่ยนไปตามคำแนะนำ: หลังจากที่ทำการเปลี่ยนแล้วรวบรวมคำแนะนำจากผู้ใช้งานของโค้ดและเปลี่ยนไปตามคำแนะนำเพิ่มเติมหากจำเป็น.

โดยการปฏิบัติตามเทคนิคเหล่านี้ คุณจะทำให้รหัส Go ของคุณยังคงสะอาด และรักษาได้อย่างเห็นใจและสามารถบำรุงรักษาได้.