गोलंग के शीर्ष 50 साक्षात्कार प्रश्न और उत्तर (2026)

द्वारा: लूना विल्सन लूना विल्सन
Hours Updated

गोलंग से संबंधित शीर्ष साक्षात्कार प्रश्न और उत्तर

Golang इंटरव्यू की तैयारी करने का मतलब है यह अनुमान लगाना कि नियोक्ता आपसे क्या प्रश्न पूछेंगे और यह क्यों महत्वपूर्ण है। Golang इंटरव्यू के प्रश्न समस्या-समाधान की क्षमता, समवर्ती कार्यप्रणाली की समझ और वास्तविक प्रणालियों के लिए उत्पादन तत्परता को दर्शाते हैं।

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

👉 मुफ़्त PDF डाउनलोड करें: गोलंग इंटरव्यू प्रश्न और उत्तर

गोलंग से संबंधित शीर्ष साक्षात्कार प्रश्न और उत्तर

1) गोलंग क्या है, और आधुनिक सॉफ्टवेयर विकास में इसका व्यापक रूप से उपयोग क्यों किया जाता है?

Go (जिसे अक्सर Golang कहा जाता है) एक स्थैतिक रूप से टाइप की गई, संकलित प्रोग्रामिंग भाषा इसे गूगल द्वारा बनाया गया है। इसे सरलता, विश्वसनीयता और कुशल समवर्तीता को ध्यान में रखकर डिज़ाइन किया गया था। इसका मूल सिद्धांत इस पर ज़ोर देता है। पठनीयता और व्यावहारिकता साथ ही उन जटिल भाषा सुविधाओं को भी हटा दिया जाता है जो बग उत्पन्न कर सकती हैं।

गो का व्यापक रूप से उपयोग किया जाता है बैकएंड सेवाएं, क्लाउड इन्फ्रास्ट्रक्चर, माइक्रोसेवाएं और वितरित प्रणालियां क्योंकि यह नेटिव बाइनरी में कंपाइल होता है और बड़े पैमाने पर कॉन्करेंसी को मैनेज करता है। गोरूटीन और चैनलयह भाषा प्रदान करती है मजबूत स्टैटिक टाइपिंग, बिल्ट-इन टूलिंग (जैसे go fmt, go test, go mod), गार्बेज कलेक्शन, और एक समृद्ध मानक लाइब्रेरीजो इसे एंटरप्राइज-ग्रेड सिस्टम के लिए उत्पादक और उच्च प्रदर्शन वाला बनाता है।

उदाहरण: गूगल, उबर और जैसी कंपनियां Dropbox उच्च समवर्तीता और कम विलंबता की आवश्यकता वाली सेवाओं के लिए Go का उपयोग करें।

2) गो में गोरूटीन और ओएस थ्रेड्स के बीच अंतर स्पष्ट कीजिए।

गो में, एक गोरूटीन गोरूटीन एक हल्का, प्रबंधित समवर्ती निष्पादन इकाई है। ऑपरेटिंग सिस्टम थ्रेड्स के विपरीत, जो महत्वपूर्ण मेमोरी और सिस्टम संसाधनों का उपभोग करते हैं, गोरूटीन की शुरुआत होती है। एक छोटा स्टैक (लगभग कुछ किलोबाइट) और गतिशील रूप से बढ़ सकता है।

मुख्य अंतर:

Feature गोरौटाइन ओएस थ्रेड
मेमोरी लागत बहुत छोटे ढेर डिफ़ॉल्ट रूप से बड़े स्टैक
निर्धारण गो रनटाइम शेड्यूलर Operaटिंग सिस्टम शेड्यूलर
निर्माण लागत निम्न हाई
अनुमापकता हजारों आसानी से सीमित

गो रनटाइम सिस्टम के माध्यम से गोरूटीन को ओएस थ्रेड्स के एक छोटे समूह पर मल्टीप्लेक्स किया जाता है, जिससे सिस्टम संसाधनों पर अत्यधिक भार डाले बिना कुशल समवर्तीता संभव हो पाती है।

उदाहरण: Go में आप न्यूनतम मेमोरी ओवरहेड के साथ सैकड़ों हजारों समवर्ती कार्यों को लॉन्च कर सकते हैं।

3) गोरूटीन के बीच संचार में चैनल किस प्रकार सहायक होते हैं? एक उदाहरण दीजिए।

चैनल हैं टाइप किए गए कंड्यूट जो गोरूटीन को सुरक्षित रूप से मान भेजने और प्राप्त करने की अनुमति देते हैं, जिससे सुविधा मिलती है तुल्यकालन और संचारआप एक चैनल बनाते हैं make(chan T), जहां T यह डेटा प्रकार है।

ch := make(chan int)
go func() {
    ch <- 42 // send to channel
}()
val := <-ch // receive from channel
fmt.Println(val)

इस उदाहरण में, गोरूटीन मान भेजता है 42 चैनल में प्रवेश करता है, और मुख्य गोरूटीन इसे प्राप्त करता है। चैनल हो सकते हैं बफर or असंबद्धजिससे यह प्रभावित होता है कि क्या दूसरा पक्ष तैयार होने तक संचार अवरुद्ध हो जाता है। Bufferएड चैनल क्षमता पूरी होने तक ब्लॉकिंग में देरी करते हैं।

चैनल टाइप सिस्टम में सिंक्रोनाइज़ेशन को एन्कोड करके सामान्य समवर्ती बग को रोकने में मदद करते हैं।

4) गो में स्लाइस क्या है, और यह ऐरे से किस प्रकार भिन्न है?

A टुकड़ा Go में एक है एक ऐरे में गतिशील, लचीला दृश्ययह अंतर्निहित ऐरे का संदर्भ प्रदान करता है और डेटा की प्रतिलिपि बनाए बिना लचीले विकास और विभाजन की अनुमति देता है।

स्लाइस और ऐरे के बीच अंतर:

Feature ऐरे टुकड़ा
आकार संकलन समय पर ठीक किया गया गतिशील
याद संपूर्ण संग्रहण आवंटित करता है संदर्भ अंतर्निहित सरणी
लचीलापन Less लचीला अत्यधिक लचीला

उदाहरण:

arr := [5]int{1,2,3,4,5}
s := arr[1:4] // slice referring to arr from index 1 to 3

स्लाइस का उपयोग गो गेम में संग्रहों के लिए व्यापक रूप से किया जाता है क्योंकि वे लचीले होते हैं।

5) गो में त्रुटि प्रबंधन कैसे काम करता है और इसके लिए सर्वोत्तम प्रथाओं का वर्णन करें।

Go त्रुटियों को अंतर्निहित मानों के रूप में दर्शाता है error इंटरफ़ेस। अपवादों के बजाय, गो फ़ंक्शन स्पष्ट रूप से त्रुटियाँ लौटाते हैं, जिससे त्रुटि जाँच और प्रबंधन लागू होता है।

विशिष्ट पैटर्न:

result, err := someFunc()
if err != nil {
    // handle error
}

Go में त्रुटियों के लिए सर्वोत्तम अभ्यास:

  • कॉल करने के तुरंत बाद त्रुटियों की जांच करें।
  • उपयोग लिपटे हुए त्रुटियाँ अतिरिक्त संदर्भ के साथ (fmt.Errorf("...: %w", err)).
  • बनाएं कस्टम त्रुटि प्रकार जब सार्थक त्रुटि जानकारी की आवश्यकता हो।
  • मानक का प्रयोग करें errors त्रुटि श्रृंखलाओं का निरीक्षण या निर्माण करने के लिए पैकेज।

यह स्पष्ट मॉडल त्रुटि प्रबंधन को पूर्वानुमानित बनाता है और अधिक मजबूत प्रोग्रामों की ओर ले जाता है।

6) गो इंटरफेस क्या हैं और उन्हें कैसे लागू किया जाता है?

An इंटरफेस Go में परिभाषित करता है विधि हस्ताक्षरों का समूह कि एक प्रकार को लागू करना होगा। कई भाषाओं के विपरीत, गो के इंटरफेस लागू किए जाते हैं। उलझाव सेइसका अर्थ है कि एक प्रकार आवश्यक विधियों को धारण करके, बिना किसी स्पष्ट घोषणा के, एक इंटरफ़ेस को संतुष्ट करता है।

उदाहरण:

type Speaker interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

यहाँ, Dog लागू करता है Speaker एक इंटरफ़ेस स्वचालित रूप से Speak() विधि। इंटरफेस बढ़ावा देते हैं ढीला युग्मन और बहुरूपता.

7) गो में वेरिएबल कैसे घोषित करते हैं और := सिंटैक्स क्या है?

