go yaml 语法学习

solate

发布于 2022-05-13 18:44:59

1.6K0

发布于 2022-05-13 18:44:59

文章被收录于专栏：solate 杂货铺solate 杂货铺

go yaml 语法学习

go使用比较多的是yaml.v2在github 地址是yaml.v2

git地址是github.com/go-yaml/yaml 但是下载到本地路径是

go get gopkg.in/yaml.v2

kubernetes底层yaml也是这个库，但是自己又封装了 sigs.k8s.io/yaml, 再往上又定义了kustomize

k8s声明式API介绍都需要使用yaml来定义，所以详细了解yaml使用非常有必要

简介

YAML=YAML Ain't Markup Language，YAML 是一种简洁的非标记语言。YAML以数据为中心，使用空白，缩进，分行组织数据，从而使得表示更加简洁易读。多用于api接口的定义。

规则

大小写敏感
使用缩进表示层级关系
禁止使用tab缩进，只能使用空格键
缩进长度没有限制，只要元素对齐就表示这些元素属于一个层级
使用#表示注释
字符串可以不用引号标注

yaml 对象

对象

对象：键值对的集合，又称为映射（map）/ 哈希（hashes） / 字典（dictionary）

使用冒号（: ）表示键值对，同一缩进的所有键值对属于一个map，示例：

# YAML表示
age : 12
name : aa
 
# 对应的Json表示
{'age':12,'name':'aa'}

package main

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

func main() {

	str := `
age : 12
name : aa
`
	type P struct {
		Name string
		Age  int
	}
	var p P
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err) // {aa 12} <nil>
}

数组

数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）

使用连字符（-）表示：
# YAML表示
- a
- b
- 12
# 对应Json表示
['a','b',12]

func main() {

	str := `
- a
- b
- 12
`
	var p []string
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err) // [a b 12] <nil>
}

纯量

纯量（scalars）：单个的、不可再分的值

数据的嵌套

map嵌套map

# YAML表示
websites:
 YAML: yaml.org 
 Ruby: ruby-lang.org 
 Python: python.org 
 Perl: use.perl.org 
# 对应Json表示
{ websites: 
   { YAML: 'yaml.org',
     Ruby: 'ruby-lang.org',
     Python: 'python.org',
     Perl: 'use.perl.org' } }

func main() {

	str := `
websites:
 YAML: yaml.org 
 Ruby: ruby-lang.org 
 Python: python.org 
 Perl: use.perl.org 
`

	var p map[string]map[string]string
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err) 
	// map[websites:map[Perl:use.perl.org Python:python.org Ruby:ruby-lang.org YAML:yaml.org]] <nil>
}

map嵌套list

# YAML表示
languages:
 - Ruby
 - Perl
 - Python 
 - c
# 对应Json表示
{ languages: [ 'Ruby', 'Perl', 'Python', 'c' ] }

func main() {

	str := `
languages:
 - Ruby
 - Perl
 - Python 
 - c
`

	var p map[string][]string
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err) // map[languages:[Ruby Perl Python c]] <nil>
}

3.list嵌套list

# YAML表示
-
  - Ruby
  - Perl
  - Python 
- 
  - c
  - c++
  - java
# 对应Json表示
[ [ 'Ruby', 'Perl', 'Python' ], [ 'c', 'c++', 'java' ] ]

func main() {

	str := `
-
  - Ruby
  - Perl
  - Python 
- 
  - c
  - c++
  - java
`

	var p [][]string
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err) // [[Ruby Perl Python] [c c++ java]] <nil>

}

4.list 嵌套map

# YAML表示
-
  id: 1
  name: huang
-
  id: 2
  name: liao
 
# 对应Json表示
[ { id: 1, name: 'huang' }, { id: 2, name: 'liao' } ]

func main() {

	str := `
-
  id: 1
  name: huang
-
  id: 2
  name: liao
`

	var p []map[string]string
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err) // [map[id:1 name:huang] map[id:2 name:liao]] <nil>
    // 这里一样的情况可以改结构体
}

其他 (这部分易错)

引号

单引号：会将字符串里面的特殊字符转义为字符串处理

name: '123\n123'
输出： 123\n123

func main() {

	str := `
name: '123\n123'
`

	var p map[string]string
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err) // map[name:123\n123] <nil>

}

双引号：不会转义字符串里面的特殊字符，特殊字符作为本身想表示的意思。

