跳至主要内容

[Golang] function & method 函式與方法

函式宣告​

最常見的宣告方式​

使用 func 來定義函式：

// 完整寫法：func add(x int, y iny) int {...}
func add(x, y int) int {
	return x + y
}

使用 expression 方式定義​

也可以使用 := 來定義函式：

func main() {
	add := func(x, y int) int {
		return x + y
	}
}

匿名函式（anonymous function）​

常用在 goroutine 或該 function 只會使用一次的情況：

// 定義一個匿名函式並直接執行
func main() {
	// 沒有參數
	func() {
		fmt.Println("Hello anonymous")
	}()

	// 有參數
	func(i, j int) {
		fmt.Println(i + j)
	}(1, 2)
}

在函式中帶入參數​

一般來說，對於基本資料型別來說，帶入的參數都會是複製一個 value 後傳進去：

type Person struct {
	Name string
	Age  int
}

func changeName(person Person, newName string) {
	fmt.Println("name before", person.Name) // name before Aaron
	person.Name = newName
	fmt.Println("name after", person.Name) // name after Chen
}

func main() {
	myPerson := Person{
		Name: "Aaron",
		Age:  32,
	}

	changeName(myPerson, "Chen")

	// 這裡的 person.Name 還是 "Aaron"
	fmt.Printf("this is my person %+v", myPerson) // this is my person {Name:Aaron Age:32}
}

然而，如果傳入的資料型別是 "reference type" 的話（例如，slice、map、channel、function），它雖然一樣會複製，但複製到的只是指稱到底層的 pointer，因此，如果對這個資料進行修改，會直接改動到原本的資料：

func changeProductName(products []string, idx int, name string) {
	products[idx] = name
	fmt.Println(products[idx]) // phone
}

func main() {
	products := []string{"toy", "book", "cookie"}
	fmt.Println(products[0]) // toy

	changeProductName(products, 0, "phone")

	// 這裡拿到的 value 會是 mutate 後的值
	fmt.Println(products[0]) // phone
}

如果對 slice 中的資料進行修改，它是會直接改動到原本 slice 中的資料。之所以會這樣，是因為 slice 其實只是一個 pointer，這個 pointer 可以連結到底層的 array，所以這裡如果我們對這個 slice 進行資料的操作，會改動到的其實是底層的 array。

函式本身可以是另一個函式參數，也可以是回傳值​

在 golang 中，函式本身可以是另一個函式的參數：

// cb 這個參數是一個函式
func cycleNames(names []string, cb func(string)) {
	for _, name := range names {
		cb(name)
	}
}

func sayBye(name string) {
	fmt.Printf("Goodbye %v \n", name)
}

func main() {
	names := []string{"Aaron", "John", "Kelly"}
	// 在參數中帶入函式
	cycleNames(names, sayBye)
}

範例二：

// compute 這個函式可接收其他函式作為參數
func compute(fn func(float64, float64) float64) float64 {
	return fn(3, 4)
}

func main() {

	// sqrt(a^2 + b^2)
	hypot := func(x, y float64) float64 {
		return math.Sqrt(x*x + y*y)
	}

	fmt.Println(compute(hypot))    // 5, hypot(3, 4)
	fmt.Println(compute(math.Pow)) // 81,math.Pow(3, 4)
}

函式也可以在執行後回傳另一個函式（閉包）：

func fibonacci() func() int {
	// ...
}

