码厩开发者笔记

#83 Golang 布隆过滤器

https://github.com/bits-and-blooms/bloom/v3

package main

import (
    "fmt"
    "github.com/bits-and-blooms/bloom/v3"
)

func main() {
    filter := bloom.New(1000000, 5)
    filter.Add([]byte("apple"))
    filter.Add([]byte("banana"))
    filter.Add([]byte("orange"))
    fmt.Println(filter.Test([]byte("apple")))
    fmt.Println(filter.Test([]byte("banana")))
    fmt.Println(filter.Test([]byte("orange")))
    fmt.Println(filter.Test([]byte("grape")))
    fmt.Println(filter.Test([]byte("watermelon")))
}

#82 Go GUI 库清单

明显，fyne 遥遥领先。

#81 Go iota

type Weekday int

const (
    Sunday Weekday = iota // 0
    Monday                // 1
    Tuesday               // 2
    Wednesday             // 3
    Thursday              // 4
    Friday                // 5
    Saturday              // 6
)

func (day Weekday) String() string {
    names := [...]string{
        "Sunday",
        "Monday",
        "Tuesday",
        "Wednesday",
        "Thursday",
        "Friday",
        "Saturday",
    }

    if day < Sunday || day > Saturday {
        return "Unknown"
    }

    return names[day]
}

type FileSizeUnit int

const (
    _ = iota // 忽略第一个值 0，让后续常量从 1 开始递增
    KB FileSizeUnit = 1 << (10 * iota)  // 1 << (10*1) = 1 << 10 = 1024
    MB                                  // 1 << (10*2) = 1 << 20 = 1048576
    GB                                  // 1 << (10*3) = 1 << 30 = 1073741824
    TB                                  // 1 << (10*4) = 1 << 40 = 1099511627776
)

package main

import "fmt"

func main() {
    {
        const (
            a = iota
            b
            c
        )
        fmt.Printf("%+v\n", []int{a, b, c})
        // [0 1 2]
    }
    {
        const (
            a = 1
            b = iota
            c
        )
        fmt.Printf("%+v\n", []int{a, b, c})
        // [1 1 2]
    }
    {
        const (
            a = 1
            b = 2
            c = iota
        )
        fmt.Printf("%+v\n", []int{a, b, c})
        // [1 2 2]
    }
    {
        const (
            a = 1
            b = iota
            c = iota
        )
        fmt.Printf("%+v\n", []int{a, b, c})
        // [1 1 2]
    }
}

总结

1. 首次出现是这个常量块中变量的顺序（0 开始）
2. 后面的常量如果没有定义，就表示是按照前面的常量定义来，只是 iota 代表的值 + 1 了
3. 如果想跳过一个值，可以使用下划线

#80 Golang dlv 调试工具的使用 [编辑中]

dlv 是 Golang 生态中一种常见的调试工具，我感觉有点类似 gdb。本文描述其基本用法。

#79 Golang GC 与 STW [编辑中]

相信 Golang 开发者可能前段时间见过两位大佬关于 Golang 性能的技术讨论（撕X），其中一个很重要的点就是涉及 Golang GC 对性能的影响。

我之前的开发经验几乎全部集中于 PHP，JS，Python 等脚本型语言，较少需要涉及 GC（只有几次涉及服务内存占用的时候检查过 GC）。
接触到 Golang 之后，如果不去研究 GC 可能很多疑问是无法解决的，很多时候的优化也和 GC 密切相关。

#78 Golang 版本

2007 Robert Griesemer、Rob Pike 和 Ken Thompson 三位巨头都在谷歌任职，开始设计一门全新的语言。

1.16 及以前的版本

我开始学习 Golang 的时候，已经是 1.5 和 1.6 版本了，更早的版本只需要对重大特性引入时间做一个简单了解。
现在主要的开发版本已经升级到 1.18 和 1.20。

• 1.0
• 第一个正式版本，核心特性都已经包含在里面，承诺以后语法不会发生不兼容变化
• 至今为止，承诺都实现了。后面的版本几乎很少有激动人心的功能，绝大多数时候都是各种改进
• 1.1
• 1.2
• 支持 slice[low:high:max] 语法
• 1.4
• for range 语法引入
• 1.5
• 实现自举
• 1.9
• type alias 语法引入
• 1.11
• Go Modules 引入
• 1.12
• 开始支持 TLS 1.3
  • 需要通过 GODEBUG=tls13=1 开启（不能通过 tls Config MaxVersion 限制版本）
  • 0-RTT 不被支持（到 2023 年，依然没有提供支持）
• 1.13
• TLS 1.3 默认开启
• 1.14
• TLS 1.3 成为默认选项，并且无法通过 GODEBUG 关闭
• 异步可抢占 goroutine
• 1.16
• Go Modules 成为默认（GO111MODULE = on）
• 支持将静态文件打包进可执行文件（//go:embed）
• 弃用 io/ioutil

参考：

• https://www.jianshu.com/p/f27c4f561544
• https://makeoptim.com/golang/new-features

1.17

• Module graph pruning（依赖图修剪）
• 切片转数组指针

参考：

• https://zhuanlan.zhihu.com/p/400886653
• https://juejin.cn/news/6972418431404507173

1.18

• 泛型（Golang 发布以来最大的语法变更）
• fuzzing（模糊测试）
• TLS 客户端默认版本改为 1.2

参考：

• https://zhuanlan.zhihu.com/p/502724510
• https://tonybai.com/2022/04/20/some-changes-in-go-1-18
• https://www.oschina.net/news/186664/go-1-18-released

1.19

没有特别值得关注的的改动。

参考：

• https://golang.google.cn/blog/go1.19
• https://www.oschina.net/news/205140/go-1-19-released
• https://tonybai.com/2022/06/12/go-1-19-foresight/

1.20

• 切片转数组

参考：

• https://golang.google.cn/blog/go1.20
• https://zhuanlan.zhihu.com/p/584462097
• https://juejin.cn/post/7197635727085273145

1.21

• min, max 和 clear
• 循环变量捕获 (loop variable capture)
  参见：2023/07/05，Go 1.21 for 语义变更
• 标准库：log/slog, slices, maps, cmp

参考：

• https://www.dolthub.com/blog/2023-07-07-golang-1.21-release/
• https://www.oschina.net/news/246660/go-1-21-rc

#77 Gin + Vue3 (ElementPlus) 开发一个通用管理后台 [编辑中]

:) 本文正在编辑中，暂时不提供浏览...

#76 Go 语言有什么优势

• 语法简单
• 确实没有很多语言特性，容易上手，但说什么大道至简，Less is more 等价值观就有点扯了。
• 静态类型、强类型、编译型语言
• 性能
• 并发：自带的协程实现（goroutine + channel）在开发效率和性能之间达成了一个不错的平衡，非常优秀
• 跨平台
• 接口，反射，GC
• C 嵌入
• 便于工程化：工具链齐全，代码规范严格
• 没有历史负担：但是向前兼容的承诺也是
• Go1 兼容性承诺（最重要特性之一）：但是也令人担忧，时间一长，可能就有太重的包袱
• 基于消息传递的通信机制
• 核心开发团队名气非常大
• robert griesemer
• rob pike
• ken thompson
• russ cox
• 生态：有大公司站台，有杀手级项目（Docker, K8S 等）

存在的问题

1. 异常处理的设计
2. 标准库相对太薄弱
3. 生态：缺乏主流框架
4. 包管理机制上存在的问题
5. 没有泛型（1.18 以前）

场景

• 云原生
• 基础设施项目
• Web 开发
• 网络编程

#75 转载：一道正确率只有15%的命名返回值和闭包的问题

哈喽，大家好，我是asong。今天新注册了twitter，在里面没事瞎逛的时候，发现了一道有意思的题，他是由Redhat的首席工程师、Prometheus开源项目维护者 Bartłomiej Płotka 发出的，经调查显示，这道题的正确率只有15.2%，惨目忍睹，接下来我们就一起来看一下这道题～
原文地址：https://twitter.com/bwplotka/status/1495002204163678211

题目：下面这段代码输出结果是多少？

func aaa() (done func(), err error) {
    return func() { print("aaa: done") }, nil
}

func bbb() (done func(), _ error) {
    done, err := aaa()
    return func() { print("bbb: surprise!"); done() }, err
}

func main() {
    done, _ := bbb()
    done()
}

• A. aaa: done
• B. bbb: surprise!aaa: done
• C. 永远不会结束
• D. 编译错误

解析

答案：C 永远不会结束

这道题考查的点就是命名返回值 + 闭包，把上面的代码换成等效的匿名返回值代码你就明白了：

func aaa() (func(), error) {
    var done func()
    done = func() {
        print("aaa: done")
    }
    return done, nil
}

func bbb() (func(), error) {
    var done func()
    done, err := aaa()
    done = func() {
        print("bbb: surprise!");
        done()
    }
    return done, err
}

func main() {
    done, _ := bbb()
    done()
}

这其实是 Go 语言设计上一个 feature，当 Go 语言的返回值赋给我们特殊的"返回参数"时，如果它们被命名了，在 return 之后，我们可以在函数主体完成后的任何执行过程中引用那些带有这些名称的值，在 defer 或闭包中一样。

我们在说回这道题，在 bbb() 函数内我们使用了命名返回值 done func(), _ error，使用短变量声明 done, err := aaa() 接收 aaa() 的返回值，这里变量 done 并不是一个新变量，这就要说到Go语言的短变量声明的语法糖了，在多变量声明中，如果其中一个变量是新的，可以使用 := 声明，编译器会进行类型推断和赋值，已经声明的变量不会重新声明，直接在原变量上赋值；之后我们return的是一个闭包函数，闭包里的done值并不会被提前解析，在bbb()函数结束后，实际对应的代码就成了这样，变成了递归。

done = func() {
    print("bbb: surprise!");
    done()
}

如果我们把代码在改成这样：

func bbb() (func(), error) {
    var done func()
    done, err := aaa()
    return func() {
        print("bbb: surprise!");
        done()
    }, err
}

答案就是【B】：bbb: surprise!aaa: done

总结

一道看似简单的题，其中蕴涵的知识点确有很多，这就说明了解设计原理是多么的重要，Go语言资深工程师的路上任重道远呀～。

#74 Go 枚举

编程语言中一般都有枚举类型。可以用来替换代码中的那些有一定范围的常量，减少幻数的使用，提升代码可读性。
有些语言的枚举支持遍历等操作，有一些语言的枚举还支持枚举值和枚举名字的映射。

Go 没有在语言层面实现枚举，只能通过定义一组变量。

比如（src/runtime/time.go）：

const (
        timerNoStatus = iota
        timerWaiting
        timerRunning
        timerDeleted
        timerRemoving
        timerRemoved
        timerModifying
        timerModifiedEarlier
        timerModifiedLater
        timerMoving
)

官方代码（src/time/time.go）中有些地方会给这些变量加一个自定义类型：

// A Weekday specifies a day of the week (Sunday = 0, ...).
type Weekday int

const (
        Sunday Weekday = iota
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
        Saturday
)

参考资料与拓展阅读

• Go 里怎么正确实现枚举？答案藏着官方的源码里