Go में वेरिएबल घोषित करने के दो प्रमुख तरीके हैं:

  • वर कीवर्ड: 
    var x int
    x = 10
  • संक्षिप्त चर घोषणा: 
    y := 10

RSI := यह सिंटैक्स एक ही चरण में वेरिएबल को घोषित और इनिशियलाइज़ करता है, जिसमें टाइप स्वचालित रूप से अनुमानित होता है। इसका उपयोग आमतौर पर फ़ंक्शन के भीतर किया जाता है। संक्षिप्त और अभिव्यंजक कोड.

संक्षिप्त घोषणाएँ पठनीयता में सुधार करती हैं, विशेष रूप से स्थानीय दायरे में।

संबंधित आलेख

8) गो पैकेज क्या हैं और वे मॉड्यूलरिटी को कैसे बेहतर बनाते हैं?

A पैकेज Go में, Go स्रोत फ़ाइलों का एक संग्रह है जिन्हें एक साथ संकलित किया जाता है। प्रत्येक फ़ाइल एक को परिभाषित करती है। package नाम सबसे ऊपर रखें। पैकेज कोड को संरचित करने, तर्क को समाहित करने और पुन: उपयोग को बढ़ावा देने में मदद करते हैं।

किसी पैकेज को आयात करने के लिए:

import "fmt"

यह मॉड्यूलर संरचना डेवलपर्स को पुन: प्रयोज्य घटकों को मिलाकर बड़े एप्लिकेशन बनाने में सक्षम बनाती है।

9) गो में डेफर कीवर्ड के उद्देश्य की व्याख्या कीजिए।

RSI defer यह कथन किसी फ़ंक्शन के निष्पादन को तब तक के लिए स्थगित कर देता है जब तक कि... आस-पास का फ़ंक्शन लौटाता हैइसका उपयोग आमतौर पर फाइलों को बंद करने, म्यूटेक्स को अनलॉक करने और बफ़र्स को फ्लश करने जैसे सफाई कार्यों के लिए किया जाता है।

उदाहरण:

f, _ := os.Open("file.txt")
defer f.Close()
// do work

डेफर कॉल निष्पादित किए जाते हैं LIFO आदेश (अंतिम घोषित, प्रथम निष्पादित), जिससे कई सफाई कार्यों को विश्वसनीय रूप से कतारबद्ध किया जा सकता है।

10) गोरूटीन लीक क्या है, और इससे कैसे बचा जा सकता है?

A गोरूटीन रिसाव यह तब होता है जब एक गोरूटीन अनिश्चित काल तक चलता रहता है क्योंकि यह किसी ऐसे चैनल या स्थिति की प्रतीक्षा में अवरुद्ध हो जाता है जो कभी घटित नहीं होती। ये लीकेज चुपचाप मेमोरी और संसाधनों का उपभोग कर सकते हैं।

सामान्य कारणों में:

  • बिना प्रेषक वाले चैनल पर प्रतीक्षा कर रहा हूँ।
  • इसमें कोई टाइमआउट या कैंसलेशन लॉजिक नहीं है।

बचाव रणनीतियाँ:

  • उपयोग select साथ में चूक or टाइमआउट मामलों अनिश्चितकालीन अवरोध से बचने के लिए।
  • उपयोग रद्द करने के संदर्भ में (context.Contextनिरस्तीकरण संकेतों को प्रसारित करने के लिए।
  • जब कोई और मान नहीं भेजा जाएगा तो चैनलों को ठीक से बंद कर दें।

11) गो में make() और new() में क्या अंतर है?

गो में, दोनों make() और new() इनका उपयोग मेमोरी आवंटन के लिए किया जाता है लेकिन ये कार्य करते हैं विभिन्न उद्देश्य.

  • new() किसी दिए गए प्रकार के चर के लिए मेमोरी आवंटित करता है और एक मान लौटाता है। सूचक यह आंतरिक डेटा संरचनाओं को आरंभ नहीं करता है।
  • make() इसका उपयोग केवल इसके लिए किया जाता है स्लाइस, मैप और चैनलआरंभ करना और वापस करना मूल्य (यह एक पॉइंटर नहीं है)।
पहलू make() new()
प्रयोग स्लाइस, मैप, चैनल किसी भी प्रकार
वापसी प्रकार आरंभिक मान सूचक
आरंभीकरण हाँ नहीं

उदाहरण:

p := new(int)
fmt.Println(*p) // 0

s := make([]int, 5)
fmt.Println(s)  // [0 0 0 0 0]

साक्षात्कारों में इस बात पर जोर दें कि make() जटिल डेटा संरचनाएं तैयार करता है, जबकि new() बस मेमोरी आरक्षित करता है।

12) गो पॉइंटर क्या होते हैं और वे सी पॉइंटर से किस प्रकार भिन्न होते हैं?

Go में पॉइंटर चरों के मेमोरी पतेजिससे मानों तक अप्रत्यक्ष पहुंच संभव हो पाती है। हालाँकि, गो पॉइंटर सुरक्षित और प्रतिबंधित C पॉइंटर्स की तुलना में, वे अंकगणितीय या प्रत्यक्ष मेमोरी हेरफेर नहीं कर सकते हैं।

उदाहरण:

x := 10
p := &x
fmt.Println(*p) // dereference

मुख्य अंतर:

  • सुरक्षा कारणों से गो पॉइंटर अंकगणित को रोकता है।
  • गार्बेज कलेक्शन स्वचालित रूप से मेमोरी प्रबंधन को संभालता है।
  • Go, पॉइंटर्स के माध्यम से बड़ी संरचनाओं को कुशलतापूर्वक पारित करने की अनुमति देता है।

Go अक्सर पॉइंटर्स का उपयोग करता है फ़ंक्शन पैरामीटर अनुकूलन और संरचना हेरफेरसुरक्षा बनाए रखते हुए अनावश्यक मेमोरी कॉपी करने को कम करना।

13) गो में गार्बेज कलेक्शन का प्रबंधन कैसे किया जाता है?

गो'स गार्बेज कलेक्टर (जीसी) यह स्वचालित रूप से उस मेमोरी को पुनः प्राप्त कर लेता है जिसका अब कोई संदर्भ नहीं है, जिससे डेवलपर्स के लिए मेमोरी प्रबंधन सरल हो जाता है। यह एक समवर्ती, त्रि-रंग मार्क-एंड-स्वीप एल्गोरिदम जिससे विराम का समय कम से कम हो जाता है।

जीसी, गोरूटीन के साथ मिलकर काम करता है और भारी भार के तहत भी प्रदर्शन को बनाए रखने के लिए क्रमिक स्वीप करता है।

जीसी को अनुकूलित करने के लिए सर्वोत्तम अभ्यास:

  • अस्थायी डेटा के लिए sync.Pool का उपयोग करके ऑब्जेक्ट्स का पुन: उपयोग करें।
  • तंग लूपों में अत्यधिक अल्पकालिक आवंटन से बचें।
  • प्रोफ़ाइल का उपयोग करके GODEBUG=gctrace=1 या फिर GC के प्रदर्शन की निगरानी के लिए pprof का उपयोग करें।

गार्बेज कलेक्शन की मदद से गो दोनों काम कर सकता है। उच्च निष्पादन और सुरक्षित स्मृति प्रबंधनपारंपरिक भाषाओं में यह संतुलन बनाना कठिन है। C++.

14) गो के समवर्ती मॉडल की व्याख्या कीजिए और यह मल्टीथ्रेडिंग से किस प्रकार भिन्न है, यह बताइए।

Go का समवर्ती मॉडल इसके इर्द-गिर्द बना है गोरूटीन और चैनलोंयह पारंपरिक धागों का अनुसरण नहीं करता है। सीएसपी (कम्युनिकेटिंग सीक्वेंशियल प्रोसेसेस) एक ऐसा मॉडल, जहां समवर्ती प्रक्रियाएं साझा मेमोरी के बजाय चैनलों के माध्यम से संवाद करती हैं।

मल्टीथ्रेडिंग से प्रमुख अंतर:

Feature गोरोउटिन्स थ्रेड्स
याद हल्का (कुछ केबी) भारी (प्रति थ्रेड MB)
प्रबंध गो रनटाइम शेड्यूलर ऑपरेटिंग सिस्टम-स्तर शेड्यूलर
संचार चैनल साझा मेमोरी / म्यूटेक्स

थ्रेडिंग की जटिलता को सरल बनाकर, Go समवर्तीता को आसान बनाता है। सरल और रचना योग्य — डेवलपर थ्रेड पूल को प्रबंधित किए बिना हजारों गोरूटीन लॉन्च कर सकते हैं।