範例程式碼：

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
	position := 0
	cache := map[int]int{}

	return func() int {
		position++
		if position == 1 {
			cache[position] = 0
			return 0
		} else if position <= 3 {
			cache[position] = 1
		} else {
			cache[position] = cache[position-2] + cache[position-1]
		}
		return cache[position]
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

適用閉包（closure）的概念​

在 golang 的函式同樣適用閉包的概念，可以利用閉包把某個變數保留起來：

func adder() func(int) int {
	sum := 0
	return func(x int) int {
		sum += x
		return sum
	}
}

func main() {
	// pos 中的 sum 和 neg 中的 sum 是不同變數
	pos, neg := adder(), adder()

	for i := 0; i < 10; i++ {
		fmt.Println(pos(i), neg(-2*i))
	}
}

透過 structure 增加參數的可擴充性​

如果原本的 function 只需要兩個參數，可以這樣寫：

func add(x, y int) int {
	return x, y
}

func main() {
	fmt.Println(add(1 ,2))
}

但若今天我們需要添加一個參數時，變成要去修改所有使用到這個 func 的地方，需要把新的參數給帶進去，例如：

package main

import "fmt"

func add(x, y, z int) int {
	return x, y
}

func main() {
	// 每一個使用到 add 這個函式的地方都要使用
	fmt.Println(add(1 ,2, 3))
}

這樣的函式很難擴充參數的使用，因此比較好的作法是去定義 struct。如此，未來如果參數需要擴充，只需要改動 struct 和 func 內就好，不用去改動使用這個 function 地方的參數：

// STEP 1：定義參數的 structure
type addOpts struct {
	x int
	y int
	z int // STEP 4：如果新增一個參數
}

// STEP 2：把參數的型別指定為 structure
func add(opts addOpts) int {
	// STEP 5：接收新的參數 z
	// return opts.x + opts.y
	return opts.x + opts.y + opts.z
}

// STEP 3：使用 add，參數的地方使用 structure
func main() {
	// STEP 6：不用改用舊有參數的寫法
	result := add(addOpts{
		x: 10,
		y: 5
	})

	newResult := add(addOpts{
		x: 10,
		y: 5,
		z: 7
	})
}

回傳​

沒有回傳值​

對於沒有回傳值的函式可以不用定義回傳的型別：

func main() {
	hello := func() {
		fmt.Println("Hello Go")
	}

	hello() // Hello Go

	add := func(x, y int) {
		fmt.Println(x + y)
	}

	add(1, 3) // 4
}

單一回傳值​

單一回傳值只需要在定義回傳型別的地方給一個型別就好：

// 原本是 func add(i int, i int) int {...}
// 當 i 和 j 都是 int 時可以簡寫如下
func add(i, j int) int {
	return i + j
}

多個回傳值​

多個回傳值，會需要在定義回傳型別的地方給多個型別：

// func nameOfFunction(<arguments>) (<type>)
func swap(x, y string) (string, string) {
	return y, x
}

func main() {
	a, b := swap("hello", "world")
	fmt.Println(a, b)
}

💡 在 golang 中，要做到 swap 的方式可以直接使用 a, b = b, a 即可。

回傳一個 function​

// 名稱為 foo 的 function 會回傳一個 function
// 這個回傳的 function 會回傳 int
func foo() func() int {
	return func() int {
		return 100
	}
}

func main() {
	bar := foo()            // bar 會是一個 function
	fmt.Printf("%T\n", bar) // func() int
	fmt.Println(bar())      // 100
}

回傳帶有命名的值​

在 Go 中可以在 func 定義回傳 type 的地方定義要回傳的變數，最後呼叫 return 的時候，該函式會自動去拿這兩個變數。這種做法稱作 naked return，但最好只使用在內容不多的函式中，否則會嚴重影響程式的可讀性：

// 用來說明回傳的內容
func swap(x, y string) (a, b string) {
	a = y
	b = x
	return
}

func main() {
	foo, bar := swap("hello", "world")
	fmt.Println(foo, bar)
}

Methods | Function Receiver | Receiver Function​

// TL;DR
// 可以是其他型別
type Person struct {
	name string
	age int
}

func (p Person) getInfo() string {
	return p.name
}

func main() {
	p := Person{name: "Aaron", age: 32}
	fmt.Println(p.getInfo())  // Aaron
}

// 如果該函式不需要使用到 receiver 本身，可以簡寫成
func (person) getInfo string {
	return "Aaron"
}

因為 Go 本身並不是物件導向程式語言（object-oriented programming language），所以只能用 Type 搭配在函式中使用 receiver 參數來實作出類似物件程式語言的功能：

💡 提示：method 就只是帶有 receiver 參數 的函式。

Value Receiver​

如果單純要呈現某個 instance 的屬性值，這時候可以使用 value receiver：

golang

範例一​

// deck.go
// 建立一個新的型別稱作 'deck'，它會是帶有許多字串的 slice
// deck 會擁有 slice of string 所帶有的行為（概念類似繼承）
type deck []string

// 建立一個 deck 的 receiver
// 任何型別是 deck type 的變數，都將可以使用 "print" 這個方法
func (d deck) print() {
	for i, card := range d {
		fmt.Println(i, card)
	}
}
  • 透過 type deck []string 來定義一個名為 deck 的型別。要留意的是，deck 的本質上仍然是 []string 它可以使用 slice type 的方法，也可以把 slice 帶入指定為 deck 型別的函式內使用。
  • (d deck) 為 deck 添加一個 receiver function
  • print 是函式名稱
  • 當我們呼叫 cards.print() 時，這個 cards 就會變成這裡指稱到的 d，這個 d 很類似在 JavaScript 中的 this 或 self，但在 Go 中慣例上不會使用 this 和 self 來取名，慣例上會使用該 type 的前一兩個字母的縮寫。

如此我們便可以在 main.go 中使用在 deck.go 中定義的 deck 型別和其 receiver function：

// main.go
package main

func main() {
	// 使用 deck type 定義變數
	cards := deck{
		"Ace of Diamonds",
		newCard(),
	}

	// 為陣列添加元素（append 本身不會改變原陣列）
	cards = append(cards, "Six of Spades")

	// 因為我們在 deck.go 中為 "deck" 這個型別添加了 print 的 receiver
	// 因此可以直接針對型別為 deck 的變數使用 print() 這個方法
	cards.print()
}

func newCard() string {
	return "Five of Diamonds"
}

如果用物件導向的概念來說明，那麼 deck 就類似一個 class，我們在這個 class 中添加了 print() 的方法，同時也可以用 cards := deck {...} 來產生一個名為 cards 的 deck instance。

要執行程式的時候可以在終端機輸入：

$ go run main.go deck.go

golang

範例二​

func main() {
	// 根據型別 color 建立變數 c
	c := color("Red")

	fmt.Println(c.describe("is an awesome color"))
}

// STEP 1：根據型別 string，定義 color 型別
type color string

// STEP 2：
// (c color)，定義 color 的 function receiver
// describe(description string) string，describe 這個 function 接受一個字串的參數 description，並會回傳 string
func (c color) describe(description string) string {
	// 這裡的 c 就類似 this
	return string(c) + " " + description
}

Pointer receivers​

也可以把某一個 method 定義給某個 Type 的 Pointer，如果是想要修改某一個 instance 中屬性的資料，這時候的 receiver 需要使用 pointer receiver 才能修改到該 instance，否則無法修改到該 instance 的資料。例如，下面程式中的 ScalePointer 這個 method 就是定義給 *Vertex 這個 pointer：

type Vertex struct {
	X, Y float64
}

func (v Vertex) Abs() float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

// Scale 這個 methods 會修改到的是 v 的複製，而無法直接修改到 v
func (v Vertex) Scale(f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}

// ScalePointer 這個 methods 可以修改 v 中的屬性與值
func (v *Vertex) ScalePointer(f float64) {
	// 由於 v 是 pointer，所以一般來說，如果想要修改其值的話，
	// 需要先 deference，應該要寫 (*v).X = (*v).X * f
	v.X = v.X * f  // 但可以簡寫成這樣
	v.Y = v.Y * f
}

func main() {
	v := Vertex{3, 4}

	v.Scale(10)
	fmt.Println(v.Abs()) // 5

	// 這裡雖然 v 的型別應該要是 *Vertex，當我們使用的是 Vertex 邏輯上要發生錯誤
	// 但因為 ScalePointer 這個方法本身有 pointer receiver
	// 因此 Go 會自動將 v.ScalePointer(10) 視為 (&v).ScalePointer(10)
	v.ScalePointer(10)   // 等同於 (&v).ScalePointer(10)
	fmt.Println(v.Abs()) // 50，等同於（&v).Abs()
}

💡 補充：同樣的，如果 receiver 接收的是 value receiver 而非 pointer receiver 時，使用 pointer receiver 去執行某方法也會成功：v.Abs() 等同於 (&v).Abs()。

同樣的功能一樣可以改用 function 的方式來寫：

type Vertex struct {
	X, Y float64
}

func Abs(v Vertex) float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func Scale(v Vertex, f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}

// 使用 *Type 當作 function 的參數，也就是 *Vertex
func ScaleWithPointer(v *Vertex, f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}

func main() {
	v := Vertex{3, 4}
	Scale(v, 10)
	fmt.Println(v) // {3 4}
	fmt.Println(Abs(v)) // 5

	// 留意帶進去的變數需要是 Pointer，也就是 &v
	ScaleWithPointer(&v, 10) // 和 receiver 不同，「不能」簡化為 ScaleWithPointer(v, 10)
	fmt.Println(v)      // {30 40}
	fmt.Println(Abs(v)) // 50
}

該選擇 Value Receiver 或 Pointer Receiver​

參考資料

Should I define methods on values or pointers? @ Golang FAQ

func (s *MyStruct) pointerMethod() {} // method on pointer
func (s MyStruct) valueMethod()    {} // method on value

考量 Receiver 要用 value 或 pointer 就和你在定義 function arguments 時，決定要傳入的是 value 或 pointer 是一樣的。以下是一些考量的點：

  • 必須：如果你的 method 需要修改 receiver 的值，那麼 receiver 必須是 pointer。
  • Efficiency: 如果 receiver 是一個很大的 struct，那麼使用 pointer receiver 會比 value receiver 更有效率（cheaper）。
  • 一致性: 如果有些 methods 必須使用 pointer receiver，那個其他的 methods 也都改用 pointer receiver，這樣才會有一致性，不會有些要帶 pointer、有些要帶 value 的情況。
  • 型別: 對於基本型別（basic types）、slices 或較小的 struct 來說，使用 value receive 並不會太貴，反而比較 efficient 和 清楚。

使用 Type Alias​

在 Golang 中，透過 Type Alias 我們可以建立某個型別的 methods，例如：

// 建立一個名為 myStr 的 type alias
type myStr string

// 我們沒辦法幫 string 添加 methods，但可以替 type lias 添加 methods
func (m myStr) log() {
	fmt.Println(m)
}

func main() {
	var a myStr = "Aaron"
	a.log()
}

其他​

IIFE​

func main() {
	slice := []string{"a", "a"}

	// 使用 IIFE 的寫法
	func(slice []string) {
		slice[0] = "b"
		slice[1] = "b"
	}(slice)

	fmt.Println(slice)
}

參考​