गोलैंग नामकरण सम्मेलनों की महारत: एक व्यावहारिक गाइड

1. नामकरण समझना

नामकरण कार्यक्रमों के विकास में अत्यंत महत्वपूर्ण है, क्योंकि यह आपको अपने चर, फ़ंक्शंस, और अन्य पहचानकर्ताओं के नामकरण के लिए एक संरूपित और वर्णनात्मक तरीके से प्रदान करते हैं। गो (जीके और गोलैंग के रूप में अक्सर संदर्भित) में स्थापित नामकरण सांस्कृतिक का पालन न केवल आपके कोड को पढ़ने और बनाए रखने में सहायता करता है बल्कि यह भी उन्हें (और आपके भविष्य के आप) आपके कोडबेस पर कम टकराव के साथ समझने और सहयोग करने की अनुमति देता है।

1.1. नामकरण का महत्व

किसी भी प्रोग्रामिंग भाषा में, आपके पहचानकर्ताओं को नाम देने का तरीका आपके कोड की समझ और रखरखाव को बहुत प्रभावित कर सकता है। गो, जो सरलता और स्पष्टता पर जोर देता है, में उचित नामकरण भी अधिक महत्वपूर्ण है। जिन नामों से किसी चर या फ़ंक्शन का उद्देश्य स्पष्ट रूप से दिखाता है, उन्हें अतिरिक्त टिप्पणियों की आवश्यकता कम करती है और कोड स्वयं-दस्तावेजिकरण बना देती है। आगे बढ़ने के लिए यह महत्वपूर्ण है, और टीम सहयोग को आसान बनाने के लिए।

1.2. नामकरण के लिए सामान्य नियम

गो के नामकरण नियम सरल लेकिन शक्तिशाली हैं:

• छोटे, संक्षिप्त नाम का उपयोग करें: गो ने छोटे नामों का प्रोत्साहन किया है, विशेष रूप से छोटे स्कोप वाले चरों के लिए। उदाहरण के लिए, i का उपयोग लूप काउंटर के लिए किया जा सकता है, लेकिन यदि अधिक स्पष्टता की आवश्यकता होती है तो index या counter का उपयोग किया जा सकता है।

• बहुसंख्याक नामों के लिए CamelCase: जब एक नाम कई शब्दों से बना हो, तो CamelCase की नोटेशन का उपयोग करें। निर्यातित नामों के लिए (जो पैकेज के बाहर से पहुँचने योग्य हों) एक कैपिटल अक्षर से शुरू होना चाहिए (MyFunction), जबकि आंतरिक नामों को एक छोटे अक्षर से शुरू करना चाहिए (myFunction)।

• अर्थपूर्ण नाम का उपयोग करें: नाम इतना वर्णनात्मक होना चाहिए कि वे अपने उद्देश्य या उपयोग को बयां कर सकें बिना अत्यधिक व्यर्थ के होने। उदाहरण के लिए, CalculateNetIncome को CNI की तुलना में पसंद किया जाता है।

• अंडरस्कोर से बचें: कुछ भाषाओं की तुलना में, गो संस्कृति नामों में अंडरस्कोर का उपयोग नहीं करती। इसके बजाय record_count की बजाय recordCount का उपयोग किया जाता है।

• संक्षिप्त रूप से यक्ष्मिक होना चाहिए: गो में पैकेज नामों को सरल और लोअरकेस रखा जाता है, कोई अंडरस्कोर या मिश्रित कैप्स नहीं होते हैं। वे एक शब्द होना चाहिए जो स्पष्टता से पैकेज के उद्देश्य को प्रतिनिधित्व करता है (net, os, json)।

• प्रकार पर आधारित चर का नामकरण: स्ट्रक्ट्स की उदाहरणों को प्रतिनिधित्व करने वाले चरों के लिए, धारी के लिए स्ट्रक्ट के नाम का लोअरकेस में यूज करना सामान्य है (var user User).

