Go语言入门05：基础数据类型全解

一、前言（本篇学习目标）

上一篇我们彻底掌握了变量、常量、命名规范、作用域，知道了如何在Go中定义数据容器。本篇我们深入学习Go所有基础数据类型。

变量是“盒子”，数据类型就是“盒子的规格”，决定盒子能装什么数据、占用多少内存、能做什么运算。

Go是强类型语言，类型约束极其严格，类型不匹配直接编译报错。掌握数据类型是写出规范、无报错代码的核心地基。

读完本篇你将彻底掌握：

1. 四大基础数据类型：整型、浮点型、布尔型、字符串完整用法

2. 不同整型的内存占用、取值范围、业务选型规则

3. 浮点精度丢失底层原因与解决方案

4. 字符串底层特性、不可变性、常用操作

5. Go强制类型转换规则、新手高频坑点

全篇实战代码落地，所有知识点配套可运行案例，零基础轻松吃透。

二、Go数据类型整体分类

Go语言数据类型分为两大类，本篇只讲解基础数据类型，复合类型后续单独精讲：

1. 基础数据类型（本篇核心）

• 整型（整数）

• 浮点型（小数）

• 布尔型（真假）

• 字符串型（文本）

2. 复合数据类型（后续连载）

数组、切片、Map、结构体、接口、通道等

三、整型（整数类型）最全详解

整型用于存储正负整数、0，是程序中使用频率最高的类型。Go针对不同内存场景提供了多种整型，精细化控制内存占用。

1. 整型分类与取值范围

整型分为 有符号整型（可正可负） 和 无符号整型（只非负）。

2. 企业选型规范（必记）

• 日常业务开发：统一使用 int，无需手动指定位数，适配性最强

• 内存极致优化、协议解析、底层开发：精准使用 int8/uint8/int32

• 时间戳、超大数值：强制使用 int64，防止溢出

• byte 是 uint8 的别名，专门用于处理字节、文件、网络数据

3. 整型实战代码

package main

import "fmt"

func main() {
	// 日常开发最常用通用整型
	var age int = 25

	// 64位大整型，用于存储大数、时间戳
	var num int64 = 16888888888

	// 无符号整型，只存正数
	var count uint8 = 100

	fmt.Println("age =", age)
	fmt.Println("超大数 =", num)
	fmt.Println("数量 =", count)
}

四、浮点型（小数类型）与精度坑点

浮点型用于存储小数、精度数值，例如价格、坐标、权重等。

1. 浮点类型介绍

• float32：单精度浮点，4字节，精度约6位小数

• float64：双精度浮点，8字节，精度约15位小数，企业开发首选

2. 浮点精度丢失（新手最大坑）

计算机二进制无法精准表示部分十进制小数，会出现精度丢失，所有语言通用问题。

package main

import "fmt"

func main() {
	var a float64 = 0.1
	var b float64 = 0.2
	fmt.Println("0.1 + 0.2 =", a+b)
}

输出结果：0.30000000000000004

避坑方案：

• 金融、金额计算禁止使用float，必须使用 decimal 高精度库

• 普通展示类小数，可保留固定位数四舍五入

五、布尔类型 bool

布尔类型只有两个值：true（真）、false（假），主要用于判断条件、状态开关。

1. 核心特性

• 默认零值：false

• 不支持 0/1 替代真假，严格独立类型（和C/Java不同）

• 无法和数字相互转换，强类型严格限制

package main

import "fmt"

func main() {
	// 布尔类型默认零值为 false
	var flag bool
	fmt.Println("布尔默认零值：", flag)

	// 布尔仅支持 true / false 两个值
	isOk := true
	if isOk {
		fmt.Println("条件成立，执行逻辑")
	}

	// 演示布尔类型不兼容数字（Go硬性规则，对比Java/C）
	var num int = 1
	// if num { // 报错：不能直接用数字代替布尔值判断
	// 	fmt.Println("数字为真")
	// }
}

六、字符串类型 string（高频核心）

字符串是Go开发中使用频率最高的类型，用于存储文本、账号密码、接口参数、日志信息等。

1. 字符串核心特性

• 默认零值：空字符串 ""，不是nil

• 不可变性：字符串一旦定义，内容无法修改

• 底层是字节数组，支持索引取值、切片截取

2. 字符串两种定义方式

• 双引号 ""：普通字符串，支持转义字符 \n \t \r

• 反引号 ``：原生字符串，原样输出，保留换行、空格、特殊符号，适合多行文本、JSON、SQL

package main

import "fmt"

func main() {
	// 普通字符串，支持转义字符
	str1 := "Hello Go\n你好Go"

	// 原生反引号字符串：原样输出，保留换行，不转义
	// 修正：去除多余缩进，输出格式工整
	str2 := `{
    "name": "Go教程",
    "author": "零基础入门"
}`

	fmt.Println(str1)
	fmt.Println(str2)
}

