Go 变量与数据类型：给数据贴上标签

Go 变量与数据类型：给数据贴上标签

上一篇我们一起搭建了 Go 的开发环境，写出了第一个 Hello World 程序。今天，我们要聊一个更基础的话题——变量和数据类型。

你可能会问：变量有什么好讲的？不就是存个值嘛。

没错，变量的本质就是存储数据。但在不同的编程语言中，变量的使用方式差别很大。Go 语言在变量和数据类型上有一些独特的设计，理解了这些，你才能写出地道的 Go 代码，而不是写出一堆看起来像 Java 的 Go 代码。

让我们开始吧！

什么是变量？

如果你把程序比作一个厨房，那变量就是厨房里的各种容器。

你有一个碗，上面贴着糖的标签，里面装的就是糖。你有一个瓶子，上面贴着酱油，里面装的就是酱油。在程序中，变量就是这些容器，标签就是变量名，里面的东西就是变量的值。

sugar := "白砂糖"    // 一个名叫 sugar 的变量，里面存着 "白砂糖"
amount := 500        // 一个名叫 amount 的变量，里面存着数字 500

在 Go 语言中，每个变量都有一个明确的类型（type），就像容器有特定的用途一样——碗装固体，瓶子装液体。类型决定了变量能存什么样的数据，能做什么操作。

Go 的变量声明方式

Go 语言提供了多种声明变量的方式，从最啰嗦到最简洁，任君选择。

方式一：完整的 var 声明

这是最正式的声明方式：

var name string = "张三"
var age int = 25
var height float64 = 175.5

语法是：var 变量名 类型 = 值

你也可以同时声明多个变量：

var (
	name   string  = "张三"
	age    int     = 25
	height float64 = 175.5
)

这种用括号把多个变量包在一起的写法，叫做变量组。在声明全局变量或者包的级别变量时特别常用。

方式二：省略类型

如果赋值的时候给出了值，Go 编译器会自动推断变量的类型，所以你可以省略类型声明：

var name = "张三"       // 编译器推断为 string
var age = 25           // 编译器推断为 int
var height = 175.5     // 编译器推断为 float64

编译器看到 “张三” 就知道它是字符串，看到 25 就知道它是整数，看到 175.5 就知道它是浮点数。

方式三：短变量声明（最常用）

在函数内部，你可以使用 := 操作符来声明变量，这是最简洁也最常用的方式：

name := "张三"
age := 25
height := 175.5

:= 是 Go 语言的一个特色语法，它把声明和赋值合二为一了。编译器会自动推断变量的类型。

注意：:= 只能在函数内部使用。在函数外面（包的级别），你必须使用 var 关键字。

// 包级别变量：必须用 var
var globalVar = "我是全局变量"

func main() {
    // 函数内部：可以用 :=
    localVar := "我是局部变量"
}

方式四：先声明后赋值

有时候你需要先声明变量，后面再给它赋值：

var name string
name = "张三"

var age int
age = 25

这种方式在你还不知道变量具体值的时候很有用，比如你打算后面通过用户输入或者从文件读取来给变量赋值。

Go 的基本数据类型

Go 语言的数据类型可以分为几大类：布尔型、整数型、浮点型、字符串、以及复合类型（数组、切片、map、结构体等）。今天我们主要讲基本类型，复合类型会在后面的文章中详细讨论。

布尔型（bool）

布尔型变量只有两个值：true 和 false。它通常用于条件判断。

var isGoFun bool = true
var isJavaHard bool = false

// 也可以从表达式中得到布尔值
age := 25
isAdult := age >= 18  // true

小贴士：Go 语言的布尔类型不会自动转换成整数。在某些语言（如 C）中，true 等于 1，false 等于 0，但在 Go 中这是不允许的。你不能把 true 当成 1 来用。

整数类型

Go 语言提供了非常丰富的整数类型，按照是否有符号和占用内存大小来区分：

另外还有两个特殊类型：

大多数时候，你只需要用 int 就够了。除非你有特殊的需求（比如需要处理超大数字，或者需要确保跨平台一致性，或者需要精确控制内存布局），否则不要纠结于用 int32 还是 int64。

