Go
Manejo de errores

Introducción

Observaciones

// This method doesn't fail
func DoSomethingSafe() {
}

// This method can fail
func DoSomething() (error) {
}

// This method can fail and, when it succeeds,
// it returns a string.
func DoAndReturnSomething() (string, error) {
}

Creando un valor de error

La forma más sencilla de crear un error es mediante el uso del paquete de errors .

errors.New("this is an error")

Si desea agregar información adicional a un error, el paquete fmt también proporciona un método útil de creación de errores:

var f float64
fmt.Errorf("error with some additional information: %g", f)

Aquí hay un ejemplo completo, donde el error es devuelto desde una función:

package main

import (
    "errors"
    "fmt"
)

var ErrThreeNotFound = errors.New("error 3 is not found")

func main() {
    fmt.Println(DoSomething(1)) // succeeds! returns nil
    fmt.Println(DoSomething(2)) // returns a specific error message
    fmt.Println(DoSomething(3)) // returns an error variable
    fmt.Println(DoSomething(4)) // returns a simple error message
}

func DoSomething(someID int) error {
    switch someID {
    case 3:
        return ErrThreeNotFound
    case 2:
        return fmt.Errorf("this is an error with extra info: %d", someID)
    case 1:
        return nil
    }

    return errors.New("this is an error")
}

Abrir en el patio

Creando un tipo de error personalizado

En Go, un error está representado por cualquier valor que pueda describirse como una cadena. Cualquier tipo que implemente la interfaz de error incorporada es un error.

// The error interface is represented by a single
// Error() method, that returns a string representation of the error
type error interface {
    Error() string
}

El siguiente ejemplo muestra cómo definir un nuevo tipo de error usando un literal compuesto de cadena.

// Define AuthorizationError as composite literal
type AuthorizationError string

// Implement the error interface
// In this case, I simply return the underlying string
func (e AuthorizationError) Error() string {
    return string(e)
}

Ahora puedo usar mi tipo de error personalizado como error:

package main

import (
    "fmt"
)

// Define AuthorizationError as composite literal
type AuthorizationError string

// Implement the error interface
// In this case, I simply return the underlying string
func (e AuthorizationError) Error() string {
    return string(e)
}

func main() {
    fmt.Println(DoSomething(1)) // succeeds! returns nil
    fmt.Println(DoSomething(2)) // returns an error message
}

func DoSomething(someID int) error {
    if someID != 1 {
        return AuthorizationError("Action not allowed!")
    }

    // do something here

    // return a nil error if the execution succeeded
    return nil
}

Devolviendo un error

En Go no generas un error. En su lugar, devuelve un error en caso de fallo.

// This method can fail
func DoSomething() error {
    // functionThatReportsOK is a side-effecting function that reports its
    // state as a boolean. NOTE: this is not a good practice, so this example
    // turns the boolean value into an error. Normally, you'd rewrite this
    // function if it is under your control.
    if ok := functionThatReportsOK(); !ok {
        return errors.New("functionThatReportsSuccess returned a non-ok state")
    }

    // The method succeeded. You still have to return an error
    // to properly obey to the method signature.
    // But in this case you return a nil error.
    return nil
}

Si el método devuelve varios valores (y la ejecución puede fallar), entonces la convención estándar es devolver el error como el último argumento.

// This method can fail and, when it succeeds,
// it returns a string.
func DoAndReturnSomething() (string, error) {
    if os.Getenv("ERROR") == "1" {
        return "", errors.New("The method failed")
    }

    s := "Success!"

    // The method succeeded.
    return s, nil
}

result, err := DoAndReturnSomething()
if err != nil {
    panic(err)
}

Manejando un error

En Go los errores pueden devolverse desde una llamada de función. La convención es que si un método puede fallar, el último argumento devuelto es un error .

func DoAndReturnSomething() (string, error) {
    if os.Getenv("ERROR") == "1" {
        return "", errors.New("The method failed")
    }

    // The method succeeded.
    return "Success!", nil
}

Utiliza múltiples asignaciones de variables para verificar si el método falló.

result, err := DoAndReturnSomething()
if err != nil {
    panic(err)
}

// This is executed only if the method didn't return an error
fmt.Println(result)

Si no está interesado en el error, simplemente puede ignorarlo asignándolo a _ .

result, _ := DoAndReturnSomething()
fmt.Println(result)

Por supuesto, ignorar un error puede tener serias implicaciones. Por lo tanto, esto generalmente no se recomienda.

Si tiene varias llamadas a métodos, y uno o más métodos en la cadena pueden devolver un error, debe propagar el error al primer nivel que puede manejarlo.

func Foo() error {
    return errors.New("I failed!")    
}

func Bar() (string, error) {
    err := Foo()
    if err != nil {
        return "", err
    }

    return "I succeeded", nil
}

func Baz() (string, string, error) {
    res, err := Bar()
    if err != nil {
        return "", "", err
    }

    return "Foo", "Bar", nil
}

Recuperándose del pánico

Un error común es declarar un sector y comenzar a solicitar índices sin inicializarlo, lo que lleva a un pánico de "índice fuera de rango". El siguiente código explica cómo recuperarse del pánico sin salir del programa, que es el comportamiento normal de un pánico. En la mayoría de las situaciones, devolver un error de esta manera en lugar de salir del programa en una situación de pánico solo es útil para fines de desarrollo o prueba.

type Foo struct {
    Is []int
}

func main() {
    fp := &Foo{}
    if err := fp.Panic(); err != nil {
        fmt.Printf("Error: %v", err)
    } 
    fmt.Println("ok")
}

func (fp *Foo) Panic() (err error) {
    defer PanicRecovery(&err)
    fp.Is[0] = 5
    return nil
}

func PanicRecovery(err *error) {

    if r := recover(); r != nil {
        if _, ok := r.(runtime.Error); ok {
             //fmt.Println("Panicing")
             //panic(r)
             *err = r.(error) 
        } else {
            *err = r.(error)
        }
    }
}

El uso de una función separada (en lugar del cierre) permite la reutilización de la misma función en otras funciones propensas al pánico.