பெயரிடும் மரபுகள் மற்றும் பாணி

Go இல் வலுவான மற்றும் பேச முடியாத பெயரிடுதல் மற்றும் நடை மரபுகள் உள்ளன: அதிகாரப்பூர்வ வடிவமைப்பான gofmt (மற்றும் அதன் சூப்பர்செட் goimports) உள்தள்ளல், இடைவெளி மற்றும் இறக்குமதி வரிசையை தீர்மானிக்கிறது. விவாதிக்கும் நடை தலைப்பிற்கு அப்பாற்பட்டதாகக் கருதப்படுகிறது: நீங்கள் gofmt -w ஐ இயக்கி, தொடரவும். இது மிகவும் சுவாரஸ்யமான சிக்கல்களுக்கு ஆற்றலை விடுவிக்கிறது.

தெரிவுநிலை: பெரிய எழுத்து அல்லது சிறிய எழுத்து

public/private முக்கிய வார்த்தைகள் இல்லை. பெயரின் முதல் எழுத்து தெரிவுநிலையை தீர்மானிக்கிறது:

• பெரிய எழுத்து → தொகுப்புக்கு வெளியே ஏற்றுமதி செய்யப்பட்டது (User, Login, MaxRetries).
• சிற்றெழுத்து → தொகுப்பிற்குத் தனிப்பட்டது (user, parseLine, defaultTimeout).

இது பொருந்தும்: வகைகள், செயல்பாடுகள், முறைகள், மாறிகள், மாறிலிகள், struct புலங்கள்.

type User struct {
    Name  string  // exported
    email string  // private to the package
}

encoding/json (தொகுதி 8 ஐப் பார்க்கவும்) ஆல் "தனிப்பட்ட" struct புலம் ** வரிசைப்படுத்தப்படவில்லை, மேலும் pkg_test இல் உள்ள சோதனைகளில் இருந்து அதை அணுக முடியாது.

ஒட்டகம், ஒருபோதும் பாம்பு_உறை

பல வார்த்தைகளின் பெயர்களில் அடிக்கோடிட்டுகள் இல்லை:

• ✅ HTTPClient, userName, parseRequest
• ❌ Http_Client, user_name, parse_request

** சுருக்கெழுத்துகள் அனைத்தும் பெரிய எழுத்து** (அல்லது அனைத்து சிறிய எழுத்துக்களும், தனிப்பட்ட நோக்கத்தில் இருந்தால்):

• ✅ URL, ID, HTML, JSON, parseURL, userID
• ❌ Url, Id, Html, Json, parseUrl, userId

type APIResponse struct {
    UserID  int
    HTMLURL string
}

குறுகிய நோக்கங்களுக்கான குறுகிய பெயர்கள்

கோ பாணியானது சமமான தெளிவில் குறுகிய நோக்கங்களில்

// idiomatic
for i, v := range items { ... }
for k, v := range m { ... }

if err := f(); err != nil { ... }

func (s *Server) Serve(w http.ResponseWriter, r *http.Request) { ... }

நிறுவப்பட்ட மரபுகள்:

• லூப் குறியீடுகளுக்கு i, j, k.
• மதிப்புகளுக்கு v, விசைகளுக்கு k.
• r *Request/io.Reader, w Writer/ResponseWriter.
• err பிழைகளுக்கு.
• context.Contextக்கு ctx.
• முறை பெறுநர்கள்: முழு வகையிலும் 1–2 சீரான எழுத்துக்கள் (s *Server, u *User). ஒருபோதும் this அல்லது self.

பரந்த நோக்கம், பெயர் இன்னும் விளக்கமாக இருக்க வேண்டும்: உள்ளூர் count பரவாயில்லை, ஆனால் ஏற்றுமதி செய்யப்பட்ட Count மாறி அது என்ன கணக்கிடுகிறது என்பதை உங்களுக்குத் தெரிவிக்கும்.

இடைமுகங்களில் "I" முன்னொட்டு இல்லை, "Impl" பின்னொட்டு இல்லை

// idiomatic
type Reader interface { ... }
type fileReader struct { ... } // concrete implementation

// not idiomatic
type IReader interface { ... }
type ReaderImpl struct { ... }

சிறிய இடைமுகங்கள் பெரும்பாலும் -er பின்னொட்டு: Reader, Writer, Stringer, Closer. அவர்கள் ஒரு நடத்தை (ஒரு முறை, சிறந்த முறையில்) விவரிக்கும் உண்மையை இது எதிரொலிக்கிறது.

தொகுப்பு பெயர்கள்

ஒரு தொகுப்பில் ஒரே பெயர், குறுகிய, எல்லா சிற்றெழுத்து, அண்டர்ஸ்கோர் இல்லை:

• ✅ bytes, http, os, userauth
• ❌ userAuth, user_auth, UserAuth

தொகுப்பின் பெயர் அதன் குறியீடுகளின் பயன்பாட்டு முன்னொட்டு ஆகும்: bytes.Buffer, http.Client. எனவே user.User தேவையற்றது: வகை (user.Account) அல்லது தொகுப்பை மறுபெயரிடுவது நல்லது.

gofmt விவாதத்திற்கு இல்லை

gofmt செயல்படுத்துகிறது:

• தாவல்கள் (இடைவெளிகள் அல்ல) உடன் உள்தள்ளல்
• கையொப்பத்தின் அதே வரியில் { பிரேஸ் செய்யவும்.
• வெற்று வரியால் பிரிக்கப்பட்ட குழுக்களில் இறக்குமதி; goimports விடுபட்ட இறக்குமதிகளையும் சேர்க்கிறது.
• ஆபரேட்டர்களைச் சுற்றியுள்ள இடங்கள்.

செய்வதற்கு முன் எப்போதும் இயக்கவும்:

go fmt ./...
goimports -w .
go vet ./...

லிண்டர்கள் (staticcheck, golangci-lint) கூடுதல் விதிகளைச் சேர்க்கின்றன (பயன்படுத்தாத மாறிகள், நிழல், பயனற்ற ஒப்பீடுகள், ...).

பயிற்சிகள்

type ??? struct {}