यहां एक उदाहरण है गो कोड का, जिसमें टिप्पणियाँ स्पष्ट करती हैं कि नामकरण के चयन का तरीका:

package main

import "fmt"

type User struct {
    FirstName string
    LastName  string
    Age       int
}

func main() {
    var currentUser User // चर का नाम धारी के रूप में लोअरकेस का उपयोग करते हुए।
    currentUser.FirstName = "John"
    currentUser.LastName = "Doe"
    currentUser.Age = 30

    fmt.Println(formatUserDetails(currentUser))
}

// formatUserDetails को एक यूजर स्ट्रक्ट के रूप में इनपुट लेता है और एक स्वरूपित स्ट्रिंग वापस करता है।
// चर का नाम रिक्त नहीं किया गया है क्योंकि यह  न रिपोर्ट किया गया है (निजी)।
func formatUserDetails(u User) string {
    return fmt.Sprintf("नाम: %s %s, आयु: %d", u.FirstName, u.LastName, u.Age)
}

इन नामकरण सांस्कृतिकों का पालन करने से आपके गो कोड की गुणवत्ता को बहुत बेहतर बनाएगा, क्योंकि इससे वह पढ़ने और रखने लायक हो जाएगा।

2. गो में पहचानकर्ताओं

गो के साथ अपना सफर शुरू करते समय, पहचानकर्ताओं की भूमिका को समझना महत्वपूर्ण है। पहचानकर्ताएं नाम हैं जो आप अपने कोड में विभिन्न तत्वों को देते हैं, जैसे कि चर, फ़ंक्शन, और स्थिर। मायनफुल और संरचित नामों का चयन करने से आपका कोड पढ़ने और रखने में अधिक सहायक होता है।

2.1. गो में चर नामकरण संस्कृतियाँ

गो में, चरों के नाम एक अक्षर या अंडरस्कोर से शुरू होना चाहिए, जिसके बाद कोई भी अक्षर, अंक, या अंडरस्कोर का कोई भी संरचना हो सकती है। हालांकि, अंडरस्कोर से शुरू करने की सलाह नहीं है क्योंकि यह अक्सर विशेष उपयोग के लिए संरक्षित होता है।

बेहतर संकेत:

• संक्षेपणीय और वर्णनात्मक नाम का उपयोग करें।
• पैकेज स्तर पर छोटे, वर्णनात्मक नाम का उपयोग करें।
• बहु शब्दित नामों के लिए camelCase का प्रयोग करें (जैसे, totalAmount)।
• निर्यात किए गए चरों के लिए (पैकेज के बाहर से पहुँचने योग्य हों) ऊपर की ओर के लेख का उपयोग करें।

उदाहरण:

var userName string // गोपनीय चर
var UserAge int     // निर्यात किए गए चर

कोड में टिप्पणियां निर्यात और गोपनीय चरों के बीच अंतर को स्पष्ट करती है।

2.2. कार्य नामकरण नियम

Go में फ़ंक्शनों का नाम चरमपर्यायों को अनुसरण करता है। नाम को फ़ंक्शन का उद्देश्य प्रतिबिम्बित करना चाहिए, और इसके scope का पहला अक्षर केस निर्धारित करता है।

सर्वोत्तम अभ्यास:

• वहा विवरणशील नाम का प्रयोग करें जो फ़ंक्शन के उद्देश्य को प्रतिबिम्बित करता है।
• आंतरिक फ़ंक्शनों के लिए पहला अक्षर लोअर-केस के साथ शुरू करें।
• निर्यात किए जाने वाले फ़ंक्शनों के लिए पैस्कल केस का प्रयोग करें (ऊपरी-केस के अक्षर से शुरू होता है)।
• फ़ंक्शन के नाम संक्षेपणमय परन्तु महत्वपूर्ण रखें।

उदाहरण:

