Golang介面型函數使用小結

2022-06-20 14:01:01

常規介面實現

defer語句用於延遲函數呼叫，每次會把一個函數壓入棧中，函數返回前再把延遲的函數取出並執行。延遲函數可以有引數：

延遲函數的引數在defer語句出現時就已確定下來（傳值的就是當前值）；
延遲函數執行按後進先出順序執行；
延遲函數可操作主函數的具名返回值（修改返回值）；

type Handler interface {
    DoFunc(k, v interface{})
}
func DoEach(m map[interface{}]interface{}, h Handler) {
    if m != nil && len(m) > 0 {
        for k, v := range m {
            h.DoFunc(k, v)
        }
    }
}

這裡我們定義了一個Handler介面，只有一個DoFunc方法，接收k，v兩個引數，這就是一個介面了，我們後面會實現他，具體做什麼由我們的實現決定。

然後我們定義了一個DoEach函數，該函數的功能就是迭代傳遞過來的map引數，然後把map的每個key和value值傳遞給Handler的DoFunc方法，

具體由這個Handler的實現來決定，這也是面向介面程式設計。

說得再多不如來點實際的例子：用我們剛剛定義的DoEach方法和Handler介面。

package main
import "fmt"
type Handler interface {
    DoFunc(k, v interface{})
}
func DoEach(m map[interface{}]interface{}, h Handler) {
    if m != nil && len(m) > 0 {
        for k, v := range m {
            h.DoFunc(k, v)
        }
    }
}
type greet string
func ( g greet) DoFunc(k, v interface{}) {
    fmt.Printf("%s,在下%s,我的必殺技是%sn", g, k, v)
}
func main() {
    persons := make(map[interface{}]interface{})
    persons["喬峰"] = "龍爪手"
    persons["鳩摩智"] = "小無相功"
    persons["慕容復"] = "斗轉星移"
    var g greet = "諸位英雄"
    DoEach(persons, g)
}

輸出：

諸位英雄,在下喬峰,我的必殺技是龍爪手
諸位英雄,在下鳩摩智,我的必殺技是小無相功
諸位英雄,在下慕容復,我的必殺技是斗轉星移

以上實現，我們定義了一個map來儲存幾位大佬，map的key是大佬的名字，value是該大佬的絕技。greet是我們新定義的型別，

其對應基本型別string，該greet實現了Handler介面，列印出自我介紹的資訊。

介面型函數出場

關於上面的實現，我們可以發現，有兩點不太好：

因為必須要實現Handler介面，DoFunc這個方法名不能修改，不能定義一個更有意義的名字
必須要新定義一個型別，才可以實現Handler介面，才能使用DoEach函數

首先我們先解決第一個問題，根據我們具體做的事情定義一個更有意義的方法名，比如例子中是自我介紹，

那麼我們使用selfintroduction是不是要比DoFunc這個語意的方法要好呢。

如果呼叫者改了方法名，那麼就不能實現Handler介面，還要使用DoEach方法怎麼辦？那就是由提供DoEach函數的負責提供Handler的實現，

我們改造下程式碼如下：

type HandlerFunc func(k, v interface{})
 
func (f HandlerFunc) DoFunc(k, v interface{}) {
    f(k, v)
}

上面程式碼我們定義了一個新的型別HandlerFunc，它是一個func(k, v interface{})型別，然後這個新的HandlerFunc實現了Handler介面(原始實現方式中的

type Handler interface { DoFunc(k, v interface{}) }

)，DoFunc方法的實現是呼叫HandlerFunc本身，因為HandlerFunc型別的變數就是一個方法。現在我們使用這種方式實現同樣的效果。

完整程式碼如下：

package main
import "fmt"
type Handler interface {
    DoFunc(k, v interface{})
}
type HandlerFunc func(k, v interface{})
func (f HandlerFunc) DoFunc(k, v interface{}) {
    f(k, v)
}
type greet string
func (g greet) selfintroduction(k, v interface{}) {
    fmt.Printf("%s,在下%s,我的必殺技是%sn", g, k, v)
}
func DoEach(m map[interface{}]interface{}, h Handler) {
    if m != nil && len(m) > 0 {
        for k, v := range m {
            h.DoFunc(k, v)
        }
    }
}
func main() {
    persons := make(map[interface{}]interface{})
    persons["喬峰"] = "龍爪手"
    persons["鳩摩智"] = "小無相功"
    persons["慕容復"] = "斗轉星移"
    var g greet = "諸位英雄"
    DoEach(persons, HandlerFunc(g.selfintroduction))
}

