GO数据类型

一、基本数据类型

 

package main

import "fmt"

func main() {
    // 布尔类型
    var flag bool = true
    
    // 整数类型
    var i int = 10          // 根据系统32或64位
    var i8 int8 = 127       // -128 ~ 127
    var i16 int16 = 1000
    var i32 int32 = 100000
    var i64 int64 = 1000000000
    
    var u uint = 10         // 无符号整数
    var u8 uint8 = 255      // 0 ~ 255
    
    // 浮点数
    var f32 float32 = 3.14
    var f64 float64 = 3.1415926535
    
    // 字符串
    var str string = "Hello Go"
    
    // 字节和rune
    var b byte = 'a'        // byte是uint8的别名
    var r rune = '中'        // rune是int32的别名，用于Unicode
    
    fmt.Printf("flag=%v, i=%d, f64=%f, str=%s\n", flag, i, f64, str)
}

 

我来逐行详细解释这段Go语言数据类型的代码：

📦 包声明和导入

package main              // 声明为可执行程序的main包
import "fmt"             // 导入fmt包，提供格式化输入输出功能
func main() {            // 程序入口函数

✅ 布尔类型 (bool)

 // 布尔类型
    var flag bool = true    // var关键字声明变量，变量名flag，类型bool，值true
                            // bool类型只有两个值：true(真) 或 false(假)
                            // 通常用于条件判断、循环控制等

🔢 有符号整数类型

 // 整数类型
    var i int = 10          // int类型，大小取决于操作系统
                            // 32位系统：4字节(-2^31~2^31-1)
                            // 64位系统：8字节(-2^63~2^63-1)
    
    var i8 int8 = 127       // int8：1字节有符号整数，范围：-128 ~ 127
                            // 127是int8能表示的最大正整数
    
    var i16 int16 = 1000    // int16：2字节有符号整数，范围：-32768 ~ 32767
                            // 1000在有效范围内
    
    var i32 int32 = 100000  // int32：4字节有符号整数，范围：-21亿 ~ 21亿
                            // 100000在有效范围内
    
    var i64 int64 = 1000000000  // int64：8字节有符号整数
                                // 范围：-9.2e18 ~ 9.2e18
                                // 10亿在有效范围内

🔢 无符号整数类型

 var u uint = 10         // uint类型，大小取决于操作系统
                            // 只能表示非负数：0 ~ 2^n-1
    
    var u8 uint8 = 255      // uint8：1字节无符号整数，范围：0 ~ 255
                            // 255是最大值（2^8-1）
                            // 常用于RGB颜色值(0-255)

💫 浮点数类型

 // 浮点数
    var f32 float32 = 3.14          // float32：32位浮点数（单精度）
                                    // 精度约6-7位小数，范围 ±1.18e-38 ~ ±3.4e38
                                    // 3.14可以用float32精确表示
    
    var f64 float64 = 3.1415926535  // float64：64位浮点数（双精度）
                                    // 精度约15-16位小数，范围 ±2.23e-308 ~ ±1.8e308
                                    // 默认浮点数类型，精度更高

📝 字符串类型

 // 字符串
    var str string = "Hello Go"     // string类型，双引号包裹
                                    // UTF-8编码，支持中文
                                    // 不可变类型，内容不能修改

🔤 字节和符文类型

 // 字节和rune
    var b byte = 'a'        // byte = uint8的别名（1字节）
                            // 用单引号表示字符，存储ASCII字符
                            // 'a'的ASCII码是97
    
    var r rune = '中'       // rune = int32的别名（4字节）
                            // 用于表示Unicode字符（包括中文、emoji等）
                            // 一个中文字符占3个UTF-8字节，但rune类型用4字节表示

🖨️ 格式化输出

 fmt.Printf("flag=%v, i=%d, f64=%f, str=%s\n", flag, i, f64, str)
    // fmt.Printf：格式化打印函数
    // %v：通用格式，根据变量自动选择格式
    // %d：十进制整数格式
    // %f：浮点数格式
    // %s：字符串格式
    // \n：换行符
    // 输出示例：flag=true, i=10, f64=3.141593, str=Hello Go

📊 数据类型对比表

类型	大小	范围	别名	常用场景
bool	1字节	true/false	-	条件判断
int	4/8字节	平台相关	-	通用整数
int8	1字节	-128~127	byte(有符号)	小整数
uint8	1字节	0~255	byte	字节数据、颜色值
int32	4字节	-21亿~21亿	rune	Unicode字符
float64	8字节	15位精度	-	科学计算
string	16字节头	任意长度	-	文本处理

💡 重要知识点

1. 零值机制：未初始化的变量有默认值（bool→false，数字→0，string→""）

2. 类型转换：Go要求显式转换，不能自动转换

var x int = 10
var y float64 = float64(x)  // 必须显式转换

1. 字符和字符串区别：

   • 单引号 ''：字符（byte/rune）

   • 双引号 ""：字符串

2. 中文字符处理：

s := "Go语言"
fmt.Println(len(s))           // 8 (Go占2字节，语言占6字节)
fmt.Println(len([]rune(s)))   // 4 (转为rune数组后)

二、类型转换

package main

import "fmt"

func main() {
    var i int = 100
    var f float64 = float64(i)    // int转float64
    var u uint = uint(i)           // int转uint
    
    var s string = "123"
    // string转int需要使用strconv包
    // import "strconv"
    // num, _ := strconv.Atoi(s)
    
    fmt.Printf("i=%d, f=%f, u=%d\n", i, f, u)
}

 

📦 包声明和导入

package main              // 声明为可执行程序的main包
import "fmt"             // 导入fmt包，提供格式化输入输出功能
func main() {            // 程序入口函数

🔄 基本类型转换（显式转换）

var i int = 100       // 声明一个int类型变量i，初始值为100
                          // int类型根据系统是32位或64位

int → float64 转换  

 var f float64 = float64(i)    // 类型转换语法：类型(变量)
                                  // 将int类型的i转换为float64类型
                                  // 100变成100.0（浮点数形式）
                                  // 这是显式转换，Go不允许隐式转换

int → uint 转换  

 var u uint = uint(i)           // 将int类型的i转换为uint（无符号整数）类型
                                   // 100变成100（但类型变为无符号）
                                   // 注意：如果i是负数，转换会得到很大的正数（溢出）

📝 字符串转换（注释部分）

var s string = "123"           // 声明字符串变量s，值为"123"
                                   // 注意：这是字符串，不是数字123
    
    // string转int需要使用strconv包
    // import "strconv"             // strconv包提供字符串和基本类型之间的转换
    // num, _ := strconv.Atoi(s)    // Atoi = ASCII to Integer
                                   // 将字符串"123"转换为整数123
                                   // 返回两个值：转换结果 和 错误信息
                                   // _ 表示忽略错误信息（不推荐，生产环境应处理错误）

🖨️ 格式化输出 

fmt.Printf("i=%d, f=%f, u=%d\n", i, f, u)
    // fmt.Printf：格式化打印函数
    // %d：十进制整数格式，用于int和uint类型
    // %f：浮点数格式，默认6位小数
    // \n：换行符
    // 输出结果：i=100, f=100.000000, u=100

📊 完整代码运行结果

i=100, f=100.000000, u=100

💡 类型转换的重要规则

1. Go要求显式转换

// ❌ 错误：Go不允许隐式类型转换
var i int = 100
var f float64 = i  // 编译错误：cannot use i (type int) as type float64
​
// ✅ 正确：必须显式转换
var f float64 = float64(i)

2. 转换可能丢失精度或溢出

var i int = 1000
var i8 int8 = int8(i)     // 1000转int8会溢出
                          // int8范围：-128~127
                          // 结果：-24（取低8位的补码）

var f float64 = 3.14159
var i int = int(f)        // 浮点转整数，小数部分被截断
                          // 结果：3（不是四舍五入）

3. 正确的字符串转换方法

package main
​
import (
    "fmt"
    "strconv"  // 必须导入strconv包
)
​
func main() {
    // 字符串 → 整数
    s1 := "123"
    num1, err := strconv.Atoi(s1)  // ASCII to Integer
    if err == nil {
        fmt.Println(num1)  // 123
    }
    
    // 字符串 → 整数（进制转换）
    s2 := "FF"
    num2, _ := strconv.ParseInt(s2, 16, 64)  // 16进制转64位整数
    fmt.Println(num2)  // 255
    
    // 整数 → 字符串
    num3 := 456
    s3 := strconv.Itoa(num3)  // Integer to ASCII
    fmt.Println(s3)  // "456"
    
    // 浮点数 → 字符串
    f := 3.14159
    s4 := strconv.FormatFloat(f, 'f', 2, 64)  // 保留2位小数
    fmt.Println(s4)  // "3.14"
}

🔧 常见类型转换速查表

从 → 到	方法	示例
int → float64	float64(i)	float64(10) → 10.0
float64 → int	int(f)	int(3.14) → 3（截断）
int → string	strconv.Itoa(i)	strconv.Itoa(65) → "65"
string → int	strconv.Atoi(s)	strconv.Atoi("123") → 123
int64 → string	strconv.FormatInt(i, 10)	FormatInt(100, 10) → "100"
string → float64	strconv.ParseFloat(s, 64)	ParseFloat("3.14", 64) → 3.14
byte → string	string(b)	string('A') → "A"

⚠️ 注意事项

1. bool类型不能转换为数字：bool和int之间不能直接转换

2. string和数字转换必须用strconv包

3. 转换溢出不会报错，但会产生意外结果

4. 浮点转整数是截断，不是四舍五入

 

三、字符串操作

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Hello, World!"
    
    // 字符串长度
    fmt.Println(len(str))
    
    // 字符串拼接
    str2 := str + " Go!"
    fmt.Println(str2)
    
    // 包含判断
    fmt.Println(strings.Contains(str, "Hello"))
    
    // 分割
    parts := strings.Split(str, ", ")
    fmt.Println(parts)
    
    // 替换
    newStr := strings.Replace(str, "World", "Go", 1)
    fmt.Println(newStr)
    
    // 子串
    fmt.Println(str[0:5])  // Hello
}

 

📦 包声明和导入

package main              // 声明为可执行程序的main包
​
import (                  // 导入多个包使用括号分组
    "fmt"                // 提供格式化输入输出功能
    "strings"            // 提供字符串操作函数（包含、分割、替换等）
)
​
func main() {            // 程序入口函数

📝 字符串基础操作

1. 字符串声明和长度

 str := "Hello, World!"     // 使用短变量声明创建字符串
                               // := 会自动推断类型为string
                               // 字符串内容：Hello, World!
    
    // 字符串长度
    fmt.Println(len(str))      // len()函数返回字符串的字节数
                               // 输出：13
                               // 注意：len()返回的是字节数，不是字符数
                               // 英文字符占1字节，中文字符占3字节

2. 字符串拼接 

// 字符串拼接
    str2 := str + " Go!"       // 使用+运算符连接两个字符串
                               // str = "Hello, World!"
                               // " Go!" 是待拼接的字符串
                               // 结果："Hello, World! Go!"
    fmt.Println(str2)          // 打印拼接结果
                               // 输出：Hello, World! Go!

3. 字符串包含判断  

 // 包含判断
    fmt.Println(strings.Contains(str, "Hello"))
    // strings.Contains()：检查字符串是否包含子串
    // 参数1：被搜索的字符串 "Hello, World!"
    // 参数2：要查找的子串 "Hello"
    // 返回值：bool类型 true/false
    // 输出：true （因为确实包含"Hello"）

4. 字符串分割  

 // 分割
    parts := strings.Split(str, ", ")
    // strings.Split()：按分隔符分割字符串
    // 参数1：要分割的字符串 "Hello, World!"
    // 参数2：分隔符 ", " (逗号+空格)
    // 返回值：[]string 字符串切片（数组）
    // 分割结果：["Hello", "World!"]
    fmt.Println(parts)           // 打印分割后的切片
                                 // 输出：[Hello World!]

5. 字符串替换 

// 替换
    newStr := strings.Replace(str, "World", "Go", 1)
    // strings.Replace()：替换字符串中的子串
    // 参数1：原始字符串 "Hello, World!"
    // 参数2：要被替换的子串 "World"
    // 参数3：替换成的新子串 "Go"
    // 参数4：替换次数 1（只替换第一次出现）
    //        -1 表示替换所有出现
    // 返回值：替换后的新字符串
    // 结果："Hello, Go!"
    fmt.Println(newStr)          // 输出：Hello, Go!

6. 字符串切片（子串）

// 子串
    fmt.Println(str[0:5])        // 输出：Hello
    // str[0:5]：字符串切片操作
    // [起始索引:结束索引] 左闭右开区间
    // 0 是起始索引（包含），5 是结束索引（不包含）
    // 取索引0、1、2、3、4的字符：H e l l o
    // 注意：这是按字节索引，如果是中文字符会出问题

📊 运行结果

13
Hello, World! Go!
true
[Hello World!]
Hello, Go!
Hello

🔧 更多字符串操作示例

字符串遍历

str := "Hello"
// 方法1：按字节遍历
for i := 0; i < len(str); i++ {
    fmt.Printf("%c ", str[i])  // H e l l o
}

// 方法2：按字符遍历（支持中文）
for index, ch := range str {
    fmt.Printf("%d:%c ", index, ch)
}

常用strings包函数

str := "  Hello Go  "

fmt.Println(strings.TrimSpace(str))      // "Hello Go" 去除首尾空格
fmt.Println(strings.ToLower(str))        // "  hello go  " 转小写
fmt.Println(strings.ToUpper(str))        // "  HELLO GO  " 转大写
fmt.Println(strings.HasPrefix(str, "  H")) // true 是否有前缀
fmt.Println(strings.HasSuffix(str, "o  ")) // true 是否有后缀
fmt.Println(strings.Index(str, "Go"))      // 7 子串位置
fmt.Println(strings.LastIndex(str, "o"))   // 9 最后出现位置
fmt.Println(strings.Count(str, "o"))       // 2 计数子串出现次数
fmt.Println(strings.Repeat("Go", 3))       // "GoGoGo" 重复拼接

⚠️ 重要注意事项

1. 中文字符处理

str := "Hello世界"
fmt.Println(len(str))           // 11 (H e l l o + 世界占6字节)
fmt.Println(len([]rune(str)))   // 7 (转为rune数组后，每个字符1个元素)

// 正确截取中文字符串
runeStr := []rune(str)
fmt.Println(string(runeStr[5:7])) // "世界"

2. 字符串是不可变的

str := "Hello"
// str[0] = 'h'  // 编译错误！字符串不能修改
​
// 要修改需要转换为字节切片
bytes := []byte(str)
bytes[0] = 'h'
str = string(bytes)  // "hello"

3. 字符串连接性能

// ❌ 不推荐：循环中使用+连接（性能差）
s := ""
for i := 0; i < 1000; i++ {
    s += "a"  // 每次都创建新字符串
}
​
// ✅ 推荐：使用strings.Builder（高性能）
var builder strings.Builder
for i := 0; i < 1000; i++ {
    builder.WriteString("a")
}
result := builder.String()

💡 知识点总结

操作	函数/方法	示例
长度	len()	len("Hello") → 5
拼接	+ 或 fmt.Sprintf()	"A"+"B" → "AB"
包含	strings.Contains()	Contains("abc","b") → true
分割	strings.Split()	Split("a,b",",") → ["a","b"]
替换	strings.Replace()	Replace("aba","a","c",1) → "cba"
子串	[start:end]	"Hello"[0:2] → "He"