उदाहरण:

go processTask()

यह नॉन-ब्लॉकिंग निष्पादन एक साथ कई इनपुट/आउटपुट की अनुमति देता है, जिससे स्केलेबिलिटी में नाटकीय रूप से सुधार होता है।

15) गो स्ट्रक्चर टैग क्या हैं, और सीरियलाइज़ेशन (जैसे, JSON) में इनका उपयोग कैसे किया जाता है?

स्ट्रक्चर टैग हैं मेटाडेटा स्ट्रक्चर फ़ील्ड से जुड़ा हुआ, अक्सर इसके लिए उपयोग किया जाता है क्रमबद्धता, सत्यापनया, ओआरएम मानचित्रण.

उदाहरण:

type User struct {
    Name  string `json:"name"`
    Email string `json:"email_address"`
}

जब क्रमबद्ध किया जाता है encoding/jsonये टैग स्ट्रक्चर फ़ील्ड को विशिष्ट JSON कुंजियों से मैप करते हैं।

लाभ:

  • कस्टम फ़ील्ड नामकरण
  • फ़ील्ड छोड़ना या हटाना
  • फ्रेमवर्क के साथ एकीकरण (जैसे, डेटाबेस ORM, सत्यापन लाइब्रेरी)

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

16) गो के मैप और स्लाइस प्रकारों के बीच मुख्य अंतर क्या हैं?

दोनों map और slice ये गतिशील डेटा संरचनाएं हैं, लेकिन ये बहुत अलग-अलग उद्देश्यों की पूर्ति करती हैं।

Feature टुकड़ा नक्शा
संरचना तत्वों की क्रमबद्ध सूची कुंजी-मूल्य जोड़े
पहुँच सूचकांक-आधारित कुंजी के आधार पर
आरंभीकरण make([]T, len) make(map[K]V)
उदाहरण अनुक्रमिक भंडारण त्वरित खोज

उदाहरण:

scores := make(map[string]int)
scores["John"] = 90
list := []int{1,2,3,4}

मैप्स को हैश टेबल के रूप में कार्यान्वित किया जाता है और वे अव्यवस्थितजबकि स्लाइस बनाए रखते हैं तत्व क्रम और कुशलतापूर्वक पुनरावृति और स्लाइसिंग कार्यों का समर्थन करता है।

17) गो पैकेज आयात को कैसे प्रबंधित करता है और चक्रीय निर्भरताओं से कैसे बचता है?

गो लागू करता है सख्त पैकेज निर्भरता नियम — प्रत्येक पैकेज को निर्भरताओं का एक निर्देशित चक्रीय ग्राफ (DAG) बनाना होगा। चक्रीय आयात (A → B → A) संकलन-समय त्रुटियाँ हैं।

इससे बचने के लिए:

  • सामान्य कार्यक्षमता को एक अलग यूटिलिटी पैकेज में विभाजित करें।
  • उपयोग इंटरफेस कंक्रीट कार्यान्वयनों को आयात करने के बजाय।
  • निर्भरता व्युत्क्रमण का प्रयोग करें: कार्यान्वयन के बजाय अमूर्त अवधारणाओं पर निर्भर रहें।

आयात का उदाहरण:

import (
    "fmt"
    "net/http"
)

गो की पैकेज प्रणाली मॉड्यूलर, पुन: प्रयोज्य और रखरखाव योग्य कोडबेस को बढ़ावा देती है - जो बड़े पैमाने पर उद्यम अनुप्रयोगों के लिए महत्वपूर्ण है।

18) गो के डेटा प्रकार क्या हैं और उन्हें कैसे वर्गीकृत किया जाता है?

Go के डेटा प्रकारों को निम्नलिखित श्रेणियों में व्यवस्थित किया गया है:

वर्ग उदाहरण विवरण
बुनियादी int, float64, स्ट्रिंग, बूल मूलभूत आदिम
कुल सरणी, संरचना डेटा का संग्रह
संदर्भ स्लाइस, मैप, चैनल अंतर्निहित डेटा के संदर्भों को रखें
इंटरफेस इंटरफ़ेस{} अमूर्त व्यवहार परिभाषाएँ

Go मजबूत टाइपिंग को लागू करता है कोई अप्रत्यक्ष रूपांतरण नहींजिससे पूर्वानुमानित व्यवहार सुनिश्चित होता है और रनटाइम त्रुटियां कम होती हैं।

टाइप अनुमान (:=यह टाइप सेफ्टी से समझौता किए बिना लचीलापन प्रदान करता है।

19) आप गोरूटीन या चैनलों में टाइमआउट को कैसे संभाल सकते हैं?

टाइमआउट गोरूटीन को अनिश्चित काल तक अवरुद्ध होने से रोकते हैं। गो का प्रचलित तरीका इसका उपयोग करता है। select टाइमआउट चैनल के साथ स्टेटमेंट बनाया गया है time.After().

उदाहरण:

select {
case res := <-ch:
    fmt.Println(res)
case <-time.After(2 * time.Second):
    fmt.Println("Timeout!")
}

यह संरचना प्रोग्राम को तब भी आगे बढ़ने की अनुमति देती है जब कोई चैनल ऑपरेशन रुक जाता है।

अधिक जटिल प्रणालियों के लिए, डेवलपर उपयोग करते हैं संदर्भ.संदर्भ गोरूटीन में रद्दीकरण और टाइमआउट को प्रसारित करने के लिए।

20) गो में कॉन्टेक्स्ट पैकेज का उद्देश्य क्या है?

RSI context पैकेज एक तरीका प्रदान करता है रद्दीकरण, समयसीमा और अनुरोध के दायरे को नियंत्रित करें कई गोरूटीन में इसका उपयोग किया जा सकता है। यह लंबे समय तक चलने वाले या वितरित कार्यों (जैसे, HTTP सर्वर, माइक्रोसेवाएं) में महत्वपूर्ण है।

उदाहरण:

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

select {
case <-time.After(3 * time.Second):
    fmt.Println("Task done")
case <-ctx.Done():
    fmt.Println("Canceled:", ctx.Err())
}

का प्रयोग context सुनिश्चित गरिमापूर्ण समाप्तियह संसाधनों के रिसाव को रोकता है और सेवाओं में रद्दीकरण प्रसार को मानकीकृत करता है। यह गो की समवर्ती वास्तुकला का एक आधारशिला है।

21) गो में यूनिट टेस्टिंग कैसे लागू की जाती है?

गो में शामिल है अंतर्निर्मित परीक्षण ढांचा मानक पुस्तकालय में (testing पैकेज)।

प्रत्येक परीक्षण फ़ाइल का अंत इससे होना चाहिए: _test.go और उन फ़ंक्शनों का उपयोग करें जिनके आगे यह लगा हो Test.

उदाहरण:

package mathutil

import "testing"

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    want := 5
    if got != want {
        t.Errorf("got %d, want %d", got, want)
    }
}

टेस्ट निम्न माध्यमों से निष्पादित किए जा सकते हैं:

go test ./...

सर्वोत्तम प्रथाओं में शामिल हैं:

  • परीक्षणों को नियतात्मक और पृथक रखना।
  • कई मामलों के लिए टेबल-आधारित परीक्षणों का उपयोग करना।
  • रोजगार t.Run() उपपरीक्षणों के लिए।
  • बेंचमार्क जोड़ना Benchmark फ़ंक्शन और उदाहरणों का उपयोग करना Example कार्य करता है.

गो के अंतर्निहित टूलिंग (go test, go coverयह सुसंगत, तीव्र और अनुरक्षणीय परीक्षण पद्धतियों को प्रोत्साहित करता है।

22) गो में वेटग्रुप क्या है, और यह समवर्तीता को कैसे प्रबंधित करता है?

A प्रतीक्षा समूह यह गो का हिस्सा है sync पैकेज और इसका उपयोग किया जाता है गोरूटीन के संग्रह की प्रतीक्षा करें निष्पादन समाप्त करने के लिए।

यह तब आदर्श होता है जब आप कई गोरूटीन लॉन्च करते हैं और सभी के पूरा होने तक ब्लॉक करने की आवश्यकता होती है।

उदाहरण:

var wg sync.WaitGroup
for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        fmt.Println("Worker:", id)
    }(i)
}
wg.Wait()

तंत्र:

  • Add(n) काउंटर को बढ़ाता है।
  • प्रत्येक गोरूटीन कॉल करता है Done() जब समाप्त हो जाए।
  • Wait() काउंटर के शून्य पर वापस आने तक ब्लॉक करता है।

यह संरचना सुनिश्चित करती है तुल्यकालन जटिल लॉकिंग तंत्रों के बिना, समवर्ती समन्वय को सरल बनाना।

