原文鏈接：https://www.zhoubotong.site/post/51.html
什麼是接口型函數？顧名思義接口函數指的是用函數實現接口，這樣在調用的時候就會非常簡便，這種方式適用於只有一個函數的接口。
這裏以迭代一個map爲例，演示這一實現的技巧。
常規接口實現
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,我的必殺技是%s\n", 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,我的必殺技是%s\n", 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,我的必殺技是%s\n", 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,我的必殺技是%s\n", 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這兩個函數，靈活方便,也更符合自然語言規則吧。