Bagaimanakah fungsi dan nilai pulangan berbilang berfungsi dalam Go?

Question

Accepted Answer

Fungsi Go diisytiharkan dengan `func`, dan ciri khas ialah **nilai pulangan berbilang** — satu fungsi boleh mengembalikan beberapa nilai pada masa yang sama. Ini digunakan secara meluas, terutamanya untuk idiom `(result, error)` yang mentakrifkan pengendalian ralat Go.

## Fungsi asas

```go
func add(a int, b int) int {     // params with types, then the return type
    return a + b
}

func greet(name string) string {
    return "Hello, " + name
}
// shorthand for same-typed params: func add(a, b int) int
```

## Nilai pulangan berbilang — ciri khas yang menentukan

```go
func divide(a, b int) (int, error) {     // returns BOTH a result AND an error
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil    // nil error = success
}

// callers handle both — the ubiquitous Go error pattern
result, err := divide(10, 2)
if err != nil {
    log.Fatal(err)       // handle the error
}
fmt.Println(result)
```

Mengembalikan `(value, error)` adalah IDIOM untuk pengendalian ralat dalam Go — bukannya pengecualian, fungsi mengembalikan ralat sebagai nilai yang peminta secara eksplisit periksa. Ini membuat pengendalian ralat ketara dan mustahil untuk diabaikan secara senyap.

## Corak comma-ok

```go
// many built-ins return (value, ok) — a boolean for "did it work?"
value, ok := myMap["key"]   // ok = false if the key is missing
if ok { ... }

v, ok := someInterface.(string)   // type assertion with ok
```

## Nilai pulangan yang dinamakan

```go
func split(sum int) (x, y int) {   // named returns
    x = sum * 4 / 9
    y = sum - x
    return   // "naked return" — returns the named values
}
```

## Fungsi variadik

```go
func sum(nums ...int) int {     // accepts any number of ints
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
sum(1, 2, 3)          // 6
sum(nums...)          // spread a slice into args
```

## Fungsi adalah kelas pertama

```go
var op func(int, int) int = add   // assign functions to variables
func apply(fn func(int) int, x int) int { return fn(x) }  // pass as arguments
```

## Mengapa ini penting

Fungsi Go adalah pusat, dan **nilai pulangan berbilang** adalah salah satu ciri khas bahasa — ia memungkinkan idiom `(result, error)` yang *ialah* pendekatan Go untuk pengendalian ralat (pemeriksaan ralat-sebagai-nilai yang jelas dan bukannya pengecualian).

Corak ini, digunakan dalam hampir setiap program Go, membuat pengendalian ralat ketara dan sengaja.

Idiom comma-ok yang berkaitan (`value, ok :=`) muncul di mana-mana (akses peta, asertasi jenis, penerimaan saluran).

Memahami nilai pulangan berbilang, corak ralat, nilai pulangan yang dinamakan, fungsi variadik, dan fungsi kelas pertama adalah penting untuk membaca dan menulis Go idiomatik — dan falsafah ralat-sebagai-nilai adalah salah satu perbezaan konseptual paling penting antara Go dan bahasa berasaskan pengecualian.