README
YAML marshaling and unmarshaling support for Go
Introduction
A wrapper around go-yaml designed to enable a better way of handling YAML when marshaling to and from structs.
In short, this library first converts YAML to JSON using go-yaml and then uses json.Marshal
and json.Unmarshal
to convert to or from the struct. This means that it effectively reuses the JSON struct tags as well as the custom JSON methods MarshalJSON
and UnmarshalJSON
unlike go-yaml. For a detailed overview of the rationale behind this method, see this blog post.
Compatibility
This package uses go-yaml and therefore supports everything go-yaml supports.
Caveats
Caveat #1: When using yaml.Marshal
and yaml.Unmarshal
, binary data should NOT be preceded with the !!binary
YAML tag. If you do, go-yaml will convert the binary data from base64 to native binary data, which is not compatible with JSON. You can still use binary in your YAML files though - just store them without the !!binary
tag and decode the base64 in your code (e.g. in the custom JSON methods MarshalJSON
and UnmarshalJSON
). This also has the benefit that your YAML and your JSON binary data will be decoded exactly the same way. As an example:
BAD:
exampleKey: !!binary gIGC
GOOD:
exampleKey: gIGC
... and decode the base64 data in your code.
Caveat #2: When using YAMLToJSON
directly, maps with keys that are maps will result in an error since this is not supported by JSON. This error will occur in Unmarshal
as well since you can't unmarshal map keys anyways since struct fields can't be keys.
Installation and usage
To install, run:
$ go get github.com/ghodss/yaml
And import using:
import "github.com/ghodss/yaml"
Usage is very similar to the JSON library:
package main
import (
"fmt"
"github.com/ghodss/yaml"
)
type Person struct {
Name string `json:"name"` // Affects YAML field names too.
Age int `json:"age"`
}
func main() {
// Marshal a Person struct to YAML.
p := Person{"John", 30}
y, err := yaml.Marshal(p)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(string(y))
/* Output:
age: 30
name: John
*/
// Unmarshal the YAML back into a Person struct.
var p2 Person
err = yaml.Unmarshal(y, &p2)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(p2)
/* Output:
{John 30}
*/
}
yaml.YAMLToJSON
and yaml.JSONToYAML
methods are also available:
package main
import (
"fmt"
"github.com/ghodss/yaml"
)
func main() {
j := []byte(`{"name": "John", "age": 30}`)
y, err := yaml.JSONToYAML(j)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(string(y))
/* Output:
name: John
age: 30
*/
j2, err := yaml.YAMLToJSON(y)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(string(j2))
/* Output:
{"age":30,"name":"John"}
*/
}
Documentation
Index ¶
- func DisallowUnknownFields(d *json.Decoder) *json.Decoder
- func JSONToYAML(j []byte) ([]byte, error)
- func Marshal(o interface{}) ([]byte, error)
- func Unmarshal(y []byte, o interface{}, opts ...JSONOpt) error
- func UnmarshalStrict(y []byte, o interface{}, opts ...JSONOpt) error
- func YAMLToJSON(y []byte) ([]byte, error)
- func YAMLToJSONStrict(y []byte) ([]byte, error)
- type JSONOpt
Constants ¶
Variables ¶
Functions ¶
func DisallowUnknownFields ¶
DisallowUnknownFields configures the JSON decoder to error out if unknown fields come along, instead of dropping them by default.
func Marshal ¶
Marshal marshals the object into JSON then converts JSON to YAML and returns the YAML.
func Unmarshal ¶
Unmarshal converts YAML to JSON then uses JSON to unmarshal into an object, optionally configuring the behavior of the JSON unmarshal.
func UnmarshalStrict ¶
UnmarshalStrict strictly converts YAML to JSON then uses JSON to unmarshal into an object, optionally configuring the behavior of the JSON unmarshal.
func YAMLToJSON ¶
YAMLToJSON converts YAML to JSON. Since JSON is a subset of YAML, passing JSON through this method should be a no-op.
Things YAML can do that are not supported by JSON: * In YAML you can have binary and null keys in your maps. These are invalid
in JSON. (int and float keys are converted to strings.)
* Binary data in YAML with the !!binary tag is not supported. If you want to
use binary data with this library, encode the data as base64 as usual but do not use the !!binary tag in your YAML. This will ensure the original base64 encoded data makes it all the way through to the JSON.
For strict decoding of YAML, use YAMLToJSONStrict.
func YAMLToJSONStrict ¶
YAMLToJSONStrict is like YAMLToJSON but enables strict YAML decoding, returning an error on any duplicate field names.