var count int = 100
var negative int = -42

// 其他整数类型
var small uint8 = 255      // byte 的别名
var big int64 = 9999999999

fmt.Println(count, negative, small, big)
// 输出：100 -42 255 9999999999

关于 byte 和 rune

Go 语言中有两个特殊的类型别名，你需要了解：

• byte：是 uint8 的别名，通常用来表示字节数据
• rune：是 int32 的别名，通常用来表示 Unicode 字符

var b byte = 'A'     // 字节，存储 ASCII 码 65
var r rune = '中'    // Unicode 字符

fmt.Printf("byte: %c (%d)\n", b, b)   // byte: A (65)
fmt.Printf("rune: %c (%d)\n", r, r)   // rune: 中 (20013)

为什么要专门搞个别名？这是为了让代码更有可读性。当你看到 byte 的时候，你就知道这里处理的是原始字节数据；当你看到 rune 的时候，你就知道这里处理的是 Unicode 字符。

浮点数类型

Go 语言有两种浮点数类型：

默认使用 float64，因为它的精度更高，而且 Go 编译器在推断类型时也会优先选择 float64。

pi := 3.14159265358979  // float64
var gravity float32 = 9.8

fmt.Printf("pi = %f\n", pi)        // pi = 3.141593
fmt.Printf("gravity = %f\n", gravity) // gravity = 9.800000

踩坑提示：浮点数运算可能会有精度问题，这不只是 Go 的问题，是所有编程语言都有的。如果你在做金融计算等对精度要求极高的场景，建议使用专门的库（比如 github.com/shopspring/decimal），不要用浮点数。

// 浮点数精度问题
a := 0.1
b := 0.2
c := a + b
fmt.Println(c == 0.3)      // false！
fmt.Printf("%.20f\n", c)   // 0.30000000000000004441

字符串类型（string）

字符串是用来存储文本数据的。在 Go 中，字符串是不可变的（immutable）——一旦创建，就不能修改。

// 双引号：普通的字符串
name := "Hello, Go!"

// 反引号：原始字符串（raw string），支持多行
poem := `
静夜思
床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。
`

fmt.Println(name)
fmt.Println(poem)

字符串的一些常用操作：

s := "Hello, Go!"

// 获取长度
fmt.Println(len(s))  // 12

// 字符串拼接
greeting := "Hello" + ", " + "World!"
fmt.Println(greeting)

// 访问单个字符（返回的是 byte）
fmt.Println(s[0])  // 72（'H' 的 ASCII 码）
fmt.Printf("%c\n", s[0])  // H

小贴士：len() 返回的是字节数，不是字符数。对于包含中文的字符串，这两者是不同的：

s := "你好"
fmt.Println(len(s))  // 6（每个中文字符占 3 个字节）

// 如果要获取字符数，使用 utf8.RuneCountInString
import "unicode/utf8"
fmt.Println(utf8.RuneCountInString(s))  // 2

复数类型

Go 语言内置了复数类型，虽然在大多数项目中不太会用到，但作为一门系统编程语言，这个特性还是很酷的。

var c1 complex64 = 3 + 4i
c2 := 5 + 6i

fmt.Printf("c1 = %v\n", c1)     // c1 = (3+4i)
fmt.Printf("c2 = %v\n", c2)     // c2 = (5+6i)

// 获取实部和虚部
fmt.Println(real(c1))  // 3
fmt.Println(imag(c1))  // 4

类型转换

Go 语言的类型转换是显式的——你必须明确告诉编译器你想做什么转换。Go 不会自动帮你做隐式转换，这一点和 JavaScript、Python 这些语言很不一样。

var i int = 42
var f float64 = float64(i)    // int → float64
var u uint = uint(f)          // float64 → uint

fmt.Println(i, f, u)  // 42 42 42

注意，类型转换可能会导致数据丢失：

var big int64 = 1 << 40   // 一个很大的数
var small int32 = int32(big)  // 溢出！
fmt.Println(small)  // 结果不是你想的那样

字符串与数字的互转

