json

package

v0.0.0-...-4849db3Latest Latest

This package is not in the latest version of its module.

Go to latest Published: Oct 27, 2025 License:BSD-3-ClauseImports:15Imported by:12

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/go-json-experiment/json

Documentation ¶

Overview¶

Package json implements encoding and decoding of JSON as defined inRFC 7159. The mapping between JSON and Go values is describedin the documentation for the Marshal and Unmarshal functions.

See "JSON and Go" for an introduction to this package:https://golang.org/doc/articles/json_and_go.html

Security Considerations¶

See the "Security Considerations" section inencoding/json/v2.

For historical reasons, the default behavior of v1encoding/jsonunfortunately operates with less secure defaults.New usages of JSON in Go are encouraged to useencoding/json/v2 instead.

Migrating to v2¶

This package (i.e.,encoding/json) is now formally known as the v1 packagesince a v2 package now exists atencoding/json/v2.All the behavior of the v1 package is implemented in terms ofthe v2 package with the appropriate set of options specified thatpreserve the historical behavior of v1.

Thejsonv2.Marshal function is the newer equivalent of v1Marshal.Thejsonv2.Unmarshal function is the newer equivalent of v1Unmarshal.The v2 functions have the same calling signature as the v1 equivalentexcept that they take in variadicOptions arguments that can be specifiedto alter the behavior of marshal or unmarshal. Both v1 and v2 generallybehave in similar ways, but there are some notable differences.

The following is a list of differences between v1 and v2:

In v1, JSON object members are unmarshaled into a Go struct using acase-insensitive name match with the JSON name of the fields.In contrast, v2 matches fields using an exact, case-sensitive match.Thejsonv2.MatchCaseInsensitiveNames andMatchCaseSensitiveDelimiteroptions control this behavior difference. To explicitly specify a Go structfield to use a particular name matching scheme, either the `case:ignore`or the `case:strict` field option can be specified.Field-specified options take precedence over caller-specified options.
In v1, when marshaling a Go struct, a field marked as `omitempty`is omitted if the field value is an "empty" Go value, which is defined asfalse, 0, a nil pointer, a nil interface value, andany empty array, slice, map, or string. In contrast, v2 redefines`omitempty` to omit a field if it encodes as an "empty" JSON value,which is defined as a JSON null, or an empty JSON string, object, or array.TheOmitEmptyWithLegacySemantics option controls this behavior difference.Note that `omitempty` behaves identically in both v1 and v2 for aGo array, slice, map, or string (assuming no user-defined MarshalJSON methodoverrides the default representation). Existing usages of `omitempty` on aGo bool, number, pointer, or interface value should migrate to specifying`omitzero` instead (which is identically supported in both v1 and v2).
In v1, a Go struct field marked as `string` can be used to quote aGo string, bool, or number as a JSON string. It does not recursivelytake effect on composite Go types. In contrast, v2 restrictsthe `string` option to only quote a Go number as a JSON string.It does recursively take effect on Go numbers within a composite Go type.TheStringifyWithLegacySemantics option controls this behavior difference.
In v1, a nil Go slice or Go map is marshaled as a JSON null.In contrast, v2 marshals a nil Go slice or Go map asan empty JSON array or JSON object, respectively.Thejsonv2.FormatNilSliceAsNull andjsonv2.FormatNilMapAsNull optionscontrol this behavior difference. To explicitly specify a Go struct fieldto use a particular representation for nil, either the `format:emitempty`or `format:emitnull` field option can be specified.Field-specified options take precedence over caller-specified options.
In v1, a Go array may be unmarshaled from a JSON array of any length.In contrast, in v2 a Go array must be unmarshaled from a JSON arrayof the same length, otherwise it results in an error.TheUnmarshalArrayFromAnyLength option controls this behavior difference.
In v1, a Go byte array is represented as a JSON array of JSON numbers.In contrast, in v2 a Go byte array is represented as a Base64-encoded JSON string.TheFormatByteArrayAsArray option controls this behavior difference.To explicitly specify a Go struct field to use a particular representation,either the `format:array` or `format:base64` field option can be specified.Field-specified options take precedence over caller-specified options.
In v1, MarshalJSON methods declared on a pointer receiver are only calledif the Go value is addressable. In contrast, in v2 a MarshalJSON methodis always callable regardless of addressability.TheCallMethodsWithLegacySemantics option controls this behavior difference.
In v1, MarshalJSON and UnmarshalJSON methods are never called for Go map keys.In contrast, in v2 a MarshalJSON or UnmarshalJSON method is eligible forbeing called for Go map keys.TheCallMethodsWithLegacySemantics option controls this behavior difference.
In v1, a Go map is marshaled in a deterministic order.In contrast, in v2 a Go map is marshaled in a non-deterministic order.Thejsonv2.Deterministic option controls this behavior difference.
In v1, JSON strings are encoded with HTML-specific or JavaScript-specificcharacters being escaped. In contrast, in v2 JSON strings use the minimalencoding and only escape if required by the JSON grammar.Thejsontext.EscapeForHTML andjsontext.EscapeForJS optionscontrol this behavior difference.
In v1, bytes of invalid UTF-8 within a string are silently replaced withthe Unicode replacement character. In contrast, in v2 the presence ofinvalid UTF-8 results in an error. Thejsontext.AllowInvalidUTF8 optioncontrols this behavior difference.
In v1, a JSON object with duplicate names is permitted.In contrast, in v2 a JSON object with duplicate names results in an error.Thejsontext.AllowDuplicateNames option controls this behavior difference.
In v1, when unmarshaling a JSON null into a non-empty Go value it willinconsistently either zero out the value or do nothing.In contrast, in v2 unmarshaling a JSON null will consistently and alwayszero out the underlying Go value. TheMergeWithLegacySemantics optioncontrols this behavior difference.
In v1, when unmarshaling a JSON value into a non-zero Go value,it merges into the original Go value for array elements, slice elements,struct fields (but not map values),pointer values, and interface values (only if a non-nil pointer).In contrast, in v2 unmarshal merges into the Go valuefor struct fields, map values, pointer values, and interface values.In general, the v2 semantic merges when unmarshaling a JSON object,otherwise it replaces the value. TheMergeWithLegacySemantics optioncontrols this behavior difference.
In v1, atime.Duration is represented as a JSON number containingthe decimal number of nanoseconds. In contrast, in v2 atime.Durationhas no default representation and results in a runtime error.TheFormatDurationAsNano option controls this behavior difference.To explicitly specify a Go struct field to use a particular representation,either the `format:nano` or `format:units` field option can be specified.Field-specified options take precedence over caller-specified options.
In v1, errors are never reported at runtime for Go struct typesthat have some form of structural error (e.g., a malformed tag option).In contrast, v2 reports a runtime error for Go types that are invalidas they relate to JSON serialization. For example, a Go structwith only unexported fields cannot be serialized.TheReportErrorsWithLegacySemantics option controls this behavior difference.

As mentioned, the entirety of v1 is implemented in terms of v2,where options are implicitly specified to opt into legacy behavior.For example,Marshal directly callsjsonv2.Marshal withDefaultOptionsV1.Similarly,Unmarshal directly callsjsonv2.Unmarshal withDefaultOptionsV1.TheDefaultOptionsV1 option represents the set of all options that specifydefault v1 behavior.

For many of the behavior differences, there are Go struct field optionsthat the author of a Go type can specify to control the behavior such thatthe type is represented identically in JSON under either v1 or v2 semantics.

The availability ofDefaultOptionsV1 andjsonv2.DefaultOptionsV2,where later options take precedence over former options allows fora gradual migration from v1 to v2. For example:

jsonv1.Marshal(v)uses default v1 semantics.
jsonv2.Marshal(v, jsonv1.DefaultOptionsV1())is semantically equivalent to jsonv1.Marshaland thus uses default v1 semantics.
jsonv2.Marshal(v, jsonv1.DefaultOptionsV1(), jsontext.AllowDuplicateNames(false))uses mostly v1 semantics, but opts into one particular v2-specific behavior.
jsonv2.Marshal(v, jsonv1.CallMethodsWithLegacySemantics(true))uses mostly v2 semantics, but opts into one particular v1-specific behavior.
jsonv2.Marshal(v, ..., jsonv2.DefaultOptionsV2())is semantically equivalent to jsonv2.Marshal sincejsonv2.DefaultOptionsV2 overrides any options specified earlierand thus uses default v2 semantics.
jsonv2.Marshal(v)uses default v2 semantics.

All new usages of "json" in Go should use the v2 package,but the v1 package will forever remain supported.

Example (CustomMarshalJSON)¶

//go:build !goexperiment.jsonv2 || !go1.25package mainimport ("fmt""log""strings""github.com/go-json-experiment/json/v1")type Animal intconst (Unknown Animal = iotaGopherZebra)func (a *Animal) UnmarshalJSON(b []byte) error {var s stringif err := json.Unmarshal(b, &s); err != nil {return err}switch strings.ToLower(s) {default:*a = Unknowncase "gopher":*a = Gophercase "zebra":*a = Zebra}return nil}func (a Animal) MarshalJSON() ([]byte, error) {var s stringswitch a {default:s = "unknown"case Gopher:s = "gopher"case Zebra:s = "zebra"}return json.Marshal(s)}func main() {blob := `["gopher","armadillo","zebra","unknown","gopher","bee","gopher","zebra"]`var zoo []Animalif err := json.Unmarshal([]byte(blob), &zoo); err != nil {log.Fatal(err)}census := make(map[Animal]int)for _, animal := range zoo {census[animal] += 1}fmt.Printf("Zoo Census:\n* Gophers: %d\n* Zebras:  %d\n* Unknown: %d\n",census[Gopher], census[Zebra], census[Unknown])}

Output:Zoo Census:* Gophers: 3* Zebras:  2* Unknown: 3

Example (TextMarshalJSON)¶

//go:build !goexperiment.jsonv2 || !go1.25package mainimport ("fmt""log""strings""github.com/go-json-experiment/json/v1")type Size intconst (Unrecognized Size = iotaSmallLarge)func (s *Size) UnmarshalText(text []byte) error {switch strings.ToLower(string(text)) {default:*s = Unrecognizedcase "small":*s = Smallcase "large":*s = Large}return nil}func (s Size) MarshalText() ([]byte, error) {var name stringswitch s {default:name = "unrecognized"case Small:name = "small"case Large:name = "large"}return []byte(name), nil}func main() {blob := `["small","regular","large","unrecognized","small","normal","small","large"]`var inventory []Sizeif err := json.Unmarshal([]byte(blob), &inventory); err != nil {log.Fatal(err)}counts := make(map[Size]int)for _, size := range inventory {counts[size] += 1}fmt.Printf("Inventory Counts:\n* Small:        %d\n* Large:        %d\n* Unrecognized: %d\n",counts[Small], counts[Large], counts[Unrecognized])}

Output:Inventory Counts:* Small:        3* Large:        2* Unrecognized: 3

Index¶

Examples¶

Constants¶

This section is empty.

Variables¶

This section is empty.

Functions¶

funcCompact ¶

func Compact(dst *bytes.Buffer, src []byte)error

Compact appends to dst the JSON-encoded src withinsignificant space characters elided.

funcHTMLEscape ¶

func HTMLEscape(dst *bytes.Buffer, src []byte)

HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029so that the JSON will be safe to embed inside HTML <script> tags.For historical reasons, web browsers don't honor standard HTMLescaping within <script> tags, so an alternative JSON encoding must be used.

Example¶

var out bytes.Bufferjson.HTMLEscape(&out, []byte(`{"Name":"<b>HTML content</b>"}`))out.WriteTo(os.Stdout)

Output:{"Name":"\u003cb\u003eHTML content\u003c/b\u003e"}

funcIndent ¶

func Indent(dst *bytes.Buffer, src []byte, prefix, indentstring)error

Indent appends to dst an indented form of the JSON-encoded src.Each element in a JSON object or array begins on a new,indented line beginning with prefix followed by one or morecopies of indent according to the indentation nesting.The data appended to dst does not begin with the prefix norany indentation, to make it easier to embed inside other formatted JSON data.Although leading space characters (space, tab, carriage return, newline)at the beginning of src are dropped, trailing space charactersat the end of src are preserved and copied to dst.For example, if src has no trailing spaces, neither will dst;if src ends in a trailing newline, so will dst.

Example¶

type Road struct {Name   stringNumber int}roads := []Road{{"Diamond Fork", 29},{"Sheep Creek", 51},}b, err := json.Marshal(roads)if err != nil {log.Fatal(err)}var out bytes.Bufferjson.Indent(&out, b, "=", "\t")out.WriteTo(os.Stdout)

Output:[={="Name": "Diamond Fork",="Number": 29=},={="Name": "Sheep Creek",="Number": 51=}=]

