การใช้ JSON ใน Go มาดูกระบวนท่าพื้นฐานที่ไม่รู้ไม่ได้แล้ว !!!

{
   "key", value
}

{
   "key", value
}

{
    "name": "Aef",
    "age": 24,
    "pets": ["dog", "cat"]
}

func Marshal(v interface{}) ([]byte, error)

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	Coffee := map[string]int{
		"Latte":      55,
		"Cappuccino": 50,
		"Americano":  45,
	}
	bytes, _ := json.Marshal(Coffee)
	fmt.Println(string(bytes))
}

//ตรวจสอบชนิดของผลลัพธ์
fmt.Printf("Type of bytes %T\n", bytes)

package main

import (
	"encoding/json"
	"fmt"
)

type Coffee struct {
	Menu     string
	Price    int
	Quantity int
}

func main() {
	myCoffee := Coffee{"Cappuccino", 50, 2}
	bytes, _ := json.Marshal(myCoffee)
	fmt.Println(string(bytes))
}

if err != nil {
    fmt.Println("Error:", err)
    return
  }

package main

import (
	"encoding/json"
	"fmt"
)

type Ingredient struct {
	Name     string `json:"name"`
	Quantity int    `json:"quantity"`
	Unit     string `json:"unit"`
}

type MenuItem struct {
	Name        string       `json:"name"`
	Description string       `json:"description"`
	Price       float64      `json:"price"`
	Ingredients []Ingredient `json:"ingredients"`
}

func main() {
	// Define a slice of menu items
	menu := []MenuItem{
		{
			Name:        "Americano",
			Description: "A classic espresso drink",
			Price:       2.50,
			Ingredients: []Ingredient{
				{
					Name:     "Espresso",
					Quantity: 1,
					Unit:     "shot",
				},
				{
					Name:     "Water",
					Quantity: 6,
					Unit:     "oz",
				},
			},
		},
		{
			Name:        "Latte",
			Description: "Espresso with steamed milk",
			Price:       4.00,
			Ingredients: []Ingredient{
				{
					Name:     "Espresso",
					Quantity: 2,
					Unit:     "shot",
				},
				{
					Name:     "Milk",
					Quantity: 8,
					Unit:     "oz",
				},
			},
		},
	}

	// Marshal the menu items as a JSON string
	jsonString, err := json.Marshal(menu)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// Print the JSON string to the console
	fmt.Println(string(jsonString))
}

jsonString, err := json.MarshalIndent(menu, "", " ")
  if err != nil {
    fmt.Println("Error:", err)
    return
}

type MenuItem struct {
  Name string `json:"name"`
  Description string `json:"-"`
  Price float64 `json:"price"`
  Ingredients []Ingredient `json:"-"`
}

package main

import (
	"encoding/json"
	"fmt"
)

type MenuItem struct {
	Name        string  `json:"name"`
	Description string  `json:"description"`
	Price       float64 `json:"price"`
}

func main() {
	// Define a JSON string representing a menu item
	jsonString := `{
        "name": "Americano",
        "description": "A classic espresso drink",
        "price": 2.50
    }`

	// Unmarshal the JSON string into a MenuItem struct
	var menuItem MenuItem
	err := json.Unmarshal([]byte(jsonString), &menuItem)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// Print the menu item to the console
	fmt.Printf("%s (%s): $%.2f\n", menuItem.Name, menuItem.Description, menuItem.Price)
}

package main

import (
    "encoding/json"
    "fmt"
)

type Ingredient struct {
    Name     string `json:"name"`
    Quantity int    `json:"quantity"`
    Unit     string `json:"unit"`
}

type MenuItem struct {
    Name        string       `json:"name"`
    Description string       `json:"description"`
    Price       float64      `json:"price"`
    Ingredients []Ingredient `json:"ingredients"`
}