这是日常开发中非常常见的需求，需要用到 strconv 包：

import "strconv"

// 字符串 → 整数
num, err := strconv.Atoi("42")
if err != nil {
    fmt.Println("转换失败:", err)
} else {
    fmt.Println(num)  // 42
}

// 整数 → 字符串
str := strconv.Itoa(42)
fmt.Println(str)  // "42"

// 更通用的转换函数
f, _ := strconv.ParseFloat("3.14", 64)
fmt.Println(f)  // 3.14

s := strconv.FormatFloat(3.14, 'f', 2, 64)
fmt.Println(s)  // "3.14"

strconv 包的名字是 string conversion 的缩写，记住这个包名，你会经常用到它。

常量和 iota

常量（const）

常量就是值不能改变的变量。一旦定义了，就不能再修改。

const Pi = 3.14159265358979
const Language = "Go"

// 常量组
const (
	StatusOK    = 200
	StatusNotFound = 404
	StatusError = 500
)

fmt.Println(Pi, Language, StatusOK)
// 输出：3.14159265358979 Go 200

常量不能使用 := 声明，只能用 const 关键字。

iota：自增常量生成器

iota 是 Go 语言中一个非常有趣的特性。它是一个常量计数器，从 0 开始，每出现一次就自动加 1。它主要用于定义一组相关的常量。

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

fmt.Println(Sunday, Monday, Saturday)
// 输出：0 1 6

注意，从第二个常量开始，你不需要重复写 = iota，Go 编译器会自动延续前面的表达式。

iota 还可以用在更复杂的表达式中：

const (
	_  = iota             // 跳过第一个值
	KB = 1 << (10 * iota) // 1 << 10 = 1024
	MB                    // 1 << 20 = 1048576
	GB                    // 1 << 30 = 1073741824
	TB                    // 1 << 40 = 1099511627776
)

fmt.Println(KB, MB, GB)
// 输出：1024 1048576 1073741824

这段代码利用位运算定义了存储单位的常量，非常优雅。_ 是 Go 中的空白标识符，用来丢弃不需要的值。

零值机制与深层语义

这是 Go 语言一个很重要的特性：当你声明一个变量但不给它赋值时，Go 会自动给它一个默认值，叫做零值（zero value）。

不同数据类型的零值是不同的：

var i int
var f float64
var b bool
var s string

fmt.Printf("int: %d\n", i)       // int: 0
fmt.Printf("float: %f\n", f)     // float: 0.000000
fmt.Printf("bool: %v\n", b)      // bool: false
fmt.Printf("string: %q\n", s)    // string: ""

零值机制让 Go 程序更加安全。你永远不会遇到未初始化的变量这种问题，因为所有变量在声明时就已经有了明确的默认值。这个设计看似简单，实际上带来了很多好处：

1. 安全性：不会出现未初始化变量的随机值问题
2. 可预测性：代码行为更加确定，便于推理
3. 简洁性：不需要像 C 语言那样 memset 清零
4. 与复合类型的协同：结构体中的每个字段都会被递归地赋予零值

小贴士：注意 %q 这个格式化动词，它会给字符串加上引号，这样你就能看到空字符串 "” 和没输出之间的区别。

进阶类型概念

类型推断的深层原理

Go 的类型推断发生在编译期，而不是运行期。编译器会根据赋值右侧的表达式来推断左侧变量的类型。这种设计保证了 Go 是静态类型语言的同时，提供了类似动态语言的简洁性。

// 字面量推断
x := 42           // int（未指定类型时默认 int）
y := 3.14         // float64（未指定类型时默认 float64）
z := 3.14 + 2i    // complex128

// 表达式推断
a := x + 1        // int
b := y * 2        // float64

// 函数返回值推断
result := len("hello")  // int

类型推断的一个重要细节是：未指定类型的整数字面量默认是 int，未指定类型的浮点字面量默认是 float64，未指定类型的复数字面量默认是 complex128。

类型别名 vs 类型定义

Go 语言中有两种方式基于现有类型创建新类型，它们的区别至关重要：

类型定义（Type Definition）：