輸出：

諸位英雄,在下喬峰,我的必殺技是龍爪手
諸位英雄,在下鳩摩智,我的必殺技是小無相功
諸位英雄,在下慕容復,我的必殺技是斗轉星移

還是差不多原來的實現，只是把原介面方法名DoFunc改為selfintroduction。HandlerFunc(g.selfintroduction)不是方法的呼叫，而是轉型，因為selfintroduction和HandlerFunc是同一種型別，

所以可以強制轉型。轉型後，因為HandlerFunc實現了Handler介面，所以我們就可以繼續使用原來的DoEach方法了。

進一步改造

現在解決了命名的問題，但是每次強制轉型是不是不太好？我們繼續重構下，可以採用新定義一個函數的方式，幫助呼叫者強制轉型。

完整程式碼如下：

package main
import "fmt"
type Handler interface {
    DoFunc(k, v interface{})
}
type HandlerFunc func(k, v interface{})
func (f HandlerFunc) DoFunc(k, v interface{}) {
    f(k, v)
}
type greet string
func (g greet) selfintroduction(k, v interface{}) {
    fmt.Printf("%s,在下%s,我的必殺技是%sn", g, k, v)
}
func DoEach(m map[interface{}]interface{}, h Handler) {
    if m != nil && len(m) > 0 {
        for k, v := range m {
            h.DoFunc(k, v)
        }
    }
}
func EachFunc(m map[interface{}]interface{}, f func(k, v interface{})) {
    DoEach(m, HandlerFunc(f))
}
func main() {
    persons := make(map[interface{}]interface{})
    persons["喬峰"] = "龍爪手"
    persons["鳩摩智"] = "小無相功"
    persons["慕容復"] = "斗轉星移"
    var g greet = "諸位英雄"
    EachFunc(persons, g.selfintroduction)
}

上面我們新增了一個EachFunc函數，幫助呼叫者強制轉型，呼叫者就不用自己做了。

現在我們發現EachFunc函數接收的是一個func(k, v interface{})型別的函數，沒有必要實現原Handler介面了，所以我們新的型別可以去掉不用了。

去掉了自定義型別greet之後，整個程式碼更簡潔，可讀性是不是更好點？簡潔乾淨的完整程式碼如下：

package main
import "fmt"
type Handler interface {
    DoFunc(k, v interface{})
}
type HandlerFunc func(k, v interface{})
func (f HandlerFunc) DoFunc(k, v interface{}) {
    f(k, v)
}
func DoEach(m map[interface{}]interface{}, h Handler) {
    if m != nil && len(m) > 0 {
        for k, v := range m {
            h.DoFunc(k, v)
        }
    }
}
func EachFunc(m map[interface{}]interface{}, f func(k, v interface{})) {
    DoEach(m, HandlerFunc(f))
}
func selfintroduction(k, v interface{}) {
    fmt.Printf("諸位英雄,在下%s,我的必殺技是%sn", k, v)
}
func main() {
    persons := make(map[interface{}]interface{})
    persons["喬峰"] = "龍爪手"
    persons["鳩摩智"] = "小無相功"
    persons["慕容復"] = "斗轉星移"
    EachFunc(persons, selfintroduction)
}

以上關於函數型介面就寫完了，如果大家仔細留意，發現和我們自己平時使用的http.Handle方法非常類似，其實介面http.Handler就是這麼實現的。

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}
 
func Handle(pattern string, handler Handler) {
    DefaultServeMux.Handle(pattern, handler)
}
 
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

這是一種非常好的技巧，提供兩種函數，既可以以介面的方式使用，也可以以方法的方式，

對應我們例子中的DoEach和EachFunc這兩個函數，靈活方便,也更符合自然語言規則吧。

無論從事什麼行業，只要做好兩件事就夠了，一個是你的專業、一個是你的人品，專業決定了你的存在，人品決定了你的人脈，剩下的就是堅持，用善良專業和真誠贏取更多的信任。

到此這篇關於Golang介面型函數使用技巧的文章就介紹到這了,更多相關Golang介面使用內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！

Golang介面型函數使用小結

目錄

常規介面實現

介面型函數出場

進一步改造

熱門文章