Error sebagai nilai

Go tidak punya exception. Error adalah nilai biasa yang dikembalikan, dibungkus, dan diperiksa seperti data lain — dengan akibat bahwa setiap jalur kegagalan terlihat di kode.

Bentuk dasarnya

type error interface {
	Error() string
}

Itu saja. Tiga cara membuatnya, dari yang paling sederhana:

// 1. Sekali pakai
return errors.New("koneksi gagal")
return fmt.Errorf("port %d sudah dipakai", port)

// 2. Sentinel — nilai tetap yang bisa dibandingkan pemanggil
var ErrTidakDitemukan = errors.New("tidak ditemukan")

// 3. Tipe error — saat pemanggil butuh DATA, bukan cuma identitas
type ErrValidasi struct {
	Field string
	Pesan string
}

func (e *ErrValidasi) Error() string {
	return fmt.Sprintf("%s: %s", e.Field, e.Pesan)
}

Membungkus dengan %w

func (p *Postgres) AmbilProduk(ctx context.Context, id int64) (Produk, error) {
	var pr Produk
	err := p.db.QueryRow(ctx, kueriAmbil, id).Scan(&pr.ID, &pr.Nama, &pr.Harga)
	if errors.Is(err, pgx.ErrNoRows) {
		// Terjemahkan error infrastruktur jadi error DOMAIN.
		return Produk{}, fmt.Errorf("produk %d: %w", id, ErrTidakDitemukan)
	}
	if err != nil {
		return Produk{}, fmt.Errorf("ambil produk %d: %w", id, err)
	}
	return pr, nil
}

Memeriksa: Is versus As

// errors.Is — "apakah di rantai ini ada error yang IDENTIK dengan X?"
if errors.Is(err, ErrTidakDitemukan) {
	http.Error(w, "tidak ditemukan", http.StatusNotFound)
	return
}

// errors.As — "apakah di rantai ini ada error bertipe T? kalau ya, isi ke variabel"
var ve *ErrValidasi
if errors.As(err, &ve) {
	http.Error(w, ve.Field+": "+ve.Pesan, http.StatusUnprocessableEntity)
	return
}

// errors.Join — beberapa kegagalan sekaligus (validasi banyak field)
err := errors.Join(errNama, errEmail)   // Is/As tetap bekerja untuk keduanya

Memetakan error domain jadi status HTTP

Ini pola yang dipakai sepanjang roadmap: domain tidak tahu apa itu HTTP, dan lapisan HTTP punya satu tempat yang menerjemahkan.

// internal/http/errors.go
func tulisError(w http.ResponseWriter, r *http.Request, err error) {
	var (
		status = http.StatusInternalServerError
		pesan  = "terjadi kesalahan"
		ve     *ErrValidasi
	)

	switch {
	case errors.Is(err, domain.ErrTidakDitemukan):
		status, pesan = http.StatusNotFound, "tidak ditemukan"
	case errors.Is(err, domain.ErrTidakBerhak):
		status, pesan = http.StatusForbidden, "tidak berhak"
	case errors.Is(err, domain.ErrKonflik):
		status, pesan = http.StatusConflict, "sudah ada"
	case errors.As(err, &ve):
		status, pesan = http.StatusUnprocessableEntity, ve.Error()
	case errors.Is(err, context.DeadlineExceeded):
		status, pesan = http.StatusGatewayTimeout, "waktu habis"
	}

	// Detail lengkap ke log, pesan aman ke pengguna.
	if status >= 500 {
		slog.ErrorContext(r.Context(), "permintaan gagal",
			"err", err, "path", r.URL.Path)
	}

	tulisJSON(w, status, map[string]string{"error": pesan})
}

Bungkus atau catat — pilih satu

Kapan boleh mengabaikan error

defer f.Close()               // baca-saja: tidak ada yang bisa dilakukan
_ = json.NewEncoder(w).Encode(v)  // klien sudah putus; sengaja diabaikan

// TAPI: pada berkas yang DITULIS, Close() bisa mengembalikan error
// dari flush terakhir — di sana error itu penting.
if err := f.Close(); err != nil {
	return fmt.Errorf("tutup %s: %w", nama, err)
}

Linter errcheck (bagian dari golangci-lint) memaksa setiap pengabaian ditulis eksplisit dengan _ =. Itu bukan formalitas — ia mengubah "lupa" jadi "keputusan yang terlihat di review".