map[interface {}]interface {} yaml文件解码 检查类型断言

解析json、yaml文件

 

DsnDG : user:pwd@tcp(ip:portr)/db?charset=utf8mb4

 

 

 

type MysqlConfig struct {

    DsnDG string `yaml:"DsnDG"`

}

// config should be a pointer to structure, if not, panic

func loadJsonConfig() *MysqlConfig {

    workPath, err := os.Getwd()

    if err != nil {

        panic(err)

    }

    configPath := filepath.Join(workPath, "conf")

    log.Println("configPath: ", configPath)

    fullPath := filepath.Join(configPath, "db.yaml")

    log.Println(fullPath)

    file, err := os.Open(fullPath)

    if err != nil {

        msg := fmt.Sprintf("Can not load config at %s. Error: %v", fullPath, err)

        panic(msg)

    }

    defer file.Close()

    var bs []byte

    bs, err = os.ReadFile(fullPath)

    if err != nil {

        panic(err)

    }

    config := &MysqlConfig{}

    err = yaml.Unmarshal(bs, &config)

    if err != nil {

        panic(err)

    }

    return config

}

 

{

    "topic":"a2",

    "group.id":"go_dev",

    "bootstrap.servers":"alikafka-pre-cn-st21wg28xxxx-1-vpc.alikafka.aliyuncs.com:9094,alikafka-pre-cn-st21wg28xxxx-2-vpc.alikafka.aliyuncs.com:9094,alikafka-pre-cn-st21wg28xxxx-3-vpc.alikafka.aliyuncs.com:9094",

    "security.protocol":"sasl_plaintext",

    "sasl.mechanism":"PLAIN",

    "sasl.username":"SASL_PLAINTEXT_dg_go",

    "sasl.password":"xxxxF$184354D20%A7F1Bent_de5F6A*301DF2D7"

    }

     

 

 

type KafkaConfig struct {

    Topic            string `json:"topic"`

    GroupId          string `json:"group.id"`

    BootstrapServers string `json:"bootstrap.servers"`

    SecurityProtocol string `json:"security.protocol"`

    SaslMechanism    string `json:"sasl.mechanism"`

    SaslUsername     string `json:"sasl.username"`

    SaslPassword     string `json:"sasl.password"`

}

 

 

 

 

 

 

// config should be a pointer to structure, if not, panic

func loadJsonConfig() *KafkaConfig {

    workPath, err := os.Getwd()

    if err != nil {

        panic(err)

    }

    configPath := filepath.Join(workPath, "conf")

    log.Println("configPath: ", configPath)

    fullPath := filepath.Join(configPath, "kafka.json")

    file, err := os.Open(fullPath)

    if err != nil {

        msg := fmt.Sprintf("Can not load config at %s. Error: %v", fullPath, err)

        panic(msg)

    }

    defer file.Close()

    decoder := json.NewDecoder(file)

    var config = &KafkaConfig{}

    err = decoder.Decode(config)

    if err != nil {

        msg := fmt.Sprintf("Decode json fail for config file at %s. Error: %v", fullPath, err)

        panic(msg)

    }

    json.Marshal(config)

    return config

}

 

 

 

 

 

map[interface {}]interface {}

 

map[interface{}]interface{} on a map[string]interface{} · Issue #139 · go-yaml/yaml https://github.com/go-yaml/yaml/issues/139

 

f1: hi世界
f2:
  f3: value
  f4: [42, 1024]
  f5: [a b]
  f6:
    f7: 77
    f8: ok

　　

 

package main

import (
	"fmt"
	"io/ioutil"

	"gopkg.in/yaml.v3"
)

func main() {
	var err error
	m := make(map[string]interface{})
	var bs []byte
	bs, err = ioutil.ReadFile("a.yaml")
	if err != nil {
		panic(err)
	}
	err = yaml.Unmarshal(bs, &m)
	if err != nil {
		panic(err)
	}
	f1v := m["f1"].(string)
	var f3v string
	var f4v []int
	var f5v []string
	var f6v map[string]interface{}

	for k, v := range m["f2"].(map[string]interface{}) {
		switch k {
		case "f3":
			f3v = v.(string)
		case "f4", "f5":
			l := v.([]interface{})
			if k == "f4" {
				for _, u := range l {
					f4v = append(f4v, u.(int))
				}
			}
			if k == "f5" {
				for _, u := range l {
					f5v = append(f5v, u.(string))
				}
			}
		case "f6":
			f6v = v.(map[string]interface{})
		default:
		}
	}
	
	fmt.Println("---->", f1v, f3v, f4v, f5v, f6v)
}

　　

 

go run *go
----> hi世界 value [42 1024] [a b] map[f7:77 f8:ok]

 

 2）

the-way-to-go_ZH_CN/11.3.md at master · unknwon/the-way-to-go_ZH_CN · GitHub https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/11.3.md

通常我们可以使用 类型断言 来测试在某个时刻 varI 是否包含类型 T 的值：

v := varI.(T)       // unchecked type assertion

varI 必须是一个接口变量，否则编译器会报错：invalid type assertion: varI.(T) (non-interface type (type of varI) on left) 。

类型断言可能是无效的，虽然编译器会尽力检查转换是否有效，但是它不可能预见所有的可能性。如果转换在程序运行时失败会导致错误发生。更安全的方式是使用以下形式来进行类型断言：

if v, ok := varI.(T); ok {  // checked type assertion
    Process(v)
    return
}
// varI is not of type T

如果转换合法，v 是 varI 转换到类型 T 的值，ok 会是 true；否则 v 是类型 T 的零值，ok 是 false，也没有运行时错误发生。

应该总是使用上面的方式来进行类型断言。

多数情况下，我们可能只是想在 if 中测试一下 ok 的值，此时使用以下的方法会是最方便的：

if _, ok := varI.(T); ok {
    // ...
}