第2课: 变量、常量与数据类型

变量声明

Go语言提供了多种变量声明方式，每种方式都有其适用场景。

方式1：标准声明（var关键字）

// 声明单个变量
var name string = "Go语言"
var age int = 15
var price float64 = 99.99

// 声明时不初始化（使用零值）
var count int        // 0
var message string   // ""
var isActive bool    // false

方式2：类型推断

// Go编译器自动推断类型
var language = "Golang"  // string
var version = 1.21       // float64
var year = 2009          // int

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

// 使用 := 操作符，只能在函数内使用
name := "张三"
age := 25
height := 1.75
isStudent := true

// 同时声明多个变量
x, y, z := 1, 2, 3
firstName, lastName := "三", "张"

方式4：批量声明

// 使用括号批量声明
var (
    username string = "admin"
    password string = "123456"
    port     int    = 8080
    debug    bool   = true
)

变量的零值

Go语言中，声明但未初始化的变量会被赋予零值（zero value）：

类型	零值
整型（int, int8, int16等）	0
浮点型（float32, float64）	0.0
布尔型（bool）	false
字符串（string）	""（空字符串）
指针、切片、映射、通道、函数、接口	nil

基本数据类型

1. 整数类型

类型	大小	范围
int8	8位	-128 到 127
int16	16位	-32768 到 32767
int32	32位	-2^31 到 2^31-1
int64	64位	-2^63 到 2^63-1
int	32或64位	取决于平台
uint8	8位	0 到 255
uint16	16位	0 到 65535
uint32	32位	0 到 2^32-1
uint64	64位	0 到 2^64-1

package main

import "fmt"

func main() {
    var a int8 = 127
    var b uint8 = 255
    var c int = 1000000

    fmt.Printf("int8: %d\n", a)
    fmt.Printf("uint8: %d\n", b)
    fmt.Printf("int: %d\n", c)
}

2. 浮点类型

// float32: 32位浮点数
var price32 float32 = 19.99

// float64: 64位浮点数（默认）
var price64 float64 = 99.99
pi := 3.14159265359  // 自动推断为float64

fmt.Printf("%.2f\n", price32)  // 保留2位小数
fmt.Printf("%.5f\n", pi)       // 保留5位小数

3. 布尔类型

var isTrue bool = true
var isFalse bool = false

// 布尔运算
result1 := true && false  // false (与)
result2 := true || false  // true (或)
result3 := !true          // false (非)

// 比较运算返回布尔值
isEqual := (10 == 10)     // true
isGreater := (5 > 3)      // true

4. 字符串类型

// 字符串声明
var str1 string = "Hello, Go!"
str2 := "你好，世界！"

// 多行字符串（使用反引号）
str3 := `这是一个
多行
字符串`

// 字符串拼接
fullName := "张" + "三"
greeting := fmt.Sprintf("你好，%s！", fullName)

// 字符串长度
length := len("Hello")  // 5
chineseLen := len("你好") // 6 (UTF-8编码，每个中文3字节)

5. 字符类型

// byte: uint8的别名，表示ASCII字符
var b byte = 'A'
fmt.Printf("字符: %c, ASCII码: %d\n", b, b)

// rune: int32的别名，表示Unicode字符
var r rune = '中'
fmt.Printf("字符: %c, Unicode码: %d\n", r, r)

常量

常量是在编译时就确定的值，运行时不可修改。

常量声明

// 单个常量
const Pi = 3.14159
const AppName = "MyApp"

// 批量声明
const (
    StatusOK = 200
    StatusNotFound = 404
    StatusInternalError = 500
)

// 类型化常量
const (
    MaxSize int = 100
    MinSize int = 10
)

iota枚举器

// iota在const关键字出现时被重置为0
const (
    Sunday = iota     // 0
    Monday            // 1
    Tuesday           // 2
    Wednesday         // 3
    Thursday          // 4
    Friday            // 5
    Saturday          // 6
)

// iota的高级用法
const (
    _  = iota             // 0 (跳过)
    KB = 1 << (10 * iota) // 1 << 10 = 1024
    MB                     // 1 << 20 = 1048576
    GB                     // 1 << 30 = 1073741824
    TB                     // 1 << 40
)

类型转换

Go语言不支持隐式类型转换，必须显式转换。

package main

import "fmt"