func main() {
    // Define a JSON string representing a slice of menu items
    jsonString := `[
        {
            "name": "Americano",
            "description": "A classic espresso drink",
            "price": 2.50,
            "ingredients": [
                {
                    "name": "Espresso",
                    "quantity": 1,
                    "unit": "shot"
                },
                {
                    "name": "Water",
                    "quantity": 6,
                    "unit": "oz"
                }
            ]
        },
        {
            "name": "Latte",
            "description": "Espresso with steamed milk",
            "price": 4.00,
            "ingredients": [
                {
                    "name": "Espresso",
                    "quantity": 2,
                    "unit": "shot"
                },
                {
                    "name": "Milk",
                    "quantity": 8,
                    "unit": "oz"
                }
            ]
        }
    ]`

    // Unmarshal the JSON string into a slice of MenuItem structs
    var menuItems []MenuItem
    err := json.Unmarshal([]byte(jsonString), &menuItems)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // Print the name, description, and price of each menu item to the console
    for _, menuItem := range menuItems {
        fmt.Printf("%s (%s): $%.2f\n", menuItem.Name, menuItem.Description, menuItem.Price)
    }
}

[
        {
            "name": "Americano",
            "description": "A classic espresso drink",
            "price": 2.50,
            "ingredients": [
                {
                    "name": "Espresso",
                    "quantity": 1,
                    "unit": "shot"
                },
                {
                    "name": "Water",
                    "quantity": 6,
                    "unit": "oz"
                }
            ]
        },
        {
            "name": "Latte",
            "description": "Espresso with steamed milk",
            "price": 4.00,
            "ingredients": [
                {
                    "name": "Espresso",
                    "quantity": 2,
                    "unit": "shot"
                },
                {
                    "name": "Milk",
                    "quantity": 8,
                    "unit": "oz"
                }
            ]
        }
    ]

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
)

type Ingredient struct {
	Name     string `json:"name"`
	Quantity int    `json:"quantity"`
	Unit     string `json:"unit"`
}

type Coffee struct {
	Name        string       `json:"name"`
	Description string       `json:"description"`
	Price       float64      `json:"price"`
	Ingredients []Ingredient `json:"ingredients"`
}

func main() {
	// Read the JSON file
	bytes, err := ioutil.ReadFile("coffee.json")
	if err != nil {
		log.Fatal(err)
	}

	// Parse the JSON data
	var coffees []Coffee
	err = json.Unmarshal(bytes, &coffees)
	if err != nil {
		log.Fatal(err)
	}

	// Print the coffee data
	for _, coffee := range coffees {
		fmt.Printf("Name: %s\n", coffee.Name)
		fmt.Printf("Description: %s\n", coffee.Description)
		fmt.Printf("Price: %.2f\n", coffee.Price)
		fmt.Println("Ingredients:")
		for _, ingredient := range coffee.Ingredients {
			fmt.Printf("- %s: %d %s\n", ingredient.Name, ingredient.Quantity, ingredient.Unit)
		}
		fmt.Println()
	}
}

package main

import (
	"encoding/json"
	"log"
	"os"
)

type Ingredient struct {
	Name     string `json:"name"`
	Quantity int    `json:"quantity"`
	Unit     string `json:"unit"`
}

type Coffee struct {
	Name        string       `json:"name"`
	Description string       `json:"description"`
	Price       float64      `json:"price"`
	Ingredients []Ingredient `json:"ingredients"`
}

func main() {
	// Define a slice of Coffee structs
	coffees := []Coffee{
		{
			Name:        "Americano",
			Description: "A classic espresso drink",
			Price:       2.50,
			Ingredients: []Ingredient{
				{Name: "Espresso", Quantity: 1, Unit: "shot"},
				{Name: "Water", Quantity: 6, Unit: "oz"},
			},
		},
		{
			Name:        "Latte",
			Description: "Espresso with steamed milk",
			Price:       4.00,
			Ingredients: []Ingredient{
				{Name: "Espresso", Quantity: 2, Unit: "shot"},
				{Name: "Milk", Quantity: 8, Unit: "oz"},
			},
		},
	}

	// Open the file for writing
	file, err := os.Create("coffe-new.json")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	// Encode the coffee data as JSON and write it to the file
	encoder := json.NewEncoder(file)
	err = encoder.Encode(coffees)
	if err != nil {
		log.Fatal(err)
	}
}