【Go语言圣经2.6】

目标

概念

1. GOPATH模型

   • GOPATH：GOPATH 是一个环境变量，指明 Go 代码的工作区路径。
   • 工作区通常包含三个目录：
     • src：存放源代码，按照导入路径组织。例如，包 gopl.io/ch2/tempconv 应存放在 $GOPATH/src/gopl.io/ch2/tempconv 中。
     • pkg：编译后生成的包文件（中间产物）。
     • bin：可执行文件。
   • 在 GOPATH 模型中，包的导入路径直接对应于 src 目录下的子目录结构
     • 例如，import "gopl.io/ch2/tempconv" 表示编译器将在 $GOPATH/src/gopl.io/ch2/tempconv 下寻找该包的源代码。

2. Go module 模型（现代依赖管理方式）

   • Go module
     • Go module 是从 Go 1.11 开始引入的，不再强制要求代码必须放在 GOPATH 内。
     • 每个模块有一个 go.mod 文件，其中定义了模块路径（作为导入路径的前缀）和依赖项及其版本。
   • 模块根目录可以放在任意位置，go.mod 中指定的模块路径决定了包的导入路径前缀。
     • 例如，如果 go.mod 声明模块为 gopl.io/ch2/tempconv，则该模块中的包可以直接用该路径导入，无需放在 GOPATH 内。
   • 优势：
     • 自动管理依赖版本，支持版本控制；
     • 使得项目结构更灵活，不受 GOPATH 限制；
     • 编译工具会根据 go.mod 自动解析和下载依赖。

3. 构建工具如何根据不同模型处理依赖和编译项目

   • go build 命令
     • 在 GOPATH 模型下，go build 根据 GOPATH/src 中的目录结构找到并编译包；
     • 在 module 模型下，go build 会读取当前目录或上级目录中的 go.mod 文件来确定模块范围，并自动处理依赖。
   • 导入包时的区别
     • 在 GOPATH 模型下，你的代码必须位于 GOPATH/src 中；
     • 在 module 模型下，你可以在任何地方创建项目，依赖管理由 go.mod 文件控制。

4. 包的作用和意义

   • 模块化与封装

     Go 语言中的包类似于其他语言中的库或模块，其目的是将相关代码组织在一起，实现模块化编程。

     • 封装：包内部的实现细节可以隐藏，仅公开需要被外部使用的部分。
     • 单独编译和重用：每个包可以单独编译，也能在不同程序中复用，提高代码可维护性和协作效率。

5. 命名空间

   每个包都有自己独立的命名空间。当不同包中存在同名的函数或类型，外部引用时加上包前缀，这避免了名称冲突

6. 导出规则

   • 包中的标识符（如变量、常量、函数、类型等）只有首字母大写时才是导出的，也就是对外可见的；否则只在包内部可见。这为包内部实现细节的隐藏提供了简单而有效的机制。

7. 文件组织与包结构

   • 一个包通常由一个或多个以 .go 为后缀的源文件组成。这些文件必须以相同的包声明开始。例如，一个包可能存放在 $GOPATH/src/gopl.io/ch2/tempconv 目录中，其导入路径就是 gopl.io/ch2/tempconv。

8. 多个源文件协同工作

   • 包级别的声明（类型、变量、常量、函数）在同一包内的所有源文件中都是共享的，就像所有代码都写在一个文件中一样。
   • 可以将不同功能或逻辑拆分到多个文件中，提高代码组织和可维护性。例如：
     • tempconv.go：放置包级的常量、类型、以及为这些类型定义的方法（如 String()）。
     • conv.go：专门放置温度转换函数，如 CToF 和 FToC。

9. 导入包

   • 导入路径与包名
     • 每个包都有一个全局唯一的导入路径，如 "gopl.io/ch2/tempconv"。这个路径由构建工具解析，通常对应一个目录。
     • 包的名字通常在包声明处指定，惯例上包名和导入路径的最后一个字段相同（例如 tempconv）

10. 包注释

    • 在每个包的源文件开头紧跟着的注释称为包注释，它应该简明扼要地说明包的功能。
      • 通常只需在一个文件中包含完整的包注释，如果包比较复杂，也可以单独放在 doc.go 文件中。

11. 开发工具支持

    goimports 和 gofmt

    • 这些工具可以自动添加或删除导入语句，并格式化代码，保持代码风格一致，有助于日常开发。

要点

导入语句的写法与使用

1. 在源文件中通过 import 语句导入包

   import ("fmt""gopl.io/ch2/tempconv"
   )

2. 导入后，包内导出的标识符（首字母大写的）可以通过“包名.标识符”访问，例如：

   tempconv.CToF(tempconv.BoilingC)
   

   • 如果导入后不使用该包，编译器会报错。这鼓励程序员只导入真正需要的包，保持依赖清晰。

3. 如果有命名冲突或为了简洁，可以将导入的包绑定到另一个名字**（重命名导入）**

   import tconv "gopl.io/ch2/tempconv"
   

   然后用 tconv.CToF 访问包中的内容。

