शून्य वैल्यू में

शून्य वैल्यू के बारे में

Go में हर वेरिएबल की एक वैल्यू होती है। किसी वेरिएबल को बिना वैल्यू असाइन किए घोषित करने पर उसकी वैल्यू उसके टाइप की शून्य वैल्यू हो जाती है।

बेसिक टाइप, जैसे bool, संख्यात्मक टाइप और string, सभी की एक तय शून्य वैल्यू होती है:

जो टाइप किसी वास्तविक डेटा का रेफरेंस रखते हैं, जैसे पॉइंटर, फंक्शन, इंटरफेस, स्लाइस, चैनल और मैप, उन सभी की शून्य वैल्यू nil होती है। लेकिन ऐरे और स्ट्रक्ट कभी nil नहीं होते, क्योंकि वे डेटा सीधे अपने अंदर रखते हैं, उसका रेफरेंस नहीं। ऐरे का हर एलिमेंट और स्ट्रक्ट का हर फील्ड अपने-अपने टाइप की शून्य वैल्यू से शुरू होता है। उदाहरण के लिए, var a [3]int ऐरे [0, 0, 0] बनाता है।

शून्य वैल्यू घोषित करना

किसी भी टाइप के लिए, बिना शुरुआती वैल्यू वाला var उसकी शून्य वैल्यू देता है:

var myBool bool   // false
var mySlice []int // nil
var p Person      // Person{Name: "", Age: 0}

स्ट्रक्ट के लिए कंपोज़िट लिटरल T{} एक और तरीका है:

myPerson := Person{} // equivalent to var myPerson Person

new(T) किसी भी टाइप की शून्य वैल्यू का पॉइंटर लौटाता है। इसका उपयोग सबसे ज़्यादा स्ट्रक्ट के साथ होता है, हालाँकि यह बेसिक टाइपों के लिए भी काम करता है:

p := new(Person) // *Person, pointing to Person{Name: "", Age: 0}
s := new(string) // *string, pointing to ""
i := new(int)    // *int, pointing to 0

शून्य वैल्यू क्यों मायने रखती हैं

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

bool की डिफॉल्ट वैल्यू false होती है, जो एक फ्लैग की तरह काम कर सकती है:

var done bool // action not done yet
done = true   // action now done

पूर्णांक की डिफॉल्ट वैल्यू 0 होती है, जो एक काउंटर की तरह काम कर सकती है:

var count int
count++ // 1
count++ // 2

स्ट्रक्ट में हर फील्ड अपने टाइप की शून्य वैल्यू से शुरू होता है। सिर्फ एक []string फील्ड वाला Stack घोषित करते ही काम करने लायक खाली स्टैक होता है। जब nil स्लाइस पर append कॉल किया जाता है, तब वह एक नया बैकिंग ऐरे बना देता है, इसलिए किसी कंस्ट्रक्टर की ज़रूरत नहीं पड़ती:

type Stack struct {
    items []string
}

func (s *Stack) Push(v string) {
    s.items = append(s.items, v)
}

func (s *Stack) IsEmpty() bool {
    return len(s.items) == 0
}

var s Stack
fmt.Println(s.IsEmpty()) // true
s.Push("a") // append allocates a new backing array
fmt.Println(s.IsEmpty()) // false

nil के साथ काम करना

जिन टाइपों की शून्य वैल्यू nil होती है, उनमें से ज़्यादातर को उपयोग से पहले कोई वैल्यू देना ज़रूरी है, वरना वे पैनिक दे देते हैं। nil स्लाइस इसका अपवाद है: आप उस पर रेंज कर सकते हैं, उसमें एपेंड कर सकते हैं, और उसे len और cap को सुरक्षित रूप से दे सकते हैं।

मैप में कोई वैल्यू रखने से पहले उसे बनाना ज़रूरी है:

var m map[string]int
m["key"] = 1 // panic

मैप आमतौर पर दो तरीकों से बनाया जाता है:

m1 := make(map[string]int)
m2 := map[string]int{}
m1["key"] = 1 // ok
m2["key"] = 1 // ok

किसी पॉइंटर का उपयोग करने से पहले जाँच लीजिए कि वह nil नहीं है:

var p *int

if p == nil {
    fmt.Println("no value assigned")
    return
}

fmt.Println(*p) // p is not nil

बेसिक टाइप हमेशा एक ठोस वैल्यू रखते हैं, इसलिए उनकी nil से तुलना करना एक कंपाइल एरर है:

var myString string

if myString == nil {
    // compile error: mismatched types
}