基本数据类型 #

一、类型概述 #

Go的基本数据类型:

分类 类型
布尔型 bool
整数型 int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr
浮点型 float32, float64
复数型 complex64, complex128
字符串 string
字符 byte, rune

二、布尔类型 #

2.1 基本用法 #

go
var isActive bool = true
var isEnabled bool = false

isReady := true

2.2 特点 #

  • 只有两个值:truefalse
  • 零值是false
  • 不能转换为整数
go
var b bool      // false
var i int = 1
b = bool(i)     // 错误:不能转换

2.3 使用场景 #

go
if isActive {
    fmt.Println("已激活")
}

isAdult := age >= 18

三、整数类型 #

3.1 有符号整数 #

类型 大小 范围
int8 1字节 -128 ~ 127
int16 2字节 -32768 ~ 32767
int32 4字节 -2147483648 ~ 2147483647
int64 8字节 -9223372036854775808 ~ 9223372036854775807
int 平台相关 32位系统为int32,64位为int64

3.2 无符号整数 #

类型 大小 范围
uint8 1字节 0 ~ 255
uint16 2字节 0 ~ 65535
uint32 4字节 0 ~ 4294967295
uint64 8字节 0 ~ 18446744073709551615
uint 平台相关 32位系统为uint32,64位为uint64
uintptr 平台相关 用于指针运算

3.3 特殊类型 #

byteuint8的别名

go
var b byte = 255
fmt.Printf("%T\n", b)  // uint8

runeint32的别名,表示Unicode码点

go
var r rune = '中'
fmt.Printf("%T\n", r)  // int32

3.4 整数运算 #

go
a := 10
b := 3

fmt.Println(a + b)   // 13 加
fmt.Println(a - b)   // 7  减
fmt.Println(a * b)   // 30 乘
fmt.Println(a / b)   // 3  除(整数除法)
fmt.Println(a % b)   // 1  取余

3.5 溢出处理 #

整数溢出会回绕:

go
var a int8 = 127
a++  // -128(溢出)

检查溢出:

go
func safeAdd(a, b int) (int, bool) {
    if b > 0 && a > math.MaxInt-b {
        return 0, false
    }
    if b < 0 && a < math.MinInt-b {
        return 0, false
    }
    return a + b, true
}

四、浮点类型 #

4.1 类型说明 #

类型 大小 精度
float32 4字节 约6位小数
float64 8字节 约15位小数

4.2 基本用法 #

go
var f1 float32 = 3.14
var f2 float64 = 3.141592653589793

f3 := 3.14  // 默认float64

4.3 科学计数法 #

go
f1 := 1.23e10    // 1.23 × 10^10
f2 := 1.23E-10   // 1.23 × 10^-10

4.4 特殊值 #

go
var inf = math.Inf(1)     // 正无穷
var neginf = math.Inf(-1) // 负无穷
var nan = math.NaN()      // 非数

fmt.Println(math.IsInf(inf, 1))  // true
fmt.Println(math.IsNaN(nan))     // true

4.5 浮点运算注意事项 #

go
f1 := 0.1
f2 := 0.2
fmt.Println(f1 + f2)  // 0.30000000000000004

// 比较浮点数
func equal(a, b float64) bool {
    return math.Abs(a-b) < 1e-9
}

五、复数类型 #

5.1 类型说明 #

类型 大小
complex64 8字节(float32实部和虚部)
complex128 16字节(float64实部和虚部)

5.2 基本用法 #

go
var c1 complex64 = 1 + 2i
var c2 complex128 = 3 + 4i

c3 := 1 + 2i  // 默认complex128

5.3 操作函数 #

go
c := 3 + 4i

fmt.Println(real(c))  // 3 实部
fmt.Println(imag(c))  // 4 虚部
fmt.Println(cmplx.Abs(c))  // 5 模

六、字符串类型 #

6.1 基本用法 #

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

var s3 string  // 零值:空字符串

6.2 字符串特点 #

  • 不可变:创建后不能修改
  • UTF-8编码
  • 双引号定义
go
s := "Hello"
s[0] = 'h'  // 错误:字符串不可变

6.3 原始字符串 #

使用反引号,支持换行和转义:

go
s := `Hello
World
"引号"`

fmt.Println(s)
// Hello
// World
// "引号"

6.4 字符串长度 #

go
s := "Hello"
fmt.Println(len(s))  // 5

s2 := "世界"
fmt.Println(len(s2))           // 6(字节数)
fmt.Println(utf8.RuneCountInString(s2))  // 2(字符数)

6.5 字符串遍历 #

按字节遍历:

go
s := "世界"
for i := 0; i < len(s); i++ {
    fmt.Printf("%d: %x\n", i, s[i])
}

按rune遍历:

go
s := "世界"
for i, r := range s {
    fmt.Printf("%d: %c\n", i, r)
}

七、字符类型 #

7.1 byte #

uint8别名,表示ASCII字符:

go
var b byte = 'A'
fmt.Printf("%c\n", b)  // A
fmt.Printf("%d\n", b)  // 65

7.2 rune #

int32别名,表示Unicode码点:

go
var r rune = '中'
fmt.Printf("%c\n", r)  // 中
fmt.Printf("%U\n", r)  // U+4E2D

7.3 字符与字符串 #

go
s := "Hello"
for _, r := range s {
    fmt.Printf("%c ", r)  // H e l l o
}

s2 := "世界"
for _, r := range s2 {
    fmt.Printf("%c ", r)  // 世 界
}

八、类型大小 #

8.1 查看类型大小 #

go
import "unsafe"

fmt.Println(unsafe.Sizeof(int(0)))      // 8(64位系统)
fmt.Println(unsafe.Sizeof(float64(0)))  // 8
fmt.Println(unsafe.Sizeof(bool(false))) // 1
fmt.Println(unsafe.Sizeof(""))          // 16(字符串头)

8.2 类型范围 #

go
import "math"

fmt.Println(math.MaxInt8)    // 127
fmt.Println(math.MinInt8)    // -128
fmt.Println(math.MaxInt64)   // 9223372036854775807
fmt.Println(math.MaxFloat64) // 1.7976931348623157e+308

九、类型选择建议 #

9.1 整数 #

  • 一般情况使用int
  • 需要明确大小时使用int64
  • 位运算使用无符号类型

9.2 浮点数 #

  • 优先使用float64
  • float32精度可能不足

9.3 字符串 #

  • 默认UTF-8编码
  • 多行文本使用反引号

十、总结 #

基本数据类型要点:

类型 说明 零值
bool 布尔值 false
int, uint 整数 0
float64 浮点数 0.0
complex128 复数 0+0i
string 字符串 “”
byte uint8别名 0
rune int32别名 0

关键点:

  1. 整数:有符号和无符号系列
  2. 浮点:注意精度问题
  3. 字符串:不可变,UTF-8编码
  4. rune:处理Unicode字符

准备好学习类型转换了吗?让我们进入下一章!

最后更新:2026-03-26