Functions

Functions: พื้นที่ที่คุ้นเคย

ฟังก์ชันใน TypeScript มีความยืดหยุ่นสูง — arrow function, default params, rest params, การคืนค่าแบบ tuple ฟังก์ชันใน Go ชัดเจนกว่าแต่ก็ทรงพลังพอกัน สิ่งที่นักพัฒนา TypeScript จะแปลกใจมากที่สุดคือ ฟังก์ชันใน Go คืนค่าได้หลายค่าโดยตรง โดยไม่ต้องห่อเป็น tuple หรือ array

ไวยากรณ์ฟังก์ชันพื้นฐาน

function add(a: number, b: number): number {
    return a + b;
}

// Arrow function
const greet = (name: string): string => {
    return `Hello, ${name}!`;
};

func add(a int, b int) int {
    return a + b
}

// No arrow functions — just func
func greet(name string) string {
    return "Hello, " + name + "!"
}

การคืนค่าหลายค่า

ใน TypeScript การคืนค่าสองอย่างหมายถึงต้องใช้ tuple หรือ object แต่ใน Go การคืนค่าหลายค่าเป็นฟีเจอร์ระดับ first-class ที่ใช้กันทุกที่ — โดยเฉพาะการคืนผลลัพธ์พร้อมกับ error

// TypeScript: tuple or object
function divide(a: number, b: number): [number, Error | null] {
    if (b === 0) return [0, new Error("division by zero")];
    return [a / b, null];
}
const [result, err] = divide(10, 2);

// Go: multiple return values
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}
result, err := divide(10, 2)

Variadic functions

variadic ของ Go ทำงานเหมือน rest parameter ของ TypeScript เป๊ะ ๆ ใช้ ...T ในรายการ parameter แล้วข้างในฟังก์ชันจะได้ค่าออกมาเป็น slice

function sum(...nums: number[]): number {
    return nums.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3, 4);

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
sum(1, 2, 3, 4)

ลองเล่นดู

Open in Playground

package main

import (
  "errors"
  "fmt"
)

func add(a, b int) int {
  return a + b
}

func divide(a, b float64) (float64, error) {
  if b == 0 {
    return 0, errors.New("division by zero")
  }
  return a / b, nil
}

func sum(nums ...int) int {
  total := 0
  for _, n := range nums {
    total += n
  }
  return total
}

func main() {
  fmt.Println(add(3, 4))

  result, err := divide(10, 3)
  if err != nil {
    fmt.Println("Error:", err)
  } else {
    fmt.Printf("10 / 3 = %.4f\n", result)
  }

  fmt.Println(sum(1, 2, 3, 4, 5))
}

🟦 Named Return Values

Go ให้คุณตั้งชื่อตัวแปรที่จะคืนค่าไว้ใน signature ของฟังก์ชันได้ จากนั้น body ใช้ return เปล่าๆ เพื่อคืนค่าที่ชื่อเหล่านั้นถืออยู่ ณ ตอนนั้น วิธีนี้มีประโยชน์ในแง่การสื่อความหมายของโค้ด และเหมาะกับฟังก์ชันสั้นๆ ที่ความหมายของแต่ละค่าคืนชัดเจนอยู่แล้ว

func minMax(nums []int) (min, max int) {
    min, max = nums[0], nums[0]
    for _, n := range nums[1:] {
        if n < min { min = n }
        if n > max { max = n }
    }
    return // bare return — returns min and max
}

ใช้ named returns อย่างประหยัด เพราะอาจลดความชัดเจนในฟังก์ชันที่ยาวขึ้น