Kif Go taħdem mal-iżbalji bħala valuri?

Question

Accepted Answer

Go **m'għandux eċċezzjonijiet** għal iżbalji ordinarji. Minflok, iż-żbalji huma **valuri** li jirritornaw minn funzjonijiet (tipikament bħala l-aħħar valur li jirritorna), u l-imċieħed **jivverifikaw espliċitament**. Dan jagħmel it-ttrattament tal-iżbalji vidibli, intenzjonat, u impossibbli biex jiġu injorati bis-sieħ — filosofija Go li tiddefinixxi.

## It-tip ta' error u l-mudell essenzjali

```go
// `error` is a built-in interface: anything with an Error() string method
type error interface {
    Error() string
}

// functions return (result, error) — error is nil on success
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")   // create an error
    }
    return a / b, nil    // nil = no error
}

// the ubiquitous calling pattern
result, err := divide(10, 0)
if err != nil {              // CHECK the error explicitly
    fmt.Println("error:", err)
    return
}
fmt.Println(result)
```

Iċċekk `if err != nil { ... }` jidher kostantement f'Go — kull operazzjoni li tista' tfalli hija segwita minn ċekk ta' żball espliċitu. Din il-verbozità hija intenzjonata: iż-żbalji huma dejjem vidibli u mttrattati fis-sit tal-ċall.

## Ħolqod iżbalji

```go
errors.New("something failed")                       // simple error
fmt.Errorf("failed to process %s: %w", name, err)    // formatted, with WRAPPING (%w)
```

## Ħoll u spezzjoni tal-iżbalji

```go
// %w WRAPS an underlying error, preserving the chain
if err != nil {
    return fmt.Errorf("reading config: %w", err)   // adds context, keeps original
}

// unwrap and inspect with errors.Is / errors.As
if errors.Is(err, os.ErrNotExist) { ... }          // check for a specific error
var pathErr *os.PathError
if errors.As(err, &pathErr) { ... }                 // extract a specific error type
```

Il-ħoll (`%w`) iżid il-kuntest hekk kif iż-żbalji jinfirdu, filwaqt li `errors.Is`/`errors.As` jippermettulek tikkontrolla jew testratta żbalji sottostanti speċifiċi — il-mod modern biex taħdem mal-ktiejing ta' żbalji.

## Tipi ta' żball personalizzat

```go
type ValidationError struct {
    Field string
}
func (e *ValidationError) Error() string {           // implement the error interface
    return "invalid field: " + e.Field
}
return &ValidationError{Field: "email"}
```

## errors vs panic

```text
error (values) → EXPECTED, recoverable conditions (file missing, bad input) — the norm
panic          → UNEXPECTED, programmer errors / unrecoverable (nil deref, out of bounds)
→ Use errors for normal failure handling; reserve panic for truly exceptional cases.
```

## Għaliex huwa importanti

L-approċċ ta' Go tal-żball-bħala-valur huwa wħaħda mid-detalji l-aktar definittivi u debattuti, fundamentalment differenti mill-lingwi bbażati fuq eċċezzjonijiet.

Billi jirritorna l-iżbalji bħala valuri li l-imċieħed għandhom jivverifikaw espliċitament (`if err != nil`), Go jagħmel it-ttrattament tal-iżbalji **vidibli, lokali, u impossibbli biex jiġu injorati b'mod mhux intenzjonat** — tara eżattament fejn kull żball jitwettaq, titjib il-affidabbiltà bil-prezz tal-verbozità.

Fhim tal-filosofija din, il-mudell `(result, error)`, il-ħoll tal-iżbalji (`%w`) bi `errors.Is`/`errors.As` biex iżid il-kuntest u spezzjoni tal-ktiejing, tipi ta' żball personalizzat, u d-distinzjoni bejn iż-żbalji (normali, ristrutturabli) u panic (eċċezzjonali, żbalji ta' programmatur) huwa assolutament essenzjali — jippermeati kull programm ta' Go u jirrappreżenta spostament mentali fundamentali għad-divelopper li ġejjin minn lingwi bbażati fuq eċċezzjonijiet.

Huwa wkoll waħda mill-aktar subjetti komuni ta' intervista ta' Go.