func calculateTotal(price int, quantity int) int { // आंतरिक फ़ंक्शन
    return price * quantity
}

func CalculateDiscount(totalPrice int) float64 { // निर्यात किया गया फ़ंक्शन
    return totalPrice * 0.1
}

टिप्पणियाँ फ़ंक्शन की पहुंच के आधार पर उसके साथ मीटी हुई हैं और उसके उद्देश्य में संक्षेप्त अंदाज में एक संक्षेप्त अंदाज प्रदान करती हैं।

2.3. स्थिर नामकरण नियम

स्थिर मान आपूर्ण मान होते हैं, जो एक बार परिभाषित कर दिये जाने पर बदला नहीं जा सकता है। Go में, स्थिरों को const की शब्दावली का प्रयोग करके संज्ञात किया जाता है और वे वर्ण, स्त्रिंग, बूलियन, या सांख्यिक मान हो सकते हैं।

सर्वोत्तम अभ्यास:

• अंडरस्कोर के साथ सभी ऊपरी-केस अक्षरों का प्रयोग करें (उदा। MAX_LIMIT के रूप में)।
• अचिन्हित स्थिरों के लिए, iota enumerator का प्रयोग करें।
• निर्यात किए जाने वाले स्थिरों को ऊपरी-केस के अक्षर से शुरू करें।

उदाहरण:

const MAX_RETRY_COUNT int = 3 // निर्यात किया गया स्थिर

type ByteSize float64
const (
    _           = iota // पहले मान को ब्लैंक पहचानकर निराकरण करें
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
    TB
)

उदाहरण में दिखाया गया है कि सरल स्थिरों और iota का प्रयोग करके संबंधित स्थिरों का समूह कैसे परिभाषित किया जाता है।

3. प्रकारों के लिए नामकरण नियम

इस अध्याय में विभिन्न प्रकारों जैसे स्ट्रक्ट्स और इंटरफ़ेसेज के लिए नामकरण के मानकों पर ध्यान केंद्रित किया गया है।

3.1. स्ट्रक्ट्स नामकरण मार्गदर्शिकाएँ

अवलोकन: Go में स्ट्रक्ट्स औपाधिक डेटा प्रकारों को प्रतिनिधित करते हैं। स्ट्रक्ट्स को नामकरण करते समय, पहले अक्षर की पास्कलकेस का प्रयोग करें, जो एक ऊपरी-केस अक्षर से आरंभ होता है।

• अच्छा अभ्यास: ऐसे स्ट्रक्ट्स को नाम दें जिनमें क्लीरली व्यक्त किया गया हो कि वे क्या प्रतिनिधित करते हैं। उदाहरण के लिए:

// अच्छा
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 में इंटरफ़ेसेज मेथड सेट को निर्धारित करती हैं और उन्हें वहाँ बहुतायती वाले नामों के साथ संवर्धित किया जाता है जदी यह संविदा बनता है।

• अच्छा अभ्यास: इंटरफेसेजों को उनकी वास्तविकता को आभास कराने के लिए नाम दें। सामान्यत: यदि एक इंटरफेस केवल एक मेथड को संवर्धित करता हो तो, नाम को उस मेथड की क्रिया को प्रतिबिम्बित करना चाहिए समेत एक '-र' संधि का प्रयोग करके।

// अच्छा
type Reader interface {
    Read(p []byte) (n int, err error)
}

• व्यवहारों का संग्रह नामकरण: यदि एक इंटरफेस व्यवहारों का संग्रह प्रतिपादित करता है, तो उसके उद्देश्य को 'र' संधि के बिना प्रतिबिम्बित करने वाला नाम चुनें।

// व्यवहारों का संग्रह उदाहरण
type Filesystem interface {
    ReadFile(path string) ([]byte, error)
    WriteFile(path string, data []byte) error
}

4. मामूली और निर्यात किए गए पहचानकरण के लिए मामूली और निर्यात किए गए पहचानकरण