23) म्यूटेक्स क्या हैं, और आपको गो में इनका उपयोग कब करना चाहिए?

A म्युटेक्स (म्यूचुअल एक्सक्लूजन लॉक) साझा संसाधनों तक एक साथ पहुंच को रोकता है। यह इससे संबंधित है। sync पैकेज का उपयोग तब किया जाना चाहिए जब डेटा दौड़ तब हो सकता है।

उदाहरण:

var mu sync.Mutex
counter := 0

for i := 0; i < 10; i++ {
    go func() {
        mu.Lock()
        counter++
        mu.Unlock()
    }()
}

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

  • लॉक करने के बाद हमेशा अनलॉक करें (उपयोग करें defer mu.Unlock()).
  • इसका प्रयोग संयम से करें — संभव हो तो चैनलों को प्राथमिकता दें।
  • डेडलॉक से बचने के लिए नेस्टेड लॉक्स का उपयोग करने से बचें।

जबकि गो प्रोत्साहित करता है चैनल-आधारित समवर्तीताजब साझा स्थिति से बचा नहीं जा सकता है, तो म्यूटेक्स महत्वपूर्ण बने रहते हैं।

24) sync.Once कंस्ट्रक्ट क्या है, और इसका उपयोग कहाँ किया जाता है?

sync.Once यह सुनिश्चित करता है कि कोड का एक हिस्सा चलता है सिर्फ एक बारभले ही इसे कई गोरूटीन से कॉल किया गया हो।

उदाहरण:

var once sync.Once
once.Do(func() {
    fmt.Println("Initialize only once")
})

इसका उपयोग आमतौर पर निम्नलिखित के लिए किया जाता है:

  • सिंगलटन आरंभीकरण।
  • कॉन्फ़िगरेशन सेटअप।
  • संसाधनों का निष्क्रिय आवंटन।

आंतरिक रूप से, sync.Once यह थ्रेड सुरक्षा की गारंटी देने के लिए एटॉमिक ऑपरेशंस और मेमोरी बैरियर का उपयोग करता है, जिससे यह एक बार के कार्यों के लिए मैन्युअल लॉक की तुलना में अधिक कुशल हो जाता है।

25) गो की परावर्तन क्रियाविधि और इसके व्यावहारिक उपयोगों की व्याख्या कीजिए।

गो'स प्रतिबिंब (के माध्यम से reflect पैकेज रनटाइम पर टाइप की जांच और संशोधन की अनुमति देता है। यह JSON एन्कोडिंग, ORM मैपिंग और डिपेंडेंसी इंजेक्शन जैसे फ्रेमवर्क के लिए आवश्यक है।

उदाहरण:

import "reflect"
t := reflect.TypeOf(42)
v := reflect.ValueOf("hello")
fmt.Println(t.Kind(), v.Kind()) // int string

सामान्य उपयोग:

  • डेटा संरचनाओं का क्रमबद्धीकरण।
  • जेनेरिक लाइब्रेरी बनाना।
  • गतिशील सत्यापन या टैगिंग।

कमियां:

  • धीमी गति से क्रियान्वयन.
  • टाइप सुरक्षा में कमी।
  • डिबगिंग करना अधिक कठिन है।

रिफ्लेक्शन का उपयोग बहुत कम ही करना चाहिए — जब कंपाइल-टाइम टाइपिंग गतिशील व्यवहार को संभाल न सके।

26) गो मॉड्यूल सिस्टम (go.mod) क्या है और यह महत्वपूर्ण क्यों है?

Go 1.11 में पेश किया गया, जाओ मॉड्यूल GOPATH-आधारित निर्भरता प्रबंधन को प्रतिस्थापित किया गया। प्रत्येक मॉड्यूल को एक द्वारा परिभाषित किया गया है। go.mod निर्भरताओं और संस्करणों के बारे में मेटाडेटा वाली फ़ाइल।

उदाहरण:

module github.com/user/project
go 1.22
require (
    github.com/gin-gonic/gin v1.9.0
)

लाभ:

  • संस्करणित निर्भरता नियंत्रण।
  • गोपाथ की कोई आवश्यकता नहीं है।
  • पुनरुत्पादनीय निर्माण (go.sum चेकसम सत्यापन के लिए)।

जैसे आदेश go mod tidy, go mod vendor, तथा go list -m all निर्भरता स्वच्छता का समर्थन करें।

मॉड्यूल अब हैं मानक पैकेज प्रबंधन प्रणाली गो में.

27) गो रेस कंडीशन को कैसे हैंडल करता है, और उनका पता कैसे लगाया जा सकता है?

रेस की स्थितियाँ तब उत्पन्न होती हैं जब एकाधिक गोरूटीन एक साथ साझा डेटा तक पहुँच प्राप्त करते हैंजिसके परिणामस्वरूप अप्रत्याशित परिणाम सामने आते हैं।

सेवा मेरे पता लगाना उन्हें:

go run -race main.go

रेस डिटेक्टर रनटाइम पर मेमोरी एक्सेस की निगरानी करता है और यदि परस्पर विरोधी ऑपरेशन होते हैं तो चेतावनी देता है।

रोकथाम के तरीके:

  • साझा चरों को सुरक्षित रखें sync.Mutex.
  • डेटा के आदान-प्रदान के लिए साझा मेमोरी के बजाय चैनलों का उपयोग करें।
  • जहां तक ​​संभव हो, गोरूटीन को स्वतंत्र रखें।

विकास के दौरान Go के अंतर्निर्मित रेस डिटेक्टर का उपयोग करना विश्वसनीय समवर्तीता प्राप्त करने के लिए महत्वपूर्ण है।

28) समझाइए कि गो क्रॉस-प्लेटफ़ॉर्म संकलन कैसे प्राप्त करता है।

Go समर्थन करता है देशी क्रॉस-संकलन अलग सोच।

डेवलपर पर्यावरण चरों का उपयोग करके विभिन्न ऑपरेटिंग सिस्टम या आर्किटेक्चर के लिए बाइनरी बना सकते हैं।

उदाहरण:

GOOS=windows GOARCH=amd64 go build

समर्थित Targets: लिनक्स, Windows, macOSफ्रीबीएसडी, एआरएम, आदि।

क्योंकि Go स्थिर रूप से लिंक किए गए बाइनरी को संकलित करता है, इसलिए आउटपुट स्व-निहित होता है - किसी बाहरी निर्भरता की आवश्यकता नहीं होती है।

यह फीचर गो को इसके लिए आदर्श बनाता है कंटेनरीकृत वातावरण, CI/CD पाइपलाइन और एम्बेडेड सिस्टम.

29) गो खेल के मुख्य फायदे और नुकसान क्या हैं?

फायदे नुकसान
तेज़ संकलन और निष्पादन कोई जेनेरिक्स उपलब्ध नहीं (गो 1.18 तक, अब सीमित)
उत्कृष्ट समवर्तीता (गोरूटीन) सीमित जीयूआई समर्थन
कचरा इकठा करना मैन्युअल त्रुटि प्रबंधन में विस्तारशीलता
सरल वाक्य रचना छोटा पारिस्थितिकी तंत्र बनाम Python/Java
क्रॉस-प्लेटफ़ॉर्म बाइनरी कोई वंशानुक्रम नहीं (इसके बजाय संयोजन)

Go की व्यावहारिक सरलता और प्रदर्शन इसे माइक्रोसेवाओं के लिए आदर्श बनाते हैं, लेकिन यह यूआई-प्रधान या स्क्रिप्ट-आधारित वातावरण के लिए कम उपयुक्त है।

30) गो डिज़ाइन पैटर्न के कुछ सामान्य प्रकार क्या हैं?

जाओ पक्ष विरासत पर संरचनाजिसके परिणामस्वरूप समवर्तीता और मॉड्यूलरिटी के लिए अनुकूलित मुहावरेदार डिजाइन पैटर्न बनते हैं।

लोकप्रिय पैटर्न:

  1. एकाकी वस्तु - के जरिए sync.Once एक बार के आरंभीकरण के लिए।
  2. फ़ैक्टरी — आरंभिक संरचनाओं को लौटाने वाले कार्यों का उपयोग करना।
  3. श्रमिक पूल — गोरूटीन और चैनलों का उपयोग करके समवर्ती जॉब प्रोसेसिंग का प्रबंधन करना।
  4. डेकोरेटर व्यवहार को विस्तारित करने के लिए फ़ंक्शन को रैप करना।
  5. पाइपलाइन चरणबद्ध डेटा प्रोसेसिंग के लिए गोरूटीन को श्रृंखला में जोड़ना।