type MyInt int  // MyInt 是一个全新的类型

func main() {
	var a int = 10
	var b MyInt = 20

	// a = b  // ❌ 编译错误！不同类型不能赋值
	c := MyInt(a)  // ✅ 需要显式转换
	fmt.Println(c)  // 10
}

类型别名（Type Alias）：

type MyInt = int  // MyInt 只是 int 的别名

func main() {
	var a int = 10
	var b MyInt = 20

	a = b  // ✅ OK！它们是同一个类型
	fmt.Println(a)  // 20
}

类型别名主要用于代码重构和兼容性处理（比如在不同包之间移动类型），而类型定义用于创建具有更强类型安全的领域模型。

自定义类型

Go 允许你为任何类型创建自定义类型，这对于构建领域模型非常有用：

package main

import "fmt"

// 基于 string 定义用户名类型
type Username string

// 基于 int 定义用户ID类型
type UserID int

// 定义一个方法（自定义类型可以有方法）
func (u UserID) String() string {
	return fmt.Sprintf("User-%d", u)
}

// 基于 string 定义状态类型
type Status string

const (
	StatusActive   Status = "active"
	StatusInactive Status = "inactive"
	StatusBanned   Status = "banned"
)

func main() {
	var name Username = "alice"
	var id UserID = 42

	fmt.Printf("用户名: %s\n", name)
	fmt.Printf("用户ID: %s\n", id.String())

	// 防止不同类型混用
	var uid UserID = 100
	// var wrong UserID = UserID("100")  // ❌ 编译错误
	fmt.Println(uid)
}

自定义类型最大的好处是类型安全：你不能把 Username 和 UserID 混用，即使它们底层都是 string 或 int。编译器会在编译期帮你发现这类错误。

类型转换陷阱

Go 的类型转换虽然显式，但仍然有一些陷阱需要注意：

package main

import "fmt"

func main() {
	// 陷阱1：大整数转小整数导致溢出
	var big uint64 = 1<<64 - 1
	var small uint8 = uint8(big)
	fmt.Printf("溢出: %d\n", small)  // 255，数据丢失但没有运行时错误！

	// 陷阱2：浮点数转整数截断小数
	f := 3.99
	i := int(f)
	fmt.Printf("截断: %d\n", i)  // 3，不是 4！

	// 陷阱3：负数转无符号数变成巨大的正数
	var n int = -1
	var u uint = uint(n)
	fmt.Printf("负数转无符号: %d\n", u)  // 18446744073709551615（对于64位系统）

	// 陷阱4：字符串转字节切片共享底层数据
	s := "hello"
	b := []byte(s)
	b[0] = 'H'
	fmt.Printf("原字符串: %s\n", s)  // 仍然是 "hello"（值语义）
	fmt.Printf("字节切片: %s\n", b)  // "Hello"
}

类型转换不会引发 panic（除了某些接口断言），但可能导致数据丢失。在进行类型转换时，要确保转换是安全的，或者在关键业务逻辑中添加范围检查。

内存布局与性能优化

了解各种类型在内存中的布局，能帮助你写出更高效的代码。

各类型内存占用对比

以下是 Go 语言各基本类型的内存占用详情：

你可以使用 unsafe 包来查看类型的实际大小：

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	fmt.Printf("bool 大小: %d 字节\n", unsafe.Sizeof(bool(true)))
	fmt.Printf("int 大小: %d 字节\n", unsafe.Sizeof(int(0)))
	fmt.Printf("int64 大小: %d 字节\n", unsafe.Sizeof(int64(0)))
	fmt.Printf("float64 大小: %d 字节\n", unsafe.Sizeof(float64(0)))
	fmt.Printf("string 头部大小: %d 字节\n", unsafe.Sizeof("hello"))
	fmt.Printf("slice 头部大小: %d 字节\n", unsafe.Sizeof([]int{1, 2, 3}))
	fmt.Printf("map 头部大小: %d 字节\n", unsafe.Sizeof(map[string]int{}))
	fmt.Printf("interface 大小: %d 字节\n", unsafe.Sizeof(interface{}(0)))
}

