中转站

延迟初始化

对于一个为nil的map做写操作（改&&增）会报panic

slice || map || func

10- 660

select 有case满足的时候就会跳出select

go 中在select语句与for语句联用时，怎样直接退出外层的for语句？

package main

import (
	"fmt"
	"time"
)

func main() {
	// 创建一个通道用于通知退出
	exit := make(chan bool)

	// 启动一个 goroutine
	go func() {
		time.Sleep(2 * time.Second)
		exit <- true
	}()

	// 使用一个布尔类型的标志控制外层的 for 循环
	exitFlag := false

	// 外层的 for 循环
	for !exitFlag {
		select {
		case <-exit:
			// 当从 exit 通道接收到消息时，设置标志并退出外层的 for 循环
			fmt.Println("Received exit signal. Breaking out of the loop.")
			exitFlag = true
		default:
			// 在没有接收到 exit 通道消息时，执行其他操作
			fmt.Println("Doing some work...")
			time.Sleep(500 * time.Millisecond)
		}
	}

	fmt.Println("Exited the main loop.")
}

一等公民

既不要把你程序的细节暴露给外界，也尽量不要让外界的变动影响到你的程序

package main

import "fmt"

func main() {
	complexArray1 := [3][]string{
		[]string{"d", "e", "f"},
		[]string{"g", "h", "i"},
		[]string{"j", "k", "l"},
	}

	fmt.Printf("The array: %v\n", complexArray1)
	complexArray2 := modifyComplexArray(complexArray1)
	fmt.Printf("The modified array: %v\n", complexArray2)
	fmt.Printf("The original array: %v\n", complexArray1)

	fmt.Println("	-------		")
	simpleArrray1 := []string{"1", "2", "3"}

	fmt.Printf("The array: %v\n", simpleArrray1)
	simpleArrray2 := modifySimpleArry(simpleArrray1)
	fmt.Printf("The modified array: %v\n", simpleArrray2)
	fmt.Printf("The original array: %v\n", simpleArrray1)

	simpleArrray2[0] = "XXX"
	fmt.Printf("The modified array: %v\n", simpleArrray2)
	fmt.Printf("The original array: %v\n", simpleArrray1)

	t1 := []string{"1", "2", "3"}
	t2 := t1
	t1[0] = "XXX"
	fmt.Println(t1)
	fmt.Println(t2)

}

func modifyComplexArray(a [3][]string) [3][]string {
	a[0][1] = "XXXXX"
	return a
}

func modifySimpleArry(a []string) []string {
	a[0] = "modifed"
	return a
}

闭包函数

package main

import (
	"errors"
	"fmt"
)

type operator func(x, y int) int
type caculatFunc func(x, y int) (int, error)

func genCalculator(op operator) caculatFunc {
	return func(x, y int) (int, error) {
		if op == nil {
			return -1, errors.New("XXXX")
		}
		return op(x, y), nil
	}
}

func main() {
	op := func(x, y int) int {
		return x + y
	}
	x, y := 10, -100
	add := genCalculator(op)

	if res, err := add(x, y); err == nil {
		fmt.Println(res)
	}
}

interface

var count uint32
trigger := func(i uint32, fn func()) {
	for {
		if n := atomic.LoadUint32(&count); n == i {
			fn()
			atomic.AddUint32(&count, 1)
			break
		}
		time.Sleep(time.Nanosecond)
	}
}
for i := uint32(0); i < 10; i++ {
	go func(i uint32) {
		fn := func() {
			fmt.Println(i)
		}
		trigger(i, fn)
	}(i)
}
trigger(10, func() {})

这里需要注意两点：

1. range表达式只会在for语句开始执行时被求值一次，无论后边会有多少次迭代；
2. range表达式的求值结果会被复制，也就是说，被迭代的对象是range表达式结果值的副本而不是原值。

panic

package main

import (
	"fmt"
)

func main() {

	fmt.Println("Enter function main.")
	caller1()
	fmt.Println("Exit function main.")
}

func caller1() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()
	fmt.Println("Enter caller1.")
	caller2()
	fmt.Println("Exit caller1.")
}

func caller2() {

	fmt.Println("Enter caller2")
	panic("panic的信息")
	fmt.Println("Exit caller2")
}

测试：

单元测试

api测试

集成测试

灰度测试

defer

• 协程记录defer的信息，函数退出调用
• 放到函数尾

panic 终止当前协程的运行

panic后会执行当前协程中已经注册的defer

反射

需求：

• 动态的获取对象的类型
• 对任意类型的变量赋值
• 调用任意方法

使用反射调用方法

• 将框架和用户方法解耦

//获取变量的type和value

	str := "XXX"

	t := reflect.TypeOf(str)
	v := reflect.ValueOf(str)

	fmt.Println(t, v)

	if str2, ok := v.Interface().(string); ok {
		fmt.Println(str2)
	}
	//反射的应用:fmt.Printf() 根据输入的 verb，reflect.TypeOf(arg).String
	fmt.Println(v.Interface())

反射的案例

func add(a, b int) int {
	return a + b
}

func sub(a, b int) int {
	return a - b
}

func callFunc(f func(a, b int) int) {
	v := reflect.ValueOf(f)
	if v.Kind() != reflect.Func {
		return
	}
	argv := make([]reflect.Value, 2)
	argv[0] = reflect.ValueOf(1)
	argv[1] = reflect.ValueOf(2)

	res := v.Call(argv)
	fmt.Println(res[0].Int())
}

func main() {
	callFunc(sub)
	callFunc(add)
}
//-1
//3