Go语言基本数据类型

Go语言是一种静态强类型语言，其数据类型分为基本类型和复合类型。基本类型是构建程序的基础，包括布尔型、数字类型、字符串类型。本章将详细讲解每种基本类型的特点、取值范围、字面量表示以及类型转换规则。

布尔型（bool）

布尔值只有两个常量：true 和 false。通常用于条件判断。布尔型占1个字节。

package main

import "fmt"

func main() {
    var flag bool = true
    var isReady bool   // 零值为 false

    // 逻辑运算符
    a := true
    b := false
    fmt.Println(a && b)  // false
    fmt.Println(a || b)  // true
    fmt.Println(!a)      // false

    // 条件表达式的布尔结果
    x := 10
    fmt.Println(x > 5)   // true
}

数字类型

Go的数字类型分为整数、浮点数和复数三大类，每类又按位宽细分，提供了精确的内存控制。

2.1 整数（有符号/无符号）

var a int = 100
var b int8 = 100
var c uint16 = 65535
// 不同类型不能直接相加减，需要显式转换
// sum := a + b  // 编译错误

2.2 浮点型

Go提供两种浮点类型：float32（约6位小数精度）和float64（约15位小数精度）。推荐使用 float64 作为默认浮点类型。

var pi float64 = 3.141592653589793
var e float32 = 2.71828
// 科学计数法
var avogadro = 6.022e23

2.3 复数

Go原生支持复数，有 complex64（由两个float32构成）和 complex128（由两个float64构成）。

var c1 complex64 = 1 + 2i
c2 := 3 + 4i   // complex128 类型
realPart := real(c2)
imagPart := imag(c2)
fmt.Printf("实部: %f, 虚部: %f\n", realPart, imagPart)

2.4 整数与浮点字面量增强（Go 1.13+）

支持二进制、八进制、十六进制及数字分隔符，提高可读性。

二进制 := 0b1010        // 10
八进制 := 0o12          // 10
十六进制 := 0x0A        // 10
带下划线 := 1_000_000    // 100万
浮点分隔 := 3.1415_9265

字符串（string）

Go中的字符串是一个只读的字节切片，底层使用UTF-8编码。字符串可以包含任意字节，但通常用于存储文本。

字符串声明与操作

s1 := "Hello, 世界"          // 双引号字符串
s2 := `原始字符串\n无转义`      // 反引号字符串（不解析转义，可换行）
fmt.Println(len(s1))        // 输出字节数（非字符数）
// 索引访问得到字节（byte）
fmt.Println(s1[0])          // 72 ('H')

// 遍历字符（按rune）
for i, ch := range s1 {
    fmt.Printf("%d: %c\n", i, ch)
}

// 字符串拼接
greeting := "Hello, " + "Go"
// 高效拼接（使用 strings.Builder）
var builder strings.Builder
builder.WriteString("Hello")
builder.WriteString(" World")
result := builder.String()

byte 与 rune

byte 是 uint8 的别名，表示ASCII码或二进制字节；rune 是 int32 的别名，表示一个Unicode码点（通常为一个字符）。

var ch byte = 'A'           // ASCII
var r rune = '中'            // Unicode 码点
fmt.Printf("字节: %c, 码点: %U\n", ch, r)

// 字符串与 rune 切片转换
str := "Go语言"
runes := []rune(str)        // 转换为字符切片
fmt.Println(len(runes))     // 4（G, o, 语, 言）
firstChar := string(runes[2]) // "语"

类型转换

Go要求显式类型转换，语法为 T(表达式)，其中 T 是目标类型。转换必须在兼容类型之间进行（如整型和浮点型）。

var i int = 42
var f float64 = float64(i)   // int -> float64
var u uint = uint(f)         // float64 -> uint
pi := 3.14
var intPi int = int(pi)      // 截断小数部分，intPi = 3

// 字符串与数字转换需使用 strconv 包
import "strconv"
num, err := strconv.Atoi("123")
str := strconv.Itoa(456)
floatNum, _ := strconv.ParseFloat("3.1415", 64)

零值机制

所有基本类型在被声明但未显式初始化时，都会被赋予默认的零值。

类型	零值
bool	false
数值类型	0
string	""（空字符串）

var a bool       // false
var b int        // 0
var c float64    // 0.0
var d string     // ""
fmt.Println(a, b, c, d == "")  // true

类型别名与自定义类型

Go允许通过 type MyInt int 创建新的类型（不是别名），新类型与原始类型不同，不能直接进行算术运算或赋值，需显式转换。

type MyInt int
var x MyInt = 10
var y int = 20
// result := x + y   // 编译错误
result := int(x) + y // 正确

综合示例：数据类型实战

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 布尔
    enabled := true

    // 整数
    var age uint8 = 30
    var score int = 98

    // 浮点
    gpa := 3.75

    // 复数
    c := 2 + 3i
    fmt.Printf("复数: %.1f+%.1fi\n", real(c), imag(c))

    // 字符串与rune
    name := "张伟"
    fmt.Printf("姓名: %s (字节长度 %d, 字符数 %d)\n", name, len(name), len([]rune(name)))

    // 类型转换
    total := float64(score) + gpa
    fmt.Printf("总分: %.2f\n", total)

    // 零值
    var defaultValue string
    fmt.Printf("空字符串零值: '%s'\n", defaultValue)

    // 数字字面量增强
    binary := 0b1010
    fmt.Printf("二进制 0b1010 = %d\n", binary)

    // 类型转换字符串
    intStr := strconv.Itoa(age)
    fmt.Println("年龄字符串: " + intStr)

    fmt.Println("Go环境已就绪，类型系统严谨高效！")
}

运行输出：