Go Yaml 解释示例

huangapple
go评论128阅读模式
英文:

Go Yaml Interpretation Example

问题

这是一个Go Yaml解析的示例，可以解析一个简单的YAML数据结构：

  1. foo: 1
  2. bar:
  3.   - one
  4.   - two

现在我想解析一个包含相同数据结构的数组，应该如何正确操作？

以下是我目前的代码，但它不能按预期工作。请帮忙看看。

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"log"
  7. 	"gopkg.in/yaml.v2"
  8. )
  10. type Config struct {
  11. 	Foo string
  12. 	Bar []string
  13. }
  15. type Configs struct {
  16. 	Cfgs []Config
  17. }
  19. var data = `
  20. - foo: 1
  21.   bar:
  22.     - one
  23.     - two
  24.     - three
  25. - foo: 2
  26.   bar:
  27.     - one1
  28.     - two2
  29.     - three3
  30. `
  32. func main() {
  34.   var config Configs
  35.   
  36. 	/*
  37. 	   filename := os.Args[1]
  38. 	   source, err := ioutil.ReadFile(filename)
  39. 	   if err != nil {
  40. 	       panic(err)
  41. 	   }
  42. 	*/
  44. 	source := []byte(data)
  46. 	err := yaml.Unmarshal(source, &config)
  47. 	if err != nil {
  48. 		log.Fatalf("error: %v", err)
  49. 	}
  51. 	//fmt.Printf("Value: %#v\n", config.Bar[0])
  52. 	
  53. 	fmt.Printf("--- config:\n%v\n\n", config)
  54. }

更新：

为了使其工作，Jfly指出，只需将我的var config Configs替换为var config []Config，就可以解决问题。现在我认为，如果将我的数据定义更改为以下内容，我的上述代码将起作用。

  1. foobars:
  2.  - foo: 1
  3.    bar:
  4.     - one
  5.     - two
  6.     - three
  8.  - foo: 2
  9.    bar:
  10.     - one1
  11.     - two2
  12.     - three3

不好意思，它还是不起作用。请帮忙看看。

英文:

This Go Yaml Interpretation Example,
https://gist.github.com/suntong001/74c85d15b19ef4b14b0e, can unmarshal a simple YAML like this:

  1. foo: 1
  2. bar:
  3.   - one
  4.   - two

Now I want to interpretation an array of the exact same data structure, what's the correct way to do?

Below is my code so far, and it is not working as expected. Please help.

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"log"
  7. 	"gopkg.in/yaml.v2"
  8. )
  10. type Config struct {
  11. 	Foo string
  12. 	Bar []string
  13. }
  15. type Configs struct {
  16. 	Cfgs []Config
  17. }
  19. var data = `
  20. - foo: 1
  21.   bar:
  22.     - one
  23.     - two
  24.     - three
  25. - foo: 2
  26.   bar:
  27.     - one1
  28.     - two2
  29.     - three3
  30. `
  32. func main() {
  34.   var config Configs
  35.   
  36. 	/*
  37. 	   filename := os.Args[1]
  38. 	   source, err := ioutil.ReadFile(filename)
  39. 	   if err != nil {
  40. 	       panic(err)
  41. 	   }
  42. 	*/
  44. 	source := []byte(data)
  46. 	err := yaml.Unmarshal(source, &config)
  47. 	if err != nil {
  48. 		log.Fatalf("error: %v", err)
  49. 	}
  51. 	//fmt.Printf("Value: %#v\n", config.Bar[0])
  52. 	
  53. 	fmt.Printf("--- config:\n%v\n\n", config)
  54. }

UPDATE:

To make it work, Jfly pointed out, simply replace my var config Configs with var config []Config, and it does the trick. Now I think if change my data definition to the following, my above code would work.

  1. foobars:
  2.  - foo: 1
  3.    bar:
  4.     - one
  5.     - two
  6.     - three
  8.  - foo: 2
  9.    bar:
  10.     - one1
  11.     - two2
  12.     - three3

Nops, it doesn't. Please help.

答案1

得分: 1

示例yaml文件的内容是对象序列，可以按照以下方式处理：

  1. package main
  3. import (
  4.     "fmt"
  5.     "log"
  7.     "gopkg.in/yaml.v2"
  8. )
  10. type Config struct {
  11.     Foo string
  12.     Bar []string
  13. }
  15. var data = `
  16. - foo: 1
  17.   bar:
  18.     - one
  19.     - two
  20.     - three
  21. - foo: 2
  22.   bar:
  23.     - one1
  24.     - two2
  25.     - three3
  26. `
  28. func main() {
  30.     var config []Config
  32.     /*
  33.        filename := os.Args[1]
  34.        source, err := ioutil.ReadFile(filename)
  35.        if err != nil {
  36.            panic(err)
  37.        }
  38.     */
  40.     source := []byte(data)
  42.     err := yaml.Unmarshal(source, &config)
  43.     if err != nil {
  44.         log.Fatalf("error: %v", err)
  45.     }
  47.     //fmt.Printf("Value: %#v\n", config.Bar[0])
  49.     fmt.Printf("--- config:\n%v\n\n", config)
  50. }

至于你更新的问题，你的代码几乎可以工作，只需给yaml解析器一个提示，像这样：

  1. type Configs struct {
  2.     Cfgs []Config `yaml:"foobars"`
  3. }
英文:

The contents of the example yaml file are sequence of objects, so do it like this:

  1. package main
  3. import (
  4.     "fmt"
  5.     "log"
  7.     "gopkg.in/yaml.v2"
  8. )
  10. type Config struct {
  11.     Foo string
  12.     Bar []string
  13. }
  15. var data = `
  16. - foo: 1
  17.   bar:
  18.     - one
  19.     - two
  20.     - three
  21. - foo: 2
  22.   bar:
  23.     - one1
  24.     - two2
  25.     - three3
  26. `
  28. func main() {
  30.     var config []Config
  32.     /*
  33.        filename := os.Args[1]
  34.        source, err := ioutil.ReadFile(filename)
  35.        if err != nil {
  36.            panic(err)
  37.        }
  38.     */
  40.     source := []byte(data)
  42.     err := yaml.Unmarshal(source, &config)
  43.     if err != nil {
  44.         log.Fatalf("error: %v", err)
  45.     }
  47.     //fmt.Printf("Value: %#v\n", config.Bar[0])
  49.     fmt.Printf("--- config:\n%v\n\n", config)
  50. }

As to your updated question, your code almost works, just give a hint to the yaml parser like this:

  1. type Configs struct {
  2.     Cfgs []Config `foobars`
  3. }

huangapple
  • 本文由 发表于 2015年6月15日 12:27:53
  • 转载请务必保留本文链接：https://go.coder-hub.com/30837357.html
  • go
  • yaml
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定