Golang通脈之方法

羌發表於2021-10-22
Golang

方法和接收者

Go語言中的方法（Method）是一種作用於特定型別變數的函式。這種特定型別變數叫做接收者（Receiver）。接收者的概念就類似於其他語言中的this或者 self。

Go 語言中同時有函式和方法。一個方法就是一個包含了接受者的函式，接受者可以是命名型別或者結構體型別的一個值或者是一個指標。所有給定型別的方法屬於該型別的方法集

方法只是一個函式，它帶有一個特殊的接收器型別，它是在func關鍵字和方法名之間編寫的。接收器可以是struct型別或非struct型別。接收方可以在方法內部訪問。

方法能給使用者自定義的型別新增新的行為。它和函式的區別在於方法有一個接收者，給一個函式新增一個接收者，那麼它就變成了方法。接收者可以是值接收者，也可以是指標接收者。

在呼叫方法的時候，值型別既可以呼叫值接收者的方法，也可以呼叫指標接收者的方法；指標型別既可以呼叫指標接收者的方法，也可以呼叫值接收者的方法。

也就是說，不管方法的接收者是什麼型別，該型別的值和指標都可以呼叫，不必嚴格符合接收者的型別。

方法的定義格式如下：

func (t Type) methodName(parameter)(return) {
  
}

其中，

  • t：接收者中的引數變數名在命名時，官方建議使用接收者型別名稱首字母的小寫，而不是self、this之類的命名。
  • Type：接收者型別和引數類似，可以是指標型別和非指標型別。
  • methodName、parameter 、return ：具體格式與函式定義相同。
//Person 結構體
type Person struct {
	name string
	age  int8
}

//NewPerson 建構函式
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}

//Dream Person做夢的方法
func (p Person) Dream() {
	fmt.Printf("%s的夢想是學好Go語言！\n", p.name)
}

func main() {
	p1 := NewPerson("張三", 25)
	p1.Dream()
}

方法與函式的區別是，函式不屬於任何型別，方法屬於特定的型別。

可以定義相同的方法名：

type Rectangle struct {
	width, height float64
}
type Circle struct {
	radius float64
}


func (r Rectangle) area() float64 {
	return r.width * r.height
}
//該 method 屬於 Circle 型別物件中的方法
func (c Circle) area() float64 {
	return c.radius * c.radius * math.Pi
}
func main() {
	r1 := Rectangle{12, 2}
	r2 := Rectangle{9, 4}
	c1 := Circle{10}
	c2 := Circle{25}
	fmt.Println("Area of r1 is: ", r1.area())
	fmt.Println("Area of r2 is: ", r2.area())
	fmt.Println("Area of c1 is: ", c1.area())
	fmt.Println("Area of c2 is: ", c2.area())
}

執行結果

Area of r1 is:  24
Area of r2 is:  36
Area of c1 is:  314.1592653589793
Area of c2 is:  1963.4954084936207
  • 雖然method的名字一模一樣，但是如果接收者不一樣，那麼method就不一樣
  • method裡面可以訪問接收者的欄位
  • 呼叫method通過.訪問，就像struct裡面訪問欄位一樣

指標型別的接收者

指標型別的接收者由一個結構體的指標組成，由於指標的特性，呼叫方法時修改接收者指標的任意成員變數，在方法結束後，修改都是有效的。這種方式就十分接近於其他語言中物件導向中的this或者self：

type Rectangle struct {
	width, height int
}

func (r *Rectangle) setVal() {
	r.height = 20
}

func main() {
	p := Rectangle{1, 2}
	s := p
	p.setVal()
	fmt.Println(p.height, s.height)
}

結果

20 2

值型別的接收者

當方法作用於值型別接收者時，Go語言會在程式碼執行時將接收者的值複製一份。在值型別接收者的方法中可以獲取接收者的成員值，但修改操作只是針對副本，無法修改接收者變數本身。

type Rectangle struct {
	width, height int
}

func (r Rectangle) setVal() {
	r.height = 20
}

func main() {
	p := Rectangle{1, 2}
	s := p
	p.setVal()
	fmt.Println(p.height, s.height) 	// 2 2
}

什麼時候應該使用指標型別接收者

  1. 需要修改接收者中的值
  2. 接收者是拷貝代價比較大的大物件
  3. 保證一致性，如果有某個方法使用了指標接收者，那麼其他的方法也應該使用指標接收者。

方法和函式

已經有了函式，為什麼還要使用方法？