func main() {
    // 整型转换
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)

    fmt.Printf("int: %d, float64: %.2f, uint: %d\n", i, f, u)

    // 字符串转换
    var num int = 65
    var char byte = byte(num)
    fmt.Printf("数字: %d, 字符: %c\n", num, char)

    // 注意：不同大小的整型转换可能溢出
    var bigNum int64 = 1000000
    var smallNum int8 = int8(bigNum)  // 溢出！
    fmt.Printf("int64: %d, int8: %d\n", bigNum, smallNum)
}

字符串与数字转换

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 字符串转整数
    str := "123"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("转换失败:", err)
    } else {
        fmt.Println("转换成功:", num)
    }

    // 整数转字符串
    num2 := 456
    str2 := strconv.Itoa(num2)
    fmt.Println("字符串:", str2)

    // 字符串转浮点数
    floatStr := "3.14"
    floatNum, _ := strconv.ParseFloat(floatStr, 64)
    fmt.Println("浮点数:", floatNum)

    // 浮点数转字符串
    floatNum2 := 2.71828
    floatStr2 := strconv.FormatFloat(floatNum2, 'f', 2, 64)
    fmt.Println("字符串:", floatStr2)
}

指针类型

package main

import "fmt"

func main() {
    // 声明变量
    var num int = 42

    // 声明指针并获取地址
    var ptr *int = &num

    fmt.Printf("变量值: %d\n", num)
    fmt.Printf("变量地址: %p\n", &num)
    fmt.Printf("指针值: %p\n", ptr)
    fmt.Printf("指针指向的值: %d\n", *ptr)

    // 通过指针修改值
    *ptr = 100
    fmt.Printf("修改后的值: %d\n", num)
}

类型别名

// 定义类型别名
type MyInt int
type MyString string

func main() {
    var num MyInt = 100
    var str MyString = "Hello"

    fmt.Println(num, str)
}

综合示例

示例1：个人信息管理

package main

import "fmt"

func main() {
    // 声明个人信息变量
    name := "张三"
    age := 25
    height := 1.75
    weight := 70.5
    isStudent := true

    // 计算BMI
    bmi := weight / (height * height)

    // 输出信息
    fmt.Println("=== 个人信息 ===")
    fmt.Printf("姓名: %s\n", name)
    fmt.Printf("年龄: %d岁\n", age)
    fmt.Printf("身高: %.2f米\n", height)
    fmt.Printf("体重: %.1f公斤\n", weight)
    fmt.Printf("BMI: %.2f\n", bmi)
    fmt.Printf("是否学生: %t\n", isStudent)
}

示例2：温度转换器

package main

import "fmt"

func main() {
    // 摄氏度转华氏度
    celsius := 25.0
    fahrenheit := celsius*9/5 + 32

    fmt.Printf("%.1f°C = %.1f°F\n", celsius, fahrenheit)

    // 华氏度转摄氏度
    fahrenheit2 := 77.0
    celsius2 := (fahrenheit2 - 32) * 5 / 9

    fmt.Printf("%.1f°F = %.1f°C\n", fahrenheit2, celsius2)
}

示例3：常量应用

package main

import "fmt"

const (
    // 定义一周的天数
    DaysPerWeek = 7

    // 定义文件大小单位
    KB = 1024
    MB = 1024 * KB
    GB = 1024 * MB
)

func main() {
    weeks := 4
    totalDays := weeks * DaysPerWeek
    fmt.Printf("%d周共有%d天\n", weeks, totalDays)

    fileSize := 2.5 * GB
    fmt.Printf("文件大小: %.2f GB = %.0f 字节\n", 2.5, fileSize)
}

最佳实践：

在函数内优先使用短变量声明 :=
包级别变量使用 var 关键字
常量名使用大驼峰命名（如 MaxSize）
变量名使用小驼峰命名（如 userName）
避免使用单字母变量名（除了循环计数器）

实践练习

声明不同类型的变量，并打印它们的零值
编写程序，计算圆的面积和周长（使用常量Pi）
使用iota定义一组HTTP状态码常量
编写程序，将整数转换为不同进制的字符串
创建一个简单的计算器，实现加减乘除运算
编写程序，交换两个变量的值（使用指针）
实现一个货币转换器（人民币、美元、欧元）
编写程序，计算并输出不同数据类型的大小（使用unsafe.Sizeof）

常见错误：

短变量声明 := 只能在函数内使用
变量声明后必须使用，否则编译错误
常量不能使用 := 声明
类型转换必须显式进行，不支持隐式转换

← 上一课下一课 →