ये पैटर्न गो के हल्के समवर्ती मॉडल के अनुरूप हैं और प्रोत्साहित करते हैं पठनीय, परीक्षण योग्य और रखरखाव योग्य कोडबेस।

31) आप Go कोड के प्रदर्शन को बेहतर बनाने के लिए उसे कैसे अनुकूलित करते हैं?

Go में परफॉर्मेंस ऑप्टिमाइजेशन में प्रोफाइलिंग, एलोकेशन को कम करना और कॉन्करेंसी का कुशलतापूर्वक उपयोग करना शामिल है।

Go का उपयोग करके बाधाओं की पहचान करके शुरुआत करें प्रोफ प्रोफाइलर:

go test -bench . -benchmem
go tool pprof cpu.prof

प्रमुख अनुकूलन तकनीकें:

  • उपयोग मूल्य प्रकार हीप एलोकेशन को कम करने के लिए पॉइंटर्स के बजाय इनका उपयोग किया जाता है।
  • मेमोरी का पुनः उपयोग करें सिंक.पूल अस्थायी वस्तुओं के लिए।
  • पसंद करते हैं पूर्व-आवंटित स्लाइस (make([]T, 0, n)).
  • जहां तक ​​संभव हो, चिंतन से बचें।
  • बफर्ड रीडर/राइटर का उपयोग करके इनपुट/आउटपुट को अनुकूलित करें।

इसके अतिरिक्त, अनुमान लगाने के बजाय अनुकूलन को निर्देशित करने के लिए महत्वपूर्ण कार्यों के लिए बेंचमार्क लिखें।

जाओ प्रोत्साहित करता है डेटा-संचालित अनुकूलन समय से पहले ट्यूनिंग करने से बचें — हमेशा पहले प्रोफाइल बनाएं, फिर एडजस्ट करें।

32) गो बिल्ड टैग क्या हैं, और उनका उपयोग कैसे किया जाता है?

बिल्ड टैग हैं संकलक निर्देश ये वे फ़ंक्शन हैं जो यह नियंत्रित करते हैं कि बिल्ड में कौन सी फ़ाइलें शामिल की जाएंगी। ये प्लेटफ़ॉर्म-विशिष्ट या सशर्त बिल्ड को सक्षम बनाते हैं।

उदाहरण:

//go:build linux
// +build linux

package main

यह फ़ाइल केवल लिनक्स सिस्टम पर ही कंपाइल होगी। बिल्ड टैग निम्नलिखित के लिए उपयोगी हैं:

  • क्रॉस-प्लेटफ़ॉर्म अनुकूलता.
  • फ़ीचर टॉगलिंग।
  • विभिन्न वातावरणों का परीक्षण करना (उदाहरण के लिए, उत्पादन बनाम स्टेजिंग)।

टैग के साथ निर्माण करने के लिए:

go build -tags=prod

बिल्ड टैग Go बाइनरी को Make या CMake जैसे जटिल बिल्ड सिस्टम के बिना पोर्टेबल और कॉन्फ़िगर करने योग्य बनाते हैं।

33) समझाइए कि गो आंतरिक रूप से मेमोरी आवंटन और गार्बेज संग्रह को कैसे संभालता है।

गो एक का उपयोग करता है हाइब्रिड मेमोरी मॉडल — मैनुअल स्टैक आवंटन को स्वचालित हीप प्रबंधन के साथ संयोजित करना।

स्थानीय चर आमतौर पर संग्रहीत होते हैं धुआँराजबकि हीप आवंटन का प्रबंधन इसके द्वारा किया जाता है। कचरा इकट्ठा करने वाला.

Go में GC एक है समवर्ती, त्रि-रंग मार्क-एंड-स्वीप सिस्टम:

  1. अंकन चरण: जीवित वस्तुओं की पहचान करता है।
  2. स्वीप चरण: अप्रयुक्त मेमोरी को मुक्त करता है।
  3. समवर्ती निष्पादन: GC, गोरूटीन के साथ-साथ चलता है ताकि विराम समय को कम किया जा सके।

मेमोरी के उपयोग को अनुकूलित करना:

  • एस्केप विश्लेषण का उपयोग करें (go build -gcflags="-m"हीप बनाम स्टैक आवंटन की जांच करने के लिए।
  • बड़े अस्थायी आवंटनों को कम करें।
  • पुन: प्रयोज्य वस्तुओं के लिए पूल का उपयोग करें।

सुरक्षा और गति का संतुलन गो के मेमोरी सिस्टम को स्केलेबल सर्वरों के लिए आदर्श बनाता है।

34) गो में बफर्ड और अनबफर्ड चैनलों के बीच क्या अंतर है?

पहलू अनबफर्ड चैनल Bufferएड चैनल
अवरोधक व्यवहार प्रेषक तब तक प्रतीक्षा करता है जब तक प्राप्तकर्ता तैयार न हो जाए। बफर भर जाने पर ही प्रेषक ब्लॉक करता है।
Syncतुल्यकालन मजबूत सिंक्रनाइज़ेशन आंशिक तुल्यकालन
निर्माण make(chan int) make(chan int, 5)

उदाहरण:

ch := make(chan int, 2)
ch <- 1
ch <- 2

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

35) सेलेक्ट स्टेटमेंट क्या हैं, और वे मल्टीपल चैनल ऑपरेशंस को कैसे मैनेज करते हैं?

RSI select यह कथन एक गोरूटीन को अनुमति देता है एक साथ कई चैनल संचालन की प्रतीक्षा करें — के समान switch लेकिन समवर्तीता के लिए।

उदाहरण:

select {
case msg := <-ch1:
    fmt.Println("Received:", msg)
case ch2 <- "ping":
    fmt.Println("Sent to ch2")
default:
    fmt.Println("No communication")
}

लक्षण:

  • केवल एक ही तैयार केस निष्पादित होता है।
  • यदि एक से अधिक तैयार हों, तो उनमें से एक को यादृच्छिक रूप से चुना जाता है।
  • RSI default केस अवरोध को रोकता है।

select कथन सरल बनाते हैं नॉन-ब्लॉकिंग संचार, फैन-इन/फैन-आउट पैटर्नऔर टाइमआउट या कैंसलेशन चैनलों का उपयोग करके सुचारू रूप से शटडाउन करना।

36) गो का context.Context समवर्ती प्रोग्रामों में रद्दीकरण और टाइमआउट हैंडलिंग को कैसे बेहतर बनाता है?

RSI context पैकेज प्रदान करता है मानकीकृत तंत्र गोरूटीन के बीच रद्दीकरण, समयसीमा और अनुरोध-आधारित डेटा को प्रसारित करने के लिए।

सामान्य उपयोग:

ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
select {
case <-doWork(ctx):
    fmt.Println("Completed")
case <-ctx.Done():
    fmt.Println("Timeout:", ctx.Err())
}

लाभ:

  • गोरूटीन जीवनचक्रों पर एकीकृत नियंत्रण।
  • गोरूटीन रिसाव को रोकता है।
  • नेस्टेड फंक्शन कॉल में कैंसलेशन को सरल बनाता है।

context.Context आधुनिक गो एपीआई में यह आवश्यक है, खासकर माइक्रोसेवाओं, एचटीटीपी सर्वरों और डेटाबेस संचालन के लिए।

37) गो में समवर्तीता समानांतरता से किस प्रकार भिन्न है?

संकल्पना संगामिति समानता
परिभाषा एक प्रोग्राम को इस प्रकार संरचित करना जिससे वह कई कार्यों को संभाल सके एक साथ कई कार्यों को निष्पादित करना
गो तंत्र गोरूटीन और चैनल एकाधिक सीपीयू कोर
फोकस कार्य समन्वय गति और सीपीयू उपयोग

Go में, समवर्तीता निम्न माध्यम से प्राप्त की जाती है: गोरूटीनजबकि समानांतरता को नियंत्रित किया जाता है गोमैक्सप्रोसीएसजो यह निर्धारित करता है कि कितने ओएस थ्रेड एक साथ चलते हैं।

runtime.GOMAXPROCS(4)

समवर्तीता निम्नलिखित से संबंधित है: कई प्रक्रियाओं का प्रबंधन करनाजबकि समानांतरता से संबंधित है उन्हें एक साथ निष्पादित करना.

Go का शेड्यूलर उपलब्ध कोर के आधार पर दोनों को सहजता से प्रबंधित करता है।

38) गो में समवर्ती कोड का परीक्षण कैसे किया जाता है?

समवर्तीता का परीक्षण करने में रेस कंडीशन और सिंक्रोनाइज़ेशन टाइमिंग के तहत शुद्धता को मान्य करना शामिल है।