type Employee struct {  
    name     string
    salary   int
    currency string
}

/*
 displaySalary() method converted to function with Employee as parameter
*/
func displaySalary(e Employee) {  
    fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)
}

func main() {  
    emp1 := Employee{
        name:     "Sam Adolf",
        salary:   5000,
        currency: "$",
    }
    displaySalary(emp1)
}

在上面的程式中，displaySalary方法被轉換為一個函式，而Employee struct作為引數傳遞給它。這個程式也產生了相同的輸出：Salary of Sam Adolf is $5000.。

為什麼可以用函式來寫相同的程式呢?有以下幾個原因：

  1. Go不是一種純粹物件導向的程式語言，它不支援類。因此，型別的方法是一種實現類似於類的行為的方法。
  2. 相同名稱的方法可以在不同的型別上定義，而具有相同名稱的函式是不允許的。

任意型別新增方法

在Go語言中，接收者的型別可以是任何型別，不僅僅是結構體，任何型別都可以擁有方法。 舉個例子，我們基於內建的int型別使用type關鍵字可以定義新的自定義型別，然後為我們的自定義型別新增方法。

//MyInt 將int定義為自定義MyInt型別
type MyInt int

//SayHello 為MyInt新增一個SayHello的方法
func (m MyInt) SayHello() {
	fmt.Println("Hello, 我是一個int。")
}
func main() {
	var m1 MyInt
	m1.SayHello() //Hello, 我是一個int。
	m1 = 100
	fmt.Printf("%#v  %T\n", m1, m1) //100  main.MyInt
}

注意事項： 非本地型別不能定義方法，也就是說我們不能給別的包的型別定義方法。

方法繼承

方法是可以繼承的，如果匿名欄位實現了一個方法，那麼包含這個匿名欄位的struct也能呼叫該方法

type Human struct {
	name  string
	age   int
	phone string
}
type Student struct {
	Human  //匿名欄位
	school string
}
type Employee struct {
	Human   //匿名欄位
	company string
}

func (h *Human) SayHi() {
	fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}
func main() {
	mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
	sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
	mark.SayHi()
	sam.SayHi()
}

執行結果：

Hi, I am Mark you can call me on 222-222-YYYY
Hi, I am Sam you can call me on 111-888-XXXX

方法重寫

type Human struct {
	name  string
	age   int
	phone string
}
type Student struct {
	Human  //匿名欄位
	school string
}
type Employee struct {
	Human   //匿名欄位
	company string
}

//Human定義method
func (h *Human) SayHi() {
	fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
}

//Employee的method重寫Human的method
func (e *Employee) SayHi() {
	fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
		e.company, e.phone) //Yes you can split into 2 lines here.
}
func main() {
	mark := Student{Human{"Mark", 25, "222-222-YYYY"}, "MIT"}
	sam := Employee{Human{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
	mark.SayHi()
	sam.SayHi()
}

執行結果：

Hi, I am Mark you can call me on 222-222-YYYY
Hi, I am Sam, I work at Golang Inc. Call me on 111-888-XXXX
  • 方法是可以繼承和重寫的
  • 存在繼承關係時，按照就近原則，進行呼叫

結構體和方法補充

因為slice和map這兩種資料型別都包含了指向底層資料的指標，因此在需要複製它們時要特別注意：

type Person struct {
	name   string
	age    int8
	dreams []string
}

func (p *Person) SetDreams(dreams []string) {
	p.dreams = dreams
}

func main() {
	p1 := Person{name: "張三", age: 18}
	data := []string{"吃飯", "睡覺", "打豆豆"}
	fmt.Printf("%p\n",data)		//0xc00006e360
	p1.SetDreams(data) 					//傳的是 data 的記憶體地址，此時p.dreams和data指向同一塊記憶體空間
	fmt.Printf("%p\n",p1.dreams)	//0xc00006e360

	// 你真的想要修改 p1.dreams 嗎？
	data[1] = "不睡覺"				//data值的修改會影響person結構體的dream欄位
	fmt.Println(p1.dreams)  // [吃飯 不睡覺 打豆豆]
}

正確的做法是在方法中使用傳入的slice的拷貝進行結構體賦值。

func (p *Person) SetDreams(dreams []string) {
	p.dreams = make([]string, len(dreams))
	copy(p.dreams, dreams)
}

同樣的問題也存在於返回值slice和map的情況，在實際編碼過程中一定要注意這個問題。

相關文章