4.1. निर्यातित और अननियोक्त नाम

Go में, एक पहचानकरण की प्रत्यक्षता अपनी खुद की पैकेज के बाहर की अपनी प्रतिभुता के आधार पर उसके पहले अक्षर के केस द्वारा निर्धारित होती है। एक पहचानकरण जो ऊपरी-केस अक्षर से शुरू होता है, 'निर्यात किया गया' होता है, जिसका अर्थ है कि उसे अन्य पैकेज से पहुंचा जा सकता है। यह अन्य प्रोग्रामिंग भाषाओं में सार्वजनिक दृष्टिकोण के समान होता है। वहीं, अंकों के साथ प्रारंभ होने वाले नाम 'निपुण' या निजी होते हैं, और वे केवल अपने ही पैकेज के भीतर ही पहुंचे जा सकते हैं।

उदाहरण:

package geometry

// निर्यातित पहचानकरण
type Rectangle struct {
    Length, Width float64
}

// निपुण पहचानकरण
type point struct {
    x, y float64
}

इस उदाहरण में, Rectangle एक निर्यातित प्रकार है क्योंकि इसमें ऊपरी-केस अक्षर से शुरू होता है और इसका प्रयोग उन पैकेजों के द्वारा किया जा सकता है जो geometry पैकेज को आयात करते हैं। परंतु, point प्रकार अनियत किया गया है और केवल geometry पैकेज के भीतर ही प्रयोग किया जा सकता है।

4.2. निर्यात किए गए पहचानकर्ताओं के लिए सर्वोत्तम प्रथाएं

पहचाने गए पहचानकर्ताओं के नामकरण के समय, दूसरों द्वारा आपके कोड को पठनीय और समझनीय बनाए रखने के लिए कुछ सर्वोत्तम प्रथाओं का पालन करना आवश्यक है:

• स्पष्टता बड़ी छोटेपन से अधिक महत्वपूर्ण है: छोटे और पहेलुजीपूर्ण नामों की बजाय स्पष्ट और वर्णित नाम चुनें। उदाहरण के लिए, क्षेत्रफल_की_गणना गणित_क्षेत्र की तुलना में पसंद की जाती है।
• संगतता: अपने कोडबेस में नामकरण संस्कृतियों के साथ संगत रहें। यदि आप किसी विशिष्ट पैटर्न के साथ समान प्रकार की इकाइयों का नामकरण करने लगते हैं, तो उनका पालन करें।
• अतिरिक्तता से बचें: पहचानकर्ताओं के नाम में पैकेज के नामों की दोहराव न करें। उदाहरण के लिए, geometry.GeometryRectangle की बजाय geometry.Rectangle का प्रयोग करें।
• परिस्थिति को ध्यान में रखें: पहचानकर्ताओं के नाम परिस्थितियों में समझदारी से प्रयोग करना चाहिए। भ्रांति से बचने के लिए उन नामों से बचें जो भ्रांतिकरक या अस्पष्ट हो सकते हैं।
• प्रलेखन टिप्पणियाँ: प्रलेखन वाले पहचानकर्ताओं को प्रलेखन करने के लिए प्रलेखन टिप्पणियों का प्रयोग करें, जिसमें वह यह बताएं कि वे क्या करते हैं और वे कैसे प्रयोग किए जाने चाहिए।

उदाहरण:

package geometry

// CalculateArea एक आयत का क्षेत्रफल लौटाता है।
func (r Rectangle) CalculateArea() float64 {
    return r.Length * r.Width
}

इस उदाहरण में, CalculateArea एक प्रकाशित फ़ंक्शन है जिसमें एक स्पष्ट, वर्णनात्मक नाम है जिसमें उसका उद्देश्य स्पष्ट करने वाली एक प्रलेखन टिप्पणी शामिल है।

5. अमल में नामकरण की प्रथाएँ