funcMarshal ¶

func Marshal(vany) ([]byte,error)

Marshal returns the JSON encoding of v.

Marshal traverses the value v recursively.If an encountered value implementsMarshalerand is not a nil pointer, Marshal calls [Marshaler.MarshalJSON]to produce JSON. If no [Marshaler.MarshalJSON] method is present but thevalue implementsencoding.TextMarshaler instead, Marshal callsencoding.TextMarshaler.MarshalText and encodes the result as a JSON string.The nil pointer exception is not strictly necessarybut mimics a similar, necessary exception in the behavior of[Unmarshaler.UnmarshalJSON].

Otherwise, Marshal uses the following type-dependent default encodings:

Boolean values encode as JSON booleans.

Floating point, integer, andNumber values encode as JSON numbers.NaN and +/-Inf values will return anUnsupportedValueError.

String values encode as JSON strings coerced to valid UTF-8,replacing invalid bytes with the Unicode replacement rune.So that the JSON will be safe to embed inside HTML <script> tags,the string is encoded usingHTMLEscape,which replaces "<", ">", "&", U+2028, and U+2029 are escapedto "\u003c","\u003e", "\u0026", "\u2028", and "\u2029".This replacement can be disabled when using anEncoder,by callingEncoder.SetEscapeHTML(false).

Array and slice values encode as JSON arrays, except that[]byte encodes as a base64-encoded string, and a nil sliceencodes as the null JSON value.

Struct values encode as JSON objects.Each exported struct field becomes a member of the object, using thefield name as the object key, unless the field is omitted for one of thereasons given below.

The encoding of each struct field can be customized by the format stringstored under the "json" key in the struct field's tag.The format string gives the name of the field, possibly followed by acomma-separated list of options. The name may be empty in order tospecify options without overriding the default field name.

The "omitempty" option specifies that the field should be omittedfrom the encoding if the field has an empty value, defined asfalse, 0, a nil pointer, a nil interface value, and any array,slice, map, or string of length zero.

As a special case, if the field tag is "-", the field is always omitted.JSON names containing commas or quotes, or names identical to "" or "-",can be specified using a single-quoted string literal, where the syntaxis identical to the Go grammar for a double-quoted string literal,but instead uses single quotes as the delimiters.

Examples of struct field tags and their meanings:

// Field appears in JSON as key "myName".Field int `json:"myName"`// Field appears in JSON as key "myName" and// the field is omitted from the object if its value is empty,// as defined above.Field int `json:"myName,omitempty"`// Field appears in JSON as key "Field" (the default), but// the field is skipped if empty.// Note the leading comma.Field int `json:",omitempty"`// Field is ignored by this package.Field int `json:"-"`// Field appears in JSON as key "-".Field int `json:"'-'"`

The "omitzero" option specifies that the field should be omittedfrom the encoding if the field has a zero value, according to rules:

1) If the field type has an "IsZero() bool" method, that will be used todetermine whether the value is zero.

2) Otherwise, the value is zero if it is the zero value for its type.

If both "omitempty" and "omitzero" are specified, the field will be omittedif the value is either empty or zero (or both).

The "string" option signals that a field is stored as JSON inside aJSON-encoded string. It applies only to fields of string, floating point,integer, or boolean types. This extra level of encoding is sometimes usedwhen communicating with JavaScript programs:

Int64String int64 `json:",string"`

The key name will be used if it's a non-empty string consisting ofonly Unicode letters, digits, and ASCII punctuation except quotationmarks, backslash, and comma.

Embedded struct fields are usually marshaled as if their inner exported fieldswere fields in the outer struct, subject to the usual Go visibility rules amendedas described in the next paragraph.An anonymous struct field with a name given in its JSON tag is treated ashaving that name, rather than being anonymous.An anonymous struct field of interface type is treated the same as havingthat type as its name, rather than being anonymous.

The Go visibility rules for struct fields are amended for JSON whendeciding which field to marshal or unmarshal. If there aremultiple fields at the same level, and that level is the leastnested (and would therefore be the nesting level selected by theusual Go rules), the following extra rules apply:

1) Of those fields, if any are JSON-tagged, only tagged fields are considered,even if there are multiple untagged fields that would otherwise conflict.

2) If there is exactly one field (tagged or not according to the first rule), that is selected.

3) Otherwise there are multiple fields, and all are ignored; no error occurs.

Handling of anonymous struct fields is new in Go 1.1.Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring ofan anonymous struct field in both current and earlier versions, give the fielda JSON tag of "-".

Map values encode as JSON objects. The map's key type must either be astring, an integer type, or implementencoding.TextMarshaler. The map keysare sorted and used as JSON object keys by applying the following rules,subject to the UTF-8 coercion described for string values above:

keys of any string type are used directly
keys that implementencoding.TextMarshaler are marshaled
integer keys are converted to strings

Pointer values encode as the value pointed to.A nil pointer encodes as the null JSON value.

Interface values encode as the value contained in the interface.A nil interface value encodes as the null JSON value.

Channel, complex, and function values cannot be encoded in JSON.Attempting to encode such a value causes Marshal to returnanUnsupportedTypeError.

JSON cannot represent cyclic data structures and Marshal does nothandle them. Passing cyclic structures to Marshal will result inan error.

Example¶

type ColorGroup struct {ID     intName   stringColors []string}group := ColorGroup{ID:     1,Name:   "Reds",Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},}b, err := json.Marshal(group)if err != nil {fmt.Println("error:", err)}os.Stdout.Write(b)

Output:{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}

funcMarshalIndent ¶

func MarshalIndent(vany, prefix, indentstring) ([]byte,error)

MarshalIndent is likeMarshal but appliesIndent to format the output.Each JSON element in the output will begin on a new line beginning with prefixfollowed by one or more copies of indent according to the indentation nesting.

Example¶

data := map[string]int{"a": 1,"b": 2,}b, err := json.MarshalIndent(data, "<prefix>", "<indent>")if err != nil {log.Fatal(err)}fmt.Println(string(b))

Output:{<prefix><indent>"a": 1,<prefix><indent>"b": 2<prefix>}

funcUnmarshal ¶

func Unmarshal(data []byte, vany)error

Unmarshal parses the JSON-encoded data and stores the resultin the value pointed to by v. If v is nil or not a pointer,Unmarshal returns anInvalidUnmarshalError.

Unmarshal uses the inverse of the encodings thatMarshal uses, allocating maps, slices, and pointers as necessary,with the following additional rules:

