जाँच करना कि क्या Go में map में कुंजी मौजूद है: पूर्ण गाइड

कुंजियों की खोज: Go map के जंगल में कैसे न खोएं

कल्पना करें: आप Go में एक माइक्रोसर्विस लिख रहे हैं। आपको जल्दी से जाँचना है कि उपयोगकर्ता सिस्टम में पंजीकृत है या नहीं। आप map का उपयोग करते हैं, जहाँ कुंजी उपयोगकर्ता का ID है और मान उसका प्रोफ़ाइल है। और फिर सवाल उठता है: क्या map में ऐसी कोई कुंजी मौजूद है?

यदि आप Python या JavaScript से आए हैं, तो आप इस बात के आदी हैं कि गैर-मौजूद कुंजी तक पहुँचने पर अपवाद (exception) उत्पन्न हो सकता है या undefined वापस आ सकता है। Go में सब कुछ अलग है। यहाँ कोई अपवाद नहीं हैं, लेकिन एक सुंदर तंत्र है। और यदि आप ऐसी कुंजी से मान पढ़ने का प्रयास करते हैं जो मौजूद नहीं है, तो Go क्रैश नहीं होगा, बल्कि मान के प्रकार के लिए शून्य मान (zero value) वापस करेगा।

सुविधाजनक लगता है? हाँ, लेकिन यह एक जाल भी है। आप "कुंजी नहीं है" की स्थिति को "कुंजी है, लेकिन मान शून्य है" की स्थिति से कैसे अलग करेंगे? इसी के लिए एक विशेष मुहावरा मौजूद है — comma ok idiom। आइए इसे हमेशा के लिए समझ लें।

Go में map कैसे काम करता है: संक्षिप्त परिचय

जाँच में गोता लगाने से पहले, आइए याद करें कि Go में map क्या है। यह एक हैश तालिका (hash table) है जो कुंजी-मान जोड़े संग्रहीत करती है। घोषणा का सिंटैक्स:

// map घोषित करें: कुंजियाँ — स्ट्रिंग्स, मान — पूर्णांक
var scores map[string]int

// एक खाली map आरंभ करें (अनिवार्य!)
scores = make(map[string]int)

// या तुरंत डेटा के साथ
scores := map[string]int{
    "Alice": 95,
    "Bob":   87,
}

महत्वपूर्ण बिंदु: यदि आप अनारंभित map (nil map) में मान लिखने का प्रयास करते हैं, तो प्रोग्राम पैनिक के साथ क्रैश हो जाएगा। ऐसा कभी न करें!

मुख्य तरीका: दो-मान असाइनमेंट (comma ok idiom)

यह Go में map में कुंजी की जाँच करने का सबसे सही और मुहावरेदार तरीका है।

सिंटैक्स इस प्रकार है:

value, ok := myMap[key]

यहाँ:

• value — कुंजी के अनुरूप मान (या यदि कुंजी नहीं है तो शून्य मान)
• ok — एक बूलियन चर जो true है यदि कुंजी मौजूद है, और false यदि नहीं है

आइए एक पूर्ण उदाहरण देखें:

package main

import "fmt"

func main() {
    // छात्रों के ग्रेड के साथ map बनाएँ
    grades := map[string]int{
        "Мария": 88,
        "Пётр":  92,
        "Анна":  0, // हाँ, Анна के 0 अंक हैं
    }

    // कुंजी "Пётр" जाँचें
    if grade, ok := grades["Пётр"]; ok {
        fmt.Printf("Пётр का ग्रेड: %d\n", grade)
    } else {
        fmt.Println("Пётр सूची में नहीं है")
    }

    // कुंजी "Иван" जाँचें
    if grade, ok := grades["Иван"]; ok {
        fmt.Printf("Иван का ग्रेड: %d\n", grade)
    } else {
        fmt.Println("Иван सूची में नहीं है")
    }

    // जटिल मामला: कुंजी "Анна" मौजूद है, लेकिन मान 0 है
    if grade, ok := grades["Анна"]; ok {
        fmt.Printf("Анна का ग्रेड: %d\n", grade) // आउटपुट: Анна का ग्रेड: 0
    }
}

ध्यान दें: कुंजी "Анна" के लिए ok true होगा, भले ही मान शून्य हो। यही कारण है कि केवल मान की जाँच पर निर्भर नहीं रहना चाहिए!

शून्य मान से तुलना क्यों नहीं कर सकते?

कई शुरुआती यह गलती करते हैं। वे कुछ इस तरह लिखते हैं:

if grades["Иван"] != 0 {
    fmt.Println("Иван सूची में है!")
}

यह गलत है दो कारणों से:

• संख्यात्मक प्रकारों के लिए: यदि Иван का वास्तव में ग्रेड 0 है, तो आप उसे छोड़ देंगे।
• अन्य प्रकारों के लिए: शून्य मान खाली स्ट्रिंग (""), false या nil हो सकता है। आप "कुंजी नहीं है" को "कुंजी है, लेकिन मान खाली है" से अलग नहीं कर पाएंगे।

एकमात्र विश्वसनीय तरीका comma ok idiom का उपयोग करना है।

मान प्राप्त किए बिना कुंजी की जाँच

कभी-कभी आपको केवल यह जानना होता है कि कुंजी मौजूद है या नहीं, और मान की आवश्यकता नहीं होती।