तकनीक:

  • उपयोग रेस डिटेक्टर (go test -raceसाझा मेमोरी संबंधी विरोधाभासों का पता लगाने के लिए।
  • रोजगार प्रतीक्षासमूह परीक्षणों में गोरूटीन को सिंक्रनाइज़ करने के लिए।
  • टाइमआउट का अनुकरण करें select और time.After().
  • उपयोग नकली चैनल घटनाओं के क्रम को नियंत्रित करने के लिए।

उदाहरण:

func TestConcurrent(t *testing.T) {
    var counter int
    var mu sync.Mutex
    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            mu.Lock()
            counter++
            mu.Unlock()
            wg.Done()
        }()
    }
    wg.Wait()
    if counter != 100 {
        t.Errorf("Expected 100, got %d", counter)
    }
}

समवर्ती गो कोड का परीक्षण करने के लिए धैर्य, सिंक्रोनाइज़ेशन टूल और बार-बार स्ट्रेस टेस्टिंग की आवश्यकता होती है।

39) माइक्रोसेवा विकास के लिए गो की सर्वोत्तम पद्धतियाँ क्या हैं?

गो एक है माइक्रोसेवाओं के लिए प्रथम श्रेणी का विकल्प इसकी दक्षता और समवर्ती कार्यक्षमता की विशेषताओं के कारण।

सर्वोत्तम प्रथाएं:

  • जैसे फ्रेमवर्क का उपयोग करें जिन, गूंजया, फाइबर REST API के लिए।
  • को लागू करें संदर्भ-अवगत रद्दीकरण और समय सीमा समाप्त होना।
  • उपयोग JSON एन्कोडिंग/डिकोडिंग स्ट्रक्चर टैग्स के साथ कुशलतापूर्वक।
  • रोजगार सहज शटडाउन का उपयोग context.WithCancel.
  • पर्यावरण चरों के साथ कॉन्फ़िगरेशन को केंद्रीकृत करें।
  • अवलोकनशीलता को लागू करें प्रोमिथेउस, ओपनटेलीमेट्रीया, पीप्रोफ.

माइक्रोसर्विस फ्लो का उदाहरण:

  • main.go एक HTTP सर्वर शुरू करता है।
  • router.go मार्गों को परिभाषित करता है।
  • handler.go यह व्यावसायिक तर्क को संसाधित करता है।
  • config.go पर्यावरण चर लोड करता है।

गो'स स्थिर बाइनरी और तेजी से स्टार्टअप डॉकर और कुबेरनेट्स जैसे कंटेनरीकृत वातावरण में परिनियोजन को सहज बनाएं।

40) गो और अन्य प्रोग्रामिंग भाषाओं (सी, Java, Python)?

Feature Go C Java Python
टाइपिंग स्थिर स्थिर स्थिर गतिशील
संकलन मूल बाइनरी मूल बाइनरी बाईटकोड व्याख्या की
संगामिति गोरूटीन, चैनल थ्रेड्स थ्रेड्स अतुल्यकालिक इनपुट/आउटपुट
कचरा इकठा करना हाँ नहीं हाँ हाँ
वाक्यविन्यास जटिलता सरल जटिल वाचाल न्यूनतम
प्रदर्शन हाई बहुत ऊँचा मध्यम निम्न
बक्सों का इस्तेमाल करें क्लाउड, माइक्रोसेवाएं, बैकएंड सिस्टम ओएस, एम्बेडेड एंटरप्राइज़ ऐप्स स्क्रिप्टिंग, एमएल

गो इन दोनों के बीच संतुलन बनाता है सी का प्रदर्शन, Javaकी सुरक्षा, तथा Pythonकी सरलता.

इसका अनूठा समवर्ती मॉडल और न्यूनतम सिंटैक्स इसे स्केलेबल बैकएंड और वितरित प्रणालियों के लिए एक आधुनिक भाषा बनाते हैं।

41) गो का शेड्यूलर अंदरूनी तौर पर गोरूटीन को कैसे प्रबंधित करता है?

Go के रनटाइम में शामिल है कार्य चुराने वाला शेड्यूलर जो लाखों गोरूटीन को कुशलतापूर्वक प्रबंधित करता है।

यह इस पर निर्मित है जीपीएम मॉडल:

  • G: गोरूटीन — फांसी का वास्तविक हल्का धागा।
  • Pप्रोसेसर — एक संसाधन जो गोरूटीन (ओएस थ्रेड्स से जुड़ा हुआ) को निष्पादित करता है।
  • M: मशीन — एक ऑपरेटिंग सिस्टम थ्रेड।

प्रत्येक P में गोरूटीन की एक स्थानीय कतार होती है। जब एक प्रोसेसर निष्क्रिय हो जाता है, तो वह गोरूटीन चुराता है कार्यभार को संतुलित करने के लिए दूसरों की कतारों से आगे बढ़कर काम करना।

पी की संख्या इसके अनुरूप है GOMAXPROCSजो समानांतरता के स्तर को निर्धारित करता है।

यह मॉडल गो को शेड्यूलिंग लागत को न्यूनतम रखते हुए कई कोर में कुशलतापूर्वक स्केल करने की अनुमति देता है।

42) गो में मेमोरी लीक के क्या कारण हैं, और उन्हें कैसे रोका जा सकता है?

कचरा संग्रहण के बावजूद, Go को समस्या का सामना करना पड़ सकता है। तार्किक मेमोरी लीक जब अप्रयुक्त वस्तुओं के संदर्भ बने रहते हैं।

सामान्य कारणों में:

  • गोरूटीन उन चैनलों पर प्रतीक्षा कर रहे हैं जो कभी बंद नहीं होते।
  • बिना डेटा हटाए बड़े डेटा स्ट्रक्चर को कैश करना।
  • संदर्भों को अनिश्चित काल तक धारण करने वाले वैश्विक चर का उपयोग करना।

रोकथाम रणनीतियाँ:

  • उपयोग context.Context गोरूटीन में रद्द करने के लिए।
  • उपयोग के बाद चैनलों को ठीक से बंद कर दें।
  • मेमोरी प्रोफाइलिंग टूल का उपयोग करें (pprof, memstats).

उदाहरण पहचान:

go tool pprof -http=:8080 mem.prof

उपयोग के बाद हमेशा संदर्भों को मुक्त करें, और असामान्य मेमोरी वृद्धि के लिए लंबे समय तक चलने वाली सेवाओं की निगरानी करें।

43) गो के डेफर स्टेटमेंट का प्रदर्शन पर क्या प्रभाव पड़ता है?

defer यह आसपास के फ़ंक्शन के समाप्त होने तक फ़ंक्शन कॉल को स्थगित करके सफाई प्रक्रिया को सरल बनाता है।

हालाँकि, इससे एक कम रनटाइम लागतक्योंकि प्रत्येक डेफर स्टैक में एक रिकॉर्ड जोड़ता है।

उदाहरण:

defer file.Close()

प्रदर्शन की दृष्टि से महत्वपूर्ण कोड (जैसे लूप) में, स्पष्ट सफाई को प्राथमिकता दें:

for i := 0; i < 1000; i++ {
    f := openFile()
    f.Close() // faster than defer inside loop
}

हालांकि डेफर का ओवरहेड कम होता है (कुछ नैनोसेकंड), लेकिन तंग लूप या उच्च-आवृत्ति वाले कार्यों में, इसे मैन्युअल सफाई से बदलने से प्रदर्शन में उल्लेखनीय सुधार हो सकता है।

44) समझाइए कि गो, गोरूटीन के लिए स्टैक वृद्धि को कैसे प्रबंधित करता है।

प्रत्येक गोरूटीन की शुरुआत इससे होती है छोटा स्टैक (≈2 KB) जो गतिशील रूप से बढ़ता और घटता है।

परंपरागत ऑपरेटिंग सिस्टम थ्रेड्स (जो MBs स्टैक स्पेस आवंटित करते हैं) के विपरीत, Go का स्टैक वृद्धि मॉडल है खंडित और मिला हुआ.

जब किसी फ़ंक्शन को अधिक स्टैक मेमोरी की आवश्यकता होती है, तो रनटाइम:

  1. एक नया, बड़ा स्टैक आवंटित करता है।
  2. यह पुराने स्टैक की प्रतिलिपि इसमें डाल देता है।
  3. स्टैक संदर्भों को स्वचालित रूप से अपडेट करता है।

यह डिज़ाइन गो को संभालने की अनुमति देता है सैकड़ों हजारों गोरूटीन यह पारंपरिक थ्रेडिंग सिस्टम की तुलना में न्यूनतम मेमोरी का उपयोग करते हुए कुशलतापूर्वक कार्य करता है।

