నామకరణ సంప్రదాయాలు మరియు శైలి

Goలో బలమైన మరియు నాన్-నెగోషియబుల్ పేరు మరియు శైలి సంప్రదాయాలు ఉన్నాయి: అధికారిక ఫార్మాట్ gofmt (మరియు దాని సూపర్‌సెట్ goimports) ఇండెంటేషన్, అంతరం మరియు దిగుమతి క్రమాన్ని నిర్ణయిస్తుంది. చర్చా శైలి ఆఫ్-టాపిక్‌గా పరిగణించబడుతుంది: మీరు gofmt -wని అమలు చేసి, కొనసాగండి. ఇది మరింత ఆసక్తికరమైన సమస్యల కోసం శక్తిని విడుదల చేస్తుంది.

దృశ్యమానత: పెద్ద అక్షరం లేదా చిన్న అక్షరం

public/private కీలకపదాలు లేవు. పేరులోని మొదటి అక్షరం దృశ్యమానతను నిర్ణయిస్తుంది:

• పెద్ద అక్షరం → ప్యాకేజీ వెలుపల ఎగుమతి చేయబడింది (User, Login, MaxRetries).
• చిన్న అక్షరం → ప్యాకేజీకి ప్రైవేట్ (user, parseLine, defaultTimeout).

ఇది వర్తిస్తుంది: రకాలు, విధులు, పద్ధతులు, వేరియబుల్స్, స్థిరాంకాలు, స్ట్రక్ట్ ఫీల్డ్‌లు.

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

encoding/json (మాడ్యూల్ 8 చూడండి) ద్వారా "ప్రైవేట్" స్ట్రక్ట్ ఫీల్డ్ ** సీరియల్ చేయబడలేదు మరియు ఇది 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 {}