instruction: Explain go by example: json
output: Go by Example
  : JSON
  Go offers built-in support for JSON encoding and
  decoding, including to and from built-in and custom
  data types.
  package
  main
  import
  (
  "encoding/json"
  "fmt"
  "os"
  "strings"
  )
  We’ll use these two structs to demonstrate encoding and
  decoding of custom types below.
  type
  response1
  struct
  {
  Page
  int
  Fruits
  []
  string
  }
  Only exported fields will be encoded/decoded in JSON.
  Fields must start with capital letters to be exported.
  type
  response2
  struct
  {
  Page
  int
  `json:"page"`
  Fruits
  []
  string
  `json:"fruits"`
  }
  func
  main
  ()
  {
  First we’ll look at encoding basic data types to
  JSON strings. Here are some examples for atomic
  values.
  bolB
  ,
  _
  :=
  json
  .
  Marshal
  (
  true
  )
  fmt
  .
  Println
  (
  string
  (
  bolB
  ))
  intB
  ,
  _
  :=
  json
  .
  Marshal
  (
  1
  )
  fmt
  .
  Println
  (
  string
  (
  intB
  ))
  fltB
  ,
  _
  :=
  json
  .
  Marshal
  (
  2.34
  )
  fmt
  .
  Println
  (
  string
  (
  fltB
  ))
  strB
  ,
  _
  :=
  json
  .
  Marshal
  (
  "gopher"
  )
  fmt
  .
  Println
  (
  string
  (
  strB
  ))
  And here are some for slices and maps, which encode
  to JSON arrays and objects as you’d expect.
  slcD
  :=
  []
  string
  {
  "apple"
  ,
  "peach"
  ,
  "pear"
  }
  slcB
  ,
  _
  :=
  json
  .
  Marshal
  (
  slcD
  )
  fmt
  .
  Println
  (
  string
  (
  slcB
  ))
  mapD
  :=
  map
  [
  string
  ]
  int
  {
  "apple"
  :
  5
  ,
  "lettuce"
  :
  7
  }
  mapB
  ,
  _
  :=
  json
  .
  Marshal
  (
  mapD
  )
  fmt
  .
  Println
  (
  string
  (
  mapB
  ))
  The JSON package can automatically encode your
  custom data types. It will only include exported
  fields in the encoded output and will by default
  use those names as the JSON keys.
  res1D
  :=
  &
  response1
  {
  Page
  :
  1
  ,
  Fruits
  :
  []
  string
  {
  "apple"
  ,
  "peach"
  ,
  "pear"
  }}
  res1B
  ,
  _
  :=
  json
  .
  Marshal
  (
  res1D
  )
  fmt
  .
  Println
  (
  string
  (
  res1B
  ))
  You can use tags on struct field declarations
  to customize the encoded JSON key names. Check the
  definition of
  response2
  above to see an example
  of such tags.
  res2D
  :=
  &
  response2
  {
  Page
  :
  1
  ,
  Fruits
  :
  []
  string
  {
  "apple"
  ,
  "peach"
  ,
  "pear"
  }}
  res2B
  ,
  _
  :=
  json
  .
  Marshal
  (
  res2D
  )
  fmt
  .
  Println
  (
  string
  (
  res2B
  ))
  Now let’s look at decoding JSON data into Go
  values. Here’s an example for a generic data
  structure.
  byt
  :=
  []
  byte
  (
  `{"num":6.13,"strs":["a","b"]}`
  )
  We need to provide a variable where the JSON
  package can put the decoded data. This
  map[string]interface{}
  will hold a map of strings
  to arbitrary data types.
  var
  dat
  map
  [
  string
  ]
  interface
  {}
  Here’s the actual decoding, and a check for
  associated errors.
  if
  err
  :=
  json
  .
  Unmarshal
  (
  byt
  ,
  &
  dat
  );
  err
  !=
  nil
  {
  panic
  (
  err
  )
  }
  fmt
  .
  Println
  (
  dat
  )
  In order to use the values in the decoded map,
  we’ll need to convert them to their appropriate type.
  For example here we convert the value in
  num
  to
  the expected
  float64
  type.
  num
  :=
  dat
  [
  "num"
  ].(
  float64
  )
  fmt
  .
  Println
  (
  num
  )
  Accessing nested data requires a series of
  conversions.
  strs
  :=
  dat
  [
  "strs"
  ].([]
  interface
  {})
  str1
  :=
  strs
  [
  0
  ].(
  string
  )
  fmt
  .
  Println
  (
  str1
  )
  We can also decode JSON into custom data types.
  This has the advantages of adding additional
  type-safety to our programs and eliminating the
  need for type assertions when accessing the decoded
  data.
  str
  :=
  `{"page": 1, "fruits": ["apple", "peach"]}`
  res
  :=
  response2
  {}
  json
  .
  Unmarshal
  ([]
  byte
  (
  str
  ),
  &
  res
  )
  fmt
  .
  Println
  (
  res
  )
  fmt
  .
  Println
  (
  res
  .
  Fruits
  [
  0
  ])
  In the examples above we always used bytes and
  strings as intermediates between the data and
  JSON representation on standard out. We can also
  stream JSON encodings directly to
  os.Writer
  s like
  os.Stdout
  or even HTTP response bodies.
  enc
  :=
  json
  .
  NewEncoder
  (
  os
  .
  Stdout
  )
  d
  :=
  map
  [
  string
  ]
  int
  {
  "apple"
  :
  5
  ,
  "lettuce"
  :
  7
  }
  enc
  .
  Encode
  (
  d
  )
  Streaming reads from
  os.Reader
  s like
  os.Stdin
  or HTTP request bodies is done with
  json.Decoder
  .
  dec
  :=
  json
  .
  NewDecoder
  (
  strings
  .
  NewReader
  (
  str
  ))
  res1
  :=
  response2
  {}
  dec
  .
  Decode
  (
  &
  res1
  )
  fmt
  .
  Println
  (
  res1
  )
  }
  $
  go run json.go
  true
  1
  2.34
  "gopher"
  ["apple","peach","pear"]
  {"apple":5,"lettuce":7}
  {"Page":1,"Fruits":["apple","peach","pear"]}
  {"page":1,"fruits":["apple","peach","pear"]}
  map[num:6.13 strs:[a b]]
  6.13
  a
  {1 [apple peach]}
  apple
  {"apple":5,"lettuce":7}
  {1 [apple peach]}
  We’ve covered the basic of JSON in Go here, but check
  out the
  JSON and Go
  blog post and
  JSON package docs
  for more.
  Next example:
  XML
  .
  by
  Mark McGranaghan
  and
  Eli Bendersky
  |
  source
  |
  license