45) गो एप्लिकेशन में आप सीपीयू और मेमोरी उपयोग का प्रोफाइल कैसे बनाते हैं?

प्रोफाइलिंग, मानक लाइब्रेरी के pprof टूल का उपयोग करके प्रदर्शन संबंधी बाधाओं की पहचान करने में मदद करती है।

सेटअप:

import _ "net/http/pprof"
go func() { http.ListenAndServe("localhost:6060", nil) }()

फिर प्रोफाइलिंग डेटा तक पहुंचें:

go tool pprof http://localhost:6060/debug/pprof/profile

सामान्य प्रोफाइल:

  • /heap → मेमोरी उपयोग
  • /goroutine → गोरूटीन डंप
  • /profile → सीपीयू उपयोग

विज़ुअलाइज़ेशन टूल जैसे go tool pprof -http=:8081 हॉटस्पॉट का पता लगाने के लिए फ्लेम ग्राफ प्रदान करें।

उत्पादन वातावरण के लिए, इसे इनके साथ संयोजित करें। प्रोमिथेउस और ग्राफाना वास्तविक समय अवलोकन क्षमता के लिए।

46) गो में इंटरफेस को आंतरिक रूप से कैसे संग्रहीत किया जाता है?

आंतरिक रूप से, Go इंटरफेस को इस प्रकार प्रस्तुत करता है: दो-शब्द संरचना:

  1. टाइप सूचना (itab) के लिए एक सूचक।
  2. वास्तविक डेटा का एक संकेतक।

यह डिजाइन टाइप-सेफ्टी को बरकरार रखते हुए डायनामिक डिस्पैच को सक्षम बनाता है।

उदाहरण:

var r io.Reader = os.Stdin

यहाँ, r दोनों प्रकार के स्टोर करता है (*os.File) और डेटा (os.Stdin).

इसे समझने से बचने में मदद मिलती है इंटरफ़ेस निल कमियां — एक इंटरफ़ेस जिसका अंतर्निहित मान शून्य है लेकिन टाइप पॉइंटर गैर-शून्य है, वह नहीं है nil.

var r io.Reader
fmt.Println(r == nil) // true
r = (*os.File)(nil)
fmt.Println(r == nil) // false

यह सूक्ष्मता अक्सर गो इंटरव्यू और डिबगिंग में भ्रम पैदा करती है।

47) गो जेनेरिक्स क्या हैं, और वे कोड की पुन: प्रयोज्यता को कैसे बेहतर बनाते हैं?

Go 1.18 ने पेश किया जेनरिकइससे डेवलपर्स को किसी भी प्रकार पर काम करने वाले फ़ंक्शन और डेटा संरचनाएं लिखने की अनुमति मिलती है।

उदाहरण:

func Max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

लाभ:

  • यह बार-बार दोहराए जाने वाले कोड (जैसे, स्लाइस, मैप्स के लिए) को हटाता है।
  • टाइप सेफ्टी को बरकरार रखता है (कास्टिंग की आवश्यकता नहीं)।
  • मोनोमॉर्फाइजेशन का उपयोग करके कुशलतापूर्वक संकलन होता है।

नुकसान:

  • थोड़ी अधिक जटिल वाक्य संरचना।
  • गतिशील व्यवहार के लिए चिंतन की आवश्यकता अभी भी हो सकती है।

जेनेरिक्स गो को और करीब लाते हैं C++/Java Go की सरलता और प्रदर्शन की गारंटी को बरकरार रखते हुए टेम्प्लेटिंग करना।

48) गो डिबगिंग की सामान्य तकनीकें और उपकरण क्या हैं?

डिबगिंग उपकरण:

डेल्व (डीएलवी) – इंटरेक्टिव डीबगर:

dlv debug main.go
  1. यह ब्रेकप्वाइंट, स्टेप-थ्रू और वेरिएबल इंस्पेक्शन को सपोर्ट करता है।
  2. पीप्रोफ – प्रदर्शन और मेमोरी प्रोफाइलिंग।
  3. रेस डिटेक्टर – समवर्ती एक्सेस विवादों का पता लगाता है (go run -race).
  4. लॉग पैकेज – रनटाइम ट्रेसिंग के लिए संरचित लॉगिंग।

सर्वोत्तम प्रथाएं:

  • टाइमस्टैम्प और गोरूटीन आईडी के साथ ट्रेस लॉगिंग जोड़ें।
  • नियंत्रित समवर्ती सीमाओं के साथ परीक्षण करें।
  • उपयोग recover() घबराहट को खूबसूरती से कैद करने के लिए।

Delve और pprof को मिलाकर, शुद्धता और प्रदर्शन दोनों में पूर्ण पारदर्शिता प्राप्त होती है।

49) आप Go का उपयोग करके एक स्केलेबल REST API कैसे डिज़ाइन करेंगे?

Archiसंरचना की रूपरेखा:

  • फ्रेमवर्क: जिन, फाइबरया, गूंज.
  • राउटिंग लेयर: एंडपॉइंट्स और मिडलवेयर को परिभाषित करती है।
  • सर्विस लेयर: इसमें बिजनेस लॉजिक शामिल होता है।
  • डेटा लेयर: डेटाबेस के साथ इंटरफेस (PostgreSQL, MongoDB, आदि).
  • अवलोकनशीलता: मेट्रिक्स को लागू करें प्रोमिथेउस और ओपनटेलीमेट्री.

सर्वोत्तम प्रथाएं:

  • उपयोग context.Context अनुरोध के दायरे को निर्धारित करने के लिए।
  • सिग्नल चैनलों के साथ शटडाउन को सुचारू रूप से संभालें।
  • रेट लिमिटिंग और कैशिंग (Redis) लागू करें।
  • संरचना मार्गों को मॉड्यूलर रूप से व्यवस्थित करें (/api/v1/users, /api/v1/orders).

स्टार्टअप का उदाहरण:

r := gin.Default()
r.GET("/health", func(c *gin.Context) {
    c.JSON(200, gin.H{"status": "ok"})
})
r.Run(":8080")

Go की अंतर्निहित समवर्तीता इसे इसके लिए आदर्श बनाती है उच्च-प्रदर्शन RESTful सिस्टम लाखों अनुरोधों को पूरा करना।

50) आप प्रोडक्शन-ग्रेड गो कोड लिखने के लिए सर्वोत्तम प्रथाओं को क्या मानते हैं?

1. कोड संरचना:

  • पैकेजों को तार्किक रूप से व्यवस्थित करें (उदाहरण के लिए, cmd/, internal/, pkg/).
  • इंटरफेस को छोटा और विशिष्ट रखें।

2. समवर्तीता:

  • गोरूटीन का विवेकपूर्ण उपयोग करें।
  • लीक को रोकने के लिए संदर्भों को रद्द करें।

3. त्रुटि प्रबंधन:

  • त्रुटियों को हमेशा संदर्भ के साथ लपेटें (fmt.Errorf("failed to X: %w", err)).
  • त्रुटियों को अनदेखा करने से बचें।

4. प्रदर्शन और अवलोकनशीलता:

  • प्रोफाइल नियमित रूप से (pprof, trace).
  • स्वास्थ्य जांच और मापदंडों को लागू करें।

5. रखरखाव:

  • उपयोग go fmt, go vet, तथा golangci-lint.
  • टेबल आधारित यूनिट टेस्ट लिखें।
  • निर्यात किए गए सभी कार्यों का दस्तावेजीकरण करें।

एक सुव्यवस्थित गो प्रोजेक्ट सरलता, स्पष्टता और विश्वसनीयता का पालन करता है - जो उत्पादन-स्तरीय सॉफ़्टवेयर की पहचान हैं।

🔍 वास्तविक दुनिया के परिदृश्यों और रणनीतिक उत्तरों के साथ शीर्ष गोलंग साक्षात्कार प्रश्न

1) गोलंग की वे कौन सी प्रमुख विशेषताएं हैं जो इसे बैकएंड डेवलपमेंट के लिए उपयुक्त बनाती हैं?

उम्मीदवार से अपेक्षित:
साक्षात्कारकर्ता गोलंग के बारे में आपकी मूलभूत समझ का आकलन करना चाहता है और यह जानना चाहता है कि बैकएंड और सिस्टम डेवलपमेंट के लिए इसे आमतौर पर क्यों चुना जाता है।