包的初始化

1. 初始化顺序规则

   • 包中的全局变量（包级变量）的初始化遵循先依赖后顺序：

     • 变量的初始化顺序是按照它们在源代码中出现的顺序进行。
     • 当一个包被导入时，所有包级变量会在 main() 函数执行前完成初始化。

     var a = b + c // a 是第三个初始化的变量
     var b = f()   // b 是第二个初始化的变量（依赖 c）
     var c = 1     // c 是第一个初始化的变量
     func f() int { return c + 1 }
     

     • 在这个例子中，初始化时会确保 c 已经赋值，这样 b 才能正确调用 f()。

   • 包初始化顺序与依赖

     • 当一个包 A 导入包 B 时，B 包会先于 A 包初始化。
     • 这种自下而上的初始化方式确保 main 包执行前，所有依赖包都已完成初始化。
2. init函数
   • init 函数的作用
     • init 函数用于在包初始化时执行额外的初始化逻辑。
     • 每个源文件可以包含多个 init 函数，且它们会在包初始化时按照声明顺序自动调用。
     • init 函数不能被显式调用或引用，仅用于初始化工作。
   • 示例

     • 构建辅助数据表或进行复杂的初始化运算。例如在 popcount 包中，用 init 函数预生成一个查表数组：

       var pc [256]bytefunc init() {for i := range pc {pc[i] = pc[i/2] + byte(i&1)}
       }
       

     • 如果初始化过程较复杂，可以采用匿名函数直接在变量声明中完成初始化

       var pc [256]byte = func()(pc [256]byte) {for i := range pc{pc[i] = pc[i/2] + byte(i&1)}return 
       }
       

语言特性

习题

1. 重写PopCount函数，用一个循环代替单一的表达式。

   // 假设已经定义查数数组pc[256]
   func PopCountLoop(x uint64) int{var sum intfor i:=0; i<8; i++{sum += int(pc[byte(x)]) // 取最低8位x >> 8}
   }
   

2. 用移位算法重写PopCount函数，每次测试最右边的1bit，然后统计总数。

   func PopCountShift(x uint64) int {var sum intfor i := 0; i < 64; i++ {sum += int(x & 1)x >>= 1}return sum
   }
   

3. 表达式x&(x-1)用于将x的最低的一个非零的bit位清零。使用这个算法重写PopCount函数

   • 二进制，x-1 会把 x 中最右边的那个“1”变成“0”，并把后面所有的 0 变成 1。（当你给 x 减 1 时，从最右边开始，所有连续的 0 都借1减1，直到碰到第一个 1，这个 1 就变成 0。）
   • 当你把 x 和 x-1 做与操作时，只有当两个对应位置都是 1 时，结果才为 1。由于 x-1 在原来最低1的位置已经变成了 0，所以 x&(x-1) 在那个位置肯定是 0，并且之前为0的低位不会改变——这就把x的最低的一个非零的bit位清零

   func PopCountClear(x uint64) int {var count intfor x != 0 {x &= x - 1  // 清除最低位的1count++}return count
   }
   

总结与补充

1. popcount算法解读

   func PopCount(x uint64) int {return int(pc[byte(x>>(0*8))] +pc[byte(x>>(1*8))] +pc[byte(x>>(2*8))] +pc[byte(x>>(3*8))] +pc[byte(x>>(4*8))] +pc[byte(x>>(5*8))] +pc[byte(x>>(6*8))] +pc[byte(x>>(7*8))])
   }
   

   想象一下你有一本“数字图鉴”，里面记着0到255这256个数字，每个数字旁边都写着它的“1的个数”。这个图鉴就是那个预先计算好的表格(pc数组)。

   • 预先计算图鉴（init函数）
     • 做法： 对于0到255中的每个数字，我们算一算它的二进制写法里有几个1，然后把这个数字和它的1的个数存进图鉴里。
     • 秘诀： 计算一个二进制数字的1的个数时，我们可以把它分解为“除以2后的数字”里的1的个数，再加上“最后一位是否为1”。比如说，如果数字6（二进制110），我们先看6/2等于3（二进制11），再加上6最后一位（0），结果就是2个1。
       • 你把一个数字除以2（也就是右移一位），其实就是把最右边那一位扔掉了。那么，这个数字中1的总数就等于“扔掉最后一位后剩下的数字中的1的个数”加上“刚刚扔掉的那一位是否是1”。
   • 用图鉴快速数1的个数（PopCount函数）
     • 大数字切小块： 当我们有一个很大的64位数字时，不用检查64个数字，而是把它分成8个8位的小数字。
       • 表达式 x >> (k*8) 的意思是把数字 x 向右移动 k*8 位，这样原本在第 k 个8位区域的数字就会移动到最右边。
       • 使用 byte() 把移动后的结果截取成一个8位的数字（一个字节）。
     • 查表加和： 对每个8位的小数字，直接在图鉴里查出它有几个1，然后把8个结果加起来，就知道整个64位数字里有多少个1。