内存对齐与结构体布局

Go 编译器会自动对结构体进行内存对齐，以提高访问效率。了解这个机制可以帮助你优化结构体的内存占用：

package main

import (
	"fmt"
	"unsafe"
)

type BadStruct struct {
	A bool    // 1 字节
	B int64   // 8 字节（需要对齐到 8 字节边界）
	C bool    // 1 字节
	D int64   // 8 字节
}

type GoodStruct struct {
	B int64   // 8 字节
	D int64   // 8 字节
	A bool    // 1 字节
	C bool    // 1 字节
	// 填充 6 字节
}

func main() {
	fmt.Printf("BadStruct 大小: %d 字节\n", unsafe.Sizeof(BadStruct{}))
	fmt.Printf("GoodStruct 大小: %d 字节\n", unsafe.Sizeof(GoodStruct{}))
}

输出可能是：

BadStruct 大小: 32 字节
GoodStruct 大小: 24 字节

通过合理安排字段顺序，我们可以减少内存填充（padding）造成的浪费。一般原则是：把相同大小的字段放在一起，大字段放在前面。

工程中的类型选择策略

在实际工程中，选择正确的类型对于代码的可维护性和性能都有重要影响。

值类型 vs 指针类型

Go 中所有类型要么是值类型，要么是指针类型。理解它们的区别至关重要：

package main

import "fmt"

func modifyValue(x int) {
	x = 100
}

func modifyPointer(x *int) {
	*x = 100
}

func main() {
	a := 1
	modifyValue(a)
	fmt.Println("值传递后:", a)  // 1（没变）

	modifyPointer(&a)
	fmt.Println("指针传递后:", a)  // 100（变了）
}

何时使用值类型：

• 数据量小（如 int、bool、小结构体）
• 不需要修改原始数据
• 并发安全（值拷贝天然线程安全）
• 函数参数和返回值

何时使用指针类型：

• 数据量大（避免复制开销）
• 需要修改原始数据
• 实现可选值（nil 表示未设置）
• 接口实现（某些场景下必须）

工程中的类型选择决策树

在实际项目中，面对类型选择时，可以参考以下决策逻辑：

对于整数：

• 通用计数、索引 → 用 int
• 需要精确控制内存（如协议解析、数据库驱动） → 用 int8/int16/int32/int64
• 位运算、位掩码 → 用 uint 系列
• 永远不可能是负数（如长度、容量） → 考虑 uint，但注意溢出问题

对于浮点数：

• 一般科学计算 → float64
• 内存敏感且精度要求不高 → float32
• 金融计算 → 不要用浮点数，用 decimal 库或定点数

对于字符串：

• 普通文本 → string
• 处理原始字节 → []byte
• 处理 Unicode 字符 → []rune

最佳实践

变量命名规范

Go 语言有明确的命名规范，遵循这些规范能让你的代码更容易被其他 Go 开发者理解：

1. 使用驼峰式命名，不使用下划线：

   • 正确：userName, httpRequest, maxConnections
   • 错误：user_name, http_request, max_connections

2. 首字母大小写决定可见性：

   • 大写开头（User）：包外可见（导出的）
   • 小写开头（user）：包内私有

3. 简短且有意义：

   • 小作用域：i, j, k, x, n（简短即可）
   • 大作用域：userService, databaseConnection（要完整描述）

4. 避免无意义的命名：

   • 错误：data1, temp, foo, result2
   • 正确：userData, tempFile, outputBuffer

5. 布尔变量用肯定语气：

   • 正确：isValid, hasPermission, canRead
   • 错误：isNotValid, hasNoPermission

6. 接口名通常以 -er 结尾：

   • Reader, Writer, Closer, Stringer
   • 但如果一个接口只包含一个方法，可以直接用方法名加 -er

函数设计原则

虽然这主要是类型相关的文章，但变量类型和函数设计密不可分：

1. 参数类型要尽可能通用：如果函数只需要读取，使用值类型；如果需要修改，使用指针类型
2. 返回具体类型而不是接口：Go 的哲学是接受接口，返回具体类型
3. 错误作为最后一个返回值：这是 Go 社区的标准约定
4. 对于大结构体，统一使用指针：避免在参数传递中出现不一致的复制行为

