Go 语言数据类型：变量、常量与基础类型

本文将深入讲解 Go 语言的变量声明、基础数据类型、常量的使用，以及字符串操作等核心概念，帮助你掌握 Go 语言的基础语法。

变量声明

变量是程序中用于存储数据的容器。在 Go 语言中，变量必须先声明后使用，且声明后必须使用，否则编译会报错。

基本声明方式

完整声明格式：

var 变量名 类型 = 初始值

示例：

var name string = "飞雪无情"
var age int = 25
var score float64 = 98.5

类型推导

Go 编译器可以根据初始值自动推断变量类型，省略类型声明：

var name = "飞雪无情"    // 推导为 string
var age = 25            // 推导为 int
var score = 98.5        // 推导为 float64

简短声明（推荐）

在函数内部，使用 := 符号可以更简洁地声明变量：

name := "飞雪无情"
age := 25
score := 98.5

注意： := 只能在函数内部使用，不能用于包级别的变量声明。

批量声明

多个变量可以一起声明：

// 方式一：使用 var 块
var (
    name  string = "飞雪无情"
    age   int    = 25
    score float64 = 98.5
)

// 方式二：简短声明批量
name, age, score := "飞雪无情", 25, 98.5

变量零值

如果只声明变量而不赋值，Go 会自动赋予该类型的"零值"：

类型	零值
数值类型 (int, float)	0
布尔类型	false
字符串	""（空字符串）
指针、slice、map、channel	nil

var i int       // i = 0
var s string    // s = ""
var b bool      // b = false

基础数据类型

整型

Go 提供多种整数类型，根据是否带符号和占用位数区分：

有符号整型（可表示负数）：

类型	位数	取值范围
int8	8位	-128 ~ 127
int16	16位	-32768 ~ 32767
int32	32位	约 -21亿 ~ 21亿
int64	64位	约 -922京 ~ 922京
int	32或64位	取决于平台

无符号整型（只表示非负数）：

类型	位数	取值范围
uint8	8位	0 ~ 255
uint16	16位	0 ~ 65535
uint32	32位	0 ~ 约 43亿
uint64	64位	0 ~ 约 1844京
uint	32或64位	取决于平台

特殊整型：

byte：uint8 的别名，用于表示字节
rune：int32 的别名，用于表示 Unicode 码点

使用建议：

一般情况使用 int，简单且足够
需要明确大小时使用 int32/int64
处理字节数据时使用 byte
处理 Unicode 字符时使用 rune

浮点型

用于表示小数，有两种精度：

类型	精度	说明
float32	单精度	约 6-7 位有效数字
float64	双精度	约 15-16 位有效数字（推荐）

var f1 float32 = 3.14159
var f2 float64 = 3.141592653589793

// 简短声明
pi := 3.14159  // 默认为 float64

注意： 由于浮点数的精度问题，不建议直接用 == 比较两个浮点数是否相等。

布尔型

布尔类型只有两种值：true 和 false。

var isActive bool = true
var isDeleted bool = false

// 逻辑运算
result := isActive && \!isDeleted  // true

逻辑运算符：

\!：逻辑非（取反）
&&：逻辑与（两边都为 true 才为 true）
||：逻辑或（一边为 true 就为 true）

字符串

Go 的字符串是不可变的字节序列，使用 UTF-8 编码。

var s1 string = "Hello"
var s2 string = "世界"

// 字符串连接
s3 := s1 + ", " + s2  // "Hello, 世界"

// 使用 += 追加
s1 += " World"  // "Hello World"

字符串常用操作：

import "strings"

s := "Hello, 世界"

// 获取长度（字节数）
len(s)  // 13（中文占 3 字节）

// 判断前缀/后缀
strings.HasPrefix(s, "Hello")  // true
strings.HasSuffix(s, "世界")    // true

// 包含子串
strings.Contains(s, "世界")     // true

// 查找位置
strings.Index(s, "世界")        // 7

// 转换大小写
strings.ToUpper(s)   // "HELLO, 世界"
strings.ToLower(s)   // "hello, 世界"

// 分割字符串
strings.Split("a,b,c", ",")  // ["a", "b", "c"]

// 替换
strings.Replace(s, "世界", "Go", 1)  // "Hello, Go"

常量

常量是在编译期确定且不可修改的值。

声明常量

使用 const 关键字：

const Pi = 3.14159
const MaxConnections = 100
const AppName = "MyApp"

常量可以是字符、字符串、布尔值或数值类型。

批量声明常量

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

iota 枚举

iota 是 Go 提供的常量生成器，用于创建递增的枚举值：

const (
    Low = iota    // 0
    Medium        // 1
    High          // 2
    Critical      // 3
)

iota 的高级用法：

// 跳过某些值
const (
    A = iota      // 0
    _             // 跳过 1
    B             // 2
    C             // 3
)

// 使用表达式
const (
    KB = 1 << (10 * iota)  // 1 << 0 = 1
    MB                     // 1 << 10 = 1024
    GB                     // 1 << 20 = 1048576
    TB                     // 1 << 30 = 1073741824
)

类型转换

Go 是强类型语言，不同类型之间必须进行显式转换：

数值类型转换

var i int = 100
var f float64 = float64(i)    // int 转 float64
var u uint = uint(i)          // int 转 uint

var pi float64 = 3.14
var n int = int(pi)           // float64 转 int（小数部分截断）

字符串与数值转换

import "strconv"

// int 转 string
s := strconv.Itoa(123)        // "123"

// string 转 int
i, err := strconv.Atoi("123") // 123, nil

// float 转 string
s = strconv.FormatFloat(3.14, 'f', 2, 64)  // "3.14"

// string 转 float
f, err := strconv.ParseFloat("3.14", 64)   // 3.14

指针简介

指针存储的是变量的内存地址。

var x int = 10
var p *int = &x  // p 指向 x 的地址

fmt.Println(p)   // 输出地址，如 0xc0000a6010
fmt.Println(*p)  // 解引用，输出 10

*p = 20          // 通过指针修改 x 的值
fmt.Println(x)   // 输出 20

综合示例

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func main() {
    // 变量声明
    name := "飞雪无情"
    age := 25
    score := 98.5
    isPassed := true

    // 输出信息
    fmt.Printf("姓名: %s\n", name)
    fmt.Printf("年龄: %d\n", age)
    fmt.Printf("成绩: %.1f\n", score)
    fmt.Printf("是否通过: %t\n", isPassed)

    // 字符串操作
    message := "Hello, " + name
    fmt.Println(message)
    fmt.Printf("长度: %d\n", len(message))
    fmt.Printf("包含 '飞雪': %t\n", strings.Contains(message, "飞雪"))

    // 类型转换
    scoreStr := strconv.FormatFloat(score, 'f', 1, 64)
    fmt.Printf("成绩字符串: %s\n", scoreStr)
}

总结

本文介绍了 Go 语言的基础语法：

概念	要点
变量声明	`var` 完整声明、`:=` 简短声明
整型	int、int8/16/32/64、uint、byte、rune
浮点型	float32、float64（推荐）
布尔型	true、false，支持 &&、\|\|、! 运算
字符串	不可变，支持 + 连接，strings 包提供丰富操作
常量	const 声明，iota 用于枚举
类型转换	必须显式转换，使用类型名作为函数

掌握这些基础知识后，你就可以编写简单的 Go 程序了。下节课将介绍 Go 语言的控制流程语句。