इस अध्याय में, हम असली दुनियावी स्थितियों में Go नामकरण की प्रथाओं का अनुप्रयोग करेंगे। इन प्रथाओं को समझना और उनका पालन करना महत्वपूर्ण है क्योंकि यह सुनिश्चित करता है कि आपका कोड आदिष्टता, पठनीय और रखनीय हो।

5.1. सामान्य गड़बड़ियों और उन्हें टालने के कैसे

सामान्यत: चूंकि प्रतिभूतियों, फ़ंक्शन्स, और अन्य पहचानकर्ताओं का नाम होद में नुकसान का स्रोत होता है। सामान्य गड़बड़ियों में इनमें शामिल हैं:

• सामान्य नामों का प्रयोग: डाटा या जानकारी जैसे नाम वर्णनात्मक नहीं होते और भ्रांति का कारण बन सकते हैं।
• अत्यधिक लम्बे नाम: जबकि वर्णनात्मक नाम अच्छे होते हैं, अत्यधिक व्यापक नामों को बोझ समझा जा सकता है। संतुलन बनाए रखें।
• ज्यामिति वाले कुल शब्द वाले पहचानकर्ताओं में अंतर्दायित्व: Go के वेरिएबल नामों के लिए कैमल केस का प्रयोग और निर्यातित फ़ंक्शन्स और प्रकार के लिए पैस्कल केस का प्रयोग करता है।
• असंगत नाम के पैटर्नों में अंतर्दायित्व: नामकरण की नियमितता नामकरण के नियम से समझ करने में मदद करती है।

इन बाधाओं से बचने के लिए टिप्स:

• संक्षेप और विवरणात्मक नाम का प्रयोग करें। उदाहरण के लिए, डेटा के बजाय, प्रयोक्ताजनित_डेटा का प्रयोग करें अगर उसमें प्रयोक्ताओं के बारे में जानकारी है।
• अक्रोनायमों के लिए Go की प्रवृत्ति का पालन करें; उन्हें ऊपर केस में रखें, जैसे HTTPServer बजाय HttpServer।
• निर्यात किए गए पैकेज स्तरीय वेरिएबल्स और स्थिरों के लिए, उनके नामों को संक्षेपित रखें क्योंकि उनका सीमित दायरा होता है।

5.2. बेहतर नामों के लिए पुनरावलोकन

पहचानकर्ताओं के नामों को सुधारने के लिए कोड के पुनरावलोकन से कोड पठ्य को बहुत सुधारा जा सकता है। यहाँ हैं आप कैसे सुरक्षित रूप से इसे कर सकते हैं:

1. वर्णनात्मक नामों का प्रयोग करें: नामों को स्पष्ट रूप से व्यक्त करने या करने वाले का पता साफ करने के लिए नामों का पुनरावलोकन करें। उदाहरण के लिए, एक फ़ंक्शन का नाम प्रोसेस से प्रोसेसउजरइनपुट में बदलें।
2. साधनों का प्रयोग: gorename जैसे साधनों का प्रयोग करें जो Go कोड को शब्दात्मक रूप से नहीं परंतु अर्थात्मक रूप से जांचने देते हैं के द्वारा सुरक्षित पुनरावलोकन का अनुसरण करें।
3. साथी समीक्षा करें: कभी-कभी वो बातें जो आपके लिए समझती हैं, वो दूसरों के लिए स्पष्ट नहीं होती हैं। सहकर्मी समीक्षा से भ्रांतिकरक नामों की पहचान में मदद मिल सकती है।
4. प्रतिक्रिया पर चर्चा करें: परिवर्तन करने के बाद, कोडबेस के उपयोगकर्ताओं से प्रतिक्रिया जुटाएं और आवश्यकतानुसार नामकरण पर पुनरावलोकन करें।

इन तकनीकों का पालन करके, आप सुनिश्चित करेंगे कि आपका Go कोडबेस साफ, समझदारीपूर्ण, और रखनीय रहता है।