<code>func CopyFile(dstName, srcName string) (written int64, err error) {
  src, err := os.Open(srcName)
  if err != nil {
    return
  }
  dst, err := os.Create(dstName)
  if err != nil {
    return
  }
  written, err = io.Copy(dst, src)
  dst.Close()
  src.Close()
  return
}
</code>

<code>func CopyFile(dstName, srcName string) (written int64, err error) {
  src, err := os.Open(srcName)
  if err != nil {
    return
  }
  defer src.Close()
  dst, err := os.Create(dstName)
  if err != nil {
    return
  }
  defer dst.Close()
  return io.Copy(dst, src)
}
</code>

<code>func a() {
  i := 0
  defer fmt.Println(i)
  i++
  return
}
</code>

<code>func b() {
  for i := 0; i < 4; i++ {
    defer fmt.Print(i)
  }
}
</code>

<code>func c() (i int) {
  defer func() { i++ }()
  return 1
}
</code>

Это удобно для изменения возвращаемого значения ошибки функции; мы скоро увидим пример этого.

Panic — это встроенная функция, которая останавливает обычный поток управления и начинает паниковать. Когда функция F вызывает panic, выполнение F прекращается, все отложенные функции в F выполняются обычным образом, а затем F возвращает управление своему вызывающему. Для вызывающей функции F тогда ведёт себя как вызов panic. Процесс продолжается по стеку, пока все функции в текущей горутине не вернутся, в этот момент программа завершает выполнение с ошибкой. Паники могут быть вызваны напрямую с помощью функции panic. Они также могут быть вызваны ошибками времени выполнения, например, при выходе за пределы массива.

Recover — это встроенная функция, которая восстанавливает контроль над паникующей горутиной. Recover полезен только внутри отложенных функций. Во время обычного выполнения вызов recover вернёт nil и не окажет никакого другого эффекта. Если текущая горутина паникует, вызов recover захватит значение, переданное в panic, и возобновит нормальное выполнение.

Вот пример программы, демонстрирующей механизмы panic и defer:

<code>package main
import "fmt"
func main() {
  f()
  fmt.Println("Returned normally from f.")
}
func f() {
  defer func() {
    if r := recover(); r != nil {
      fmt.Println("Recovered in f", r)
    }
  }()
  fmt.Println("Calling g.")
  g(0)
  fmt.Println("Returned normally from g.")
}
func g(i int) {
  if i > 3 {
    fmt.Println("Panicking!")
    panic(fmt.Sprintf("%v", i))
  }
  defer fmt.Println("Defer in g", i)
  fmt.Println("Printing in g", i)
  g(i + 1)
}
</code>

Функция g принимает целое число i и паникует, если i больше 3, иначе она вызывает саму себя с аргументом i+1. Функция f откладывает функцию, которая вызывает recover и выводит восстановленное значение (если оно не nil). Попробуйте представить, какой будет вывод этой программы, прежде чем продолжить чтение.

Программа выведет:

<code>Calling g.
Printing in g 0
Printing in g 1
Printing in g 2
Printing in g 3
Panicking!
Defer in g 3
Defer in g 2
Defer in g 1
Defer in g 0
Recovered in f 4
Returned normally from f.
</code>

Если мы удалим отложенную функцию из f, паника не будет восстановлена и дойдёт до вершины стека вызовов горутины, завершив выполнение программы. Эта изменённая программа выведет:

<code>Calling g.
Printing in g 0
Printing in g 1
Printing in g 2
Printing in g 3
Panicking!
Defer in g 3
Defer in g 2
Defer in g 1
Defer in g 0
panic: 4
panic PC=0x2a9cd8
[stack trace omitted]
</code>

Для реального примера использования panic и recover, смотрите пакет json из стандартной библиотеки Go. Он кодирует интерфейс с помощью набора рекурсивных функций. Если возникает ошибка при обходе значения, вызывается panic, чтобы раскрутить стек до вызова верхнего уровня, который восстанавливает панику и возвращает соответствующее значение ошибки (см. методы 'error' и 'marshal' типа encodeState в encode.go).

В библиотеках Go принято то, что даже если пакет использует panic внутренне, его внешний API всё равно предоставляет явные значения ошибок.

Другие способы использования defer (помимо примера file.Close, приведённого выше) включают освобождение мьютекса:

<code>mu.Lock()
defer mu.Unlock()
</code>

печать нижнего колонтитула:

<code>printHeader()
defer printFooter()
</code>

и другие.

В заключение, инструкция defer (со или без panic и recover) предоставляет необычный и мощный механизм управления потоком выполнения. Она может использоваться для моделирования целого ряда возможностей, реализованных специализированными структурами в других языках программирования. Попробуйте это применить.