To unmarshal JSON into a pointer, Unmarshal first handles the case ofthe JSON being the JSON literal null. In that case, Unmarshal setsthe pointer to nil. Otherwise, Unmarshal unmarshals the JSON intothe value pointed at by the pointer. If the pointer is nil, Unmarshalallocates a new value for it to point to.

To unmarshal JSON into a value implementingUnmarshaler,Unmarshal calls that value's [Unmarshaler.UnmarshalJSON] method, includingwhen the input is a JSON null.Otherwise, if the value implementsencoding.TextUnmarshalerand the input is a JSON quoted string, Unmarshal callsencoding.TextUnmarshaler.UnmarshalText with the unquoted form of the string.

To unmarshal JSON into a struct, Unmarshal matches incoming objectkeys to the keys used byMarshal (either the struct field name or its tag),preferring an exact match but also accepting a case-insensitive match. Bydefault, object keys which don't have a corresponding struct field areignored (seeDecoder.DisallowUnknownFields for an alternative).

To unmarshal JSON into an interface value,Unmarshal stores one of these in the interface value:

bool, for JSON booleans
float64, for JSON numbers
string, for JSON strings
[]any, for JSON arrays
map[string]any, for JSON objects
nil for JSON null

To unmarshal a JSON array into a slice, Unmarshal resets the slice lengthto zero and then appends each element to the slice.As a special case, to unmarshal an empty JSON array into a slice,Unmarshal replaces the slice with a new empty slice.

To unmarshal a JSON array into a Go array, Unmarshal decodesJSON array elements into corresponding Go array elements.If the Go array is smaller than the JSON array,the additional JSON array elements are discarded.If the JSON array is smaller than the Go array,the additional Go array elements are set to zero values.

To unmarshal a JSON object into a map, Unmarshal first establishes a map touse. If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshalreuses the existing map, keeping existing entries. Unmarshal then storeskey-value pairs from the JSON object into the map. The map's key type musteither be any string type, an integer, or implementencoding.TextUnmarshaler.

If the JSON-encoded data contain a syntax error, Unmarshal returns aSyntaxError.

If a JSON value is not appropriate for a given target type,or if a JSON number overflows the target type, Unmarshalskips that field and completes the unmarshaling as best it can.If no more serious errors are encountered, Unmarshal returnsanUnmarshalTypeError describing the earliest such error. In anycase, it's not guaranteed that all the remaining fields followingthe problematic one will be unmarshaled into the target object.

The JSON null value unmarshals into an interface, map, pointer, or sliceby setting that Go value to nil. Because null is often used in JSON to mean“not present,” unmarshaling a JSON null into any other Go type has no effecton the value and produces no error.

When unmarshaling quoted strings, invalid UTF-8 orinvalid UTF-16 surrogate pairs are not treated as an error.Instead, they are replaced by the Unicode replacementcharacter U+FFFD.

Example¶

var jsonBlob = []byte(`[{"Name": "Platypus", "Order": "Monotremata"},{"Name": "Quoll",    "Order": "Dasyuromorphia"}]`)type Animal struct {Name  stringOrder string}var animals []Animalerr := json.Unmarshal(jsonBlob, &animals)if err != nil {fmt.Println("error:", err)}fmt.Printf("%+v", animals)

