In der Go-Sprache ist Panik wie eine Ausnahme, sie entsteht auch zur Laufzeit. Mit anderen Worten, Panik bedeutet, dass in Ihrem Go-Programm ein unerwarteter Zustand auftritt, aufgrund dessen die Ausführung Ihres Programms abgebrochen wird. Manchmal tritt zur Laufzeit eine Panik auf, wenn eine bestimmte Situation auftritt, wie z panic()- Funktion, wie in Beispiel 2 gezeigt.
Die Panikfunktion ist eine eingebaute Funktion, die unter dem eingebauten Paket der Go-Sprache definiert ist. Diese Funktion beendet den Kontrollfluss und beginnt in Panik zu geraten.

Syntax:

func panic(v interface{})

Es kann jede Art von Argument empfangen. Wenn die Panik im Go-Programm auftritt, wird das Programm zur Laufzeit beendet und im Ausgabebildschirm wird eine Fehlermeldung sowie der Stack-Trace bis zu dem Punkt angezeigt, an dem die Panik aufgetreten ist. Im Allgemeinen wird in der Go-Sprache, wenn die Panik im Programm auftritt, das Programm nicht sofort beendet, sondern beendet, wenn go die gesamte anstehende Arbeit dieses Programms abschließt.
Zum BeispielAngenommen, eine Funktion A ruft Panik auf, dann wird die Ausführung der Funktion A gestoppt, und wenn in A verzögerte Funktionen verfügbar sind, werden sie normal ausgeführt, nachdem die Funktion A zu ihrem Aufrufer zurückkehrt und sich der Aufrufer A wie ein Anruf verhält in Panik geraten. Dieser Prozess wird fortgesetzt, bis alle Funktionen in der aktuellen Goroutine zurückgegeben werden, danach stürzt das Programm ab, wie in Beispiel 3 gezeigt.

Beispiel 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])
  
}

Ausgabe:

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

Beispiel 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)
}

Ausgabe:

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

Beispiel 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)
}

Ausgabe:

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

Hinweis: Die Defer-Anweisung oder -Funktion wird immer ausgeführt, auch wenn das Programm in Panik gerät.

Verwendung von Panik:

  • Sie können Panik für einen nicht behebbaren Fehler verwenden, bei dem das Programm seine Ausführung nicht fortsetzen kann.
  • Sie können auch Panik verwenden, wenn Sie einen Fehler für eine bestimmte Bedingung in Ihrem Programm haben möchten.