यह क्या है और क्यों ज़रूरी है?

mapstructure लाइब्रेरी Go भाषा के लिए एक सबसे आम समस्या को हल करती है: डायनामिक डेटा को स्ट्रक्चर में बदलना। यानी, map[string]interface{} को टाइप-सेफ Go स्ट्रक्चर में कन्वर्ट करना। असली प्रोजेक्ट्स में डेटा अक्सर JSON, YAML, TOML या बाहरी APIs से आता है, जहाँ स्ट्रक्चर गारंटीड नहीं होता। स्टैंडर्ड encoding/json JSON के लिए ठीक है, लेकिन जब आप मनमाने map (जैसे कॉन्फ़िगरेशन फ़ाइलों, Redis Hash, या SQL क्वेरी रिज़ल्ट्स) के साथ काम करते हैं, तो आपको एक ऐसे टूल की ज़रूरत होती है जो लचीला और सुरक्षित तरीके से डेटा मैप कर सके।

mapstructure का मुख्य काम है — map[स्ट्रिंग]इंटरफ़ेस लेना और स्ट्रक्चर के फ़ील्ड्स को भरना, ऑटोमैटिकली टाइप्स कन्वर्ट करना, नेस्टेड स्ट्रक्चर, स्लाइस, पॉइंटर्स और कस्टम टाइप्स को सपोर्ट करना। यह लाइब्रेरी कॉन्फ़िगरेशन पार्स करने में बहुत उपयोगी है, जहाँ कीज़ snake_case में हो सकती हैं और स्ट्रक्चर फ़ील्ड्स CamelCase में, या जब डेटा ऐसे स्रोतों से आता है जो स्टैंडर्ड JSON स्कीमा को सपोर्ट नहीं करते।

मैन्युअल मैपिंग की तुलना में mapstructure का सबसे बड़ा फ़ायदा है — डिक्लेरेटिव अप्रोच। आप सिर्फ़ स्ट्रक्चर को टैग्स के साथ डिफ़ाइन करते हैं, और लाइब्रेरी खुद ही रिकर्सिव ट्रैवर्सल, टाइप कन्वर्ज़न (जैसे string को int में), ऑप्शनल फ़ील्ड्स और टाइप मिसमैच एरर्स को हैंडल करती है। इससे कोड क्लीनर, सुरक्षित और बहुत कम boilerplate कोड के साथ हो जाता है।

इंस्टॉलेशन

लाइब्रेरी इंस्टॉल करने के लिए स्टैंडर्ड Go पैकेज मैनेजर का उपयोग करें। सुनिश्चित करें कि आपने मॉड्यूल इनिशियलाइज़ किया है (go mod init)।

go get github.com/mitchellh/mapstructure

कमांड चलाने के बाद लाइब्रेरी go.mod और go.sum में जुड़ जाएगी। इसे कोड में इम्पोर्ट करें:

import "github.com/mitchellh/mapstructure"

इस लेख के समय वर्शन v1.5.0 है। इस लाइब्रेरी की कोई बाहरी डिपेंडेंसी नहीं है, सिर्फ़ Go की स्टैंडर्ड लाइब्रेरी पर निर्भर है।

त्वरित शुरुआत — एक मिनिमल उदाहरण

एक सरल Person स्ट्रक्चर बनाएँ और map[string]interface{} को इस स्ट्रक्चर के इंस्टेंस में बदलें।

package main

import (
    "fmt"
    "github.com/mitchellh/mapstructure"
)

type Person struct {
    Name string
    Age  int
    City string
}

func main() {
    input := map[string]interface{}{
        "name": "Ravi",
        "age":  25,
        "city": "मुंबई",
    }

    var person Person
    err := mapstructure.Decode(input, &person)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Person: %+v\n", person)
    // आउटपुट: Person: {Name:Ravi Age:25 City:मुंबई}
}

जैसा कि आप देख सकते हैं, map की कीज़ ऑटोमैटिकली स्ट्रक्चर फ़ील्ड्स से मैच हो गईं (डिफ़ॉल्ट रूप से केस-इनसेंसिटिव)। अगर की "AGE" होती, तब भी वह Age फ़ील्ड में आ जाती।

मुख्य तरीके और फ़ंक्शन

mapstructure लाइब्रेरी के 8 मुख्य फ़ंक्शन/तरीकों को देखते हैं। हर तरीके के साथ सिग्नेचर, विवरण और कोड उदाहरण दिया गया है।

1. Decode

सिग्नेचर: func Decode(input interface{}, output interface{}) error

यह क्या करता है: map को स्ट्रक्चर में डिकोड करने का मुख्य फ़ंक्शन। यह किसी भी input (आमतौर पर map[string]interface{}) और output स्ट्रक्चर का पॉइंटर लेता है। अगर टाइप्स असंगत हैं या कोई अन्य समस्या है तो एरर रिटर्न करता है।

type Config struct {
    Host string
    Port int
}

func main() {
    data := map[string]interface{}{
        "host": "localhost",
        "port": 8080,
    }
    var cfg Config
    if err := mapstructure.Decode(data, &cfg); err != nil {
        panic(err)
    }
    fmt.Printf("Config: %+v\n", cfg)
    // Config: {Host:localhost Port:8080}
}