ฟังก์ชันและค่าที่ส่งคืนหลายค่าในภาษา Go ทำงานอย่างไร

Question

Accepted Answer

ฟังก์ชัน Go ได้รับการประกาศด้วย `func` และคุณลักษณะพิเศษคือ **ค่าที่ส่งคืนหลายค่า** — ฟังก์ชันสามารถส่งคืนค่าหลายค่าพร้อมกันได้ สิ่งนี้ใช้อย่างแพร่หลาย โดยเฉพาะสำหรับ `(result, error)` idiom ที่กำหนดแนวทางการจัดการข้อผิดพลาดของ Go

## ฟังก์ชันพื้นฐาน

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

## ค่าที่ส่งคืนหลายค่า — คุณลักษณะที่กำหนด

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

การส่งคืน `(value, error)` คือ IDIOM สำหรับการจัดการข้อผิดพลาดใน Go — แทนที่จะใช้ข้อยกเว้น ฟังก์ชันส่งคืนข้อผิดพลาดเป็นค่าที่ผู้เรียกใช้ต้องตรวจสอบอย่างชัดแจ้ง ซึ่งทำให้การจัดการข้อผิดพลาดมองเห็นได้และเป็นไปไม่ได้ที่จะเพิกเฉยเงียบๆ

## รูปแบบ 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
```

## ค่าที่ส่งคืนที่ตั้งชื่อ

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

## ฟังก์ชัน Variadic

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

## ฟังก์ชันอยู่ในชั้นหนึ่ง

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

## เหตุใดจึงสำคัญ

ฟังก์ชัน Go เป็นสิ่งสำคัญ และ **ค่าที่ส่งคืนหลายค่า** เป็นหนึ่งในคุณลักษณะที่กำหนดภาษา — ฟังก์ชันเหล่านี้ช่วยให้ `(result, error)` idiom ซึ่งเป็น *แนวทาง* ของ Go ในการจัดการข้อผิดพลาด (การตรวจสอบข้อผิดพลาดเป็นค่าอย่างชัดแจ้งแทนข้อยกเว้น)

รูปแบบนี้ซึ่งใช้ในเกือบทุกโปรแกรม Go ทำให้การจัดการข้อผิดพลาดมองเห็นได้และตั้งใจเจอ

idiom comma-ok ที่เกี่ยวข้อง (`value, ok :=`) ปรากฏขึ้นทุกที่ (การเข้าถึง map ประเมินประเภท การรับจากช่อง)

การทำความเข้าใจค่าที่ส่งคืนหลายค่า รูปแบบข้อผิดพลาด ค่าที่ส่งคืนที่ตั้งชื่อ ฟังก์ชัน variadic และฟังก์ชันชั้นหนึ่งถือเป็นสิ่งจำเป็นสำหรับการอ่านและเขียนโค้ด Go ที่ถูกต้องตามหลักเกณฑ์ — และปรัชญาข้อผิดพลาดเป็นค่าเป็นหนึ่งในความแตกต่างทางความคิดที่สำคัญที่สุดระหว่าง Go และภาษาที่ใช้ข้อยกเว้น