Golang接口型函数如何使用

这篇文章主要介绍“Golang接口型函数如何使用”，在日常操作中，相信很多人在Golang接口型函数如何使用问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Golang接口型函数如何使用”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

常规接口实现

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 mainimport "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 stringfunc ( 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 mainimport "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 stringfunc (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 mainimport "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 stringfunc (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 mainimport "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)}

到此，关于“Golang接口型函数如何使用”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注编程网网站，小编会继续努力为大家带来更多实用的文章！