类型安全最佳实践

1. 使用自定义类型增强类型安全：不要把所有东西都声明为 string 或 int，为业务概念创建专门的类型
2. 避免使用空接口 interface{}：除非你确实需要处理任意类型，否则尽量使用具体类型或合适的接口
3. 注意类型断言时的 ok 模式：

   v, ok := i.(string)
   if !ok {
       // 处理类型不匹配的情况
   }
   

4. 利用编译器检查：Go 的强类型系统是你的朋友，让编译器帮你发现错误，而不是等到运行时

常见问题 FAQ

Q1：为什么要显式类型转换，不能像 Python 一样自动转换吗？

A：显式类型转换是 Go 语言设计哲学的一部分——明确优于隐晦。自动类型转换虽然写起来方便，但容易导致难以发现的 bug。显式转换让代码的意图一目了然，也便于代码审查。另外，显式转换让编译器可以在编译期就发现潜在的类型错误，而不是等到运行时。

Q2：int 和 int32 有什么区别？我应该用哪个？

A：int 的大小取决于你的系统架构（32 位系统上是 4 字节，64 位系统上是 8 字节），而 int32 固定是 4 字节。大多数情况下用 int 就好，它是 Go 中最通用的整数类型。只有在需要精确控制内存布局（如二进制协议解析、与 C 代码交互）或确保跨平台一致性时，才需要使用固定大小的类型。

Q3：float64 精度够吗？为什么浮点数计算会出错？

A：float64 提供约 15 位有效数字的精度，对于大多数科学计算和工程应用已经足够。浮点数精度问题是二进制浮点表示法的固有特性，不是 Go 特有的。0.1 在二进制中是一个无限循环小数，所以无法精确表示。解决方法：

1. 对于货币计算，用 shopspring/decimal 等库
2. 比较浮点数时，使用误差范围而不是精确相等
3. 考虑使用定点数或整数来表示小数（如用分而不是元）

Q4：string 是不可变的，那怎么修改字符串？

A：Go 的字符串确实是不可变的，这和其他很多语言一样。需要修改时，先把字符串转成 []byte 或 []rune，修改后再转回 string。注意：[]byte 适合处理 ASCII 文本，[]rune 适合处理包含中文等 Unicode 字符的文本。

s := "hello"
// 不能直接修改：s[0] = 'H'  // ❌ 编译错误
b := []byte(s)
b[0] = 'H'
s2 := string(b)  // "Hello"

Q5：:= 和 = 有什么区别？

A：:= 是短变量声明，用于声明并初始化新变量；= 是赋值，用于给已存在的变量赋新值。:= 只能在函数内部使用，而且至少有一个变量必须是新声明的。:= 也可以用于重新赋值已存在的变量（在同一作用域），只要同时有至少一个新变量。

Q6：nil 和零值有什么区别？

A：零值是每种类型在声明但没有显式赋值时的默认值（如 int 的 0，bool 的 false）。nil 是一种特殊的零值，只适用于引用类型（指针、切片、map、通道、函数、接口）。比如，string 的零值是 “"，不是 nil；int 的零值是 0，不是 nil。

Q7：自定义类型有什么性能开销？

A：几乎没有！自定义类型在编译后和底层类型有完全相同的内存布局和性能特征。类型定义只是编译期的概念，运行时不产生额外开销。这是 Go 类型系统的一大优势——你获得了类型安全，但不需要付出性能代价。

Q8：为什么 Go 没有隐式类型转换？

A：这是 Go 设计者的有意选择。Rob Pike 和其他设计者认为，隐式类型转换虽然方便，但代价是隐藏了类型转换的发生，可能导致数据丢失或意外行为。Go 的哲学是显式优于隐式，代码应该清晰地表达程序员的意图。这确实会让代码稍长一些，但大大减少了因类型问题导致的 bug。

Q9：什么时候应该使用 uint 而不是 int？

