Eksepsi #

Dalam bahasa pemrograman Golang, penanganan kesalahan (error handling) adalah proses yang penting untuk memastikan program dapat menangani situasi yang tidak terduga atau kondisi kesalahan dengan cara yang elegan. Golang tidak menggunakan mekanisme exception seperti dalam banyak bahasa pemrograman lainnya (seperti Java atau Python), tetapi menggunakan nilai kesalahan (error values) untuk mengindikasikan dan menangani kesalahan.

Paket `errors` #

Paket errors menyediakan fungsi untuk membuat objek kesalahan.

package main

import (
    "errors"
    "fmt"
)

func main() {
    err := errors.New("an error occurred")
    fmt.Println(err)
}

Mengembalikan Nilai Kesalahan #

Biasanya, fungsi yang dapat menghasilkan kesalahan akan mengembalikan dua nilai: hasil dan kesalahan. Jika tidak ada kesalahan, nilai kesalahan akan nil.

package main

import (
    "errors"
    "fmt"
)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

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

Paket `fmt` untuk Membuat Kesalahan #

Paket fmt menyediakan fungsi Errorf untuk membuat pesan kesalahan yang diformat.

package main

import (
    "fmt"
)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("cannot divide %f by zero", a)
    }
    return a / b, nil
}

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

Pengecekan Kesalahan #

Kesalahan yang terjadi dalam fungsi harus diperiksa oleh pemanggil fungsi tersebut. Ini memungkinkan program untuk mengambil tindakan yang sesuai berdasarkan jenis kesalahan.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    number, err := strconv.Atoi("123a")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Converted number:", number)
}

Custom Error Types #

Anda dapat membuat tipe kesalahan khusus dengan mengimplementasikan antarmuka error.

package main

import (
    "fmt"
)

// Definisi tipe kesalahan khusus
type MyError struct {
    Code int
    Msg  string
}

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

func doSomething() error {
    return &MyError{Code: 123, Msg: "something went wrong"}
}

func main() {
    err := doSomething()
    if err != nil {
        fmt.Println("Error:", err)
    }
}

Membungkus Kesalahan #

Anda dapat membungkus kesalahan dengan informasi tambahan menggunakan paket errors atau fmt.

package main

import (
    "errors"
    "fmt"
)

func readFile() error {
    return errors.New("file not found")
}

func processFile() error {
    if err := readFile(); err != nil {
        return fmt.Errorf("processFile: %w", err)
    }
    return nil
}

func main() {
    err := processFile()
    if err != nil {
        fmt.Println("Error:", err)
    }
}

Unwrapping Errors #

Golang 1.13 memperkenalkan fungsi errors.Is dan errors.As untuk membandingkan dan mengekstrak kesalahan.

package main

import (
    "errors"
    "fmt"
)

var ErrNotFound = errors.New("not found")

func readFile() error {
    return fmt.Errorf("readFile: %w", ErrNotFound)
}

func processFile() error {
    if err := readFile(); err != nil {
        return fmt.Errorf("processFile: %w", err)
    }
    return nil
}

func main() {
    err := processFile()
    if errors.Is(err, ErrNotFound) {
        fmt.Println("File not found error")
    } else {
        fmt.Println("Error:", err)
    }
}

Contoh Lengkap #

package main

import (
    "errors"
    "fmt"
)

// Definisi tipe kesalahan khusus
type MyError struct {
    Code int
    Msg  string
}

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

// Fungsi yang dapat menghasilkan kesalahan
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, &MyError{Code: 400, Msg: "division by zero"}
    }
    return a / b, nil
}

// Fungsi yang membungkus kesalahan
func process() error {
    result, err := divide(4, 0)
    if err != nil {
        return fmt.Errorf("process: %w", err)
    }
    fmt.Println("Result:", result)
    return nil
}

func main() {
    err := process()
    if err != nil {
        var myErr *MyError
        if errors.As(err, &myErr) {
            fmt.Printf("Custom error occurred: Code %d, Msg: %s\n", myErr.Code, myErr.Msg)
        } else {
            fmt.Println("Error:", err)
        }
    }
}

Kesimpulan #

Dengan penanganan kesalahan yang baik, Anda dapat menulis program Golang yang lebih andal dan mudah untuk didiagnosis ketika terjadi kesalahan.

« Interface

Array »