type User struct {
 Email string `json:"email"`
 Password string `json:"password"`
 // many more fields…
}

json.Marshal(struct {
 *User
 Password bool `json:"password,omitempty"`
}{
 User: user,
})

type User struct {
 Email string `json:"email"`
 Password string `json:"password"`
 // many more fields…
}

json.Marshal(struct {
 *User
 Token string `json:"token"`
 Password bool `json:"password,omitempty"`
}{
 User: user,
 Token: token,
})

type BlogPost struct {
 URL string `json:"url"`
 Title string `json:"title"`
}

type Analytics struct {
 Visitors int `json:"visitors"`
 PageViews int `json:"page_views"`
}

json.Marshal(struct{
 *BlogPost
 *Analytics
}{post, analytics})

json.Unmarshal([]byte(`{
 "url": "attila@attilaolah.eu",
 "title": "Attila's Blog",
 "visitors": 6,
 "page_views": 14
}`), &struct {
 *BlogPost
 *Analytics
}{&post, &analytics})

type CacheItem struct {
 Key string `json:"key"`
 MaxAge int `json:"cacheAge"`
 Value Value `json:"cacheValue"`
}

json.Marshal(struct{
 *CacheItem

 // Omit bad keys
 OmitMaxAge omit `json:"cacheAge,omitempty"`
 OmitValue omit `json:"cacheValue,omitempty"`

 // Add nice keys
 MaxAge int `json:"max_age"`
 Value *Value `json:"value"`
}{
 CacheItem: item,

 // Set the int by value:
 MaxAge: item.MaxAge,

 // Set the nested struct by reference, avoid making a copy:
 Value: &item.Value,
})

type TestObject struct {
 Field1 int `json:",string"`
}

import "github.com/json-iterator/go/extra"

extra.RegisterFuzzyDecoders()

var val string
jsoniter.UnmarshalFromString(`100`, &val)

var val float32
jsoniter.UnmarshalFromString(`"1.23"`, &val)

import "github.com/json-iterator/go/extra"

extra.RegisterFuzzyDecoders()

var val map[string]interface{}
jsoniter.UnmarshalFromString(`[]`, &val)

type timeImplementedMarshaler time.Time

func (obj timeImplementedMarshaler) MarshalJSON() ([]byte, error) {
 seconds := time.Time(obj).Unix()
 return []byte(strconv.FormatInt(seconds, 10)), nil
}

type TestObject struct {
 Field timeImplementedMarshaler
}
should := require.New(t)
val := timeImplementedMarshaler(time.Unix(123, 0))
obj := TestObject{val}
bytes, err := jsoniter.Marshal(obj)
should.Nil(err)
should.Equal(`{"Field":123}`, string(bytes))

import "github.com/json-iterator/go/extra"

extra.RegisterTimeAsInt64Codec(time.Microsecond)
output, err := jsoniter.Marshal(time.Unix(1, 1002))
should.Equal("1000001", string(output))

f, _, _ := big.ParseFloat("1", 10, 64, big.ToZero)
val := map[*big.Float]string{f: "2"}
str, err := MarshalToString(val)
should.Equal(`{"1":"2"}`, str)

type TestObject struct {
 Field1 string
 Field2 json.RawMessage
}
var data TestObject
json.Unmarshal([]byte(`{"field1": "hello", "field2": [1,2,3]}`), &data)
should.Equal(` [1,2,3]`, string(data.Field2))

decoder1 := json.NewDecoder(bytes.NewBufferString(`123`))
decoder1.UseNumber()
var obj1 interface{}
decoder1.Decode(&obj1)
should.Equal(json.Number("123"), obj1)

json := Config{UseNumber:true}.Froze()
var obj interface{}
json.UnmarshalFromString("123", &obj)
should.Equal(json.Number("123"), obj)

output, err := jsoniter.Marshal(struct {
 UserName string `json:"user_name"`
 FirstLanguage string `json:"first_language"`
}{
 UserName: "taowen",
 FirstLanguage: "Chinese",
})
should.Equal(`{"user_name":"taowen","first_language":"Chinese"}`, string(output))

import "github.com/json-iterator/go/extra"

extra.SetNamingStrategy(LowerCaseWithUnderscores)
output, err := jsoniter.Marshal(struct {
 UserName string
 FirstLanguage string
}{
 UserName: "taowen",
 FirstLanguage: "Chinese",
})
should.Nil(err)
should.Equal(`{"user_name":"taowen","first_language":"Chinese"}`, string(output))

import "github.com/json-iterator/go/extra"

extra.SupportPrivateFields()
type TestObject struct {
 field1 string
}
obj := TestObject{}
jsoniter.UnmarshalFromString(`{"field1":"Hello"}`, &obj)
should.Equal("Hello", obj.field1)