A：uint（无符号整数）只适合那些数学上绝对不可能是负数的场景，如位掩码、哈希值、内存地址等。对于一般的计数器和索引，建议仍然使用 int。原因是：

1. int 是 Go 标准库和大多数第三方库使用的默认类型
2. 混合使用 int 和 uint 会导致频繁的强制类型转换
3. uint 的溢出行为（变成巨大的正数）比 int 的溢出更加隐蔽和危险

Q10：const 和 var 的区别是什么？

A：const 声明常量，值在编译时确定且不能修改；var 声明变量，值可以在运行时改变。const 只能用于基本类型（布尔、数字、字符串）以及基于它们的表达式。const 不支持切片、map、结构体等复合类型（除非这些类型可以作为常量表达式）。const 在编译期计算，而 var 在运行期分配内存。

延伸阅读

如果你想更深入地学习 Go 语言的类型系统，以下是一些推荐的资源：

• Go 语言规范 - 类型：https://golang.org/ref/spec#Types
• Effective Go - 变量：https://golang.org/doc/effective_go.html#variables
• Go by Example - Variables：https://gobyexample.com/variables
• Go 类型系统深入：https://go.dev/blog/declaration-syntax
• Go 内存模型：https://golang.org/ref/mem
• Go 数据对齐：https://go101.org/article/memory-layout.html

小结

今天我们深入学习了 Go 语言中关于变量和数据类型的知识。让我们回顾关键要点：

1. 变量声明的四种方式：完整 var 声明、省略类型、短变量声明 :=、先声明后赋值
2. 基本数据类型：bool、整数类型（int 家族）、浮点数（float32/float64）、字符串（string）、复数
3. byte 和 rune：分别是 uint8 和 int32 的别名，用于处理字节和 Unicode 字符
4. 类型转换：Go 要求显式转换，不会自动做隐式转换，注意转换陷阱
5. 常量和 iota：const 定义不可变的值，iota 是自增常量生成器
6. 零值机制：所有变量声明后都有默认值，不会存在未初始化的变量
7. 类型别名与类型定义：alias 是同一类型，definition 是全新类型
8. 自定义类型：增强类型安全，可附加方法，零运行时开销
9. 内存布局：了解类型大小和对齐规则，优化结构体字段排列
10. 值类型与指针类型：理解传值和传引用的区别，选择正确的传递方式
11. 命名规范：遵循 Go 社区约定，提高代码可读性

这些知识看似简单，但它们是 Go 编程的基石。理解了这些，你才能更好地理解后面要学的函数、结构体、接口等更高级的概念。尤其是类型安全和显式转换的哲学，会贯穿你整个 Go 编程生涯，帮助你写出更可靠、更易维护的代码。

练习时间

1. 声明各种类型的变量：分别用四种方式声明一个 string、int、float64、bool 类型的变量
2. 类型转换练习：写一个程序，把一个整数转换成浮点数，再把浮点数转换回整数，观察结果变化
3. 字符串处理：写一个程序，计算 “Hello, 世界！” 这个字符串的字节数和字符数
4. 用 iota 定义常量：定义一组表示 HTTP 状态码的常量（200, 301, 404, 500），使用 iota 和表达式
5. BMI 计算器：写一个程序，输入身高（米）和体重（公斤），计算 BMI 值
6. 自定义类型练习：定义一个 Temperature 类型（基于 float64），并给它添加 Celsius、Fahrenheit、Kelvin 三种转换方法
7. 内存对齐观察：创建两个字段相同但排列顺序不同的结构体，用 unsafe.Sizeof 比较它们的大小差异
8. 类型转换陷阱实验：编写程序演示大整数转小整数的溢出、浮点数转整数的截断、负数转无符号数的行为

下一篇预告

在下一篇文章中，我们将学习 Go 语言的控制流——让程序学会做选择和循环。你会学到：

• if/else 条件判断
• switch 多分支选择
• for 循环（Go 唯一的循环结构！）
• break、continue、goto 的用法
• range 遍历

我们下篇见！

参考资料：

• Go 语言规范 - 类型
• Effective Go - 变量
• Go by Example - Variables
• Go 类型系统深入