instruction: Explain go by example: temporary files and directories
output: Go by Example
  : Temporary Files and Directories
  Throughout program execution, we often want to create
  data that isn’t needed after the program exits.
  Temporary files and directories
  are useful for this
  purpose since they don’t pollute the file system over
  time.
  package
  main
  import
  (
  "fmt"
  "os"
  "path/filepath"
  )
  func
  check
  (
  e
  error
  )
  {
  if
  e
  !=
  nil
  {
  panic
  (
  e
  )
  }
  }
  func
  main
  ()
  {
  The easiest way to create a temporary file is by
  calling
  os.CreateTemp
  . It creates a file
  and
  opens it for reading and writing. We provide
  ""
  as the first argument, so
  os.CreateTemp
  will
  create the file in the default location for our OS.
  f
  ,
  err
  :=
  os
  .
  CreateTemp
  (
  ""
  ,
  "sample"
  )
  check
  (
  err
  )
  Display the name of the temporary file. On
  Unix-based OSes the directory will likely be
  /tmp
  .
  The file name starts with the prefix given as the
  second argument to
  os.CreateTemp
  and the rest
  is chosen automatically to ensure that concurrent
  calls will always create different file names.
  fmt
  .
  Println
  (
  "Temp file name:"
  ,
  f
  .
  Name
  ())
  Clean up the file after we’re done. The OS is
  likely to clean up temporary files by itself after
  some time, but it’s good practice to do this
  explicitly.
  defer
  os
  .
  Remove
  (
  f
  .
  Name
  ())
  We can write some data to the file.
  _
  ,
  err
  =
  f
  .
  Write
  ([]
  byte
  {
  1
  ,
  2
  ,
  3
  ,
  4
  })
  check
  (
  err
  )
  If we intend to write many temporary files, we may
  prefer to create a temporary
  directory
  .
  os.MkdirTemp
  ’s arguments are the same as
  CreateTemp
  ’s, but it returns a directory
  name
  rather than an open file.
  dname
  ,
  err
  :=
  os
  .
  MkdirTemp
  (
  ""
  ,
  "sampledir"
  )
  check
  (
  err
  )
  fmt
  .
  Println
  (
  "Temp dir name:"
  ,
  dname
  )
  defer
  os
  .
  RemoveAll
  (
  dname
  )
  Now we can synthesize temporary file names by
  prefixing them with our temporary directory.
  fname
  :=
  filepath
  .
  Join
  (
  dname
  ,
  "file1"
  )
  err
  =
  os
  .
  WriteFile
  (
  fname
  ,
  []
  byte
  {
  1
  ,
  2
  },
  0666
  )
  check
  (
  err
  )
  }
  $
  go run temporary-files-and-directories.go
  Temp file name: /tmp/sample610887201
  Temp dir name: /tmp/sampledir898854668
  Next example:
  Embed Directive
  .
  by
  Mark McGranaghan
  and
  Eli Bendersky
  |
  source
  |
  license