name: "123\n123" 
输出： 123 换行 123

func main() {

	str := `
name: "123\n123"
`

	var p map[string]string
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err) 
	// map[name:123
	// 123] <nil>

}

2.文本块

|：使用|标注的文本内容缩进表示的块，可以保留块中已有的回车换行

value: |
   hello
   world!
输出：hello 换行 world！

func main() {

	str := `
value: |
   hello
   world!
`

	var p map[string]string
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err)
	// map[value:hello
	// world!
	// ] <nil>

}

+表示保留文字块末尾的换行，-表示删除字符串末尾的换行。

value: |
hello

value: |-
hello

value: |+
hello
输出：hello\n hello hello\n\n(有多少个回车就有多少个\n)

func main() {

	str := `
value: |
   hello
`

	str1 := `
value: |-
   hello
`
	str2 := `
value: |+
   hello

`

	var p map[string]string
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err)
	// map[value:hello
	// ] <nil>

	var p1 map[string]string
	err = yaml.Unmarshal([]byte(str1), &p1)
	fmt.Println(p1, err)
	// map[value:hello] <nil>

	var p2 map[string]string
	err = yaml.Unmarshal([]byte(str2), &p2)
	fmt.Println(p2, err)
	// map[value:hello
	//
	// ] <nil>

}

：使用 > 标注的文本内容缩进表示的块，将块中回车替换为空格，最终连接成一行

value: > hello
world!
输出：hello 空格 world！
注意 “>” 与 文本之间的空格

例子中必须换行才能正确解析，并且需要缩进YAML Lint

func main() {

	str := `
value: > 
  hello 
  world!
`
	var p map[string]string
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err)
	// map[value:hello  world!
	// ] <nil>
}

3.锚点与引用

使用 & 定义数据锚点（即要复制的数据），使用 * 引用锚点数据（即数据的复制目的地）

name: &a yaml
book: *a
books: 
   - java
   - *a
   - python
输出book： yaml 
输出books：[java,yaml,python]
注意*引用部分不能追加内容

func main() {

	str := `
name: &a yaml
book: *a
books: 
   - java
   - *a
   - python
`

	type P struct {
		Name  string
		Book  string
		Books []string
	}
	var p P
	err := yaml.Unmarshal([]byte(str), &p)
	fmt.Println(p, err) // {yaml yaml [java yaml python]} <nil>
}

& 用来建立锚点（defaults），<< 表示合并到当前数据，* 用来引用锚点。 YAML 入门教程

defaults: &defaults
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  <<: *defaults

test:
  database: myapp_test
  <<: *defaults

相当于

defaults:
  adapter:  postgres
  host:     localhost

development:
  database: myapp_development
  adapter:  postgres
  host:     localhost

test:
  database: myapp_test
  adapter:  postgres
  host:     localhost

4.存量，数据类型约定

字符串

使用”或”“或不使用引号

#YAML
str: abc

#YAML
#包含特殊字符需要加引号
str: '内容:字符串'

#YAML
#单双引号均可，双引号不会对特殊符号转义
s1: '内容\n字符串'
s2: "内容\n字符串"

2.布尔值

true或false表示。

#YAML
isTrue: true
isTrue: false

3.数字

12 #整数 
014 # 八进制整数 
0xC ＃十六进制整数 
13.4 ＃浮点数 
1.2e+34 ＃指数 
.inf空值 ＃无穷大

#YAML
int: 10
float: 1.23
double: 2.34

4.空值

null或~表示

#YAML
person: ~

5.时间

使用 iso-8601 标准表示

#YAML
iso8601: 2018-05-20t10:59:43.10-05:00

6. 日期

日期采用ISO8601的格式yyyy-MM-dd表示

#YAML
date: 2018-05-20

7. 强制类型转换

YAML 允许使用个感叹号!，强制转换数据类型，单叹号通常是自定义类型，双叹号是内置类型。

money: !!str
123
date: !Boolean
true
内置类型：
!!int # 整数类型 
!!float # 浮点类型 
!!bool # 布尔类型 
!!str # 字符串类型 
!!binary # 也是字符串类型 
!!timestamp # 日期时间类型 
!!null # 空值 
!!set # 集合 
!!omap,!!pairs # 键值列表或对象列表
!!seq # 序列，也是列表 !!map # 键值表