Output:[{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]

funcValid ¶

func Valid(data []byte)bool

Valid reports whether data is a valid JSON encoding.

Example¶

goodJSON := `{"example": 1}`badJSON := `{"example":2:]}}`fmt.Println(json.Valid([]byte(goodJSON)), json.Valid([]byte(badJSON)))

Output:true false

Types¶

typeDecoder ¶

type Decoder struct {// contains filtered or unexported fields}

A Decoder reads and decodes JSON values from an input stream.

Example¶

This example uses a Decoder to decode a stream of distinct JSON values.

const jsonStream = `{"Name": "Ed", "Text": "Knock knock."}{"Name": "Sam", "Text": "Who's there?"}{"Name": "Ed", "Text": "Go fmt."}{"Name": "Sam", "Text": "Go fmt who?"}{"Name": "Ed", "Text": "Go fmt yourself!"}`type Message struct {Name, Text string}dec := json.NewDecoder(strings.NewReader(jsonStream))for {var m Messageif err := dec.Decode(&m); err == io.EOF {break} else if err != nil {log.Fatal(err)}fmt.Printf("%s: %s\n", m.Name, m.Text)}

Output:Ed: Knock knock.Sam: Who's there?Ed: Go fmt.Sam: Go fmt who?Ed: Go fmt yourself!

funcNewDecoder ¶

func NewDecoder(rio.Reader) *Decoder

NewDecoder returns a new decoder that reads from r.

The decoder introduces its own buffering and mayread data from r beyond the JSON values requested.

func (*Decoder)Buffered ¶

func (dec *Decoder) Buffered()io.Reader

Buffered returns a reader of the data remaining in the Decoder'sbuffer. The reader is valid until the next call toDecoder.Decode.

func (*Decoder)Decode ¶

func (dec *Decoder) Decode(vany)error

Decode reads the next JSON-encoded value from itsinput and stores it in the value pointed to by v.

See the documentation forUnmarshal for details aboutthe conversion of JSON into a Go value.

Example (Stream)¶

This example uses a Decoder to decode a streaming array of JSON objects.

const jsonStream = `[{"Name": "Ed", "Text": "Knock knock."},{"Name": "Sam", "Text": "Who's there?"},{"Name": "Ed", "Text": "Go fmt."},{"Name": "Sam", "Text": "Go fmt who?"},{"Name": "Ed", "Text": "Go fmt yourself!"}]`type Message struct {Name, Text string}dec := json.NewDecoder(strings.NewReader(jsonStream))// read open brackett, err := dec.Token()if err != nil {log.Fatal(err)}fmt.Printf("%T: %v\n", t, t)// while the array contains valuesfor dec.More() {var m Message// decode an array value (Message)err := dec.Decode(&m)if err != nil {log.Fatal(err)}fmt.Printf("%v: %v\n", m.Name, m.Text)}// read closing brackett, err = dec.Token()if err != nil {log.Fatal(err)}fmt.Printf("%T: %v\n", t, t)

Output:json.Delim: [Ed: Knock knock.Sam: Who's there?Ed: Go fmt.Sam: Go fmt who?Ed: Go fmt yourself!json.Delim: ]

func (*Decoder)DisallowUnknownFields ¶

func (dec *Decoder) DisallowUnknownFields()

DisallowUnknownFields causes the Decoder to return an error when the destinationis a struct and the input contains object keys which do not match anynon-ignored, exported fields in the destination.

func (*Decoder)InputOffset ¶

func (dec *Decoder) InputOffset()int64

InputOffset returns the input stream byte offset of the current decoder position.The offset gives the location of the end of the most recently returned tokenand the beginning of the next token.

func (*Decoder)More ¶

func (dec *Decoder) More()bool

More reports whether there is another element in thecurrent array or object being parsed.

func (*Decoder)Token ¶

func (dec *Decoder) Token() (Token,error)

Token returns the next JSON token in the input stream.At the end of the input stream, Token returns nil,io.EOF.

Token guarantees that the delimiters [ ] { } it returns areproperly nested and matched: if Token encounters an unexpecteddelimiter in the input, it will return an error.

The input stream consists of basic JSON values—bool, string,number, and null—along with delimiters [ ] { } of typeDelimto mark the start and end of arrays and objects.Commas and colons are elided.

Example¶

This example uses a Decoder to decode a stream of distinct JSON values.

const jsonStream = `{"Message": "Hello", "Array": [1, 2, 3], "Null": null, "Number": 1.234}`dec := json.NewDecoder(strings.NewReader(jsonStream))for {t, err := dec.Token()if err == io.EOF {break}if err != nil {log.Fatal(err)}fmt.Printf("%T: %v", t, t)if dec.More() {fmt.Printf(" (more)")}fmt.Printf("\n")}

Output:json.Delim: { (more)string: Message (more)string: Hello (more)string: Array (more)json.Delim: [ (more)float64: 1 (more)float64: 2 (more)float64: 3json.Delim: ] (more)string: Null (more)<nil>: <nil> (more)string: Number (more)float64: 1.234json.Delim: }

func (*Decoder)UseNumber ¶

func (dec *Decoder) UseNumber()

UseNumber causes the Decoder to unmarshal a number into aninterface value as aNumber instead of as a float64.

typeDelim ¶

type Delimrune

A Delim is a JSON array or object delimiter, one of [ ] { or }.

func (Delim)String ¶

func (dDelim) String()string

typeEncoder ¶

type Encoder struct {// contains filtered or unexported fields}

An Encoder writes JSON values to an output stream.

funcNewEncoder ¶

func NewEncoder(wio.Writer) *Encoder

NewEncoder returns a new encoder that writes to w.

func (*Encoder)Encode ¶

func (enc *Encoder) Encode(vany)error

Encode writes the JSON encoding of v to the stream,followed by a newline character.

See the documentation forMarshal for details about theconversion of Go values to JSON.

func (*Encoder)SetEscapeHTML ¶

func (enc *Encoder) SetEscapeHTML(onbool)

SetEscapeHTML specifies whether problematic HTML charactersshould be escaped inside JSON quoted strings.The default behavior is to escape &, <, and > to \u0026, \u003c, and \u003eto avoid certain safety problems that can arise when embedding JSON in HTML.

In non-HTML settings where the escaping interferes with the readabilityof the output, SetEscapeHTML(false) disables this behavior.

func (*Encoder)SetIndent ¶

func (enc *Encoder) SetIndent(prefix, indentstring)

SetIndent instructs the encoder to format each subsequent encodedvalue as if indented by the package-level function Indent(dst, src, prefix, indent).Calling SetIndent("", "") disables indentation.

typeInvalidUTF8Errordeprecated

type InvalidUTF8Error struct {Sstring// the whole string value that caused the error}

Before Go 1.2, an InvalidUTF8Error was returned byMarshal whenattempting to encode a string value with invalid UTF-8 sequences.As of Go 1.2,Marshal instead coerces the string to valid UTF-8 byreplacing invalid bytes with the Unicode replacement rune U+FFFD.

Deprecated: No longer used; kept for compatibility.

func (*InvalidUTF8Error)Error ¶

func (e *InvalidUTF8Error) Error()string

typeInvalidUnmarshalError ¶

type InvalidUnmarshalError struct {Typereflect.Type}

An InvalidUnmarshalError describes an invalid argument passed toUnmarshal.(The argument toUnmarshal must be a non-nil pointer.)

func (*InvalidUnmarshalError)Error ¶

func (e *InvalidUnmarshalError) Error()string

typeMarshaler ¶

type Marshaler =jsonv2.Marshaler

Marshaler is the interface implemented by types thatcan marshal themselves into valid JSON.

typeMarshalerError ¶

type MarshalerError struct {Typereflect.TypeErrerror// contains filtered or unexported fields}

A MarshalerError represents an error from calling a[Marshaler.MarshalJSON] orencoding.TextMarshaler.MarshalText method.

func (*MarshalerError)Error ¶

func (e *MarshalerError) Error()string

func (*MarshalerError)Unwrap ¶

func (e *MarshalerError) Unwrap()error

Unwrap returns the underlying error.

typeNumber ¶

type Numberstring

A Number represents a JSON number literal.

func (Number)Float64 ¶

func (nNumber) Float64() (float64,error)

Float64 returns the number as a float64.

func (Number)Int64 ¶

func (nNumber) Int64() (int64,error)

Int64 returns the number as an int64.

func (Number)MarshalJSONTo ¶

func (nNumber) MarshalJSONTo(enc *jsontext.Encoder)error

MarshalJSONTo implementsjsonv2.MarshalerTo.

func (Number)String ¶

func (nNumber) String()string

String returns the literal text of the number.

func (*Number)UnmarshalJSONFrom ¶

func (n *Number) UnmarshalJSONFrom(dec *jsontext.Decoder)error

UnmarshalJSONFrom implementsjsonv2.UnmarshalerFrom.

typeOptions ¶

type Options =jsonopts.Options

Options are a set of options to configure the v2 "json" packageto operate with v1 semantics for particular features.Values of this type can be passed to v2 functions likejsonv2.Marshal orjsonv2.Unmarshal.Instead of referencing this type, usejsonv2.Options.

See the "Migrating to v2" section for guidance on how to migrate usageof "json" from using v1 to using v2 instead.

funcCallMethodsWithLegacySemantics ¶

func CallMethodsWithLegacySemantics(vbool)Options

CallMethodsWithLegacySemantics specifies that calling of type-providedmarshal and unmarshal methods follow legacy semantics:

When marshaling, a marshal method declared on a pointer receiveris only called if the Go value is addressable.Values obtained from an interface or map element are not addressable.Values obtained from a pointer or slice element are addressable.Values obtained from an array element or struct field inheritthe addressability of the parent. In contrast, the v2 semanticis to always call marshal methods regardless of addressability.
When marshaling or unmarshaling, theMarshaler orUnmarshalermethods are ignored for map keys. However,encoding.TextMarshalerorencoding.TextUnmarshaler are still callable.In contrast, the v2 semantic is to serialize map keyslike any other value (with regard to calling methods),which may include callingMarshaler orUnmarshaler methods,where it is the implementation's responsibility to represent theGo value as a JSON string (as required for JSON object names).
When marshaling, if a map key value implements a marshal methodand is a nil pointer, then it is serialized as an empty JSON string.In contrast, the v2 semantic is to report an error.
When marshaling, if an interface type implements a marshal methodand the interface value is a nil pointer to a concrete type,then the marshal method is always called.In contrast, the v2 semantic is to never directly call methodson interface values and to instead defer evaluation based uponthe underlying concrete value. Similar to non-interface values,marshal methods are not called on nil pointers andare instead serialized as a JSON null.

This affects either marshaling or unmarshaling.The v1 default is true.

funcDefaultOptionsV1 ¶

func DefaultOptionsV1()Options

DefaultOptionsV1 is the full set of all options that define v1 semantics.It is equivalent to the following boolean options being set to true:

All other options are not present.

TheMarshal andUnmarshal functions in this package aresemantically identical to calling the v2 equivalents with this option:

jsonv2.Marshal(v, jsonv1.DefaultOptionsV1())jsonv2.Unmarshal(b, v, jsonv1.DefaultOptionsV1())

funcFormatByteArrayAsArray ¶

func FormatByteArrayAsArray(vbool)Options

FormatByteArrayAsArray specifies that a Go [N]byte isformatted as as a normal Go array in contrast to the v2 default offormatting [N]byte as using binary data encoding (RFC 4648).If a struct field has a `format` tag option,then the specified formatting takes precedence.

This affects either marshaling or unmarshaling.The v1 default is true.

funcFormatBytesWithLegacySemantics ¶

func FormatBytesWithLegacySemantics(vbool)Options

FormatBytesWithLegacySemantics specifies that handling of[]~byte and [N]~byte types follow legacy semantics:

A Go []~byte is to be treated as using some form ofbinary data encoding (RFC 4648) in contrast to the v2 defaultof only treating []byte as such. In particular, v2 does nottreat slices of named byte types as representing binary data.
When marshaling, if a named byte implements a marshal method,then the slice is serialized as a JSON array of elements,each of which call the marshal method.
When unmarshaling, if the input is a JSON array,then unmarshal into the []~byte as if it were a normal Go slice.In contrast, the v2 default is to report an error unmarshalinga JSON array when expecting some form of binary data encoding.

This affects either marshaling or unmarshaling.The v1 default is true.

funcFormatDurationAsNano ¶

func FormatDurationAsNano(vbool)Options

FormatDurationAsNano specifies that atime.Duration isformatted as a JSON number representing the number of nanosecondsin contrast to the v2 default of reporting an error.If a duration field has a `format` tag option,then the specified formatting takes precedence.

This affects either marshaling or unmarshaling.The v1 default is true.

funcMatchCaseSensitiveDelimiter ¶

func MatchCaseSensitiveDelimiter(vbool)Options

MatchCaseSensitiveDelimiter specifies that underscores and dashes arenot to be ignored when performing case-insensitive name matching whichoccurs underjsonv2.MatchCaseInsensitiveNames or the `case:ignore` tag option.Thus, case-insensitive name matching is identical tostrings.EqualFold.Use of this option diminishes the ability of case-insensitive matchingto be able to match common case variants (e.g, "foo_bar" with "fooBar").

This affects either marshaling or unmarshaling.The v1 default is true.

funcMergeWithLegacySemantics ¶

func MergeWithLegacySemantics(vbool)Options

MergeWithLegacySemantics specifies that unmarshaling into a non-zeroGo value follows legacy semantics:

When unmarshaling a JSON null, this preserves the original Go valueif the kind is a bool, int, uint, float, string, array, or struct.Otherwise, it zeros the Go value.In contrast, the default v2 behavior is to consistently and alwayszero the Go value when unmarshaling a JSON null into it.
When unmarshaling a JSON value other than null, this merges intothe original Go value for array elements, slice elements,struct fields (but not map values),pointer values, and interface values (only if a non-nil pointer).In contrast, the default v2 behavior is to merge into the Go valuefor struct fields, map values, pointer values, and interface values.In general, the v2 semantic merges when unmarshaling a JSON object,otherwise it replaces the original value.

This only affects unmarshaling and is ignored when marshaling.The v1 default is true.

funcOmitEmptyWithLegacySemantics ¶

func OmitEmptyWithLegacySemantics(vbool)Options

OmitEmptyWithLegacySemantics specifies that the `omitempty` tag optionfollows a definition of empty where a field is omitted if the Go value isfalse, 0, a nil pointer, a nil interface value,or any empty array, slice, map, or string.This overrides the v2 semantic where a field is empty if the valuemarshals as a JSON null or an empty JSON string, object, or array.

The v1 and v2 definitions of `omitempty` are practically the same forGo strings, slices, arrays, and maps. Usages of `omitempty` onGo bools, ints, uints floats, pointers, and interfaces should migrate to usethe `omitzero` tag option, which omits a field if it is the zero Go value.

This only affects marshaling and is ignored when unmarshaling.The v1 default is true.

funcParseBytesWithLooseRFC4648 ¶

func ParseBytesWithLooseRFC4648(vbool)Options

ParseBytesWithLooseRFC4648 specifies that when parsingbinary data encoded as "base32" or "base64",to ignore the presence of '\r' and '\n' characters.In contrast, the v2 default is to report an error in order to bestrictly compliant withRFC 4648, section 3.3,which specifies that non-alphabet characters must be rejected.

This only affects unmarshaling and is ignored when marshaling.The v1 default is true.

funcParseTimeWithLooseRFC3339 ¶

func ParseTimeWithLooseRFC3339(vbool)Options

ParseTimeWithLooseRFC3339 specifies that atime.Timeparses according to loose adherence toRFC 3339.In particular, it permits historically incorrect representations,allowing for deviations in hour format, sub-second separator,and timezone representation. In contrast, the default v2 behavioris to strictly comply with the grammar specified inRFC 3339.

This only affects unmarshaling and is ignored when marshaling.The v1 default is true.

funcReportErrorsWithLegacySemantics ¶

func ReportErrorsWithLegacySemantics(vbool)Options

ReportErrorsWithLegacySemantics specifies that Marshal and Unmarshalshould report errors with legacy semantics:

When marshaling or unmarshaling, the returned error values areusually of types such asSyntaxError,MarshalerError,UnsupportedTypeError,UnsupportedValueError,InvalidUnmarshalError, orUnmarshalTypeError.In contrast, the v2 semantic is to always return errors as eitherjsonv2.SemanticError orjsontext.SyntacticError.
When marshaling, if a user-defined marshal method reports an error,it is always wrapped in aMarshalerError, even if the error itselfis already aMarshalerError, which may lead to multiple redundantlayers of wrapping. In contrast, the v2 semantic is toalways wrap an error withinjsonv2.SemanticErrorunless it is already a semantic error.
When unmarshaling, if a user-defined unmarshal method reports an error,it is never wrapped and reported verbatim. In contrast, the v2 semanticis to always wrap an error withinjsonv2.SemanticErrorunless it is already a semantic error.
When marshaling or unmarshaling, if a Go struct contains type errors(e.g., conflicting names or malformed field tags), then such errorsare ignored and the Go struct uses a best-effort representation.In contrast, the v2 semantic is to report a runtime error.
When unmarshaling, the syntactic structure of the JSON inputis fully validated before performing the semantic unmarshalingof the JSON data into the Go value. Practically speaking,this means that JSON input with syntactic errors do not resultin any mutations of the target Go value. In contrast, the v2 semanticis to perform a streaming decode and gradually unmarshal the JSON inputinto the target Go value, which means that the Go value may bepartially mutated when a syntactic error is encountered.
When unmarshaling, a semantic error does not immediately terminate theunmarshal procedure, but rather evaluation continues.When unmarshal returns, only the first semantic error is reported.In contrast, the v2 semantic is to terminate unmarshal the momentan error is encountered.

This affects either marshaling or unmarshaling.The v1 default is true.

funcStringifyWithLegacySemantics ¶

func StringifyWithLegacySemantics(vbool)Options

StringifyWithLegacySemantics specifies that the `string` tag optionmay stringify bools and string values. It only takes effect on fieldswhere the top-level type is a bool, string, numeric kind, or a pointer tosuch a kind. Specifically, `string` will not stringify bool, string,or numeric kinds within a composite data type(e.g., array, slice, struct, map, or interface).

When marshaling, such Go values are serialized as their usualJSON representation, but quoted within a JSON string.When unmarshaling, such Go values must be deserialized froma JSON string containing their usual JSON representation orGo number representation for that numeric kind.Note that the Go number grammar is a superset of the JSON number grammar.A JSON null quoted in a JSON string is a valid substitute for JSON nullwhile unmarshaling into a Go value that `string` takes effect on.

This affects either marshaling or unmarshaling.The v1 default is true.

funcUnmarshalArrayFromAnyLength ¶

func UnmarshalArrayFromAnyLength(vbool)Options

UnmarshalArrayFromAnyLength specifies that Go arrays can be unmarshaledfrom input JSON arrays of any length. If the JSON array is too short,then the remaining Go array elements are zeroed. If the JSON arrayis too long, then the excess JSON array elements are skipped over.

This only affects unmarshaling and is ignored when marshaling.The v1 default is true.

typeRawMessage ¶

type RawMessage =jsontext.Value

RawMessage is a raw encoded JSON value.It implementsMarshaler andUnmarshaler and canbe used to delay JSON decoding or precompute a JSON encoding.

Example (Marshal)¶

This example uses RawMessage to use a precomputed JSON during marshal.

h := json.RawMessage(`{"precomputed": true}`)c := struct {Header *json.RawMessage `json:"header"`Body   string           `json:"body"`}{Header: &h, Body: "Hello Gophers!"}b, err := json.MarshalIndent(&c, "", "\t")if err != nil {fmt.Println("error:", err)}os.Stdout.Write(b)

Output:{"header": {"precomputed": true},"body": "Hello Gophers!"}

Example (Unmarshal)¶

This example uses RawMessage to delay parsing part of a JSON message.

type Color struct {Space stringPoint json.RawMessage // delay parsing until we know the color space}type RGB struct {R uint8G uint8B uint8}type YCbCr struct {Y  uint8Cb int8Cr int8}var j = []byte(`[{"Space": "YCbCr", "Point": {"Y": 255, "Cb": 0, "Cr": -10}},{"Space": "RGB",   "Point": {"R": 98, "G": 218, "B": 255}}]`)var colors []Colorerr := json.Unmarshal(j, &colors)if err != nil {log.Fatalln("error:", err)}for _, c := range colors {var dst anyswitch c.Space {case "RGB":dst = new(RGB)case "YCbCr":dst = new(YCbCr)}err := json.Unmarshal(c.Point, dst)if err != nil {log.Fatalln("error:", err)}fmt.Println(c.Space, dst)}

Output:YCbCr &{255 0 -10}RGB &{98 218 255}

typeSyntaxError ¶

type SyntaxError struct {Offsetint64// error occurred after reading Offset bytes// contains filtered or unexported fields}

A SyntaxError is a description of a JSON syntax error.Unmarshal will return a SyntaxError if the JSON can't be parsed.

func (*SyntaxError)Error ¶

func (e *SyntaxError) Error()string

typeToken ¶

type Tokenany

A Token holds a value of one of these types:

Delim, for the four JSON delimiters [ ] { }
bool, for JSON booleans
float64, for JSON numbers
Number, for JSON numbers
string, for JSON string literals
nil, for JSON null

typeUnmarshalFieldErrordeprecated

type UnmarshalFieldError struct {KeystringTypereflect.TypeFieldreflect.StructField}

An UnmarshalFieldError describes a JSON object key thatled to an unexported (and therefore unwritable) struct field.

Deprecated: No longer used; kept for compatibility.

func (*UnmarshalFieldError)Error ¶

func (e *UnmarshalFieldError) Error()string

typeUnmarshalTypeError ¶

type UnmarshalTypeError struct {Valuestring// description of JSON value - "bool", "array", "number -5"Typereflect.Type// type of Go value it could not be assigned toOffsetint64// error occurred after reading Offset bytesStructstring// name of the root type containing the fieldFieldstring// the full path from root node to the valueErrerror// may be nil}

An UnmarshalTypeError describes a JSON value that wasnot appropriate for a value of a specific Go type.

func (*UnmarshalTypeError)Error ¶

func (e *UnmarshalTypeError) Error()string

func (*UnmarshalTypeError)Unwrap ¶

func (e *UnmarshalTypeError) Unwrap()error

typeUnmarshaler ¶

type Unmarshaler =jsonv2.Unmarshaler

Unmarshaler is the interface implemented by typesthat can unmarshal a JSON description of themselves.The input can be assumed to be a valid encoding ofa JSON value. UnmarshalJSON must copy the JSON dataif it wishes to retain the data after returning.

typeUnsupportedTypeError ¶

type UnsupportedTypeError struct {Typereflect.Type}

An UnsupportedTypeError is returned byMarshal when attemptingto encode an unsupported value type.

func (*UnsupportedTypeError)Error ¶

func (e *UnsupportedTypeError) Error()string

typeUnsupportedValueError ¶

type UnsupportedValueError struct {Valuereflect.ValueStrstring}

An UnsupportedValueError is returned byMarshal when attemptingto encode an unsupported value.

func (*UnsupportedValueError)Error ¶

func (e *UnsupportedValueError) Error()string

Source Files¶

View all Source files

?	: This menu
/	: Search site
f orF	: Jump to
y orY	: Canonical URL

Movatterモバイル変換

Details

Repository

Links

Documentation¶

Overview¶

Security Considerations¶

Migrating to v2¶

Index¶

Examples¶

Constants¶

Variables¶

Functions¶

funcCompact¶

funcHTMLEscape¶

funcIndent¶

funcMarshal¶

funcMarshalIndent¶

funcUnmarshal¶

funcValid¶

Types¶

typeDecoder¶

funcNewDecoder¶

func (*Decoder)Buffered¶

func (*Decoder)Decode¶

func (*Decoder)DisallowUnknownFields¶

func (*Decoder)InputOffset¶

func (*Decoder)More¶

func (*Decoder)Token¶

func (*Decoder)UseNumber¶

typeDelim¶

func (Delim)String¶

typeEncoder¶

funcNewEncoder¶

func (*Encoder)Encode¶

func (*Encoder)SetEscapeHTML¶

func (*Encoder)SetIndent¶

typeInvalidUTF8Errordeprecated

func (*InvalidUTF8Error)Error¶

typeInvalidUnmarshalError¶

func (*InvalidUnmarshalError)Error¶

typeMarshaler¶

typeMarshalerError¶

func (*MarshalerError)Error¶

func (*MarshalerError)Unwrap¶

typeNumber¶

func (Number)Float64¶

func (Number)Int64¶

func (Number)MarshalJSONTo¶

func (Number)String¶

func (*Number)UnmarshalJSONFrom¶

typeOptions¶

funcCallMethodsWithLegacySemantics¶

funcDefaultOptionsV1¶

funcFormatByteArrayAsArray¶

funcFormatBytesWithLegacySemantics¶

funcFormatDurationAsNano¶

funcMatchCaseSensitiveDelimiter¶

funcMergeWithLegacySemantics¶

funcOmitEmptyWithLegacySemantics¶

funcParseBytesWithLooseRFC4648¶

funcParseTimeWithLooseRFC3339¶

funcReportErrorsWithLegacySemantics¶

funcStringifyWithLegacySemantics¶

funcUnmarshalArrayFromAnyLength¶

typeRawMessage¶

typeSyntaxError¶

func (*SyntaxError)Error¶

typeToken¶

typeUnmarshalFieldErrordeprecated

func (*UnmarshalFieldError)Error¶

typeUnmarshalTypeError¶

func (*UnmarshalTypeError)Error¶

func (*UnmarshalTypeError)Unwrap¶

typeUnmarshaler¶

typeUnsupportedTypeError¶

func (*UnsupportedTypeError)Error¶

typeUnsupportedValueError¶

func (*UnsupportedValueError)Error¶

Source Files¶

Documentation ¶

funcCompact ¶

funcHTMLEscape ¶

funcIndent ¶

funcMarshal ¶

funcMarshalIndent ¶

funcUnmarshal ¶

funcValid ¶

typeDecoder ¶

funcNewDecoder ¶

func (*Decoder)Buffered ¶

func (*Decoder)Decode ¶

func (*Decoder)DisallowUnknownFields ¶

func (*Decoder)InputOffset ¶

func (*Decoder)More ¶

func (*Decoder)Token ¶

func (*Decoder)UseNumber ¶

typeDelim ¶

func (Delim)String ¶

typeEncoder ¶

funcNewEncoder ¶

func (*Encoder)Encode ¶

func (*Encoder)SetEscapeHTML ¶

func (*Encoder)SetIndent ¶

func (*InvalidUTF8Error)Error ¶

typeInvalidUnmarshalError ¶

func (*InvalidUnmarshalError)Error ¶

typeMarshaler ¶

typeMarshalerError ¶

func (*MarshalerError)Error ¶

func (*MarshalerError)Unwrap ¶

typeNumber ¶

func (Number)Float64 ¶

func (Number)Int64 ¶

func (Number)MarshalJSONTo ¶

func (Number)String ¶

func (*Number)UnmarshalJSONFrom ¶

typeOptions ¶

funcCallMethodsWithLegacySemantics ¶

funcDefaultOptionsV1 ¶

funcFormatByteArrayAsArray ¶

funcFormatBytesWithLegacySemantics ¶

funcFormatDurationAsNano ¶

funcMatchCaseSensitiveDelimiter ¶

funcMergeWithLegacySemantics ¶

funcOmitEmptyWithLegacySemantics ¶

funcParseBytesWithLooseRFC4648 ¶

funcParseTimeWithLooseRFC3339 ¶

funcReportErrorsWithLegacySemantics ¶

funcStringifyWithLegacySemantics ¶

funcUnmarshalArrayFromAnyLength ¶

typeRawMessage ¶

typeSyntaxError ¶

func (*SyntaxError)Error ¶

typeToken ¶

func (*UnmarshalFieldError)Error ¶

typeUnmarshalTypeError ¶

func (*UnmarshalTypeError)Error ¶

func (*UnmarshalTypeError)Unwrap ¶

typeUnmarshaler ¶

typeUnsupportedTypeError ¶

func (*UnsupportedTypeError)Error ¶

typeUnsupportedValueError ¶

func (*UnsupportedValueError)Error ¶