उदाहरण उत्तर: "गोराउटिन और चैनल का उपयोग करने वाले इसके मजबूत कॉन्करेंसी मॉडल, तेज कंपाइलेशन गति और कुशल मेमोरी प्रबंधन के कारण गोलंग बैकएंड डेवलपमेंट के लिए उपयुक्त है। इसकी मानक लाइब्रेरी व्यापक है और नेटवर्किंग, HTTP सर्वर और टेस्टिंग को सहजता से सपोर्ट करती है। इन विशेषताओं के कारण स्केलेबल और रखरखाव योग्य बैकएंड सेवाएं बनाना आसान हो जाता है।"

2) गोरूटीन पारंपरिक थ्रेड्स से किस प्रकार भिन्न होते हैं?

उम्मीदवार से अपेक्षित:
साक्षात्कारकर्ता समवर्तीता अवधारणाओं और गोलंग के निष्पादन मॉडल के बारे में आपकी समझ का परीक्षण कर रहा है।

उदाहरण उत्तर: “गोरूटीन हल्के फंक्शन होते हैं जिन्हें ऑपरेटिंग सिस्टम के बजाय गो रनटाइम द्वारा प्रबंधित किया जाता है। इन्हें पारंपरिक थ्रेड्स की तुलना में काफी कम मेमोरी की आवश्यकता होती है और इन्हें बड़ी संख्या में बनाया जा सकता है। गो शेड्यूलर गोरूटीन को कुशलतापूर्वक प्रबंधित करता है, जिससे समवर्ती कार्यों को थ्रेड्स से जुड़े सामान्य ओवरहेड के बिना स्केल करने की अनुमति मिलती है।”

3) क्या आप बता सकते हैं कि चैनलों का उपयोग कैसे किया जाता है और आप बफ़र्ड बनाम अनबफ़र्ड चैनलों का चयन कब करेंगे?

उम्मीदवार से अपेक्षित:
साक्षात्कारकर्ता आपकी समवर्ती प्रणालियों को डिजाइन करने और संचार पैटर्न को समझने की क्षमता का मूल्यांकन करना चाहता है।

उदाहरण उत्तर: "गोरूटीन के बीच डेटा को सुरक्षित रूप से पारित करने के लिए चैनलों का उपयोग किया जाता है। अनबफर्ड चैनल तब उपयोगी होते हैं जब सिंक्रोनाइज़ेशन की आवश्यकता होती है, क्योंकि प्रेषक और प्राप्तकर्ता दोनों को तैयार रहना चाहिए।" Bufferडेटा के अचानक प्रवाह को संभालने जैसे मामलों में, प्रेषकों और प्राप्तकर्ताओं को अलग करने के लिए अस्थायी भंडारण की आवश्यकता होने पर, इलेक्ट्रॉनिक चैनल बेहतर होते हैं।

4) एक ऐसी स्थिति का वर्णन करें जहां आपको गो एप्लिकेशन में प्रदर्शन संबंधी समस्या को डीबग करना पड़ा हो।

उम्मीदवार से अपेक्षित:
साक्षात्कारकर्ता समस्या-समाधान कौशल और प्रदर्शन उपकरणों से परिचित होने की तलाश में है।

उदाहरण उत्तर: “अपनी पिछली भूमिका में, मुझे अत्यधिक गोरूटीन निर्माण के कारण प्रदर्शन संबंधी समस्या का सामना करना पड़ा। मैंने सीपीयू और मेमोरी उपयोग का विश्लेषण करने के लिए pprof जैसे गो प्रोफाइलिंग टूल का उपयोग किया। निष्कर्षों के आधार पर, मैंने वर्कर गोरूटीन के पुन: उपयोग के लिए कोड को रिफैक्टर किया, जिससे प्रदर्शन में काफी सुधार हुआ और मेमोरी की खपत कम हुई।”

5) गोलंग में त्रुटि प्रबंधन कैसे काम करता है, और इसे इस तरह से क्यों डिजाइन किया गया है?

उम्मीदवार से अपेक्षित:
साक्षात्कारकर्ता गो की स्पष्ट त्रुटि-प्रबंधन पद्धति पर आपका दृष्टिकोण समझना चाहता है।

उदाहरण उत्तर: “गोलैंग अपवादों के बजाय स्पष्ट त्रुटि रिटर्न का उपयोग करता है। यह डिज़ाइन डेवलपर्स को त्रुटियों को तुरंत और स्पष्ट रूप से संभालने के लिए प्रोत्साहित करता है, जिससे कोड का व्यवहार अधिक अनुमानित हो जाता है। हालांकि यह विस्तृत हो सकता है, लेकिन यह पठनीयता में सुधार करता है और छिपे हुए नियंत्रण प्रवाह को कम करता है।”

6) मुझे उस समय के बारे में बताएं जब आपको जल्दी से कोई नई गो लाइब्रेरी या फ्रेमवर्क सीखना पड़ा हो।

उम्मीदवार से अपेक्षित:
साक्षात्कारकर्ता आपकी अनुकूलन क्षमता और सीखने के दृष्टिकोण का मूल्यांकन कर रहा है।

उदाहरण उत्तर: “पिछली नौकरी में, मुझे एक एपीआई प्रोजेक्ट को सपोर्ट करने के लिए जिन वेब फ्रेमवर्क को जल्दी से सीखना पड़ा। मैंने आधिकारिक दस्तावेज़ों की समीक्षा की, नमूना परियोजनाओं का अध्ययन किया और एक छोटा प्रोटोटाइप बनाया। इस दृष्टिकोण ने मुझे कम समय में ही कुशल बनने में मदद की।”

7) गो में इंटरफेस कैसे काम करते हैं, और वे क्यों महत्वपूर्ण हैं?

उम्मीदवार से अपेक्षित:
साक्षात्कारकर्ता गो भाषा में अमूर्तता और डिजाइन सिद्धांतों के बारे में आपकी समझ का आकलन करना चाहता है।

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

8) आप Golang का उपयोग करके RESTful API को कैसे डिज़ाइन करेंगे, इसका वर्णन करें।

उम्मीदवार से अपेक्षित:
साक्षात्कारकर्ता वास्तविक दुनिया के बैकएंड परिदृश्य में गो (Go) को लागू करने की आपकी क्षमता का परीक्षण कर रहा है।

उदाहरण उत्तर: “अपनी पिछली नौकरी में, मैंने net/http और एक राउटिंग लाइब्रेरी का उपयोग करके RESTful API डिज़ाइन किए थे। मैंने हैंडलर, सेवाओं और डेटा एक्सेस लेयर्स के बीच स्पष्ट विभाजन के साथ प्रोजेक्ट को संरचित किया था। मैंने उचित अनुरोध सत्यापन, सुसंगत त्रुटि प्रतिक्रियाएँ और व्यापक यूनिट परीक्षण भी सुनिश्चित किए थे।”

9) गो प्रोजेक्ट्स पर काम करते समय आप समय सीमा का सख्ती से पालन कैसे करते हैं?

उम्मीदवार से अपेक्षित:
साक्षात्कारकर्ता आपके समय प्रबंधन और प्राथमिकता निर्धारण कौशल के बारे में जानकारी प्राप्त करना चाहता है।

उदाहरण उत्तर: “अपनी पिछली भूमिका में, मैंने कार्यों को छोटे, प्रबंधनीय इकाइयों में विभाजित करके और महत्वपूर्ण कार्यक्षमता को प्राथमिकता देकर समय सीमा का सख्ती से पालन किया। मैंने हितधारकों के साथ नियमित रूप से प्रगति की जानकारी साझा की और कोड की गुणवत्ता बनाए रखते हुए, काम करने योग्य सुविधाओं को शीघ्रता से वितरित करने के लिए Go की सरलता का उपयोग किया।”

10) मान लीजिए कि उत्पादन में चल रही एक Go सेवा बीच-बीच में क्रैश हो रही है। आप इसे हल करने के लिए क्या तरीका अपनाएंगे?

उम्मीदवार से अपेक्षित:
साक्षात्कारकर्ता आपके निर्णय लेने और घटना से निपटने के कौशल का मूल्यांकन कर रहा है।

उदाहरण उत्तर: “मैं सबसे पहले लॉग और मॉनिटरिंग डेटा का विश्लेषण करके पैटर्न या त्रुटि संदेशों की पहचान करूंगा। इसके बाद, यदि आवश्यक हो तो मैं अतिरिक्त लॉगिंग या ट्रेसिंग को सक्षम करूंगा और एक स्टेजिंग वातावरण में समस्या को पुन: उत्पन्न करने का प्रयास करूंगा। मूल कारण की पहचान हो जाने के बाद, मैं समाधान लागू करूंगा, समस्या के दोबारा उत्पन्न होने से रोकने के लिए परीक्षण जोड़ूंगा और तैनाती के बाद सेवा की बारीकी से निगरानी करूंगा।”

इस पोस्ट को संक्षेप में इस प्रकार लिखें: