go学习笔记对象排序、flag.Var多字段处理demo

接口

go的接口类型是interface。
可以实现类似java的接口接口继承，但是这里不需要显式的继承某个接口类型，只需要实现接口的方法即可。

下面的两个例子是排序和命令参数解析到类的，以及一个对象的格式化输出。

1.排序要实现的接口方法

type Interface interface { 
    // Len is the number of elements in the collection. 
    Len() int 
    // Less reports whether the element with 
    // index i should sort before the element with index j. 
    Less(i, j int) bool 
    // Swap swaps the elements with indexes i and j. 
    Swap(i, j int) 
    }

1.2.有多个字段的对象

//对象定义
type testInterFace struct {
	name string
	desc string
}

//集合
type testSort struct {
	test []testInterFace
	less func(x, y testInterFace) bool
}

// 输出格式化
func (p testSort) String() string {
	var str = ""
	for i := 0; i < len(p.test); i++ {
		str = fmt.Sprintf("%s\n%s", str, p.test[i].String())
	}
	return str
}

//实现接口
func (p testSort) Len() int {
	return len(p.test)
}

func (p testSort) Less(a, b int) bool {
	return p.less(p.test[a], p.test[b])
}

func (p testSort) Swap(i, j int) {
	p.test[i], p.test[j] = p.test[j], p.test[i]
}

1.3测试

var pSlice = []testInterFace{
	{
		"1",
		"第一个",
	},
	{
		"5",
		"第五个",
	},
	{
		"2",
		"第二个",
	},
}

func main() {
	nameSort := testSort{
		test: pSlice,
		less: func(x, y testInterFace) bool {
			return strings.Compare(x.name, y.name) > 0
		},
	}
	sort.Stable(nameSort)
	fmt.Printf("sort test%v\n", nameSort)
}

2.flag.Val的多字段解析

2.1接口定义

//输出接口
func (test *testInterFace) String() string {
	return fmt.Sprintf("name:%s;desc:%s", test.name, test.desc)
}

func (test *testInterFace) Set(s string) error {
	fmt.Println(s)
	if s != "" {
		//按照空格隔开
		//strings.Fields(s)
		arr := strings.Split(s, ",")
		if len(arr) > 1 {
			test.name = arr[0]
			test.desc = arr[1]
		}
	}
	return nil
}

2.2测试

这里有个坑 1.执行命令的时候 数据参数加空格、分号会被认为是下一个参数的
          2.这里用,代替了
        
        var period testInterFace
	flag.Var(&period, "addr", "Database hosts")
	flag.Parse()
	fmt.Printf("接口多参数数据解析 %v\n", &period)