go结构体、集合和高阶函数

过年玩了一段时间，本想着趁着过年时间学习go，年后涨薪好几倍，但是也只是停留在了计划中，梦中我都当了总裁，现实中还是一个码农。

开工大吉，开工第一天，一定要学习，只有不断的学习才可以避免被淘汰，加油打工人~（学习中工作，工作中学习更加适合我。因为我可以占老板便宜，上着班赚这钱顺便提升自己，真不错）

今天在github上面把整个十一章内容看完了，看的头晕眼花，顺便记录一下高阶函数的使用，给我感觉，和java中的spring bean 创建过程中的一段代码理念其实相同（当你使用的时候才调用），如果有熟悉spring框架并且看过spring是如何解决循环依赖的话，可以加速你的理解。

废话说完了，直接贴代码

// cars.go
package main

import (
	"fmt"
)
// 接口
type Any interface{}

// 实体
type Car struct {
	Model        string
	Manufacturer string
	BuildYear    int
	// ...
}

// 自定义一个类型是car的数组
type Cars []*Car

func main() {
	// make some cars:
	ford := &Car{"Fiesta", "Ford", 2008}
	bmw := &Car{"XL 450", "BMW", 2011}
	merc := &Car{"D600", "Mercedes", 2009}
	bmw2 := &Car{"X 800", "BMW", 2008}
	// query:
	allCars := Cars([]*Car{ford, bmw, merc, bmw2})
	// 调用FindAll方法（不是函数）
	allNewBMWs := allCars.FindAll(func(car *Car) bool {
		// 需要注意，这里只有在使用的时候才会调用，可以自己debug看下
		return (car.Manufacturer == "BMW") && (car.BuildYear > 2010)
	})
	fmt.Println("AllCars: ", allCars)
	fmt.Println("New BMWs: ", allNewBMWs)
	//
	manufacturers := []string{"Ford", "Aston Martin", "Land Rover", "BMW", "Jaguar"}
	sortedAppender, sortedCars := MakeSortedAppender(manufacturers)
	allCars.Process(sortedAppender)
	fmt.Println("Map sortedCars: ", sortedCars)
	BMWCount := len(sortedCars["BMW"])
	fmt.Println("We have ", BMWCount, " BMWs")
}

// Process all cars with the given function f:
func (cs Cars) Process(f func(car *Car)) {
	for _, c := range cs {
		f(c)
	}
}

// Find all cars matching a given criteria.
func (cs Cars) FindAll(f func(car *Car) bool) Cars {
	cars := make([]*Car, 0)
	// 这里会先调用Process方法
	cs.Process(func(c *Car) {
		// Process方法中的for循环的f(c)会回调这里
		// 然后f(c)这里会调用main函数中的return (car.Manufacturer == "BMW") && (car.BuildYear > 2010)
		// 没想到还可以这样玩，真好玩
		if f(c) {
			cars = append(cars, c)
		}
	})
	return cars
}

// Process cars and create new data.
func (cs Cars) Map(f func(car *Car) Any) []Any {
	result := make([]Any, len(cs))
	ix := 0
	cs.Process(func(c *Car) {
		result[ix] = f(c)
		ix++
	})
	return result
}

func MakeSortedAppender(manufacturers []string) (func(car *Car), map[string]Cars) {
	// Prepare maps of sorted cars.
	sortedCars := make(map[string]Cars)

	for _, m := range manufacturers {
		sortedCars[m] = make([]*Car, 0)
	}
	sortedCars["Default"] = make([]*Car, 0)

	// Prepare appender function:
	appender := func(c *Car) {
		if _, ok := sortedCars[c.Manufacturer]; ok {
			sortedCars[c.Manufacturer] = append(sortedCars[c.Manufacturer], c)
		} else {
			sortedCars["Default"] = append(sortedCars["Default"], c)
		}
	}
	return appender, sortedCars
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

看到go的高阶函数使用，这里得惊叹一声，先生大才，万万没想到go还可以这么玩（说实话，实际使用中，这么写，非常不方便理解，不过应该可以让别人叫你一声大佬？）。