Kepiye fungsi lan nilai balik ganda makarya ing Go?

Question

Accepted Answer

Fungsi Go dinyatakake nganggo `func`, lan fitur sing khas yaiku **nilai balik ganda** — fungsi bisa bali marang nilai sawetara bebarengan. Iki digunakake kanthi luas, utamane kanggo idiom `(result, error)` sing nemtokake panganan kesalahan Go.

## Fungsi dhasar

```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 balik ganda — fitur kang nemtokake

```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)
```

Mbali `(value, error)` yaiku idiom kanggo panganan kesalahan ing Go — tinimbang pengecualian, fungsi bali kesalahan minangka nilai sing kanthi sadar dicek dening panyeru. Iki nggawe panganan kesalahan katon lan ora bisa kanthi senyap disingkirake.

## Pola 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 balik sing dingarani

```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 variadis

```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 minangka kelas pisanan

```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 iku penting

Fungsi Go minangka pusat, lan **nilai balik ganda** yaiku salah sawijining fitur kang nemtokake basa — padha bisa idiom `(result, error)` sing *yaiku* cara Go panganan kesalahan (parikso kesalahan eksplisit minangka nilai tinimbang pengecualian).

Pola iki, digunakake ing meh saben program Go, nggawe panganan kesalahan katon lan kekarepan.

Idiom comma-ok sing kakait (`value, ok :=`) katon ing kabeh papan (akses peta, asertsi tipe, panarima saluran).

Memahami nilai balik ganda, pola kesalahan, nilai balik sing dingarani, fungsi variadis, lan fungsi kelas pisanan mbutuhake kanggo maca lan nulis Go idiomatik — lan filosofi kesalahan minangka nilai yaiku salah sawijining béda konseptual paling penting antarane Go lan basa dhasar pengecualian.