Go (Golang) में YAML का उपयोग

Go (Golang) में YAML के साथ काम करना — gopkg.in/yaml.v3 लाइब्रेरी

YAML (YAML Ain't Markup Language) एक लोकप्रिय डेटा सीरियलाइज़ेशन फ़ॉर्मेट है, जिसका उपयोग अक्सर कॉन्फ़िगरेशन फ़ाइलों, API (OpenAPI/Swagger) विवरण, CI/CD पाइपलाइनों (GitLab CI, GitHub Actions) और Docker Compose के लिए किया जाता है। Go (Golang) इकोसिस्टम में YAML के साथ काम करने के लिए कोई मानक लाइब्रेरी नहीं है, इसलिए डेवलपर्स शक्तिशाली और स्थिर थर्ड-पार्टी लाइब्रेरी gopkg.in/yaml.v3 का उपयोग करते हैं। इस लेख में, हम विस्तार से जानेंगे कि Go में YAML को कैसे पढ़ें, लिखें और प्रोसेस करें।

लाइब्रेरी इंस्टॉल करना

शुरू करने के लिए, अपने प्रोजेक्ट में पैकेज जोड़ें:

go get gopkg.in/yaml.v3

इसके बाद, इसे अपने कोड में इम्पोर्ट करें:

import "gopkg.in/yaml.v3"

YAML के साथ काम करने के लिए मुख्य स्ट्रक्चर

yaml.v3 लाइब्रेरी निम्नलिखित सुविधाएँ प्रदान करती है:

मार्शलिंग (Marshal) — Go स्ट्रक्चर को YAML स्ट्रिंग में बदलना।
अनमार्शलिंग (Unmarshal) — YAML स्ट्रिंग को Go स्ट्रक्चर में पार्स करना।
स्ट्रीम पार्सिंग (Decoder/Encoder) फ़ाइलों के साथ काम करने के लिए।
टैग yaml:"fieldname" फ़ील्ड नामों को कस्टमाइज़ करने के लिए।

उदाहरण 1: स्ट्रिंग से YAML पढ़ना

सबसे सरल मामला — YAML स्ट्रिंग को Go स्ट्रक्चर में पार्स करना:

package main

import (
    "fmt"
    "gopkg.in/yaml.v3"
)

type Config struct {
    Server struct {
        Port int    `yaml:"port"`
        Host string `yaml:"host"`
    } `yaml:"server"`
    Database struct {
        User string `yaml:"user"`
        Pass string `yaml:"pass"`
    } `yaml:"database"`
}

func main() {
    yamlData := `
server:
  port: 8080
  host: "localhost"
database:
  user: "admin"
  pass: "secret"
`
    var cfg Config
    err := yaml.Unmarshal([]byte(yamlData), &cfg)
    if err != nil {
        panic(err)
    }
    fmt.Printf("सर्वर: %s:%d\n", cfg.Server.Host, cfg.Server.Port)
    fmt.Printf("डेटाबेस: %s\n", cfg.Database.User)
}

उदाहरण 2: YAML को फ़ाइल में लिखना

YAML फ़ाइल में डेटा लिखने के लिए yaml.Marshal और फ़ाइल सिस्टम में लिखने का उपयोग करें:

package main

import (
    "os"
    "gopkg.in/yaml.v3"
)

type AppConfig struct {
    Name    string `yaml:"name"`
    Version string `yaml:"version"`
    Debug   bool   `yaml:"debug"`
}

func main() {
    config := AppConfig{
        Name:    "MyApp",
        Version: "1.0.0",
        Debug:   true,
    }

    data, err := yaml.Marshal(&config)
    if err != nil {
        panic(err)
    }

    err = os.WriteFile("config.yaml", data, 0644)
    if err != nil {
        panic(err)
    }
    println("config.yaml फ़ाइल बन गई")
}

उदाहरण 3: नेस्टेड और जटिल स्ट्रक्चर के साथ काम करना

YAML लिस्ट, map-स्ट्रक्चर और गहरी नेस्टिंग को सपोर्ट करता है। यहाँ सर्वरों की लिस्ट को पार्स करने का उदाहरण है:

package main

import (
    "fmt"
    "gopkg.in/yaml.v3"
)

type Service struct {
    Name    string   `yaml:"name"`
    Ports   []int    `yaml:"ports"`
    Enabled bool     `yaml:"enabled"`
}

type Deployment struct {
    Version  string    `yaml:"version"`
    Services []Service `yaml:"services"`
}

func main() {
    input := `
version: "2.1"
services:
  - name: web
    ports: [80, 443]
    enabled: true
  - name: api
    ports: [3000]
    enabled: false
`
    var dep Deployment
    if err := yaml.Unmarshal([]byte(input), &dep); err != nil {
        panic(err)
    }

    for _, s := range dep.Services {
        fmt.Printf("सेवा %s: पोर्ट %v, सक्रिय: %t\n", s.Name, s.Ports, s.Enabled)
    }
}

स्ट्रीम रीडिंग और राइटिंग (Decoder/Encoder)

बड़ी फ़ाइलों या डेटा स्ट्रीम के साथ काम करने के लिए yaml.Decoder और yaml.Encoder का उपयोग करें:

package main

import (
    "bytes"
    "fmt"
    "gopkg.in/yaml.v3"
)

func main() {
    // Encoder का उदाहरण
    var buf bytes.Buffer
    encoder := yaml.NewEncoder(&buf)
    // ... कोड जारी है
}