第 2 课 - 变量与基本类型

学习目标

完成本课学习后，你将能够：

理解并使用 var 关键字和短变量声明 (:=) 来声明和初始化变量。
掌握 Go 语言中常用的基本数据类型，如整型、浮点型、布尔型和字符串型。
学会使用 const 关键字定义常量。
理解类型转换的基本概念和用法。
能够运用零值概念为未显式初始化的变量赋予合理的默认值。

核心概念

1. 变量：程序的“小盒子”

想象程序是一个工具箱，变量就是里面的“小盒子”，每个盒子都有名字（变量名），用来存放特定类型的数据（值）。在 Go 中，声明一个变量就是准备一个这样的盒子。

Go 提供了两种主要的变量声明方式：

var 关键字声明：这是标准、完整的声明方式。你可以指定变量的类型，也可以让编译器根据初始值自动推断类型。
短变量声明 (:=)：这是一种简洁的语法糖，只能在函数内部使用。它声明并初始化变量，并自动推断类型。

// var 关键字声明（可在函数内或包级别使用）
var message string = "Hello" // 显式指定类型
var count = 10               // 由初始值 `10` 推断类型为 `int`
var width, height float64    // 同时声明多个同类型变量，未初始化，为零值

// 短变量声明 (只能在函数内使用)
score := 98.5                // 声明并初始化，类型推断为 float64
name, age := "Alice", 30     // 同时声明并初始化多个变量

2. 基本类型：数据的“形状”

Go 是一门静态类型语言，每个变量都有确定的类型，就像每个盒子都规定了只能装苹果（整型）或橘子（字符串）。

整型 (int, int8, int16, int32, int64 等)：存放整数。最常用的是 int，它的大小依赖于平台（32位或64位系统）。
浮点型 (float32, float64)：存放小数。float64 是默认类型，精度更高。
布尔型 (bool)：只有两个值：true 或 false。
字符串型 (string)：存放一串字符。字符串在Go中是不可变的。

3. 常量：不可变的“标签”

常量像是贴在值上的永久标签，一旦设定，在程序运行期间不能修改。非常适合定义固定的值，如数学常数 π 或配置项。

const pi = 3.14159265358979
const maxRetries = 3
const greeting = "Welcome"
// pi = 3.14 // 这行会报错，不能修改常量

4. 零值：盒子的“出厂设置”

当声明一个变量但没有显式初始化时，Go 会自动给它一个默认的“零值”。这避免了未初始化变量带来的潜在问题。

数值类型 (int, float64 等): 0
布尔类型 (bool): false
字符串类型 (string): "" (空字符串)

5. 类型转换：改变盒子的“形状”

Go 不允许不同类型的变量直接混合运算。你需要显式地进行类型转换，就像把盒子里的苹果（整数）拿出来，称一下重量后放入一个标有“浮点数”的新盒子。

var i int = 42
var f float64 = float64(i) // 将 int 转换为 float64
var u uint = uint(f)       // 将 float64 转换为 uint

代码示例

以下是一个完整的示例程序，演示了本课涉及的大部分概念。

package main

import "fmt"

// 包级别常量
const AppVersion = "1.0.0"

func main() {
	// 1. 使用 var 声明并初始化
	var username string = "gopher"
	var loginCount int = 5
	var isActive bool = true
	fmt.Println("用户:", username, "登录次数:", loginCount, "是否活跃:", isActive)

	// 2. 使用短变量声明
	city := "北京"
	temperature := 26.8
	fmt.Printf("城市：%s，温度：%.1f°C\n", city, temperature) // 使用格式化输出

	// 3. 演示零值
	var unusedInt int
	var unusedFloat float64
	var unusedBool bool
	var unusedString string
	fmt.Println("零值演示 -> 整型:", unusedInt, "浮点型:", unusedFloat, "布尔型:", unusedBool, "字符串:'" + unusedString + "'")

	// 4. 演示常量
	fmt.Println("应用版本:", AppVersion)
	const DaysInWeek = 7
	fmt.Println("一周有", DaysInWeek, "天")

	// 5. 演示类型转换
	year := 2024         // int
	piApprox := 3.14     // float64
	// 直接相加会报错：invalid operation: year + piApprox (mismatched types int and float64)
	// 正确的做法是进行类型转换
	yearFloat := float64(year) // int -> float64
	result := yearFloat + piApprox
	fmt.Printf("转换与计算：%.2f + %.2f = %.2f\n", yearFloat, piApprox, result)

	// 整型之间的转换
	var bigInt int64 = 1000000
	var smallInt int32 = int32(bigInt) // int64 -> int32，可能溢出
	fmt.Println("大整数转小整数:", bigInt, "->", smallInt)
}

运行结果：

用户: gopher 登录次数: 5 是否活跃: true
城市：北京，温度：26.8°C
零值演示 -> 整型: 0 浮点型: 0 布尔型: false 字符串:''
应用版本: 1.0.0
一周有 7 天
转换与计算：2024.00 + 3.14 = 2027.14
大整数转小整数: 1000000 -> 1000000

实践练习

练习 1：基础变量声明

声明并初始化以下变量，并打印它们的值和类型。

你的名字（字符串）
你的年龄（整数）
你的身高，单位为米（浮点数，例如 1.75）
你是否喜欢编程（布尔值）

预期输出格式：

姓名：小明, 类型：string
年龄：25, 类型：int
身高：1.75, 类型：float64
喜欢编程：true, 类型：bool

练习 2：类型推断与零值

使用短变量声明一个变量 score 并赋值为 85。然后声明一个 var averageScore float64（不初始化）。最后，将 score 转换为 float64 类型后赋值给 averageScore，并打印两者。

练习 3：温度转换

编写一个小程序，将一个华氏温度（fahrenheit）转换为摄氏温度（celsius）。公式为：celsius = (fahrenheit - 32) * 5 / 9。请使用合适的变量和类型，确保计算结果是浮点数。

常见错误

混淆 := 和 =：

func main() {
    x := 10 // 正确：声明并初始化
    // x := 20 // 错误：不能再次使用 := 声明已存在的变量 x
    x = 20   // 正确：给已声明的变量 x 重新赋值
}

在包级别使用短变量声明 (:=)：

// name := "Go" // 错误：:= 只能在函数内部使用
var name = "Go" // 正确：在包级别使用 var

忽略零值：初学者有时会误以为未初始化的变量是 null 或未定义，但在 Go 中它们有明确的零值。理解零值有助于调试程序逻辑。

隐式类型转换陷阱： Go 不支持自动类型转换。即使是 int 和 int64 这样的“近亲”，也需要显式转换。

var a int = 10
var b int64 = 20
// c := a + b // 错误：不同整型不能直接相加
c := int64(a) + b // 正确：将 a 显式转换为 int64

小结

本节课我们学习了 Go 语言编程的基石——变量和基本类型：

变量是存储数据的容器，可以通过 var 或短声明 := 来创建。
Go 是静态类型语言，常用基本类型包括 int, float64, bool, string。
常量 (const) 用于存储不可更改的值。
变量未初始化时，会自动赋予该类型的零值。
不同类型间的运算需要进行显式类型转换。

熟练掌握变量声明和类型系统，将为你学习后续的函数、控制流等更复杂的概念打下坚实的基础。在下一课中，我们将学习如何将这些变量组织和封装到函数中。

变量与基本类型