3. 字符串简单拼接

package main

import "fmt"

func main() {
	name := "Go语言"
	msg := name + " 零基础入门教程"
	fmt.Println(msg)
}

七、Go类型转换（强类型核心规则）

Go语言不支持隐式类型转换，不同类型之间赋值、运算必须手动强制转换，这是新手报错最多的点。

1. 语法格式

目标类型(变量)

2. 数值类型互转实战

package main

import "fmt"

func main() {
	// int 强制转 float64
	var a int = 10
	var b float64 = float64(a)

	// float64 强制转 int（截断小数，不四舍五入）
	var c float64 = 3.99
	var d int = int(c)

	fmt.Println("int转float64结果：", b)
	fmt.Println("float64转int结果：", d)
}

重点规则：浮点转整型，直接截断小数，不会四舍五入，容易丢失精度，业务需慎用。

3. 全类型互相转换实战（新增完整版）

前面只演示了基础数值转换，这里补齐整型、浮点、字符串、布尔常见跨类型转换实战，修正新手所有转换误区。

核心前置结论：

• 数值 <> 数值：支持直接强制转换

• 数值 <> 字符串：不支持强制转换，必须用 strconv 标准库

• 数值、字符串 不能与 bool 互转，Go语法严格禁止

① 整型 <=> 浮点型（互转完整版）

package main

import "fmt"

func main() {
	// 整型 → 浮点型（无损转换）
	var numInt int = 66
	numFloat := float64(numInt)
	fmt.Println("int转float64：", numFloat)

	// 浮点型 → 整型（截断小数，精度丢失）
	var price float64 = 99.99
	priceInt := int(price)
	fmt.Println("float64转int：", priceInt)
}

② 数字 <=> 字符串（strconv 标准库正确写法）

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// ========== 1. 整型 <=> 字符串 ==========
	// 整型转字符串
	var age int = 20
	ageStr := strconv.Itoa(age)
	fmt.Printf("整型转字符串：%s | 变量类型：%T\n", ageStr, ageStr)

	// 字符串转整型（规范写法：必须捕获错误）
	intStr := "88"
	num, err := strconv.Atoi(intStr)
	if err != nil {
		fmt.Println("字符串转整型失败：", err)
		return
	}
	fmt.Printf("字符串转整型：%d | 变量类型：%T\n", num, num)

	// ========== 2. 浮点型 <=> 字符串（新增补齐） ==========
	// 浮点转字符串
	floatVal := 3.1415
	floatStr := strconv.FormatFloat(floatVal, 'f', 2, 64)
	fmt.Printf("浮点转字符串：%s | 变量类型：%T\n", floatStr, floatStr)

	// 字符串转浮点
	parseFloatStr := "99.99"
	floatNum, err := strconv.ParseFloat(parseFloatStr, 64)
	if err != nil {
		fmt.Println("字符串转浮点失败：", err)
		return
	}
	fmt.Printf("字符串转浮点：%f | 变量类型：%T\n", floatNum, floatNum)
}

③ 错误写法汇总（新手必避坑）

package main

import "fmt"

func main() {
	// ========== 以下全部为【非法代码】取消注释直接编译报错 ==========
	
	// 错误1：int 不能强转 string
	// var a int = 10
	// var b string = string(a)

	// 错误2：数值不能强转 bool
	// var flag bool = bool(1)

	// 错误3：字符串不能强转 bool
	// var flag2 bool = bool("true")
}

④ 字符串转数字完整知识点总结

1. strconv.Atoi：字符串转整型，日常数字字符串转换首选；
2. strconv.ParseFloat：字符串转浮点型，用于小数字、精度数值转换；
3. 所有字符串转数字操作必须接收 error，防止传入空字符串、字母、特殊符号导致程序 panic；
4. 不存在 string(bool)、bool(string) 转换，布尔类型仅用于逻辑判断。

八、新手高频坑点与避坑总结

• ❌ 混用不同位数整型：int 和 int64 不互通，必须手动转换

• ❌ 浮点运算做金额判断：精度丢失导致判断异常

• ❌ 把0/1当作布尔值使用：Go严格禁止，bool是独立类型

• ❌ 尝试修改字符串某个字符：字符串不可变，修改必须转切片

• ❌ 强行转换数字/字符串与布尔：Go无兼容逻辑，直接编译报错

九、本篇总结

1. 整型分多档位，日常开发优先使用 int，大数用 int64，字节数据用 byte；

2. 浮点型存在精度丢失，金融业务严禁使用 float；

3. bool 类型只有 true/false，不兼容数字，零值为 false；

4. 字符串支持双引号与反引号，内容不可变，是最常用的文本类型；

5. Go无隐式类型转换，不同类型必须手动强制转换，严格遵循强类型规范。

十、下期预告

下一篇我们精讲 Go流程控制：if-else、for循环、switch分支、goto使用规范与实战案例，彻底搞定Go全部逻辑判断语法！