Go इंटरव्यू कैसे पास करें: शीर्ष प्रश्न और उत्तर

Go साक्षात्कार कैसे पास करें: कोड उदाहरणों के साथ शीर्ष प्रश्न

Go डेवलपर पद के लिए साक्षात्कार न केवल सिंटैक्स की जांच है, बल्कि कंकरेंसी मॉडल, मेमोरी प्रबंधन और भाषा की इडियोमैटिक शैली की गहरी समझ भी है। इस लेख में हमने शीर्ष 10 प्रश्नों को शामिल किया है, जो Golang साक्षात्कारों में सबसे अधिक पूछे जाते हैं, विस्तृत उत्तरों और कोड उदाहरणों के साथ। यह सामग्री Junior और Middle दोनों स्तरों के लिए उपयुक्त है।

1. गोरूटीन बनाम OS थ्रेड: क्या अंतर है?

यह एक बुनियादी प्रश्न है जो Go के निष्पादन मॉडल की समझ की जांच करता है। उत्तर स्पष्ट होना चाहिए:

• स्टैक आकार: गोरूटीन ~2 KB स्टैक से शुरू होती है, जो गतिशील रूप से बढ़ता है। OS थ्रेड का स्टैक निश्चित होता है (1-8 MB)।
• कॉन्टेक्स्ट स्विचिंग: गोरूटीन यूज़र स्पेस में स्विच होती हैं (Go scheduler)। थ्रेड्स सिस्टम कॉल के माध्यम से स्विच होते हैं (अधिक महंगा)।
• निर्माण लागत: गोरूटीन की लागत ~4 KB मेमोरी है, थ्रेड की ~1 MB। हजारों गोरूटीन चलाई जा सकती हैं।

// उदाहरण: 10000 गोरूटीनfunc main() {    for i := 0; i < 10000; i++ {        go func(n int) {            fmt.Println("गोरूटीन", n)        }(i)    }    time.Sleep(time.Second)}

2. चैनल: बफ़र्ड और अनबफ़र्ड

सिंक्रोनाइज़ेशन की समझ पर प्रश्न। उदाहरण के साथ अंतर समझाएं:

• अनबफ़र्ड चैनल: भेजना प्राप्त होने तक ब्लॉक होता है। सिंक्रोनसिटी सुनिश्चित करता है।
• बफ़र्ड चैनल: भेजना तब तक ब्लॉक नहीं होता जब तक बफ़र भर न जाए। एसिंक्रोनस ट्रांसमिशन की अनुमति देता है।

// अनबफ़र्ड चैनलch := make(chan int)go func() { ch <- 42 }()val := <-ch // मान आने तक ब्लॉक होता है

// बफ़र्ड चैनलbufCh := make(chan int, 2)bufCh <- 1 // ब्लॉक नहीं होताbufCh <- 2 // ब्लॉक नहीं होता// bufCh <- 3 // ब्लॉक होता है - बफ़र भरा है

3. Select और एकाधिक चैनलों का प्रबंधन

select स्टेटमेंट कई चैनल ऑपरेशनों की प्रतीक्षा करने की अनुमति देता है। अक्सर default और टाइमआउट के बारे में पूछा जाता है:

func main() {    ch1 := make(chan string)    ch2 := make(chan string)

    go func() { time.Sleep(2 * time.Second); ch1 <- "from ch1" }()    go func() { time.Sleep(1 * time.Second); ch2 <- "from ch2" }()

    select {    case msg := <-ch1:        fmt.Println(msg)    case msg := <-ch2:        fmt.Println(msg)    case <-time.After(3 * time.Second):        fmt.Println("टाइमआउट")    }}

4. इंटरफ़ेस: खाली इंटरफ़ेस और type assertion

interface{} (any) और सुरक्षित टाइप कास्टिंग की समझ की जांच:

func describe(i interface{}) {    switch v := i.(type) {    case int:        fmt.Printf("पूर्णांक: %d", v)    case string:        fmt.Printf("स्ट्रिंग: %s", v)    default:        fmt.Printf("अज्ञात प्रकार: %T", v)    }}

func main() {    describe(42)    describe("hello")    describe(3.14)}

5. मेमोरी प्रबंधन: स्टैक और हीप, escape analysis

यह समझने पर प्रश्न कि Go कैसे तय करता है कि वेरिएबल कहाँ रखे जाएं। मुख्य बिंदु — escape analysis:

• यदि कंपाइलर देखता है कि फ़ंक्शन से लौटने के बाद वेरिएबल का उपयोग किया जा सकता है, तो वह हीप में "escape" कर जाता है।
• पॉइंटर्स, इंटरफ़ेस और क्लोज़र का उपयोग अक्सर हीप में एलोकेशन का कारण बनता है।

// वेरिएबल x हीप में "escape" करता हैfunc createPointer() *int {    x := 42    return &x // x स्टैक पर नहीं रह सकता}

6. Defer: निष्पादन क्रम और विशेषताएं

Defer LIFO (Last In, First Out) सिद्धांत पर निष्पादित होता है। आर्गुमेंट्स घोषणा के समय मूल्यांकित होते हैं, निष्पादन के समय नहीं:

func main() {    x := 10    defer fmt.Println("x का मान:", x) // यहाँ x=10 प्रिंट होगा    x = 20    fmt.Println("अंतिम x:", x)}