El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Conceptes Bàsics de la Gestió d'Errors

Següent ►
►

La gestió d'errors és una part fonamental de qualsevol llenguatge de programació, i Go no és una excepció. En aquest tema, aprendrem com Go maneja els errors, com crear i retornar errors, i com gestionar-los de manera eficient.

Continguts

  1. Introducció a la Gestió d'Errors en Go
  2. Creació i Retorn d'Errors
  3. Gestió d'Errors
  4. Exemples Pràctics
  5. Exercicis

  1. Introducció a la Gestió d'Errors en Go

En Go, els errors es gestionen mitjançant el tipus error, que és una interfície predefinida. Aquesta interfície conté un únic mètode:

type error interface {
    Error() string
}

El mètode Error() retorna una cadena de text que descriu l'error.

  1. Creació i Retorn d'Errors

Creació d'Errors

Go proporciona el paquet errors que conté funcions per crear errors. La funció més utilitzada és errors.New.

import (
    "errors"
    "fmt"
)

func main() {
    err := errors.New("aquest és un error")
    fmt.Println(err)
}

Retorn d'Errors

És una pràctica comuna en Go retornar errors com a segon valor de retorn en les funcions. Això permet que el codi que crida la funció pugui gestionar l'error adequadament.

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("no es pot dividir per zero")
    }
    return a / b, nil
}

  1. Gestió d'Errors

Comprovar Errors

Quan es crida una funció que pot retornar un error, és important comprovar si l'error és nil abans de continuar.

func main() {
    result, err := divide(4, 0)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Resultat:", result)
}

Errors Personalitzats

És possible crear errors personalitzats implementant la interfície error.

type MyError struct {
    Msg string
}

func (e *MyError) Error() string {
    return e.Msg
}

func main() {
    err := &MyError{Msg: "aquest és un error personalitzat"}
    fmt.Println(err)
}

  1. Exemples Pràctics

Exemple 1: Funció de Divisió amb Gestió d'Errors

package main

import (
    "errors"
    "fmt"
)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("no es pot dividir per zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Resultat:", result)
}

Exemple 2: Error Personalitzat

package main

import (
    "fmt"
)

type MyError struct {
    Msg string
}

func (e *MyError) Error() string {
    return e.Msg
}

func doSomething(flag bool) error {
    if !flag {
        return &MyError{Msg: "alguna cosa va anar malament"}
    }
    return nil
}

func main() {
    err := doSomething(false)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Tot va bé")
}

  1. Exercicis

Exercici 1: Funció de Divisió

Crea una funció divide que prengui dos enters i retorni el resultat de la divisió i un error si el divisor és zero.

Solució

package main

import (
    "errors"
    "fmt"
)

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("no es pot dividir per zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Resultat:", result)
}

Exercici 2: Error Personalitzat

Crea un error personalitzat que contingui un codi d'error i un missatge. Implementa la interfície error per aquest error i utilitza'l en una funció.

Solució

package main

import (
    "fmt"
)

type CustomError struct {
    Code int
    Msg  string
}

func (e *CustomError) Error() string {
    return fmt.Sprintf("Codi: %d, Missatge: %s", e.Code, e.Msg)
}

func doSomething(flag bool) error {
    if !flag {
        return &CustomError{Code: 123, Msg: "alguna cosa va anar malament"}
    }
    return nil
}

func main() {
    err := doSomething(false)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Tot va bé")
}

Conclusió

En aquesta secció, hem après els conceptes bàsics de la gestió d'errors en Go, incloent com crear, retornar i gestionar errors. També hem vist com crear errors personalitzats per a situacions específiques. La gestió d'errors és una habilitat essencial per escriure codi robust i fiable. En el proper tema, explorarem com crear errors personalitzats més avançats.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats