nayun blog

小知识

Mon, 02 Mar 2026 11:16:37 +0800

string和[]byte
string是不可变类型，不能通过下标修改值，适合表示不可变的文本数据，安全、简洁，适合 map 键和比较操作。
[]byte可变类型，可以通过下标修改值，也可以动态扩容，适合处理可变的字节流，性能更高，适合 I/O 和缓冲区操作。
具名函数定义必须位于包级别中，不能在函数体内嵌套定义具名函数
类型断言value, ok := x.(T)/ value := x.(T)
询问接口值 x 中存储的动态类型是否是 T
导入的包必须在代码中被使用，除非使用空白标识符作为别名，仅为了执行包的初始化过程，而不直接使用包中的任何导出函数、类型或变量。，如import _ "net/http/pprof"
切片扩容
- 特殊直接分配：如果所需容量大于旧容量的两倍，新容量直接等于所需容量。
- 小容量翻倍：如果旧容量小于256，新容量一般直接翻倍（乘以2）。
- 大容量平滑过渡：如果旧容量大于等于256，则会进入一个循环，通过特定公式计算新容量。这个公式会让扩容倍数从2开始，随着容量增大，平滑地趋近于1.25倍，而不是一个固定的倍数。

性能优化

Mon, 26 Jan 2026 15:44:49 +0800

📊 性能优化分类总览
#

</>
text


 1┌─ 代码层面优化
 2│ ├─ 内存优化
 3│ ├─ 并发优化
 4│ ├─ 算法优化
 5│ └─ 编译器优化
 6│
 7├─ 运行时优化
 8│ ├─ GC 优化
 9│ ├─ 调度优化
10│ └─ 内存管理
11│
12├─ I/O 优化
13│ ├─ 网络优化
14│ ├─ 文件系统优化
15│ └─ 数据库优化
16│
17└─ 系统层面优化
18 ├─ 部署优化
19 ├─ 监控优化
20 └─ 硬件优化

🔧 详细的性能优化思路
#

一、内存管理优化（重点！）
#

1. 减少内存分配
#

</>
go


 1// ❌ 避免在循环中频繁分配
 2for i := 0; i < 1000; i++ {
 3 data := make([]byte, 1024) // 每次循环都分配
 4 // 使用 data...
 5}
 6
 7// ✅ 预分配或复用
 8buffer := make([]byte, 1024)
 9for i := 0; i < 1000; i++ {
10 // 复用 buffer
11}

2. 使用对象池 sync.Pool
#

</>
go


 1var bufferPool = sync.Pool{
 2 New: func() interface{} {
 3 return bytes.NewBuffer(make([]byte, 0, 1024))
 4 },
 5}
 6
 7func getBuffer() *bytes.Buffer {
 8 return bufferPool.Get().(*bytes.Buffer)
 9}
10
11func putBuffer(buf *bytes.Buffer) {
12 buf.Reset()
13 bufferPool.Put(buf)
14}

3. 避免内存逃逸
#

</>
go


1// ❌ 可能逃逸到堆
2func newUser() *User {
3 return &User{Name: "John"} // 逃逸到堆
4}
5
6// ✅ 如果可能，让调用方分配
7func fillUser(u *User) {
8 u.Name = "John"
9}

4. 使用栈分配
#

</>
go


 1// 小对象尽量在栈上分配
 2type Small struct {
 3 a, b int32
 4}
 5
 6// 编译器会优先在栈上分配
 7func process() {
 8 var s Small // 栈分配
 9 // ...
10}

二、并发与并行优化
#

1. 控制 Goroutine 数量
#

</>
go


 1// ❌ 无限制创建 goroutine
 2for _, task := range tasks {
 3 go process(task) // 可能创建太多 goroutine
 4}
 5
 6// ✅ 使用 worker pool
 7type WorkerPool struct {
 8 workers int
 9 tasks chan Task
10}
11
12func (wp *WorkerPool) Start() {
13 for i := 0; i < wp.workers; i++ {
14 go wp.worker()
15 }
16}

2. 减少锁竞争
#

</>
go


 1// ❌ 粗粒度锁
 2var mu sync.Mutex
 3var data map[string]int
 4
 5func update(key string, value int) {
 6 mu.Lock()
 7 data[key] = value
 8 mu.Unlock()
 9}
10
11// ✅ 细粒度锁或分片锁
12type ShardedMap struct {
13 shards []map[string]int
14 locks []sync.RWMutex
15}
16
17func (sm *ShardedMap) getShard(key string) int {
18 return int(fnv32(key)) % len(sm.shards)
19}

3. 使用 atomic 操作
#

</>
go


 1// ❌ 使用锁保护计数器
 2var count int
 3var mu sync.Mutex
 4
 5func increment() {
 6 mu.Lock()
 7 count++
 8 mu.Unlock()
 9}
10
11// ✅ 使用 atomic
12var count int64
13
14func increment() {
15 atomic.AddInt64(&count, 1)
16}

4. 利用 CPU 缓存行
#

</>
go


 1// ❌ 伪共享问题
 2type Data struct {
 3 a int64
 4 b int64 // 可能在同一缓存行
 5}
 6
 7// ✅ 缓存行对齐
 8type Data struct {
 9 a int64
10 _ [56]byte // 填充，确保在不同缓存行
11 b int64
12}

三、数据结构与算法优化
#

1. 选择合适的数据结构
#

</>
go


1// 根据使用场景选择
2- 查找频繁 → map
3- 有序数据 → slice + 二分查找
4- 频繁插入删除 → linked list
5- 唯一性检查 → map 或 bitset

2. 预分配容量
#

</>
go


 1// ❌ 动态扩容
 2var users []User
 3for i := 0; i < 10000; i++ {
 4 users = append(users, User{}) // 多次扩容
 5}
 6
 7// ✅ 预分配
 8users := make([]User, 0, 10000)
 9for i := 0; i < 10000; i++ {
10 users = append(users, User{})
11}

3. 使用更快的算法
#

</>
go


 1// ❌ O(n²)
 2for i := 0; i < n; i++ {
 3 for j := 0; j < n; j++ {
 4 // 处理
 5 }
 6}
 7
 8// ✅ O(n log n) 或 O(n)
 9sort.Slice(data, func(i, j int) bool {
10 return data[i] < data[j]
11})

4. 利用位运算
#

</>
go


1// ❌ 乘除运算
2x := a * 2
3y := b / 2
4
5// ✅ 位运算
6x := a << 1 // 乘以2
7y := b >> 1 // 除以2

四、I/O 性能优化
#

1. 批量操作
#

</>
go


1// ❌ 单条操作
2for _, user := range users {
3 db.Insert(user)
4}
5
6// ✅ 批量操作
7db.BulkInsert(users)

2. 缓冲 I/O
#

</>
go


 1// ❌ 无缓冲
 2file, _ := os.Open("data.txt")
 3buf := make([]byte, 1)
 4for {
 5 n, err := file.Read(buf)
 6 // ...
 7}
 8
 9// ✅ 带缓冲
10reader := bufio.NewReader(file)
11for {
12 line, err := reader.ReadString('\n')
13 // ...
14}

3. 连接复用
#

</>
go


 1// ❌ 每次创建连接
 2func query() {
 3 db, _ := sql.Open(...)
 4 defer db.Close()
 5 // ...
 6}
 7
 8// ✅ 连接池
 9var db *sql.DB
10
11func init() {
12 db, _ = sql.Open(...)
13 db.SetMaxOpenConns(100)
14 db.SetMaxIdleConns(10)
15}

4. 零拷贝技术
#

</>
go


 1// ❌ 数据复制
 2func process(data []byte) []byte {
 3 result := make([]byte, len(data))
 4 copy(result, data)
 5 // 处理
 6 return result
 7}
 8
 9// ✅ 避免复制
10func processInPlace(data []byte) {
11 // 原地处理
12 for i := range data {
13 data[i] = data[i] + 1
14 }
15}

五、编译器与运行时优化
#

1. 内联优化
#

</>
go


 1// 编译器会自动内联小函数
 2// 标记为 //go:noinline 可以阻止内联
 3func smallFunction(a, b int) int {
 4 return a + b // 可能被内联
 5}
 6
 7//go:noinline
 8func largeFunction() {
 9 // 不会被内联
10}

2. 逃逸分析优化
#

</>
go


1// 查看逃逸分析
2go build -gcflags="-m -l"
3
4// 输出会显示哪些变量逃逸到堆

3. 编译器指令
#

</>
go


 1// 边界检查消除
 2func sum(arr []int) int {
 3 s := 0
 4 for i := range arr {
 5 s += arr[i] // 编译器可能消除边界检查
 6 }
 7 return s
 8}
 9
10// 编译时禁用边界检查
11// go build -gcflags="-B"

4. 使用 PGO（Profile-Guided Optimization）
#

</>
go


1// 1. 收集性能数据
2go test -cpuprofile=cpu.prof -bench=.
3
4// 2. 使用 PGO 编译
5go build -pgo=cpu.prof

六、字符串与字节处理优化
#

1. strings.Builder
#

</>
go


 1// ❌ 字符串拼接
 2var result string
 3for i := 0; i < 1000; i++ {
 4 result += strconv.Itoa(i)
 5}
 6
 7// ✅ 使用 strings.Builder
 8var builder strings.Builder
 9for i := 0; i < 1000; i++ {
10 builder.WriteString(strconv.Itoa(i))
11}
12result := builder.String()

2. 避免 []byte 与 string 转换
#

</>
go


 1// ❌ 频繁转换
 2func process(s string) {
 3 b := []byte(s) // 分配新内存
 4 // 处理 b
 5 s2 := string(b) // 再次分配
 6}
 7
 8// ✅ 统一使用 []byte
 9func process(b []byte) []byte {
10 // 原地处理
11 return b
12}

3. 使用 bytes 包代替 strings 包
#

</>
go


1// bytes 包操作 []byte，避免转换
2// ❌
3s := "hello"
4s = strings.ToUpper(s)
5
6// ✅
7b := []byte("hello")
8b = bytes.ToUpper(b)

七、网络与协议优化
#

1. 协议选择
#

</>
go


1// 根据场景选择协议
2- REST/HTTP/1.1 → 简单，兼容性好
3- HTTP/2 → 多路复用，头部压缩
4- gRPC → 高性能，protobuf 编码
5- WebSocket → 实时双向通信

2. 连接复用（HTTP/2, HTTP/3）
#

</>
go


 1// 配置 HTTP 客户端
 2client := &http.Client{
 3 Transport: &http.Transport{
 4 MaxIdleConns: 100,
 5 MaxIdleConnsPerHost: 10,
 6 IdleConnTimeout: 90 * time.Second,
 7 // 启用 HTTP/2
 8 ForceAttemptHTTP2: true,
 9 },
10}

3. 压缩与序列化
#

</>
go


1// 选择合适的序列化格式
2- JSON → 通用，可读性好
3- Protobuf → 高效，二进制
4- MessagePack → 二进制 JSON
5- FlatBuffers → 零拷贝序列化
6
7// 使用压缩
8import "compress/gzip"

八、数据库优化
#

1. SQL 优化
#

</>
go


 1// ❌ N+1 查询
 2for _, user := range users {
 3 db.Query("SELECT * FROM orders WHERE user_id = ?", user.ID)
 4}
 5
 6// ✅ JOIN 或批量查询
 7db.Query(`
 8 SELECT u.*, o.*
 9 FROM users u
10 LEFT JOIN orders o ON u.id = o.user_id
11`)

2. 索引优化
#

</>
go


1// 添加合适索引
2CREATE INDEX idx_user_email ON users(email);
3CREATE INDEX idx_order_user_date ON orders(user_id, created_at);

3. 连接池配置
#

</>
go


1db.SetMaxOpenConns(100) // 最大连接数
2db.SetMaxIdleConns(25) // 最大空闲连接数
3db.SetConnMaxLifetime(5 * time.Minute) // 连接最大生命周期

九、监控与分析工具
#

1. 使用 pprof
#

</>
go


1import _ "net/http/pprof"
2
3go func() {
4 http.ListenAndServe(":6060", nil)
5}()
6
7// 收集数据
8go tool pprof http://localhost:6060/debug/pprof/profile
9go tool pprof http://localhost:6060/debug/pprof/heap

2. 使用 trace
#

</>
go


1import "runtime/trace"
2
3trace.Start(w)
4defer trace.Stop(w)
5
6// 分析
7go tool trace trace.out

3. 使用 expvar
#

</>
go


 1import "expvar"
 2
 3var (
 4 requestCount = expvar.NewInt("request_count")
 5 avgLatency = expvar.NewFloat("avg_latency_ms")
 6)
 7
 8func handler(w http.ResponseWriter, r *http.Request) {
 9 start := time.Now()
10 // 处理请求
11 latency := time.Since(start).Milliseconds()
12 requestCount.Add(1)
13 // 更新平均延迟...
14}

十、部署与系统优化
#

1. 容器优化
#

</>
dockerfile


1# 多阶段构建
2FROM golang:1.21 AS builder
3WORKDIR /app
4COPY . .
5RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .
6
7FROM alpine:latest
8COPY --from=builder /app/app .
9CMD ["./app"]

2. 操作系统优化
#

</>
bash


1# 调整系统参数
2sysctl -w net.core.somaxconn=65535
3sysctl -w net.ipv4.tcp_tw_reuse=1
4sysctl -w net.ipv4.ip_local_port_range="1024 65000"

3. CPU 亲和性
#

</>
go


1import "runtime"
2
3// 设置 GOMAXPROCS
4runtime.GOMAXPROCS(runtime.NumCPU())
5
6// 使用 taskset 绑定 CPU
7// taskset -c 0-3 ./app

📈 性能优化优先级
#

优先级 1：影响最大的优化
#

算法优化 - 改变复杂度（O(n²) → O(n log n)）
减少不必要的操作 - 避免重复计算
批量处理 - 减少 I/O 次数

优先级 2：显著的优化
#

内存分配优化 - 减少 GC 压力
并发优化 - 合理使用 goroutine 和锁
数据结构优化 - 选择合适的数据结构

优先级 3：微优化
#

编译器优化 - 内联、逃逸分析
CPU 缓存优化 - 缓存行对齐
指令级优化 - 位运算等

🎯 性能优化黄金法则
#

测量第一 - 使用 pprof 等工具找到瓶颈
20/80 法则 - 优化 20% 的代码获得 80% 的收益
渐进优化 - 先做简单有效的大优化，再做复杂的小优化
保持可读性 - 不要为了性能牺牲代码可维护性
考虑 ROI - 评估优化投入与收益比

📚 实用检查清单
#

</>
go


 1// 性能优化检查清单
 2□ 1. 是否有不必要的内存分配？
 3□ 2. 是否可以复用对象（sync.Pool）？
 4□ 3. 是否有锁竞争？
 5□ 4. 是否使用了合适的并发模式？
 6□ 5. 算法复杂度是否可以降低？
 7□ 6. 是否有重复计算？
 8□ 7. I/O 操作是否可以批量处理？
 9□ 8. 是否使用了缓冲 I/O？
10□ 9. 数据库查询是否有索引？
11□ 10. 是否启用了连接池？
12□ 11. 是否避免了不必要的 []byte/string 转换？
13□ 12. 是否使用了合适的序列化格式？
14□ 13. 是否监控了关键指标？

记住：过早优化是万恶之源。在优化之前，一定要通过 profiling 确定真正的性能瓶颈，有针对性的进行优化。

类型与interface

Mon, 26 Jan 2026 11:05:26 +0800

类型拥有方法，接口声明方法(签名)

interface
#

1. 接口%v格式化输出
#

非空接口：输出的是动态值的 %v 格式化结果
空接口：同样输出动态值的 %v 格式化结果
如果类型实现了 String() 方法：%v 会调用该方法
%#v 输出更详细信息：包括类型信息

2. 组合、嵌套
#

</>
go


 1// 基础接口
 2type Reader interface {
 3 Read(p []byte) (n int, err error)
 4}
 5
 6type Writer interface {
 7 Write(p []byte) (n int, err error)
 8}
 9
10type Closer interface {
11 Close() error
12}
13
14// 接口组合
15type ReadWriter interface {
16 Reader
17 Writer
18}
19
20type ReadWriteCloser interface {
21 Reader
22 Writer
23 Closer
24}
25
26// 组合+额外方法
27type BufferedReadWriter interface {
28 Reader
29 Writer
30 Buffered() int
31 Peek(n int) ([]byte, error)
32}
33
34// 实现组合接口
35type BufferedIO struct {
36 buffer bytes.Buffer
37}
38
39func (bio *BufferedIO) Read(p []byte) (int, error) {
40 return bio.buffer.Read(p)
41}
42
43func (bio *BufferedIO) Write(p []byte) (int, error) {
44 return bio.buffer.Write(p)
45}
46
47func (bio *BufferedIO) Buffered() int {
48 return bio.buffer.Len()
49}
50
51func (bio *BufferedIO) Peek(n int) ([]byte, error) {
52 if n > bio.buffer.Len() {
53 return nil, io.EOF
54 }
55 data := bio.buffer.Bytes()
56 return data[:n], nil
57}

类型
#

类型实现接口方法，编译时类型值验证接口定义

1. 结构体类型struct
#

嵌入特性（Embedding）

</>
go


 1type Animal struct {
 2 Name string
 3}
 4type Dog struct {
 5 Animal // 嵌入结构体（组合而非继承）
 6}
 7func main() {
 8 // 创建 Dog 实例
 9 dog := Dog{
10 Animal: Animal{Name: "Buddy"},
11 }
12
13 // 访问方式1：通过嵌入类型访问
14 fmt.Println(dog.Animal.Name) // "Buddy"
15
16 // 访问方式2：直接访问（提升字段）
17 fmt.Println(dog.Name) // "Buddy"
18
19 // 也可以直接设置
20 dog.Name = "Max"
21 fmt.Println(dog.Name) // "Max"
22}

2. 函数类型
#

</>
go


 1// 函数类型实现接口
 2type Handler func(http.ResponseWriter, *http.Request)
 3
 4func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 5 h(w, r)
 6}
 7
 8// 使用
 9func helloHandler(w http.ResponseWriter, r *http.Request) {
10 fmt.Fprintf(w, "Hello!")
11}
12
13func main() {
14 http.Handle("/hello", Handler(helloHandler))
15}

3. 基本类型（int, string 等）
#

</>
go


 1// 为基本类型定义新类型
 2type Celsius float64
 3type Fahrenheit float64
 4
 5// 为 Celsius 定义方法
 6func (c Celsius) String() string {
 7 return fmt.Sprintf("%.1f°C", c)
 8}
 9
10// 为 Fahrenheit 定义方法
11func (f Fahrenheit) ToCelsius() Celsius {
12 return Celsius((f - 32) * 5 / 9)
13}
14
15// 使用
16var temp Celsius = 37.5
17fmt.Println(temp.String()) // 37.5°C

4. 切片类型
#

</>
go


 1// 为切片定义类型
 2type IntSlice []int
 3
 4// 为切片类型定义方法
 5func (s IntSlice) Sum() int {
 6 total := 0
 7 for _, v := range s {
 8 total += v
 9 }
10 return total
11}
12
13// 使用
14nums := IntSlice{1, 2, 3, 4}
15fmt.Println(nums.Sum()) // 10

5. 映射类型(map)
#

</>
go


 1// 为映射定义类型
 2type StringMap map[string]string
 3
 4// 为映射类型定义方法
 5func (m StringMap) Keys() []string {
 6 keys := make([]string, 0, len(m))
 7 for k := range m {
 8 keys.append(k)
 9 }
10 return keys
11}
12
13// 使用
14m := StringMap{"a": "apple", "b": "banana"}
15fmt.Println(m.Keys()) // [a b]

6. 通道类型
#

</>
go


 1// 为通道定义类型
 2type ResultChan chan Result
 3
 4// 为通道类型定义方法
 5func (ch ResultChan) SafeClose() {
 6 defer func() {
 7 if recover() != nil {
 8 fmt.Println("Channel already closed")
 9 }
10 }()
11 close(ch)
12}

7. 数组类型
#

</>
go


 1// 为数组定义类型
 2type Matrix3x3 [3][3]float64
 3
 4// 为数组类型定义方法
 5func (m Matrix3x3) Determinant() float64 {
 6 // 计算 3x3 矩阵的行列式
 7 return m[0][0]*(m[1][1]*m[2][2]-m[1][2]*m[2][1]) -
 8 m[0][1]*(m[1][0]*m[2][2]-m[1][2]*m[2][0]) +
 9 m[0][2]*(m[1][0]*m[2][1]-m[1][1]*m[2][0])
10}

8. 接口类型 (不常见，但可以)
#

</>
go


 1// 为接口类型本身定义方法（罕见用法）
 2type Shape interface {
 3 Area() float64
 4}
 5
 6// 为 Shape 接口类型定义方法
 7func (s Shape) Describe() string {
 8 return "This is a shape"
 9}
10// 注意：这很少见，因为接口通常是其他类型实现的

9. 指针类型 (特例)
#

</>
go


1// 为指针类型本身定义方法（不是常见的指针接收者）
2type IntPointer *int
3
4// 这是允许的，但不常用
5func (ip IntPointer) Address() uintptr {
6 return uintptr(unsafe.Pointer(ip))
7}

10. 自定义类型别名 (任意类型的别名)
#

</>
go


 1// 任意类型的别名都可以定义方法
 2type UserID string
 3type Money decimal.Decimal
 4type Timestamp time.Time
 5
 6// 为这些别名定义方法
 7func (uid UserID) IsValid() bool {
 8 return len(uid) > 0 && uid[0] != '#'
 9}
10
11func (m Money) Format() string {
12 return fmt.Sprintf("$%.2f", m)
13}
14
15func (t Timestamp) ISOString() string {
16 return time.Time(t).Format(time.RFC3339)
17}

内建函数

Mon, 26 Jan 2026 10:04:30 +0800

append
#

参考一篇文章带你看懂Go append方法｜ Go主题月

recover
#

recover 只能在延迟函数（defer）中直接调用才有用，如果在正常执行的函数中调用 recover，它会返回 nil，没有其他效果
当 panic 发生时，当前函数会立即停止执行，开始执行已注册的 defer 函数；在这些 defer 中调用 recover，可以捕获 panic 的值，并阻止 panic 继续向上传播。
recover 返回的值是传给 panic 的参数（任意类型）。如果没有发生 panic，则返回 nil。

fmt格式化动词表

Mon, 26 Jan 2026 09:56:42 +0800

通用格式化：
#

动词	描述	示例
`%v`	值的默认格式	`fmt.Printf("%v", 42)` → `42`
`%#v`	Go语法表示	`fmt.Printf("%#v", "hello")` → `"hello"`
`%T`	值的类型	`fmt.Printf("%T", 3.14)` → `float64`
`%%`	字面百分号	`fmt.Printf("%%")` → `%`

布尔类型：
#

动词	描述	示例
`%t`	true 或 false	`fmt.Printf("%t", true)` → `true`

整数类型：
#

动词	描述	示例
`%b`	二进制	`fmt.Printf("%b", 5)` → `101`
`%c`	Unicode字符	`fmt.Printf("%c", 65)` → `A`
`%d`	十进制	`fmt.Printf("%d", 42)` → `42`
`%o`	八进制	`fmt.Printf("%o", 8)` → `10`
`%O`	带0o前缀的八进制	`fmt.Printf("%O", 8)` → `0o10`
`%x`	十六进制（小写）	`fmt.Printf("%x", 255)` → `ff`
`%X`	十六进制（大写）	`fmt.Printf("%X", 255)` → `FF`
`%U`	Unicode格式	`fmt.Printf("%U", 'A')` → `U+0041`
`%q`	单引号字符	`fmt.Printf("%q", 65)` → `'A'`

浮点数：
#

动词	描述	示例
`%f`	十进制浮点数	`fmt.Printf("%f", 3.1415)` → `3.141500`
`%e`	科学计数法（e）	`fmt.Printf("%e", 1000.0)` → `1.000000e+03`
`%E`	科学计数法（E）	`fmt.Printf("%E", 1000.0)` → `1.000000E+03`
`%g`	自动选择 %e 或 %f	`fmt.Printf("%g", 3.1415)` → `3.1415`
`%G`	自动选择 %E 或 %f	`fmt.Printf("%G", 3.1415)` → `3.1415`

字符串和字节切片：
#

动词	描述	示例
`%s`	普通字符串	`fmt.Printf("%s", "hello")` → `hello`
`%q`	双引号字符串	`fmt.Printf("%q", "hello")` → `"hello"`
`%x`	十六进制（小写）	`fmt.Printf("%x", "Go")` → `476f`
`%X`	十六进制（大写）	`fmt.Printf("%X", "Go")` → `476F`

指针：
#

动词	描述	示例
`%p`	十六进制指针地址	`fmt.Printf("%p", &x)` → `0xc0000120a0`

宽度和精度控制：
#

</>
go


 1// 宽度：最小字段宽度
 2fmt.Printf("|%6d|%6d|\n", 123, 45) // | 123| 45|
 3
 4// 精度：小数点后位数（浮点数）
 5fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.456) // | 1.20| 3.46|
 6
 7// 宽度和精度结合
 8fmt.Printf("|%8s|%8s|\n", "foo", "barbaz") // | foo| barbaz|
 9
10// 左对齐
11fmt.Printf("|%-6d|%-6d|\n", 123, 45) // |123 |45 |
12
13// 始终显示符号
14fmt.Printf("|%+6d|%+6d|\n", 123, -45) // | +123| -45|
15
16// 填充0而不是空格
17fmt.Printf("|%06d|%06d|\n", 123, 45) // |000123|000045|
18
19// 空格占位符
20fmt.Printf("|% d|% d|\n", 123, -45) // | 123|-45|

复杂示例：
#

</>
go


 1package main
 2
 3import "fmt"
 4
 5type Person struct {
 6 Name string
 7 Age int
 8}
 9
10func main() {
11 // 结构体格式化
12 p := Person{"Alice", 30}
13 fmt.Printf("%v\n", p) // {Alice 30}
14 fmt.Printf("%+v\n", p) // {Name:Alice Age:30}
15 fmt.Printf("%#v\n", p) // main.Person{Name:"Alice", Age:30}
16
17 // 切片和数组
18 arr := [3]int{1, 2, 3}
19 slice := []int{1, 2, 3}
20 fmt.Printf("%v\n", arr) // [1 2 3]
21 fmt.Printf("%#v\n", arr) // [3]int{1, 2, 3}
22 fmt.Printf("%#v\n", slice) // []int{1, 2, 3}
23
24 // 指针
25 x := 42
26 ptr := &x
27 fmt.Printf("%p\n", ptr) // 0xc0000120a0
28 fmt.Printf("%v\n", ptr) // 0xc0000120a0
29 fmt.Printf("%T\n", ptr) // *int
30
31 // 多种类型混合
32 fmt.Printf("Name: %s, Age: %d, Score: %.2f\n", "Bob", 25, 95.5)
33 // Name: Bob, Age: 25, Score: 95.50
34
35 // 十六进制查看内存
36 data := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f}
37 fmt.Printf("% x\n", data) // 48 65 6c 6c 6f
38 fmt.Printf("%X\n", data) // 48656C6C6F
39}

特殊技巧：
#

</>
go


 1// 1. 索引引用参数（重复使用）
 2fmt.Printf("%[2]d %[1]d %[2]d\n", 1, 2) // 2 1 2
 3
 4// 2. 切片格式化
 5s := []int{1, 2, 3, 4, 5}
 6fmt.Printf("%v\n", s) // [1 2 3 4 5]
 7fmt.Printf("%#v\n", s) // []int{1, 2, 3, 4, 5}
 8
 9// 3. 映射格式化
10m := map[string]int{"a": 1, "b": 2}
11fmt.Printf("%v\n", m) // map[a:1 b:2]
12fmt.Printf("%#v\n", m) // map[string]int{"a":1, "b":2}
13
14// 4. 自定义类型的 String() 方法
15type MyType int
16func (m MyType) String() string {
17 return fmt.Sprintf("MyType(%d)", m)
18}
19var mt MyType = 42
20fmt.Printf("%v\n", mt) // MyType(42)

常用组合：
#

</>
go


1// 调试信息常用
2fmt.Printf("变量: %#v, 类型: %T, 地址: %p\n", var, var, &var)
3
4// 表格输出
5fmt.Printf("|%-10s|%10d|%10.2f|\n", "Alice", 30, 95.5)
6fmt.Printf("|%-10s|%10d|%10.2f|\n", "Bob", 25, 88.75)
7
8// 进度条样式
9fmt.Printf("\r进度: [%-50s] %d%%", strings.Repeat("=", 25), 50)

CICD

Thu, 08 Jan 2026 15:04:14 +0800

Jenkins流水线部署
#

Jenkins Node
用agent.jar指定工作目录和节点名，部署jenkins节点
配置参数、code repo、shell脚本、归档，或直接使用jenkins groovy脚本构建任务工作流

bg3伤害计算

Tue, 11 Nov 2025 10:50:08 +0800

基础
#

线性函数的Sigma求和闭合公式
#

$$ f(k) = ak + b$$

\begin{align} \sum_{k=s}^{e}f(k) &= \sum_{k=s}^{e} (ak + b) \\ &= a \sum_{k=s}^{e} k + b \sum_{k=s}^{e} 1 \\ &= a \cdot \frac{(s + e)(e - s + 1)}{2} + b \cdot (e - s + 1) \end{align}

bg3掷骰概率

Tue, 02 Sep 2025 09:50:08 +0800

核心定理：星条定理
#

组合公式
n! / r!⋅(n−r)!

星与条定理（将 n 个相同的物品（星星 ★）分配到 k 个不同的组中，允许某些组为空）公式：
n+k-1
n

–>

(n+k-1)!/(n!*(k-1)!)

问题1：DC21检定优势骰（2次掷骰）不通过概率
#

根据D20骰子的投掷规则：

投掷1时，最终结果为1，总是小于21点。
投掷20时，最终结果为正无穷，总是大于或等于21点，因此不计入小于21点的概率。
投掷2到19时，最终结果为投掷点数加上加值G，其中G = 1D6 + 3D4 + 11（15~29）。

加值G的概率分布经计算如下：

G的取值范围为15到29。
P(G=15) = 1/384
P(G=16) = 4/384
P(G=17) = 10/384
P(G=18) = 20/384
其他G值的概率不影响本次计算。

最终结果F小于21点的概率取决于D20投掷结果R：

当R=1时，P(F<21) = 1。
当R=2时，需要G ≤ 18，P(G≤18) = 35/384。
当R=3时，需要G ≤ 17，P(G≤17) 15/384。
当R=4时，需要G ≤ 16，P(G≤16) 5/384。
当R=5时，需要G ≤ 15，P(G≤15) 1/384。
当R=6到20时，P(F<21) = 0。

由于D20每个面概率均为1/20，单次投掷概率为：
P(F<21) = ¹/₂₀(1+³⁵/₃₈₄+¹⁵/₃₈₄+⁵/₃₈₄+¹/₃₈₄) = ¹¹/₁₉₂

Bg3附伤装备表

Mon, 25 Aug 2025 11:00:09 +0800

（7号补丁）

常规A类	特殊A类	常规B类	特殊B类	C类	完全伤害段	不完全伤害段	其他	未知
1暗夜法官链甲	1暗夜法官手套的“召唤黑暗”	1蔽影戒指（徒手攻击）	1奥术蓄能	1暗夜法官手套黯蚀附伤	1决斗者的特权	1闪电混语投掷	1蔽影戒指（投掷）	1法威手套
2残缺的黯狱护甲	2黯狱护甲	2不羁库席戈的手套	2灼热趋同对敌人的伤害	2黯狱手套	2卑劣短棒（隐藏的1d6附伤）	2矮人投手投掷	2暗夜法官半身甲	2追猎手套
3骨刺装束	3黯狱之靴的“地狱爬行者”	3不死灾祸	3至上真神力量之戒	3奥术力场之弩			3回旋手斧对自己的伤害	3古尔的长臂
4火热之欲手套	4导力的爆炸	4多洛的凄凉（悲惨重击系列）	4狍子守护者护甲	4奥术协同			4猎人匕首“裂地”	4恐惧铁匕首
5闪电护符“闪电释能”	5奉献皎月长袍	5和声决斗者“老练调谐”	5残缺背甲	5暴君铁手套			5偷生之剑	5生死相依
6铁藤盾牌	6有毒烟雾	6狂战士的号角	6悼霜	6蔽影戒指（徒手攻击）
7血肉消融披风	7骨刺头盔	7灵能移动之靴	7闪电充能（加1的闪电附伤）	7博德安的巨人杀手
8仪式斧（对自己的伤害）	8覆霜	8元素吸收	8狂想曲	8不羁库席戈之靴
9灼热复仇盾牌	9黑曜石花边长袍	9斯凯比的拳击手饰环	9生死离别尖啸	9狂怒
	10界限突破手套“界限突破”对自己的伤害	10泰坦弦弓	10威能长袍	10残缺的黯狱手套
	11烬蛾披风	11投掷之戒	11无情光芒之戒	11残忍蜇刺
	12精神疲劳	12元素注能戒指	12元素强化项链	12巢穴之母的复仇
	13残响	13正义之锤	13玛科赫什基“克雷斯卡的恩惠”熟练项附伤	13刺客之触
	14劳薇塔的灾祸			14大师的遗产
	15流血			15当锤棒喝
	16尼鲁纳对投掷目标的雷鸣附伤			16地狱短矛
	17闪电充能的“爆发”伤害			17地狱髯须长戟
	18圣枪头盔			18地狱硬头锤
	19维康尼亚的行走堡垒			19第一滴血短剑
	20现实火花壁垒			20东倒西歪
	21异能复仇饰环			21伏击
	22自我献祭对自己的伤害			22腐蚀指环
	23仪式匕首技能对自己的伤害			23怪物猎手长柄刀
	24元素折磨护符			24黑色之手侍从手套
				25剿灭者之斧
				26荆棘之刃
				27巨龙之握
				28君主之剑
				29柯瑞隆的恩赐
				30科温的焚化工具
				31雷掌前锋
				32灵魂捕捉手套
				33尼鲁纳（对投掷目标以外的单位的雷鸣附伤）
				34碾压手套
				35女妖之弓
				36奇异通道之戒
				37拳击天使
				38染血巨斧
				39塞伦涅的暗夜短矛“月之尘埃”
				40莎尔的黄昏短矛
				41闪电誓缚战锤
				42身心高歌
				43深度挖掘
				44神圣战士斗篷“十字军披风”
				45碎魂者巨剑
				46天地装束
				47箭术手套
				48投毒者的长袍
				49瘟疫使者
				50沃斯的银剑
				51星界银剑
				52猩红诡计
				53凶残切割
				54雪尘修道院手套
				55引火者
				56至上真神之视

Bg3能力一图流

Wed, 20 Aug 2025 14:16:02 +0800

0. 种族&专长
#

种族
#

种族 (Race)	亚种 (Subrace)	种族特性 (Racial Features)	移动速度 (Movement Speed)	视觉 (Vision)
精灵 (Elf)		精灵武器训练（长剑、短剑、短弓、长弓熟练项）、敏锐感官（察觉熟练项）、精灵血统（对抗魅惑有优势，免疫魔法睡眠）	9m	黑暗视觉12m
	高等精灵 (High Elf)	获得一个高等精灵戏法（可从酸液飞溅、冻寒之触、火焰箭、毒气喷溅、冷冻射线、电爪、剑刃防护、交友术、舞光术、光亮术、法师之手、初级幻影、克敌机先中选择）	9m	黑暗视觉12m
	木精灵 (Wood Elf)	轻捷步伐（移动速度增加1.5m）、荒野面具（隐匿熟练项）	10.5m	黑暗视觉12m
	卓尔精灵 (Drow)	卓尔武器训练（刺剑、短剑、手弩熟练项）、卓尔魔法（戏法：舞光术；3级每日一次妖火；5级每日一次黑暗术）、精灵血统	9m	高级黑暗视觉24m
提夫林 (Tiefling)		黑暗视觉、炎狱抗性（火焰伤害抗性）、地狱遗赠（戏法：奇术；3级每日一次炼狱叱喝；5级每日一次黑暗术）	9m	黑暗视觉12m
	阿斯蒙蒂斯提夫林 (Asmodeus Tiefling)	燃火术（戏法）	9m	黑暗视觉12m
	梅菲斯特提夫林 (Mephistopheles Tiefling)	法师之手（戏法）	9m	黑暗视觉12m
	扎瑞尔提夫林 (Zariel Tiefling)	奇术（戏法，威吓和表演检定有优势）	9m	黑暗视觉12m
人类 (Human)		人类民兵（短矛、长矛、长戟、长柄刀熟练项、轻甲熟练项）、人类通才（一个额外技能熟练项，负重能力提高25%)	9m	标准视觉
吉斯洋基人 (Githyanki)		军事奇才（短剑、长剑、巨剑、轻甲、中甲熟练项）、吉斯洋基心灵异能（戏法：法师之手；3级每日一次跳跃术；5级每日一次迷踪步）	9m	标准视觉
矮人 (Dwarf)		黑暗视觉、矮人体魄（对抗毒素有优势，毒素伤害抗性）、矮人战斗训练（战斧、手斧、轻锤、战锤熟练项）	7.5m	黑暗视觉12m
	黄金矮人 (Gold Dwarf)	矮人刚毅（生命值上限+1，每次升级再+1）	7.5m	黑暗视觉12m
	盾矮人 (Shield Dwarf)	矮人护甲训练（轻甲、中甲熟练项）	7.5m	黑暗视觉12m
	灰矮人 (Duergar)	高级黑暗视觉、灰矮人坚韧（对抗幻术、魅惑、麻痹有优势）	7.5m	高级黑暗视觉24m
半精灵 (Half-Elf)		黑暗视觉、精灵血统（对抗魅惑有优势，免疫魔法睡眠）、人类民兵（短矛、长矛、长戟、长柄刀熟练项、轻甲熟练项）	9m	黑暗视觉12m
	半高等精灵 (Half-High Elf)	获得一个高等精灵戏法（选择同高等精灵）	9m	黑暗视觉12m
	半木精灵 (Half-Wood Elf)	轻捷步伐（移动速度增加1.5m）	10.5m	黑暗视觉12m
	半卓尔精灵 (Half-Drow)	戏法：舞光术	9m	黑暗视觉12m
半身人 (Halfling)		幸运（攻击、属性、豁免检定掷出1时可重掷）、半身人灵巧（可穿越大于自身体型的生物空间）	7.5m	标准视觉
	轻足半身人 (Lightfoot Halfling)	天生善匿（隐匿熟练项）	7.5m	标准视觉
	壮心半身人 (Stout Halfling)	强心体魄（对抗毒素有优势，毒素伤害抗性）	7.5m	标准视觉
侏儒 (Gnome)		黑暗视觉、侏儒狡猾（对抗魔法的智力、感知、魅力豁免检定时有优势）	7.5m	黑暗视觉12m
	森林侏儒 (Forest Gnome)	(同上)	7.5m	黑暗视觉12m
	地底侏儒 (Deep Gnome/Svirfneblin)	高级黑暗视觉、岩石伪装（多岩地区隐匿检定有优势）	7.5m	高级黑暗视觉24m
	岩侏儒 (Rock Gnome)	工匠的知识（关于魔法物品、炼金物品等的智力（历史）检定加双倍熟练加值）	7.5m	黑暗视觉12m
半兽人 (Half-Orc)		黑暗视觉、凶蛮攻击（近战重击时额外掷一个武器伤害骰）、不屈（当伤害降至0而非死亡时，可改为降至1点生命值）	9m	黑暗视觉12m
龙裔 (Dragonborn)		龙族血统（决定吐息武器和伤害抗性的类型）、吐息武器（动作，造成与龙族血统相关的范围伤害，短休或长休后恢复）	9m	标准视觉

专长
#

专长	效果描述	推荐度与备注
属性提升	一项属性+2，或两项属性各+1（上限20）	通用选择，缺啥补啥
演员	魅力+1（上限20），表演和欺瞒检定熟练加值翻倍	适合魅力型角色，剧情流可选
警觉	先攻+5，不会陷入受惊状态	极力推荐，几乎所有角色都受益于高先攻
运动健将	力量或敏捷+1（上限20），倒地站立所需移动力更低，跳跃距离增加50%	近战角色不错，跳跃是强大的机动手段
冲锋	获得冲击：武器攻击以及冲击：推击	不推荐，动作消耗大，性价比低
弩械专家	近战用弩无劣势，穿刺射击开放伤口时长翻倍	弩箭手可选，应对近身贴脸
防御式决斗	被熟练的灵巧武器近战命中时，可用反应使AC+2	适合敏捷型近战角色，相当于无限次“护盾术”
双持客	可双持非轻型武器，双持近战武器时AC+1	法师必学（双持法杖），近战双持流可选
地城探索者	察觉侦测隐藏、豁免抵抗陷阱有优势，有陷阱伤害抗性	不推荐，宠物或队友可处理陷阱
耐久	体质+1（上限20），短休恢复全部生命值	前期开荒可选，后期药水多，作用下降
元素导师	选择一种法术类型无视其伤害抗性，对应法术不会骰出1	法系输出可选，但若打易伤则收益低
巨武器大师	重击或击杀后可用附赠动作再攻击一次；可选-5命中+10伤害	双手武器近战必学，需配合优势或命中加成抵消惩罚
重甲训练	获得重甲熟练项，力量+1（上限20）	需要重甲但职业不提供时才考虑，通常职业自带
重甲大师	力量+1（上限20），穿重甲时非魔法攻击的穿刺、挥砍、钝击伤害-3	重甲坦克强力推荐，显著提升生存能力
轻甲训练	获得轻甲熟练项，力量或敏捷+1（上限20）	需要轻甲但职业不提供时才考虑
幸运	获得3点幸运点（长休回复），可用于让自身检定获优势或让敌人重骰攻击	泛用性强，战斗内外都有用
法师猎手	近战范围内敌人施法时，其豁免检定处于劣势，可反应攻击，命中后敌人专注检定劣势	PVP强，PVE法师怪较少威胁一般
魔法学徒	学会2种戏法和1种1环法术（对应职业列表，长休施放一次），施法关键属性取决于所选职业	不推荐，收益较低，通常不如属性提升或专用专长
战技专家	学会2种战技，获得1颗优势骰（短休或长休回复）	兼职战技大师且等级不高时可考虑，否则骰子太少
中甲大师	中甲不为隐匿检定加劣势，敏捷调整值获得的AC加值变为+3	适合中甲潜行流派
灵活移动	移动速度增加，疾走时劣势地形不降速，发动近战攻击后移动不招致借机	游荡者必点，其他职业根据需要
中甲训练	获得中甲和盾牌熟练项，力量或敏捷+1（上限20）	需要中甲但职业不提供时才考虑
表演者	获得乐器熟练项，魅力+1（上限20）	吟游诗人自带，其他职业除非特别需要乐器
长柄武器大师	用特定长柄武器攻击时，可用附赠动作进行握柄攻击；目标进入范围可发动借机攻击	长柄武器流可选，注意某些效果可能有Bug
坚如磐石	一项属性+1（上限20），并获得该属性豁免检定的熟练项	缺特定豁免熟练项时可考虑，但一般优先度不高
仪式施法者	学会2种任选的仪式法术	不推荐，仪式法术可通过其他方式获得
凶蛮打手	近战武器攻击时，伤害骰掷两次取高	近战输出强力推荐，稳定提升伤害
神射手	远程武器攻击无视高地规则减值；可选-5命中+10伤害	远程物理输出核心专长，需注意命中率
盾牌大师	持盾时敏捷豁免+2；可反应法术敏捷豁免成功免伤，失败减半	持盾前排推荐，显著提升法术生存能力
熟习	选择任意三种技能并获得其熟练项	缺关键技能时考虑
法术狙击	学会一种戏法，触发重击所需攻击骰点数-1（可叠加）	法系输出可选，注意效果是否正常触发
酒馆斗殴者	力量或敏捷+1（上限20），徒手、临时武器或投掷物时，伤害和攻击骰可加双倍力量调整值	投掷流核心，但需注意版本变动
哨兵	近战范围内敌人攻击盟友时，可用反应对该敌人攻击；借机攻击有优势，且命中后目标本回合无法移动	控制型近战推荐，保护队友，限制敌人移动
武器大师	选择四种武器获得熟练项，力量或敏捷+1（上限20）	缺特定武器熟练项时考虑，近战职业通常不缺
战地施法者	维持法术专注的豁免检定有优势；可用反应对移出近战范围的目标施展电爪	前排法师或需要维持专注的施法者可考虑
健壮	每级生命上限+2（计算基于当前等级）	通用生存向专长，任何角色都可以考虑，提升血量

来源：拽拽z

ParamSpec

Wed, 06 Aug 2025 11:31:02 +0800

在 Python 的类型系统中，ParamSpec（参数规格）是一种高级泛型工具，用于捕获函数或方法的参数类型信息，使得泛型高阶函数（如装饰器、回调工厂）能够精确保留原始函数的参数类型。以下是关于 ParamSpec 的详细解析：

1. `ParamSpec` 的核心作用
#

解决的问题：在泛型装饰器或高阶函数中，传统 TypeVar 无法描述函数的参数列表（如 *args 和 **kwargs 的类型）。
功能：ParamSpec 允许你泛化函数的参数签名，保留参数名称、类型和顺序信息。

2. 基本语法
#

(1) 导入与定义
#

</>
python


1from typing import ParamSpec, Callable, TypeVar
2
3P = ParamSpec("P") # 定义参数规格变量
4R = TypeVar("R") # 定义返回值类型变量

P 表示一个函数的参数规格（包括位置参数和关键字参数）。
R 表示函数的返回值类型。

(2) 使用场景
#

主要用于泛型 Callable 类型或装饰器：

3.12高级类型参数

Wed, 06 Aug 2025 11:14:51 +0800

Python 3.12 通过 PEP 695 引入了更强大的高级类型参数机制，包括 可变类型参数（*Ts） 和 参数规格（**P），用于处理复杂泛型场景（如可变参数函数、回调函数类型等）。以下是对它们的详细解析：

1. **可变类型参数（`*Ts`）**
#

用途
#

表示一组不定数量的类型参数，类似 *args 的泛型版本。常用于：

泛型元组或可变长度容器
函数参数的类型标注（如 *args: *Ts）

语法与示例
#

</>
python


 1from typing import Tuple
 2
 3# 定义泛型元组，第一个元素为 str，其余元素类型可变
 4type LabeledTuple[*Ts] = tuple[str, *Ts] # PEP 695 语法
 5
 6# 使用
 7x: LabeledTuple[int, float] = ("id", 42, 3.14) # 等效于 tuple[str, int, float]
 8y: LabeledTuple[bool] = ("flag", True) # 等效于 tuple[str, bool]
 9
10# 函数中的可变参数类型
11def zip[*T](*args: *T) -> list[tuple[*T]]: # 模拟内置 zip 的类型
12 return list(zip(*args))

关键点
#

*Ts 表示类型元组，可匹配任意数量的类型参数。
运行时会被擦除为 tuple，仅静态类型检查器（如 mypy）会验证类型安全性。
与传统 TypeVarTuple 等效（Python 3.11 之前需用 from typing import TypeVarTuple）。

2. 参数规格（`P`）**
#

用途
#

描述函数的参数类型和返回值类型，用于泛型高阶函数（如装饰器、回调函数）。类似 **kwargs 的泛型扩展。

3.12泛型特性

Wed, 06 Aug 2025 11:04:17 +0800

1. 泛型函数
#

可以直接在函数名后使用 [T] 定义类型参数，无需显式导入 TypeVar：

</>
python


1def max[T](args: Iterable[T]) -> T: # 定义泛型函数
2 return max(args, default=None)
3
4max([1, 2, 3]) # T 自动推断为 int
5max(["a", "b"]) # T 自动推断为 str

特点：

类型参数 T 的作用域仅限于该函数。
支持默认类型推断，无需手动指定 [int] 或 [str]。

2. 泛型类
#

类名后可直接声明类型参数：

</>
python


1class Box[T]:
2 def __init__(self, value: T):
3 self.value = value
4
5 def get(self) -> T:
6 return self.value
7
8int_box = Box[int](42) # 明确指定 T 为 int
9str_box = Box("hello") # 自动推断 T 为 str

特点：

泛型

Wed, 06 Aug 2025 10:31:06 +0800

泛型（Generics）是编程语言中一种允许在定义函数、数据结构或类时使用类型参数的特性。通过泛型，开发者可以编写更通用、灵活的代码，而无需为每种具体类型重复实现相同的逻辑。

1. 泛型的核心概念
#

（1）类型参数（Type Parameters）
#

在定义函数或结构体时，可以声明一个或多个类型参数，用方括号 [] 包裹（Go 语言风格，其他语言可能用 <>）。
例如：

</>
go


1// T 是类型参数，可以是任何类型
2func identity[T any](value T) T {
3 return value
4}

（2）类型约束（Type Constraints）
#

限制类型参数的范围，例如要求类型必须支持某些操作（如比较大小、相加等）。

Go 中通过接口定义约束：

</>
go


1type Number interface {
2 int | float64 // 约束 T 只能是 int 或 float64
3}
4
5func add[T Number](a, b T) T {
6 return a + b
7}

其他语言（如 Java）通过泛型边界（<T extends Comparable>）实现类似功能。

（3）泛型数据结构
#

泛型不仅用于函数，还可用于定义通用的数据结构（如链表、队列等）。
例如，Go 中的泛型切片：

Go语言特点

Wed, 06 Aug 2025 10:18:47 +0800

Go语言（Golang）的语法设计以简洁和明确性为核心，因此它避免了许多其他语言中常见的抽象或复杂的语法特性。以下是Go语言中一些相对少见或独特的语法设计，以及与其他语言的对比：

1. 没有三元运算符（`?:`）
#

Go语言明确移除了C语言风格的三元运算符（condition ? a : b），而是要求开发者使用if-else语句来实现条件判断。这种设计旨在提高代码的可读性，避免嵌套过深的表达式。

示例：

</>
go


1// Go 使用 if-else 替代三元运算符
2var result int
3if condition {
4 result = a
5} else {
6 result = b
7}

相比之下，C/C++、Java、JavaScript等语言支持三元运算符，而Go选择更显式的写法。

2. 没有传统泛型（Go 1.18 前）
#

Go在早期版本中没有像C++、Java那样的泛型支持，而是使用interface{}、类型断言和反射来模拟泛型行为。

示例：

</>
go


 1// 使用 interface{} 和类型断言模拟泛型
 2func max(a, b interface{}) interface{} {
switch a.(type) {
case int:
if a.(int) > b.(int) {
return a
}
return b
case float64:
if a.(float64) > b.(float64) {
return a
}
return b
}
return nil
16}

Go 1.18 引入了泛型（类型参数），但之前的代码风格仍然广泛存在。

3. 没有类继承（OOP 风格）
#

Go语言没有类（class）和继承（inheritance），而是使用结构体（struct）和接口（interface）的组合来实现类似功能。

示例：

</>
go


 1type Animal struct {
 2 Name string
 3}
 4
 5func (a *Animal) Speak() {
 6 fmt.Println(a.Name, "makes a sound")
 7}
 8
 9type Dog struct {
10 Animal // 嵌入结构体（组合而非继承）
11}
12
13func (d *Dog) Speak() {
14 fmt.Println(d.Name, "barks")
15}

这种方式更接近组合（composition over inheritance），而非传统OOP的继承机制。

4. 没有异常处理（`try-catch`）
#

Go语言使用显式的错误返回（error 类型）而非异常机制，要求开发者手动检查错误。

示例：

</>
go


1file, err := os.Open("example.txt")
2if err != nil {
3 log.Fatal(err)
4}
5defer file.Close()

相比之下，Java、Python等语言使用try-catch机制，而Go选择更可控的错误处理方式。

5. 没有`while`循环
#

Go语言只有for循环，没有单独的while关键字。while循环的功能通过for实现。

示例：

</>
go


1// Go 的 while 循环等效写法
2for condition {
3 // 循环体
4}
5
6// 无限循环
7for {
8 // 循环体
9}

这种设计减少了语言的关键字数量，使语法更简洁。

6. 没有函数重载（Overloading）
#

Go不支持函数名重载（即相同函数名不同参数列表），而是鼓励使用不同的函数名或可变参数（...）。

示例：

</>
go


1func AddInt(a, b int) int {
2 return a + b
3}
4
5func AddFloat(a, b float64) float64 {
6 return a + b
7}

相比之下，C++、Java等语言允许函数重载。

7. `switch` 语句的独特设计
#

Go的switch语句不需要break，默认不会“穿透”（fallthrough），除非显式使用fallthrough关键字。

示例：

</>
go


1switch value {
2case 1:
3 fmt.Println("One")
4case 2:
5 fmt.Println("Two")
6 fallthrough // 显式继续执行下一个 case
7case 3:
8 fmt.Println("Three")
9}

这种设计避免了C/C++中常见的switch穿透问题。

8. `defer` 关键字
#

Go的defer用于延迟执行函数调用，通常用于资源清理（如文件关闭、锁释放等），这在其他语言中较少见。

示例：

</>
go


1file, err := os.Open("file.txt")
2if err != nil {
3 log.Fatal(err)
4}
5defer file.Close() // 确保函数退出时关闭文件

类似的功能在C++中可能使用RAII，而在Python中可能使用with语句。

9. `:=` 短变量声明
#

Go使用:=进行短变量声明，编译器自动推断类型，这在静态类型语言中较为少见。

示例：

</>
go


1x := 42 // 自动推断为 int
2name := "Alice" // 自动推断为 string

类似的功能在Python中是动态类型的自然特性，但在静态类型语言中较少见。

10. 没有`do-while`循环
#

Go语言没有do-while循环结构，类似的功能需要通过for循环模拟。

示例：

</>
go


1for {
2 // 循环体
3 if !condition {
4 break
5 }
6}

总结
#

Go语言的语法设计强调简洁性和明确性，因此它移除了许多其他语言中常见的抽象或复杂特性（如三元运算符、异常、类继承等），转而采用更直接的方式（如if-else、错误返回、组合模式）。这些设计选择使Go代码更易读、易维护，但也可能让习惯其他语言的开发者感到陌生。

Gochannel

Tue, 05 Aug 2025 17:37:17 +0800

Go 语言 Channel 详解及其与 Linux 管道的比较
#

1. Go Channel 基本概念
#

Channel（通道）是 Go 语言中的一种核心并发原语，用于在不同的 goroutine 之间进行通信和同步。它类似于 Unix 系统中的管道概念，但具有更丰富的特性和更强的类型安全性。

Channel 的特性：
#

类型化的：每个 channel 只能传递特定类型的值
并发安全：多个 goroutine 可以同时访问 channel 而无需额外同步
阻塞机制：发送和接收操作在默认情况下是阻塞的
先进先出 (FIFO)：保持消息的发送顺序

2. Channel 的基本使用
#

创建 Channel
#

</>
go


1ch := make(chan int) // 无缓冲 channel
2ch := make(chan int, 5) // 缓冲大小为5的 channel

发送和接收数据
#

</>
go


1// 发送数据
2ch <- 42
3
4// 接收数据
5value := <-ch
6
7// 关闭 channel
8close(ch)

3. Channel 与 Linux 管道的比较
#

相似之处：
#

特性	Go Channel	Linux 管道
通信方式	进程内通信	进程间通信
数据流	单向/双向	单向
同步机制	阻塞操作	阻塞操作
数据顺序	FIFO	FIFO

主要区别：
#

特性	Go Channel	Linux 管道
作用范围	主要在单个进程内的 goroutine 之间	主要在进程之间
类型安全	强类型，编译时检查	字节流，无类型
缓冲机制	可配置缓冲大小	固定大小缓冲区(通常64KB)
多路复用	原生支持 select 多路复用	需要配合 select/poll/epoll
关闭机制	有明确的关闭操作	文件描述符关闭即结束
性能	更高(内存间通信)	较低(涉及系统调用)

4. Channel 的高级特性
#

方向性 Channel
#

</>
go


1func sender(ch chan<- int) { // 只发送channel
2 ch <- 1
3}
4
5func receiver(ch <-chan int) { // 只接收channel
6 v := <-ch
7}

Select 多路复用
#

</>
go


1select {
2case v := <-ch1:
3 fmt.Println(v)
4case ch2 <- 42:
5 fmt.Println("sent")
6default:
7 fmt.Println("default")
8}

Channel 的遍历
#

</>
go


1for v := range ch {
2 fmt.Println(v)
3}

5. 实际应用场景
#

goroutine 同步：等待多个 goroutine 完成
工作池模式：分发任务给多个 worker
事件通知：作为轻量级的事件总线
数据流水线：构建多阶段处理管道

6. 性能考虑
#

无缓冲 channel 的通信延迟约 50ns
缓冲 channel 的吞吐量可达每秒数百万次
与 Linux 管道相比，channel 的性能通常高 1-2 个数量级

总结
#

Go 的 channel 设计确实受到了 Unix 管道的启发，但它针对 Go 的并发模型进行了专门优化：

中间件工厂

Tue, 05 Aug 2025 17:02:12 +0800

概念
#

在函数式编程和软件架构中，中间件工厂是一种创建中间件的高阶函数模式。它是在函数工厂（能够生成其他函数的函数）概念基础上的扩展应用。

定义
#

中间件工厂是一个函数，它接收配置参数并返回一个中间件函数。这种模式常见于Web框架（如Express、Koa）和数据处理流程中。

</>
javascript


 1// 中间件工厂示例
 2function createMiddleware(config) {
 3 return function middleware(req, res, next) {
 4 // 使用config和实现中间件逻辑
 5 if (config.condition) {
 6 // 做一些事情
 7 }
 8 next();
 9 };
10}
11
12// 使用
13const myMiddleware = createMiddleware({ condition: true });
14app.use(myMiddleware);

核心意义
#

1. 配置与复用性
#

中间件工厂通过参数化配置，使得单个中间件实现可以适应多种使用场景，大大提高了代码的复用性。

Go基础语法

Tue, 05 Aug 2025 16:21:19 +0800

赋值
#

Go 是强类型语言，赋值时类型必须匹配

基本赋值

</>
go


1var a int
2a = 10 // 基本赋值
3
4b := 20 // 短变量声明并赋值

数组赋值

</>
go


1var arr [3]int
2arr = [3]int{1, 2, 3}
3
4// 或者
5arr2 := [...]int{4, 5, 6}

Map赋值

</>
go


1m := make(map[string]int)
2m["key1"] = 1 // 添加或修改键值对
3
4// 初始化赋值
5m2 := map[string]int{
6 "a": 1,
7 "b": 2,
8}

指针赋值

</>
go


1var a int = 10
2var p *int = &a // p 指向 a
3
4*p = 20 // 通过指针修改 a 的值
5fmt.Println(a) // 输出 20

运算后赋值

</>
go


 1a := 10
 2a += 5 // a = a + 5
 3a -= 3 // a = a - 3
 4a *= 2 // a = a * 2
 5a /= 4 // a = a / 4
 6a %= 3 // a = a % 3
 7a <<= 1 // a = a << 1 (左移)
 8a >>= 1 // a = a >> 1 (右移)
 9a &= 1 // a = a & 1 (按位与)
10a |= 1 // a = a | 1 (按位或)
11a ^= 1 // a = a ^ 1 (按位异或)

接口赋值

</>
go


1var w io.Writer
2w = os.Stdout // 只要 os.Stdout 实现了 io.Writer 接口

匿名函数
#

</>
go


1func(参数列表) 返回值列表 {
2 // 函数体
3}
4
5add := func(a, b int) int {
6 return a + b
7}

make
#

make 是 Go 语言中用于初始化某些内置类型（slice、map 和 channel）的内建函数。与 new 不同，make 不仅分配内存，还会进行初始化设置。

画图

Tue, 05 Aug 2025 15:50:51 +0800

matplotlib
#

</>
python


 1import matplotlib.pyplot as plt
 2def draw(x:list, y:list, titles, fileName, output='./'
,lineColor='blue',marker='.',markerfacecolor='white',markeredgecolor='#fd5e0f',fillBetColor='white'):
'''绘图的主要方法
 5
:param x: x轴
:param y: y轴
:param titles: 图片内部标题
:param fileName: 图片文件名称
'''
fig,ax = plt.subplots(figsize=(20, 6))
ax.set_facecolor('white')
plt.grid(which='both', color='grey', linestyle='--', alpha=0.5)
plt.rcParams['axes.unicode_minus'] = False
plt.rcParams['figure.max_open_warning'] = 30
plt.plot(x, y,color=lineColor,marker=marker, markerfacecolor=markerfacecolor, markeredgecolor=markeredgecolor)
plt.fill_between(x,y,color=fillBetColor)
plt.title(label=titles, fontsize=23, loc='left')
fig.subplots_adjust(left=0.03, right=1)
ax.margins(x=0)
plt.xticks(fontsize=10)
plt.yticks(fontsize=10)
x_num = len(x)//10
x_coordinate = x[::x_num]
plt.xticks(x_coordinate, x_coordinate)
filePath = os.path.join(output, fileName)
plt.savefig(f"{filePath}.png", dpi=300)

LinuxHttp工具

Tue, 05 Aug 2025 14:28:04 +0800

wget
#

wget获取指定ip路由下的全部文件
-r：递归
--no-parent：无父目录
--accept：接收文件，支持通配符
--reject：拒绝文件，支持通配符
-P：指定下载路径

</>
shell


1wget -r --no-parent --accept "*.zip*" --reject "*.html" ip:port -P ./download/

Http文件服务器
#

python3 http server模块快速启动
python3 -m http.server 8000 --directory /path/

</>
console


1Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

优点：快速
缺点：不能直观看到本地ip

python3 代码

</>
python


 1import socket
 2import sys
 3import http.server
 4import socketserver
 5import traceback
 6
 7class Handler(http.server.SimpleHTTPRequestHandler):
 8 def __init__(self, *args, **kwargs):
 9 super().__init__(*args, directory=target, **kwargs)
10
11 def end_headers(self):
12 self.send_header('Connection', 'close')
13 super().end_headers()
14
15def get_local_ip() -> str:
16 try:
17 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
18 s.connect(("8.8.8.8", 80))
19 local_ip = s.getsockname()[0]
20 s.close()
21 return local_ip
22 except Exception as e:
23 raise Exception(f"无法获取IP: {str(e)}\n请检查网络环境")
24
25if __name__ == '__main__':
26 local_ip = get_local_ip()
27 target = ''
28 try:
29 target = sys.argv[1]
30 except:
31 target = "."
32
33 with socketserver.ThreadingTCPServer(("", 0), Handler) as httpd:
34 port = httpd.server_address[1]
35 print(f"Serving HTTP on http://{local_ip}:{port}/")
36 try:
37 httpd.serve_forever()
38 except:
39 print(traceback.format_exc())
40 finally:
41 httpd.server_close()
42 print('exit.')

</> shell

1python3 autofileserver.py /path/

优点：快速、直观看到ip:port

LearnHugo250804

Mon, 04 Aug 2025 17:11:01 +0800

设置code-header.language-label点击折叠
#

设置悬停spacing扩展效果

</>
css


 1.language-brackets {
 2 /* 全属性切换过渡动画效果 */
 3 transition: all 0.3s ease;
 4}
 5/* 悬停间距扩展，颜色高亮 */
 6.language-label:hover .language-brackets {
 7 letter-spacing: 3px;
 8 color: var(--code-header-hover-color);
 9}
10.language-label:hover .language-name {
11 color: var(--code-header-hover-color);
12}

js设置点击label切换chroma.collapsed

</>
javascript


document.querySelectorAll('.language-label').forEach(button => {
button.addEventListener('click', () => {
const codeBlock = button.closest('.code-block-wrapper');
const chroma = codeBlock?.querySelector('pre.chroma');
if (chroma) {
chroma.classList.toggle('collapsed');
}
else console.error('chroma折叠失败');
});
});

设置pre.chroma.collapsed折叠样式

</>
css


1pre.chroma.collapsed{
2 /* 折叠方法：设置高度为0 */
3 max-height: 0 !important;
4 /* 去除溢出拖动条 */
5 overflow: hidden !important;
6 /* 去除顽固padding */
7 padding: 0 !important;
8}

设置代码块换行按钮功能
#

核心样式方案：把ln设置固定宽度，cl设置为block，固定左侧间距

</>
css


 1pre.chroma .ln {
 2 float: left;
 3 /* 设置行号区域的宽度 */
 4 width: 20px;
 5 text-align: right;
 6 margin-right: 10px;
 7 user-select: none; /* 禁止行号被选中 */
 8}
 9
10pre.chroma .cl {
11 display: block;
12 margin-left: 30px; /* 与行号宽度一致 */
13}
14
15pre.chroma.wrap-lines .cl {
16 display: block;
17 margin-left: 30px; /* 与行号宽度一致 */
18 white-space: pre-wrap !important;
19}

js代码

</>
javascript


document.querySelectorAll('.code-block-wrapper').forEach(wrapper => {
// 为每个代码块创建换行状态存储
const preElement = wrapper.querySelector('pre.chroma');
if (preElement) {
// 默认从 localStorage 读取用户偏好
const wrapEnabled = localStorage.getItem('codeWrapEnabled') === 'true';
if (wrapEnabled) {
preElement.classList.add('wrap-lines');
const wrapButton = wrapper.querySelector('.wrap-button');
if (wrapButton) {
wrapButton.classList.add('active');
const span = wrapButton.querySelector('span');
if (span) span.textContent = '不换行';
}
}
}
});
// 换行按钮功能
document.addEventListener('click', function(e) {
if (e.target.closest('.wrap-button')) {
const button = e.target.closest('.wrap-button');
const codeBlock = button.closest('.code-block-wrapper');
const preElement = codeBlock.querySelector('pre.chroma');
24
if (preElement) {
preElement.classList.toggle('wrap-lines');
button.classList.toggle('active');
28
// 保存用户偏好
const isNowWrapped = preElement.classList.contains('wrap-lines');
localStorage.setItem('codeWrapEnabled', isNowWrapped.toString());
32
// 更新按钮文本
const span = button.querySelector('span');
if (span) {
span.textContent = isNowWrapped ? '换行' : '不换行';
}
}
}
});

时间字符串

Thu, 31 Jul 2025 15:44:35 +0800

1. datetime系列
#

一般来说用from datetime import datetime

1. `.fromtimestamp`
#

接收一个浮点ts参数，返回datetime结构体，可接续使用datetime内置方法
经典场景：ts -> 格式化timestr
datetime.fromtimestamp(ts).strftime('%Y-%m-%d-%H:%M:%S')

</>
python


1def ts2timestr(ts:float) -> str:
2 return datetime.fromtimestamp(ts).strftime('%Y-%m-%d-%H:%M:%S')

2. `.strptime`
#

接收1. 格式化timestr, 2. 格式format；返回datetime结构体(接续使用其他内置方法)
经典场景：格式化timestr -> ts
datetime.strptime(timestr, pattern).timestamp()

</>
python


1def timestr2ts(timestr, pattern='%Y-%m-%d %H:%M:%S'):
2 return datetime.strptime(timestr, pattern).timestamp()

3. `.replace`
#

python hint

</>
python


 1(method) def replace(
year: SupportsIndex = ...,
month: SupportsIndex = ...,
day: SupportsIndex = ...,
hour: SupportsIndex = ...,
minute: SupportsIndex = ...,
second: SupportsIndex = ...,
microsecond: SupportsIndex = ...,
tzinfo: _TzInfo | None = ...,
*,
fold: int = ...
12) -> datetime

一般使用关键字参数指定参数传参：
.replace(hour=23, minute=59, second=59, microsecond=0)

Requests

Thu, 31 Jul 2025 15:29:43 +0800

requests.request方法
#

基础用法：

</>
python


1requests.request(method, url, headers, json)
2requests.request(method, url, headers, data)

参数json和data的区别：
json为字典对象
data为字典字符串，需要使用json.dumps(payload)转换为字符串

压缩解压

Wed, 30 Jul 2025 17:51:10 +0800

解压
#

基础
#

解压zip
模块：zipfile

</>
python


1import zipfile
2with zipfile.ZipFile(fp, 'r') as zip_ref:
3 zip_ref.extractall()

递归解压zip
#

模块：zipfile, pathlib
zipfile.ZipFile.extract(fi, ep)方法逐个判断fi.filename是否匹配zip文件，匹配则进入递归解压

</>
python


 1import zipfile
 2from pathlib import Path
 3from os.path import join
 4def r_unzip(fp:Path, ep:str='./unzip') -> int:
# 统计解压的zip文件数
c = 1
try:
extr_path = join(ep, fp.stem.split('.zip')[0])
with zipfile.ZipFile(fp, 'r') as zip_ref:
for finfo in zip_ref.infolist():
zip_ref.extract(finfo, extr_path)
extr_file = Path(join(extr_path, finfo.filename))
if extr_file.match("*.zip"):
c += r_unzip(extr_file, extr_path)
except Exception as e:
print(f'file error, pass:{fp}, error msg:{e}')
finally:
return c

读日志

Wed, 30 Jul 2025 16:44:17 +0800

读取单个日志
#

1. 读全部日志
#

处理方法：直接读取整体文件内容，或者逐行读取，返回lines列表

</>
python


1def readlog(logfile):
2 with open(logfile, 'r') as f:
3 return f.read() or f.readlines()

2. 读部分日志（限定时间范围）
#

需要考虑：日志文件过大，逐行判断时间戳性能过低
处理方法：

二分查找起始位置

</>
python


 1import datetime
 2import os
 3
 4def bs_read_log(logfile, st, et):
 5 text = []
 6 file_size = os.path.getsize(logfile)
 7
 8 with open(logfile, 'r', encoding='utf-8') as f:
 9 # 二分查找定位起始位置
10 low, high = 0, file_size
11 start_pos = 0
12
13 while low < high:
14 mid = (low + high) // 2
15 f.seek(mid)
16 f.readline() # 移动到完整行首
17 line = f.readline()
18
19 if not line:
20 break
21
22 line_tm = logline_time(line)
23 if line_tm is None: # 跳过无效行
24 continue
25
26 if line_tm < st:
27 low = mid + 1
28 start_pos = f.tell() # 记录最后有效位置
29 else:
30 high = mid
31
32 # 定位到起始区域
33 f.seek(start_pos)
34 while True:
35 line = f.readline()
36 if not line:
37 break
38
39 line_tm = logline_time(line)
40 if line_tm is None:
41 continue
42
43 if line_tm > et:
44 break
45
46 if st <= line_tm <= et:
47 text.append(line.strip())
48
49 return text

二分查找起始位置 + 分块检测日志时间

</>
python


 1def readlog(logfile, st, et):
# 入参检测
if st > et:
return None
# 根据日志大小设置分块大小
chunksize = 1024
# chunk值初始设置为chunksize 大小，可以在读第一行日志时先判断日志时间是否在(st, et)区间，不在即可直接退出
chunk = 1024
text = []
file_size = os.path.getsize(logfile)
with open(logfile, 'rb') as f:
# 二分查找定位起始位置
low, high = 0, file_size
start_pos = 0
15
while low < high:
mid = (low + high) // 2
f.seek(mid)
f.readline() # 移动到完整行首
line = f.readline()
21
if not line:
break
24
line_tm = logline_time(line)
if line_tm is None: # 跳过无效行
continue
28
if line_tm < st:
low = mid + 1
start_pos = f.tell() # 记录最后有效位置
else:
high = mid
34
# 定位到起始区域
f.seek(start_pos)
while(line:=f.readline().decode(errors='ignore')):
chunk += 1
if chunk >= chunksize:
chunk = 1
if (tm:=logline_time(line)) != None and tm > et:
break
43
text.append(line)
45
# 如果追求读取范围结束时间准确性，可以从后往前逐行清除区间外日志，不追求结束时间准确性可以不做
while logline_time(text[-1]) > et:
text.pop(-1)
return text

3. 反向读日志
#

思路：定位到文件尾，逐行读取
核心：

日志分析

Wed, 30 Jul 2025 16:44:17 +0800

纯python处理
#

支持关键字正则表达式组合，逐行后处理，跨平台兼容

日志关键字处理
#

需求：

1次遍历，O(n)
多关键字(支持regex pattern)
关键字一对一自定义处理方法解耦
处理结果统计，每个关键字的成功/失败处理量+处理总量

例子：
找到日志中包含kwA的日志，执行dealA(line) -> pass/fail处理方法
找到日志中包含kwB的日志，执行dealB(line) -> pass/fail处理方法
…

思路：

每行日志查询全部关键字，有关键字出现，进入deallog回调
通过deal_log回调函数，在回调内部区分kw，执行不同逻辑
结束时输出关键字相关处理总量

</>
python


 1import re
 2from collection import defaultdict
 3def keywords_check(checktitle, text, checklist, deal_log=(lambda pt, line:True)) -> int, str:
# checklist 入参多类型支持(dict, list)
checklist = list(dict.fromkeys(checklist))
# 计数器
kw_counter, err_counter = defaultdict(int), defaultdict(int)
for line in text:
found = [pattern for pattern in checklist if re.search(pattern, line) is not None]
if not found:continue
for pattern in found:
kw_counter[pattern] += 1
if False == deal_log(pattern, line):
err_counter[pattern] += 1
msg = "{} done, total {} records, {} errors\n{}".format(
checktitle
, (kw_sum:=sum(kw_counter.values()))
, sum(err_counter.values())
, "".join(["[{}]: {} records, {} errors\n".format(
pattern
, kw_counter.get(pattern, 0)
, err_counter.get(pattern, 0)
) for pattern in checklist
])
)
return kw_sum, msg
27
28checklist = {
'pt1':r"^kwA*$",
'pt2':r"^kwB*$",
'pt3':r"^kwC*$",
32}
33def deal_log(pt, line):
if pt == checklist['pt1']:
return dealA(line)
elif pt == checklist['pt2']:
return dealB(line)
elif pt == checklist['pt3']:
return dealC(line)
else:
return False
42
43keywords_check('check keywords', checklist.values(), deal_log)

数据收集
#

可以使用上面的keywords_check方法，通过自定义deal_log方法收集数据
完成数据收集之后自定义数据分析方法

Vscode

Wed, 30 Jul 2025 16:18:18 +0800

vscode 设置制表符转换空格
#

打开设置，搜索indent
Editor: DetectIndentation勾选
Editor: tab size 设置为4

强制转换文档的table –> 4 spaces
#

在vscode界面使用ctrl+shift+p，搜索convert
点选convert indentation to spaces

脚本日志

Wed, 30 Jul 2025 14:10:07 +0800

print
#

纯print输出
#

通过sys.stdout/sys.stderr重定向输出至文件

</>
python


 1import sys
 2class Tee:
 3 """同时重定向 stdout 和 stderr 到文件和终端"""
 4 def __init__(self, filename):
 5 self.file = open(filename, 'a') # 追加模式
 6 self.stdout = sys.stdout
 7 self.stderr = sys.stderr
 8
 9 def write(self, message):
10 self.file.write(message)
11 self.stdout.write(message) # 标准输出到终端
12 self.file.flush() # 确保实时写入文件
13
14 def flush(self):
15 self.file.flush()
16
17# 脚本日志重定向
18sys.stdout = Tee(f"{__file__.split('.')[0]}.log")
19sys.stderr = Tee(f"{__file__.split('.')[0]}.log")

封装print，自定义输出
#

</>
python


1from datetime import datetime
2class Logger:
3 def now(self):return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
4 def info(self, msg):print(self.now() + ' - INFO - ' + msg)
5 def warning(self, msg):print(self.now() + ' - WARN - ' + msg)
6 def error(self, msg):print(self.now() + ' - ERROR - ' + msg)
7
8logger = Logger()

logging
#

通用代码
#

</>
python


 1import logging
 2import os
 3from datetime import datetime
 4
 5def setup_logger(name, log_level=logging.INFO, log_file_path=None):
 6 logger = logging.getLogger(name)
 7 logger.setLevel(log_level)
 8 formatter = logging.Formatter(
 9 '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
10 datefmt='%Y-%m-%d %H:%M:%S'
11 )
12 console_handler = logging.StreamHandler()
13 console_handler.setFormatter(formatter)
14 logger.addHandler(console_handler)
15
16 if log_file_path is None:
17 return logger
18
19 file_handler = logging.FileHandler(log_file_path)
20
21 file_handler.setFormatter(formatter)
22 logger.addHandler(file_handler)
23 return logger

默认logger再封装
#

不设置formatter，自定义logging的info/debug/error方法
实现：

Bufio

Tue, 29 Jul 2025 17:43:19 +0800

bufio 包详解
#

bufio 是 Go 标准库中的一个包，提供了带缓冲的 I/O 操作功能。它可以包装现有的 io.Reader 和 io.Writer 对象，创建具有缓冲功能的对象，从而提高 I/O 操作的效率。

核心概念
#

缓冲 I/O 的优势
#

减少系统调用：通过缓冲数据，减少实际的 I/O 操作次数
提高性能：特别是对于小数据量的频繁读写操作
提供更方便的接口：如按行读取等功能

主要类型和方法
#

1. Reader
#

bufio.Reader 为读取操作提供缓冲。

异常处理

Tue, 29 Jul 2025 15:24:57 +0800

核心思想：按需捕获
#

场景	处理方式	示例
不接受异常，基本不可能异常	抛出	不做处理，自然抛出
不接受异常，但有可能异常	抛出	1. assert condition, reason 2. catch后自定义raise
接受异常	捕获	正常捕获选择日志输出

代码示例
#

异常重试
#

需求：执行特定流程抛出异常时，执行指定次数重试
思路：retry变量控制
基本写法：

</>
python


 1def process_wp(retry=3):
e = None
res = None
while retry:
try:
res = might_err_process()
except:
print(f'retry {retry}...')
e = traceback.format_exc()
retry -= 1
# 按需等待
time.sleep(0.1)
else:
raise Exception(str(e))
return res

todo：python可写成装饰器

Linux文件读写

Tue, 29 Jul 2025 15:19:16 +0800

核心思想
#

一切皆文件（Everything is a File），提供了一套统一的接口 (open(), read(), write(), close(), ioctl() 等系统调用) 来操作各种资源，极大地简化了程序设计。

不仅指普通的文本文件、二进制可执行文件、图片、视频等，还包括：

硬件设备：硬盘 (/dev/sda1)、键盘 (/dev/input)、显示器 (/dev/fb0)、声卡 (/dev/snd)、甚至内存 (/dev/mem) 都被表示为文件。对这些“设备文件”的读写操作实际上是与硬件交互。
进程信息：正在运行的程序（进程）的信息和控制接口可以通过 /proc 文件系统访问（如 /proc/1234 对应 PID 为 1234 的进程）。
系统信息和配置： /sys 文件系统暴露内核参数、硬件信息和配置选项。
网络套接字：网络通信的端点。
管道：进程间通信的通道。

特性	普通文件	管道(Pipe)	Socket(TCP)
打开方式	路径直接打开	pipe()系统调用	socket()+bind/connect
数据存储	持久化存储	内存缓冲区	网络传输
访问模式	随机访问	顺序访问	顺序访问
生命周期	显式创建/删除	进程结束自动销毁	连接关闭即失效
进程通信	不支持进程间通信	支持相关进程通信	支持跨网络通信
阻塞行为	通常非阻塞	读空阻塞/写满阻塞	默认阻塞

1. 普通文件
#

代码通用实现
#

1. python
#

基本方法：with open(fp, mode)
示例

</>
python


 1with open('text.txt', 'w', encoding='utf-8') as f: # 'w' 覆盖写
 2 f.write("Hello Python!\n")
 3 f.writelines(["Line 1\n", "Line 2\n"]) # 写入多行
 4
 5with open('text.txt', 'r', encoding='utf-8') as f:
 6 content = f.read() # 一次性读取
 7
 8with open('text.txt', 'r') as f:
 9 lines = f.readlines() # 返回列表
10
11# ========== 二进制文件读写 ==========
12data = b'\x48\x65\x6C\x6C\x6F\x21' # "Hello!" 的二进制
13with open('binary.bin', 'wb') as f: # 'wb' 二进制写
14 f.write(data)
15
16with open('binary.bin', 'rb') as f:
17 binary_content = f.read()
18 print("二进制内容:", binary_content) # b'Hello!'
19 print("解码为字符串:", binary_content.decode('utf-8'))

2. c++
#

基本方法：fstream
1. 读：std::ifstream
2. 写：std::ofstream
注：创建流对象后需要手动关闭
示例

</>
c++


 1#include <iostream>
 2#include <fstream>
 3#include <vector>
 4#include <string>
 5
 6int main() {
// ========== 文本文件读写 ==========
// 写入文本文件
std::ofstream textOut("text.txt");
if (textOut.is_open()) {
textOut << "Hello C++!\n";
textOut << "Line 1\nLine 2\n";
textOut.close();
std::cout << "文本写入成功" << std::endl;
} else {
std::cerr << "文本文件打开失败" << std::endl;
}
18
// 读取文本文件
std::ifstream textIn("text.txt");
if (textIn.is_open()) {
std::string line;
std::cout << "文本内容:" << std::endl;
while (std::getline(textIn, line)) { // 逐行读取
std::cout << line << std::endl;
}
textIn.close();
} else {
std::cerr << "文本文件打开失败" << std::endl;
}
31
// ========== 二进制文件读写 ==========
// 写入二进制文件
std::ofstream binOut("binary.bin", std::ios::binary);
char data[] = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x21}; // "Hello!"
if (binOut.is_open()) {
binOut.write(data, sizeof(data));
binOut.close();
std::cout << "二进制写入成功" << std::endl;
} else {
std::cerr << "二进制文件打开失败" << std::endl;
}
43
// 读取二进制文件
std::ifstream binIn("binary.bin", std::ios::binary);
if (binIn.is_open()) {
// 获取文件大小
binIn.seekg(0, std::ios::end);
size_t size = binIn.tellg();
binIn.seekg(0, std::ios::beg);
51
// 读取到vector
std::vector<char> buffer(size);
binIn.read(buffer.data(), size);
binIn.close();
56
std::cout << "二进制内容: ";
for (char c : buffer) std::cout << c; // 输出 "Hello!"
std::cout << std::endl;
} else {
std::cerr << "二进制文件打开失败" << std::endl;
}
63
return 0;
65}

3. golang
#

基本方法：os
1. 读：
  1. 整体读取：os.ReadFile
  2. 逐行读取：
    1. os.Open
    2. bufio.NewScanner
2. 写：os.WriteFile

</>
golang


 1package main
 2
 3import (
"fmt"
"io"
"os"
"bufio"
 8)
 9
10func main() {
textContent := "Hello Go!\nLine 1\nLine 2\n"
err := os.WriteFile("text.txt", []byte(textContent), 0644) // 覆盖写入
if err != nil {
fmt.Println("文本写入失败:", err)
} else {
fmt.Println("文本写入成功")
}
18
data, err := os.ReadFile("text.txt") // 一次性读取
if err != nil {
fmt.Println("文本读取失败:", err)
} else {
fmt.Println("文本内容:\n", string(data))
}
25
// 逐行读取（使用 bufio）
file, err := os.Open("text.txt")
if err != nil {
fmt.Println("文件打开失败:", err)
return
}
defer file.Close()
33
fmt.Println("逐行读取:")
scanner := bufio.NewScanner(file)
for scanner.Scan() {
fmt.Println(scanner.Text()) // 输出每一行
}
39
// ========== 二进制文件读写 ==========
binaryData := []byte{0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x21} // "Hello!"
err = os.WriteFile("binary.bin", binaryData, 0644)
if err != nil {
fmt.Println("二进制写入失败:", err)
} else {
fmt.Println("二进制写入成功")
}
48
binContent, err := os.ReadFile("binary.bin")
if err != nil {
fmt.Println("二进制读取失败:", err)
} else {
fmt.Println("二进制内容:", binContent) // [72 101 108 108 111 33]
fmt.Println("解码为字符串:", string(binContent)) // "Hello!"
}
56
// 大文件分块读取
largeFile, err := os.Open("largefile.bin")
if err != nil {
fmt.Println("大文件打开失败:", err)
return
}
defer largeFile.Close()
64
buffer := make([]byte, 1024) // 1KB缓冲区
for {
n, err := largeFile.Read(buffer)
if err == io.EOF {
break // 文件结束
}
if err != nil {
fmt.Println("读取错误:", err)
break
}
fmt.Printf("读取 %d 字节\n", n)
// 处理 buffer[:n]
}
78}

2. 管道
#

代码实现
#

1. python
#

</>
python


 1import os
 2r, w = os.pipe()
 3pid = os.fork()
 4if pid == 0: # Child
 5 os.close(w)
 6 data = os.read(r, 100)
 7 print("Pipe read:", data.decode())
 8 os._exit(0)
 9else: # Parent
10 os.close(r)
11 os.write(w, b"Pipe message")
12 os.wait()

2. c++
#

</>
c++


 1#include <iostream>
 2#include <fstream>
 3#include <unistd.h>
 4#include <sys/wait.h>
 5#include <sys/socket.h>
 6#include <netinet/in.h>
 7
 8int main() {
 9 int fd[2]; pipe(fd);
10 if (fork() == 0) { // Child
11 close(fd[1]);
12 char buf[100];
13 read(fd[0], buf, sizeof(buf));
14 std::cout << "Pipe read: " << buf << std::endl;
15 exit(0);
16 } else { // Parent
17 close(fd[0]);
18 write(fd[1], "Pipe message", 13);
19 wait(nullptr);
20 }
21}

3. golang
#

</>
golang


 1package main
 2
 3import (
 4 "fmt"
 5 "io"
 6 "net"
 7)
 8func main() {
 9
10 r, w, _ := os.Pipe()
11 go func() {
12 w.Write([]byte("Pipe message"))
13 w.Close()
14 }()
15 pipeData, _ := io.ReadAll(r)
16 fmt.Println("Pipe read:", string(pipeData))
17}

3. 网络套接字socket
#

代码实现
#

1.python
#

</>
python


 1
 2import socket
 3# Server
 4srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 5srv.bind(('127.0.0.1', 12345))
 6srv.listen(1)
 7# Client
 8cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 9cli.connect(('127.0.0.1', 12345))
10# Accept and send
11conn, _ = srv.accept()
12conn.send(b"Socket data")
13print("Socket read:", cli.recv(100).decode())
14cli.close(); srv.close()

2. c++
#

</>
c++


 1#include <iostream>
 2#include <fstream>
 3#include <unistd.h>
 4#include <sys/wait.h>
 5#include <sys/socket.h>
 6#include <netinet/in.h>
 7
 8int main() {
 9 // Server setup
10 int srv_fd = socket(AF_INET, SOCK_STREAM, 0);
11 sockaddr_in addr = {AF_INET, htons(12345), INADDR_ANY};
12 bind(srv_fd, (sockaddr*)&addr, sizeof(addr));
13 listen(srv_fd, 1);
14 // Client connect
15 int cli_fd = socket(AF_INET, SOCK_STREAM, 0);
16 connect(cli_fd, (sockaddr*)&addr, sizeof(addr));
17 // Communication
18 int conn_fd = accept(srv_fd, nullptr, nullptr);
19 send(conn_fd, "Socket data", 12, 0);
20 char buffer[100];
21 recv(cli_fd, buffer, sizeof(buffer), 0);
22 std::cout << "Socket read: " << buffer << std::endl;
23 close(cli_fd); close(srv_fd);
24}

3. golang
#

</>
golang


 1package main
 2
 3import (
 4 "fmt"
 5 "io"
 6 "net"
 7)
 8func main() {
 9 // Server
10 listener, _ := net.Listen("tcp", "127.0.0.1:12345")
11 go func() {
12 conn, _ := listener.Accept()
13 conn.Write([]byte("Socket data"))
14 conn.Close()
15 }()
16 // Client
17 conn, _ := net.Dial("tcp", "127.0.0.1:12345")
18 sockData, _ := io.ReadAll(conn)
19 fmt.Println("Socket read:", string(sockData))
20}

艾尔登法环

Tue, 29 Jul 2025 13:50:52 +0800

build
#

具体build
#

1. 定制战技
#

远程
#

大剑/直剑+风暴刃
火焰大剑+火焰枪
骑士长矛+幻影枪

近战
#

魔像戟+黑暗波动
岩石剑：
1. 晨星拳套

中距离
#

黑夜骑兵戟/泥人鱼叉+冰枪

2. 失色
#

猎犬长牙

build思路
#

出血
1. 武器
  1. 逆刺
2. 普通战技
  1. 切腹
冰冻
失衡
增伤

博德之门3

Tue, 29 Jul 2025 13:50:23 +0800

todo
#

自定义荣誉刺客独狼
#

第一章收集：
第一滴血、巨人短棒、座狼牙、泰坦弦弓、国王匕首、迷城匕首、灾祸短剑、生死离别、警觉短弓、狩猎短弓(蜘蛛女王、枭熊、鲨蜥兽)
迅捷头、奥协头、智力头
养鸡半身甲、兽皮甲+2、精金中甲、精金盾牌、优雅布衣
摘星手套、敏捷手套、决斗者手套、惊奇手套
闪电飞靴、破阵战靴、元素亢奋之靴
轻声承诺、守护戒指、粉碎机、奥协戒指、腐蚀指环、走私犯戒指、照明灯（触发光戒）、心灵通道戒指、探索者之戒（巴伦上方岩石骷髅身上）、跳跃戒指
卡哈项链、白银吊坠、心灵火花、伤口闭合护符

启动：

跑图：
1. 金龙术士开16 16 12 8 8 14，法手幻影交友术睡眠术，2级大跳羽落伪装术跑图
2. 营地大门战大跳上坡吹号、白银吊坠
3. 杀萨扎、游说罗兰、招募威尔卡菈克、艾隆的书、动物交谈(药水在熊地精坡上的土堆里)(察觉失败)干草堆、变形者戒指、对话塞夫洛、苏洛、喂熊、阿尔菲拉、幻影偷鸟钥匙、阿拉贝尔、荆棘仪式
4. 枭熊小队、挠挠、变卓尔正门进村、迅捷头盔、走私犯戒指、死灵书禁忌知识、夸塞魔、高崖图纸、救顾问（不需要探伤者）
5. 先撬锁再烙印、睡眠术时停救瓦罗、烙印后风车地精救巴克斯、嘴死女祭司
6. 发光护甲、生死离别、第一滴血、飒拉、探索者之戒、巨人短棒、照明灯、杀内蒂（远古之匙）、鬼婆传送门、(树篱漫游者皮甲、探索者之戒、远古之匙)鱼人村智力自然检定红帽子妖精
7. 守护火花壁垒、躲藏幻影杀复仇守卫(精金中甲、精金盾牌)、洗点、国王匕首、宝箱怪惊奇手套、软泥怪、活化护甲、食人魔树人
买：
1. 轻声承诺、狩猎短弓、摘星手套、兽皮甲+2、变形者戒指、树篱漫游者皮甲
2. 警觉短弓
3. 心灵火花、灾祸短剑、腐蚀指环、跳跃戒指、喧嚣风暴之靴

第二章收集：
龙息长柄刀、阴影之握、荆棘之刃、身心高歌、暗夜法官匕首
智能盾牌、黑火短弓、从未射失->眼球
守护披风
暗夜法官半身甲
光戒、永察之戒、幽影刃戒指

战斗：

第一章
1. 树人、卡哈、鸟妖、食人魔、提尔圣武士、豺狼人首领、地精营地（外+内）、地精3头目、山隘小队、枭熊、蜘蛛女王、河边灰矮人、鬼婆
2. 鲨蜥兽、牛头人、恐爪兽、眼魔、伯纳德、灰矮人（杀完灰矮人之后不急着交任务，堕影冥界前交）、尼讷
1.5章
1. 修道院、养鸡场、审判官（审判官后先不进棱镜，堕影冥界前进）、死亡牧者
第二章
1. 修道院进，卡尼斯小队、马库斯、凌弱怪、蔽影狗、魑魅、鱼人村、泥巴怪、停尸房、治疗中心大门
2. 莎尔神殿、巴萨扎尔、图书馆
3. 医生、酒馆、征收所、往日身影、工匠坊、尤格、暗夜法官、哈尔辛保卫战、深影之家、蔓生怪、监狱
4. 黑夜女士(极乐孢子、洛山达祝福、棱镜祝福术)、堕影冥界、月塔底、凯萨里克、夺心魔营地、米尔寇、养鸡人小队

BD：

Hugo学习250728

Mon, 28 Jul 2025 15:33:17 +0800

1. 可折叠列表 HTML5 标签，折叠内容无法支持原生markdown语法
#

config.yaml中配置，允许渲染 HTML 标签

</>
yaml


1markup:
2 goldmark:
3 renderer:
4 unsafe: true

使用原生html5 details标签

</>
html


1<details>
2 <summary>点击展开查看详情</summary>
3
4 这里是隐藏的内容，支持 **Markdown** 格式：
5
6 - 列表项1
7 - 列表项2
8 - [链接](https://example.com)
9</details>

效果：

这里是隐藏的内容，支持 Markdown 格式：

列表项1
列表项2
链接

本质是隐藏细节

嵌套

一级折叠标题

这是一级内容…

二级折叠标题

<details>
<summary>三级折叠标题</summary>
- 这是三级列表
- 支持 Markdown
- 可以无限嵌套（但建议不超过3-4层）
</details>

一级内容中的普通列表
也可以混合使用

似乎只能嵌套两层

元类MetaClass

Fri, 25 Jul 2025 16:08:19 +0800

元类作用时机
当使用此元类定义新类时（如 class MyClass(metaclass=StaticMethodMeta)），元类的 __new__ 方法会在类创建时被调用。

利用元类改变类特性 -> 创建一个成员函数自动转换为静态成员函数的类

</>
python


 1class StaticMethodMeta(type):
 2 def __new__(cls, name, bases, namespace):
 3 for attr_name, attr_value in namespace.items():
 4 if callable(attr_value) and not attr_name.startswith('__'):
 5 namespace[attr_name] = staticmethod(attr_value)
 6 return super().__new__(cls, name, bases, namespace)
 7
 8class tool(metaclass=StaticMethodMeta):
 9 # 静态成员没有self参数
10 def tool1(p1, p2):
11 pass

词云实践流程

Thu, 24 Jul 2025 17:15:11 +0800

1. 通过deepseek生成词云`html、js、css`代码
#

</>
prompt参考


1我在做hugo页面，帮我生成标签词云的代码，我会在首页index.html中导入，词云内容为tag，点击跳转对应url，每个tag样式为圆形，大小只和tag字符关联，无旋转，排序权值使用tag文章数量，权值越高越靠中间，分成html css js三个文件实现，tag在html中使用.Site.Taxonomies.tags生成
2让词云标签贴合，至少行对齐（居中、等分对齐），有一定的对齐的美感

</>
生成


1tag-cloud.html
2tag-cloud.css
3tag-cloud.js

2. tag-cloud绑定在baseURL/tags/url上
#

原理：

</>
路由机制


1Hugo 会自动将 layouts/taxonomy/tag.terms.html 映射到 /tags/ URL
2这是 Hugo 分类系统（Taxonomy）的标准行为

流程：

- 1. 创建layouts/taxonomy/tag.terms.html
#

- 2. 在tag.terms.html中直接调用tag-cloud.html
#

</>
tag.terms.html


1{{ define "main" }}
2{{ partial "tag-cloud.html" . }}
3{{ end }}

- 3. 导入css、js文件
#

为了方便，直接在tag-cloud.html中嵌入了css、js的导入（缺点，页面会动态加载js）

hugo学习250723

Wed, 23 Jul 2025 15:01:34 +0800

hugo工作流程
#

url route -> 确定页面类型

hugo页面类型推断
#

(1) 文件系统结构
#

Hugo 会扫描 content/ 目录下的内容文件（如 .md 或 .html），根据文件的位置和命名规则自动推断页面类型：

</>
text


1_index.md → 列表页（kind: "section" 或 kind: "home"）
2
3普通内容文件（如 post.md） → 单页（kind: "page" 或 kind: "single"）
4
5分类/标签页 → 分类列表（kind: "taxonomy" 或 kind: "term"）

(2) 页面 Front Matter
#

通过 Front Matter 中的 type 或 layout 字段可手动指定类型（覆盖自动推断）：

用户态、内核态内存空间

Mon, 14 Jul 2025 15:39:03 +0800

用户态、内核态指内存空间，CPU的各寄存器则是CPU硬件，不属于内存部分，仅在需要存档备份数据时保存至（用户态/内核态）内存
1、进程内核栈
每个进程都有自己独立的位于内核空间的内核栈，保存进程在内核态执行的函数调用栈、局部变量、寄存器状态等数据

linux系统切换进程时会切换

内核栈
将 CPU 的栈指针寄存器 (SP/ESP/RSP, x86架构) 从指向进程 A 的内核栈顶部，修改为指向进程 B 的内核栈顶部
页目录
系统切换进程时找到进程的页目录的物理基地址（mm->pgd指针），写入CR3(x86)/TTBR0(ARM)寄存

2、进程页目录
存储在物理内存中，进程在创建时，系统创建mm_struct结构，用mm->pgd指针保存页目录物理基地址（用来在系统切换进程时找到进程的页目录的物理基地址，写入CR3(x86)/TTBR0(ARM)寄存器，完成进程上下文切换）
页目录包含进程使用的全部内存的虚拟内存地址->物理内存地址的映射关系
3、进程硬件上下文
运行时各寄存器的中间结果、比如PC程序计数器（下一条指令地址）、SP栈指针寄存器（当前调用栈顶）
切换时，这些数据被保存到进程内核栈中

4、线程切换总是发生在同一个进程（同一个虚拟地址空间）内的线程之间。不同进程的线程之间的切换，本质上是通过上层的进程切换完成的
5、切换线程时只切换线程内核栈，同样CPU栈指针寄存器从指向线程A的内核栈顶->B的内核栈顶。因为同属一个进程，所以不切换页目录，也即使用同一虚拟内存空间

6、进程、线程切换都依赖内核调度器，抢占式调度（时间片、中断）
7、协程切换只在用户态通过程序本身调度切换，主动让出，显式让出控制权
8、

进程	线程	协程
切换内核栈、页目录	切换内核栈	仅切换寄存器状态

9、用户态进程与内核态进程全双工通信 -> Netlink Socket

相比传统 IPC (syscall, ioctl, procfs)，Netlink 具有显著优势：易于扩展、异步通信、完美支持内核模块、强大的组播能力、真正的全双工通信、开发者友好的标准 Socket API。

单播回显: 用户请求->内核处理->内核响应的双向通信模式
内核主动组播: 内核主动向多个订阅进程广播事件的能力

netlink属于无连接协议（无连接协议是一种通信协议，其中每个数据包的处理都是独立的，不需要在发送数据之前建立连接）

闭包

Mon, 14 Jul 2025 11:35:25 +0800

在创建时封装当时状态，并使当时的状态生存周期延长至与闭包生存周期一致
闭包思想产物：
1. python装饰器
2. 回调函数
3. 函数工厂
4. 惰性求值
…

典型用法
#

1. python装饰器
#

</>
python


1def execute(f):
2 f()
3
4@execute
5def execute_when_defined():
6 print('executed')

2. 函数工厂
#

保存调用函数工厂时的参数
调用生成的函数时，使用函数工厂创建函数时的参数上下文

示例
#

python api函数工厂

</>
python


1def get_table_grids_wp(cli:Client, docid):
2 def func(tableid):
3 return [c['children'][0] for c in cli.fetchblocks(docid, tableid)['data']['items']]
4 return func
5
6get_table_grids = get_table_grids_wp(cli, docid)
7get_table_grids(tid)

go 基础函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5// 函数工厂：返回一个加法函数
 6func makeAdder(addend int) func(int) int {
 7 return func(x int) int {
 8 return x + addend
 9 }
10}
11
12func main() {
13 add5 := makeAdder(5) // 创建一个加5的函数
14 add10 := makeAdder(10) // 创建一个加10的函数
15
16 fmt.Println(add5(3)) // 输出: 8 (3 + 5)
17 fmt.Println(add10(3)) // 输出: 13 (3 + 10)
18}

go 中间件工厂
带配置的函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5type GreeterConfig struct {
 6 Prefix string
 7 Suffix string
 8}
 9
10// 创建问候函数
11func NewGreeter(config GreeterConfig) func(string) string {
12 return func(name string) string {
13 return fmt.Sprintf("%s, %s%s", config.Prefix, name, config.Suffix)
14 }
15}
16
17func main() {
18 friendlyGreeter := NewGreeter(GreeterConfig{
19 Prefix: "Hello",
20 Suffix: "! Welcome!",
21 })
22
23 formalGreeter := NewGreeter(GreeterConfig{
24 Prefix: "Dear",
25 Suffix: ", we are pleased to meet you",
26 })
27
28 fmt.Println(friendlyGreeter("Alice")) // 输出: Hello, Alice! Welcome!
29 fmt.Println(formalGreeter("Bob")) // 输出: Dear, Bob, we are pleased to meet you
30}

缓存函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5// 创建带缓存的函数
 6func makeCachedFunc(fn func(int) int) func(int) int {
 7 cache := make(map[int]int)
 8 return func(x int) int {
 9 if result, found := cache[x]; found {
10 fmt.Printf("Cache hit for %d\n", x)
11 return result
12 }
13 result := fn(x)
14 cache[x] = result
15 fmt.Printf("Calculated for %d\n", x)
16 return result
17 }
18}
19
20func expensiveCalculation(x int) int {
21 // 模拟耗时计算
22 return x * x
23}
24
25func main() {
26 cachedCalc := makeCachedFunc(expensiveCalculation)
27
28 fmt.Println(cachedCalc(5)) // 输出: Calculated for 5 \n 25
29 fmt.Println(cachedCalc(5)) // 输出: Cache hit for 5 \n 25
30}

Outline

Mon, 14 Jul 2025 11:20:25 +0800

通用编程思想
#

闭包
#

多态
#

泛型
#

前端
#

hugo
#

后端
#

Linux理解
#

用户态、内核态内存空间
#

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1

Hugo理解

Wed, 09 Jul 2025 14:07:34 +0800

hugo工作流程
#

导入主题后，完成自定义配置和资源

</>
markdown


 1- config yaml/toml/json
 2- assets
- css
- js
- images
 6- layouts
- 404.html : 404错误页面模板
- _default/ : 默认模板
- baseof.html : 基础模板框架
- list.html : 列表页模板（如分类、标签页）
- single.html : 单内容页模板（如文章页）
- terms.html : 分类列表模板（如所有标签的列表）
- partials/ : 可重用部分模板
- header.html : 页头部分
- footer.html : 页脚部分
- head.html : <head>部分
- ... : 其他部分模板
- shortcodes/ : 短代码模板
- figure.html : 图片短代码
- ... : 其他短代码
- index.html : 首页模板
- section/ : 分区模板（如博客、文档等）
- blog.html : 博客分区模板
- ... : 其他分区模板
- taxonomy/ : 分类法模板
- category.html : 分类页面模板
- tag.html : 标签页面模板
- ... : 其他自定义模板

所有layouts模板均可

Hugo博客搭建记录

Tue, 08 Jul 2025 10:18:41 +0800

环境准备
#

设备：ubuntu
github地址：https://github.com/gohugoio/hugo
安装：

</>
shell


1wget https://github.com/gohugoio/hugo/releases/download/v0.147.9/hugo_extended_0.147.9_Linux-64bit.tar.gz
2tar -xvzf hugo_extended_0.147.9_Linux-64bit.tar.gz
3sudo su
4mv hugo /usr/bin

Start!
#

1. 基础
#

1. 创建新博客
#

</> shell

1hugo new site siteproducer

2. 重要配置&配置逻辑链
#

2. 使用stack主题
#

</> shell

1git submodule add https://github.com/CaiJimmy/hugo-theme-stack themes/hugo-theme-stack

Hugo Tricks
#

1. 自定义样式
#

1. 样式覆盖规则：后引入覆盖前引入
#

params.yaml配置中指定自定义custom_css

</>
yaml


1custom_css: ["scss/custom.scss"]

assets/custom.scss中

</>
scss


1// 引入主题样式
2@import "general";
3// 引入你的自定义覆盖
4@import "custom-markdown"; // 无下划线、无扩展名

2. 自定义鸿蒙字体
#

下载鸿蒙字体
解压到siteproducer/assets/fonts目录
在assets/scss/中创建_fonts.scss，并在scss/custom.scss中引用

font.scss

关于我

Sun, 07 Jul 2024 00:00:00 +0000

Linux service / CICD

python、c++、golang
shell、markdown、x/y/toml、json、html/css/js、groovy

nayun blog

小知识

性能优化

📊 性能优化分类总览 #

🔧 详细的性能优化思路 #

一、内存管理优化（重点！） #

1. 减少内存分配 #

2. 使用对象池 sync.Pool #

3. 避免内存逃逸 #

4. 使用栈分配 #

二、并发与并行优化 #

1. 控制 Goroutine 数量 #

2. 减少锁竞争 #

3. 使用 atomic 操作 #

4. 利用 CPU 缓存行 #

三、数据结构与算法优化 #

1. 选择合适的数据结构 #

2. 预分配容量 #

3. 使用更快的算法 #

4. 利用位运算 #

四、I/O 性能优化 #

1. 批量操作 #

2. 缓冲 I/O #

3. 连接复用 #

4. 零拷贝技术 #

五、编译器与运行时优化 #

1. 内联优化 #

2. 逃逸分析优化 #

3. 编译器指令 #

4. 使用 PGO（Profile-Guided Optimization） #

六、字符串与字节处理优化 #

1. strings.Builder #

2. 避免 []byte 与 string 转换 #

3. 使用 bytes 包代替 strings 包 #

七、网络与协议优化 #

1. 协议选择 #

2. 连接复用（HTTP/2, HTTP/3） #

3. 压缩与序列化 #

八、数据库优化 #

1. SQL 优化 #

2. 索引优化 #

3. 连接池配置 #

九、监控与分析工具 #

1. 使用 pprof #

2. 使用 trace #

3. 使用 expvar #

十、部署与系统优化 #

1. 容器优化 #

2. 操作系统优化 #

3. CPU 亲和性 #

📈 性能优化优先级 #

优先级 1：影响最大的优化 #

优先级 2：显著的优化 #

优先级 3：微优化 #

🎯 性能优化黄金法则 #

📚 实用检查清单 #

类型与interface

interface #

1. 接口%v格式化输出 #

2. 组合、嵌套 #

类型 #

1. 结构体类型struct #

2. 函数类型 #

3. 基本类型（int, string 等） #

4. 切片类型 #

5. 映射类型(map) #

6. 通道类型 #

7. 数组类型 #

8. 接口类型 (不常见，但可以) #

9. 指针类型 (特例) #

10. 自定义类型别名 (任意类型的别名) #

内建函数

append #

recover #

fmt格式化动词表

通用格式化： #

布尔类型： #

整数类型： #

浮点数： #

字符串和字节切片： #

📊 性能优化分类总览
#

🔧 详细的性能优化思路
#

一、内存管理优化（重点！）
#

1. 减少内存分配
#

2. 使用对象池 sync.Pool
#

3. 避免内存逃逸
#

4. 使用栈分配
#

二、并发与并行优化
#

1. 控制 Goroutine 数量
#

2. 减少锁竞争
#

3. 使用 atomic 操作
#

4. 利用 CPU 缓存行
#

三、数据结构与算法优化
#

1. 选择合适的数据结构
#

2. 预分配容量
#

3. 使用更快的算法
#

4. 利用位运算
#

四、I/O 性能优化
#

1. 批量操作
#

2. 缓冲 I/O
#

3. 连接复用
#

4. 零拷贝技术
#

五、编译器与运行时优化
#

1. 内联优化
#

2. 逃逸分析优化
#

3. 编译器指令
#

4. 使用 PGO（Profile-Guided Optimization）
#

六、字符串与字节处理优化
#

1. strings.Builder
#

2. 避免 []byte 与 string 转换
#

3. 使用 bytes 包代替 strings 包
#

七、网络与协议优化
#

1. 协议选择
#

2. 连接复用（HTTP/2, HTTP/3）
#

3. 压缩与序列化
#

八、数据库优化
#

1. SQL 优化
#

2. 索引优化
#

3. 连接池配置
#

九、监控与分析工具
#

1. 使用 pprof
#

2. 使用 trace
#

3. 使用 expvar
#

十、部署与系统优化
#

1. 容器优化
#

2. 操作系统优化
#

3. CPU 亲和性
#

📈 性能优化优先级
#

优先级 1：影响最大的优化
#

优先级 2：显著的优化
#

优先级 3：微优化
#

🎯 性能优化黄金法则
#

📚 实用检查清单
#

interface
#

1. 接口%v格式化输出
#

2. 组合、嵌套
#

类型
#

1. 结构体类型struct
#

2. 函数类型
#

3. 基本类型（int, string 等）
#

4. 切片类型
#

5. 映射类型(map)
#

6. 通道类型
#

7. 数组类型
#

8. 接口类型 (不常见，但可以)
#

9. 指针类型 (特例)
#

10. 自定义类型别名 (任意类型的别名)
#

append
#

recover
#

通用格式化：
#

布尔类型：
#

整数类型：
#

浮点数：
#

字符串和字节切片：
#

指针：
#

宽度和精度控制：
#

复杂示例：
#

特殊技巧：
#

常用组合：
#

Jenkins流水线部署
#