博客

本篇介绍在go中使用map实现不同的类型调用不同处理函数，在没有学习到反射之前，这个实现是一个很不错的方法。里面如有错误望指正。

知识点：函数作为变量值

函数变量是把函数作为值保存到变量中.在go中函数变量是引用类型。例如:

package main
 
// 将函数作为值保存到变量中
import (
        "fmt"
)
 
func hello() {
        fmt.Println("hello world!")
}
 
func main(){
        hi := hello  //将函数传递给一个变量hi hi此时是一个函数变量  可以实现函数功能类似回调
        hi()
        fmt.Println(reflect.ValueOf(hi).Kind().String())  //这里使用到反射包里查看类型



/*
hello world！
func
*/

知识点：全局匿名函数

将匿名函数赋给一个全局变量，那么这个匿名函数，就成为一个全局匿名函数，可以在程序有效。

package main

import (
	"fmt"
	"reflect"
	"time"
)

/*
有时候需要根据某些条件决定调用哪个函数，比如根据来决定执行函数。
*/

type TaskHandle func(i, j int) int //把这个类型的匿名函数重命名成TaskHandle
type FmtHandle func(i int) int    //同理  这里也只能接收形参和返回值一致的函数变量
const (
	ADD      = 1
	Subtract = 2
	Multiply = 3
	Divide   = 4
)

type Tasks struct {
	Handle map[int]TaskHandle //声明接收TaskHandle类型
}

var tasksInstance *Tasks

func init() {
	tasksInstance = &Tasks{
		Handle: make(map[int]TaskHandle), //为map分配空间
	}
	tasksInstance.RegisterHandle() //把真正的处理函数传入  形参和返回值要一致
}

func (t *Tasks) RegisterHandle() {
	t.Handle[ADD] = t.ADDTask //这里不用给参数  把函数作为变量传递
	t.Handle[Subtract] = t.SubtractTask
	t.Handle[Multiply] = t.MultiplyTask
	t.Handle[Divide] = t.DivideTask
}

func (t *Tasks) ADDTask(i, j int) int {   //写成方法或者函数没有影响
	return i + j
}

func (t *Tasks) SubtractTask(i, j int) int {
	return i - j
}

func (t *Tasks) MultiplyTask(i, j int) int {
	return i * j
}

func (t *Tasks) DivideTask(i, j int) int {
	if j == 0 {
		return 0
	}
	return i / j
}

func main() {
	//执行ADD类型对应的处理函数
	handle := tasksInstance.Handle[ADD]
	fmt.Printf("type:%d  handle:%s  result:%d \n", ADD,
		reflect.ValueOf(handle).String(), handle(2, 2))
	//全部执行
	time.Sleep(time.Second)
	for Type, handle := range tasksInstance.Handle {
		fmt.Printf("type:%d  handle:%s  result:%d \n", Type,
			reflect.ValueOf(handle).String(), handle(2, 2))
	}
	time.Sleep(time.Second)
}