Encoding

Package encoding defines interfaces shared by other packages that convert data to and from byte-level and textual representations. Packages that check for these interfaces include encoding/gob, encoding/json, and encoding/xml.

JSON Encoding/Decoding

Package json implements encoding and decoding of JSON as defined in RFC 7159.

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name  string `json:"name"`
	Age   int    `json:"age"`
	Email string `json:"email,omitempty"`
}

func main() {
	// JSON Encoding
	person := Person{Name: "Lite Rank", Age: 30}
	jsonData, err := json.Marshal(person)
	if err != nil {
		fmt.Println("JSON encoding error:", err)
		return
	}
	fmt.Println("JSON Encoded:", string(jsonData))
    // => JSON Encoded: {"name":"Lite Rank","age":30}

	// JSON Decoding
	var decodedPerson Person
	err = json.Unmarshal(jsonData, &decodedPerson)
	if err != nil {
		fmt.Println("JSON decoding error:", err)
		return
	}
	fmt.Println("JSON Decoded:", decodedPerson)
    // => JSON Decoded: {Lite Rank 30 }
}

XML Encoding/Decoding

Package xml implements a simple XML 1.0 parser that understands XML name spaces.

package main

import (
	"encoding/xml"
	"fmt"
)

type PersonXML struct {
	XMLName xml.Name `xml:"person"`
	Name    string   `xml:"name"`
	Age     int      `xml:"age"`
	Email   string   `xml:"email,omitempty"`
}

func main() {
	// XML Encoding
	person := PersonXML{Name: "John Doe", Age: 30}
	xmlData, err := xml.MarshalIndent(person, "", "    ")
	if err != nil {
		fmt.Println("XML encoding error:", err)
		return
	}
	fmt.Println("XML Encoded:")
	fmt.Println(string(xmlData))
    // => XML Encoded:
//<person>
//    <name>John Doe</name>
//    <age>30</age>
//</person>

	// XML Decoding
	var decodedPerson PersonXML
	err = xml.Unmarshal(xmlData, &decodedPerson)
	if err != nil {
		fmt.Println("XML decoding error:", err)
		return
	}
	fmt.Println("XML Decoded:", decodedPerson)
    // => XML Decoded: {{ person} John Doe 30 }
}

Base64 Encoding/Decoding

Package base64 implements base64 encoding as specified by RFC 4648.

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	// Base64 Encoding
	data := []byte("Hello, Base64 Encoding!")
	encodedData := base64.StdEncoding.EncodeToString(data)
	fmt.Println("Base64 Encoded:", encodedData)
    // => Base64 Encoded: SGVsbG8sIEJhc2U2NCBFbmNvZGluZyE=

	// Base64 Decoding
	decodedData, err := base64.StdEncoding.DecodeString(encodedData)
	if err != nil {
		fmt.Println("Base64 decoding error:", err)
		return
	}
	fmt.Println("Base64 Decoded:", string(decodedData))
    // => Base64 Decoded: Hello, Base64 Encoding!
}

Gob Encoding/Decoding

The encoding/gob package in Go is used for encoding and decoding data structures in a binary format.

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
	"log"
)

// Person struct represents a person.
type Person struct {
	Name string
	Age  int
}

func main() {
	// Encoding
	person := Person{Name: "Alice", Age: 25}

	var buffer bytes.Buffer
	encoder := gob.NewEncoder(&buffer)

	err := encoder.Encode(person)
	if err != nil {
		log.Fatal("Encode error:", err)
	}

	encodedData := buffer.Bytes()
	fmt.Println("Encoded Data:", encodedData)
    // => Encoded Data: [37 255 129 3 1 1 6 80 101 114 115 111 110 1 255 130 0 1 2 1 4 78 97 109 101 1 12 0 1 3 65 103 101 1 4 0 0 0 12 255 130 1 5 65 108 105 99 101 1 50 0]

	// Decoding
	var decodedPerson Person
	decoder := gob.NewDecoder(bytes.NewReader(encodedData))

	err = decoder.Decode(&decodedPerson)
	if err != nil {
		log.Fatal("Decode error:", err)
	}

	fmt.Println("Decoded Person:", decodedPerson)
    // => Decoded Person: {Alice 25}
}

Code Challenge

Create a program that reads configuration data from a JSON file and performs specific actions based on the configuration.