instruction: Explain go by example: string formatting
output: Go by Example
  : String Formatting
  Go offers excellent support for string formatting in
  the
  printf
  tradition. Here are some examples of
  common string formatting tasks.
  package
  main
  import
  (
  "fmt"
  "os"
  )
  type
  point
  struct
  {
  x
  ,
  y
  int
  }
  func
  main
  ()
  {
  Go offers several printing “verbs” designed to
  format general Go values. For example, this prints
  an instance of our
  point
  struct.
  p
  :=
  point
  {
  1
  ,
  2
  }
  fmt
  .
  Printf
  (
  "struct1: %v\n"
  ,
  p
  )
  If the value is a struct, the
  %+v
  variant will
  include the struct’s field names.
  fmt
  .
  Printf
  (
  "struct2: %+v\n"
  ,
  p
  )
  The
  %#v
  variant prints a Go syntax representation
  of the value, i.e. the source code snippet that
  would produce that value.
  fmt
  .
  Printf
  (
  "struct3: %#v\n"
  ,
  p
  )
  To print the type of a value, use
  %T
  .
  fmt
  .
  Printf
  (
  "type: %T\n"
  ,
  p
  )
  Formatting booleans is straight-forward.
  fmt
  .
  Printf
  (
  "bool: %t\n"
  ,
  true
  )
  There are many options for formatting integers.
  Use
  %d
  for standard, base-10 formatting.
  fmt
  .
  Printf
  (
  "int: %d\n"
  ,
  123
  )
  This prints a binary representation.
  fmt
  .
  Printf
  (
  "bin: %b\n"
  ,
  14
  )
  This prints the character corresponding to the
  given integer.
  fmt
  .
  Printf
  (
  "char: %c\n"
  ,
  33
  )
  %x
  provides hex encoding.
  fmt
  .
  Printf
  (
  "hex: %x\n"
  ,
  456
  )
  There are also several formatting options for
  floats. For basic decimal formatting use
  %f
  .
  fmt
  .
  Printf
  (
  "float1: %f\n"
  ,
  78.9
  )
  %e
  and
  %E
  format the float in (slightly
  different versions of) scientific notation.
  fmt
  .
  Printf
  (
  "float2: %e\n"
  ,
  123400000.0
  )
  fmt
  .
  Printf
  (
  "float3: %E\n"
  ,
  123400000.0
  )
  For basic string printing use
  %s
  .
  fmt
  .
  Printf
  (
  "str1: %s\n"
  ,
  "\"string\""
  )
  To double-quote strings as in Go source, use
  %q
  .
  fmt
  .
  Printf
  (
  "str2: %q\n"
  ,
  "\"string\""
  )
  As with integers seen earlier,
  %x
  renders
  the string in base-16, with two output characters
  per byte of input.
  fmt
  .
  Printf
  (
  "str3: %x\n"
  ,
  "hex this"
  )
  To print a representation of a pointer, use
  %p
  .
  fmt
  .
  Printf
  (
  "pointer: %p\n"
  ,
  &
  p
  )
  When formatting numbers you will often want to
  control the width and precision of the resulting
  figure. To specify the width of an integer, use a
  number after the
  %
  in the verb. By default the
  result will be right-justified and padded with
  spaces.
  fmt
  .
  Printf
  (
  "width1: |%6d|%6d|\n"
  ,
  12
  ,
  345
  )
  You can also specify the width of printed floats,
  though usually you’ll also want to restrict the
  decimal precision at the same time with the
  width.precision syntax.
  fmt
  .
  Printf
  (
  "width2: |%6.2f|%6.2f|\n"
  ,
  1.2
  ,
  3.45
  )
  To left-justify, use the
  -
  flag.
  fmt
  .
  Printf
  (
  "width3: |%-6.2f|%-6.2f|\n"
  ,
  1.2
  ,
  3.45
  )
  You may also want to control width when formatting
  strings, especially to ensure that they align in
  table-like output. For basic right-justified width.
  fmt
  .
  Printf
  (
  "width4: |%6s|%6s|\n"
  ,
  "foo"
  ,
  "b"
  )
  To left-justify use the
  -
  flag as with numbers.
  fmt
  .
  Printf
  (
  "width5: |%-6s|%-6s|\n"
  ,
  "foo"
  ,
  "b"
  )
  So far we’ve seen
  Printf
  , which prints the
  formatted string to
  os.Stdout
  .
  Sprintf
  formats
  and returns a string without printing it anywhere.
  s
  :=
  fmt
  .
  Sprintf
  (
  "sprintf: a %s"
  ,
  "string"
  )
  fmt
  .
  Println
  (
  s
  )
  You can format+print to
  io.Writers
  other than
  os.Stdout
  using
  Fprintf
  .
  fmt
  .
  Fprintf
  (
  os
  .
  Stderr
  ,
  "io: an %s\n"
  ,
  "error"
  )
  }
  $
  go run string-formatting.go
  struct1: {1 2}
  struct2: {x:1 y:2}
  struct3: main.point{x:1, y:2}
  type: main.point
  bool: true
  int: 123
  bin: 1110
  char: !
  hex: 1c8
  float1: 78.900000
  float2: 1.234000e+08
  float3: 1.234000E+08
  str1: "string"
  str2: "\"string\""
  str3: 6865782074686973
  pointer: 0xc0000ba000
  width1: | 12| 345|
  width2: | 1.20| 3.45|
  width3: |1.20 |3.45 |
  width4: | foo| b|
  width5: |foo |b |
  sprintf: a string
  io: an error
  Next example:
  Text Templates
  .
  by
  Mark McGranaghan
  and
  Eli Bendersky
  |
  source
  |
  license