Go साक्षात्कार कैसे पास करें: शीर्ष प्रश्न और उत्तर

Go साक्षात्कार कैसे पास करें: शीर्ष प्रश्न

Go (Golang) उच्च-लोड सर्वर एप्लिकेशन और माइक्रोसर्विसेज बनाने के लिए सबसे अधिक मांग वाली भाषाओं में से एक है। Go-डेवलपर पद के लिए साक्षात्कार अक्सर न केवल सिंटैक्स के ज्ञान की जाँच करता है, बल्कि आंतरिक संरचना की समझ भी: गोरूटीन, चैनल, इंटरफ़ेस और मेमोरी प्रबंधन। इस लेख में, हम शीर्ष-10 प्रश्नों पर चर्चा करेंगे जो साक्षात्कारों में सबसे अधिक पूछे जाते हैं, कोड उदाहरणों और स्पष्टीकरणों के साथ।

1. ऐरे और स्लाइस में क्या अंतर है (array vs slice)?

यह Go की मूल बातें समझने पर एक क्लासिक प्रश्न है।

• ऐरे (array) — एक ही प्रकार के तत्वों का एक निश्चित क्रम है। ऐरे का आकार इसके प्रकार का हिस्सा है।
• स्लाइस (slice) — एक गतिशील संरचना है जो एक अंतर्निहित ऐरे को संदर्भित करती है। स्लाइस बढ़ सकता है और आकार बदल सकता है।

// ऐरे — निश्चित आकारvar arr [3]int = [3]int{1, 2, 3}// स्लाइस — गतिशीलvar slc []int = []int{1, 2, 3}

// महत्वपूर्ण: arr और [4]int अलग-अलग प्रकार हैं// स्लाइस संदर्भ द्वारा पास किए जाते हैं (अंतर्निहित ऐरे पर पॉइंटर)

सलाह: यदि लंबाई बदलने की आवश्यकता है — स्लाइस का उपयोग करें। यदि निश्चित आकार की गारंटी चाहिए — ऐरे का उपयोग करें।

2. गोरूटीन क्या हैं और वे कैसे काम करती हैं?

गोरूटीन एक हल्का निष्पादन थ्रेड है, जो Go रनटाइम द्वारा प्रबंधित होता है। सिस्टम थ्रेड्स (OS threads) के विपरीत, गोरूटीन का स्टैक छोटा होता है (2 KB से शुरू) और वे तेज़ी से स्विच होती हैं।

• गोरूटीन शुरू करना: go func()
• गोरूटीन एक ही एड्रेस स्पेस में काम करती हैं, इसलिए साझा डेटा तक पहुँच को सिंक्रोनाइज़ करने की आवश्यकता होती है (चैनल या म्यूटेक्स के माध्यम से)।

package main

import (    "fmt"    "time")

func printNumbers() {    for i := 1; i <= 5; i++ {        time.Sleep(100 * time.Millisecond)        fmt.Println(i)    }}

func main() {    go printNumbers() // गोरूटीन शुरू करना    time.Sleep(1 * time.Second) // पूरा होने की प्रतीक्षा    fmt.Println("Main done")}

महत्वपूर्ण: मुख्य फ़ंक्शन गोरूटीन के पूरा होने की प्रतीक्षा नहीं करता। सिंक्रोनाइज़ेशन के लिए sync.WaitGroup या चैनल का उपयोग करें।

3. चैनल (channels) कैसे काम करते हैं?

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

• अनबफ़र किया गया चैनल: भेजने वाला तब तक ब्लॉक रहता है जब तक प्राप्तकर्ता डेटा नहीं पढ़ लेता।
• बफ़र किया गया चैनल: भेजने वाला केवल तब ब्लॉक होता है जब बफ़र भर जाता है।

ch := make(chan int)    // अनबफ़र किया गयाchBuf := make(chan int, 3) // बफ़र किया गया (क्षमता 3)

// भेजनाgo func() {    ch <- 42}()

// प्राप्त करनाvalue := <-chfmt.Println(value)

// चैनल बंद करनाclose(ch)// बंद चैनल से पढ़ने पर zero value मिलती है

अक्सर पूछा जाने वाला प्रश्न: यदि nil-चैनल से पढ़ा जाए तो क्या होगा? — उत्तर: गोरूटीन हमेशा के लिए ब्लॉक हो जाएगी (deadlock)।

4. Go में इंटरफ़ेस क्या हैं और वे अन्य भाषाओं से कैसे भिन्न हैं?

Go में इंटरफ़ेस विधियों का एक सेट है। Java या C# के विपरीत, Go में इंटरफ़ेस का कार्यान्वयन अंतर्निहित (duck typing) है: एक प्रकार स्वचालित रूप से इंटरफ़ेस को संतुष्ट करता है यदि वह इसकी सभी विधियों को लागू करता है।

type Speaker interface {    Speak() string}

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

type Cat struct{}func (c Cat) Speak() string { return "Meow!" }

func makeSound(s Speaker) {    fmt.Println(s.Speak())}

func main() {    makeSound(Dog{}) // Woof!    makeSound(Cat{}) // Meow!}

यह क्यों महत्वपूर्ण है: लचीला, शिथिल रूप से युग्मित कोड लिखने की अनुमति देता है। खाली इंटरफ़ेस interface{} (या Go 1.18+ में any) किसी भी प्रकार का मान संग्रहीत कर सकता है।