Na linguagem Go, o pânico é como uma exceção, ele também surge em tempo de execução. Ou em outras palavras, pânico significa que uma condição inesperada surge em seu programa Go devido à qual a execução de seu programa é encerrada. Às vezes, o pânico ocorre no tempo de execução quando alguma situação específica surge como acessos de array fora dos limites, etc., conforme mostrado no Exemplo 1 ou às vezes é deliberadamente acionado pelo programador para lidar com o pior cenário no programa Go com a ajuda de função panic() conforme mostrado no Exemplo 2.
A função panic é uma função embutida que é definida no pacote embutido da linguagem Go. Esta função termina o fluxo de controle e começa a entrar em pânico.

Sintaxe:

func panic(v interface{})

Pode receber qualquer tipo de argumento. Quando o pânico ocorre no programa Go, o programa termina em tempo de execução e na tela de saída é exibida uma mensagem de erro, bem como o rastreamento da pilha até o ponto onde ocorreu o pânico. Geralmente, na linguagem Go, quando o pânico ocorre no programa, o programa não é encerrado imediatamente, ele é encerrado quando o go conclui todo o trabalho pendente desse programa.
Por exemplo, suponha que uma função A chame o pânico, então a execução da função A é interrompida e se alguma função adiada estiver disponível em A, então elas são executadas normalmente após o retorno da função A para seu chamador e para o chamador A se comporta como uma chamada entrar em pânico. Este processo continua até que todas as funções na goroutine atual sejam retornadas, depois disso o programa falha, conforme mostrado no exemplo 3.

Exemplo 1:

// Simple Go program which illustrates
// the concept of panic
package main
  
import "fmt"
  
// Main function
func main() {
  
    // Creating an array of string type
    // Using var keyword
    var myarr [3]string
  
    // Elements are assigned
    // using an index
    myarr[0] = "GFG"
    myarr[1] = "GeeksforGeeks"
    myarr[2] = "Geek"
  
    // Accessing the elements
    // of the array
    // Using index value
    fmt.Println("Elements of Array:")
    fmt.Println("Element 1: ", myarr[0])
  
    // Program panics because
    // the size of the array is
    // 3 and we try to access
    // index 5 which is not 
    // available in the current array,
    // So, it gives an runtime error
    fmt.Println("Element 2: ", myarr[5])
  
}

Saída:

./prog.go:32:34: invalid array index 5 (out of bounds for 3-element array)

Exemplo 2:

// Go program which illustrates 
// how to create your own panic
// Using panic function
package main
  
import "fmt"
  
// Function
func entry(lang *string, aname *string) {
  
    // When the value of lang 
    // is nil it will panic
    if lang == nil {
        panic("Error: Language cannot be nil")
    }
      
    // When the value of aname
    // is nil it will panic
    if aname == nil {
        panic("Error: Author name cannot be nil")
    }
  
    // When the values of the lang and aname 
    // are non-nil values it will print 
    // normal output
    fmt.Printf("Author Language: %s \n Author Name: %s\n", *lang, *aname)
}
  
// Main function
func main() {
  
    A_lang := "GO Language"
  
    // Here in entry function, we pass 
    // a non-nil and nil values
    // Due to nil value this method panics
    entry(&A_lang, nil)
}

Saída:

panic: Error: Author name cannot be nil

goroutine 1 [running]:
main.entry(0x41a788, 0x0)
    /tmp/sandbox108627012/prog.go:20 +0x140
main.main()
    /tmp/sandbox108627012/prog.go:37 +0x40

Exemplo 3:

// Go program which illustrates the
// concept of Defer while panicking
package main
  
import (
    "fmt"
)
  
// Function
func entry(lang *string, aname *string) {
  
    // Defer statement
    defer fmt.Println("Defer statement in the entry function")
  
    // When the value of lang
    // is nil it will panic
    if lang == nil {
        panic("Error: Language cannot be nil")
    }
      
    // When the value of aname
    // is nil it will panic
    if aname == nil {
        panic("Error: Author name cannot be nil")
    }
  
    // When the values of the lang and aname
    // are non-nil values it will 
    // print normal output
    fmt.Printf("Author Language: %s \n Author Name: %s\n", *lang, *aname)
}
  
// Main function
func main() {
  
    A_lang := "GO Language"
  
    // Defer statement
    defer fmt.Println("Defer statement in the Main function")
  
    // Here in entry function, we pass
    // one non-nil and one-nil value
    // Due to nil value this method panics
    entry(&A_lang, nil)
}

Saída:

Defer statement in the entry function
Defer statement in the Main function
panic: Error: Author name cannot be nil

goroutine 1 [running]:
main.entry(0x41a780, 0x0)
    /tmp/sandbox121565297/prog.go:24 +0x220
main.main()
    /tmp/sandbox121565297/prog.go:44 +0xa0

Nota: Adiar a instrução ou função sempre é executada, mesmo se o programa entrar em pânico.

Uso do Panic:

• Você pode usar o pânico para um erro irrecuperável em que o programa não é capaz de continuar sua execução.
• Você também pode usar o pânico se quiser um erro para uma condição específica em seu programa.