当前位置：首页 > news >正文

Golang 基本数据类型

news 2025/8/6 21:06:39

介绍：

1、整型

2、浮点型

浮点数的精度问题

3、布尔型

4、字符串

结语：

介绍：

在Go语言中数据类型分为基本数据类型和复合数据类型。

基本数据类型有：

整型、浮点型、布尔型、字符串。

复合数据类型有：

数组、切片、结构体、函数、map、通道（ channel ）、接口等。

1、整型

整形分为以下两大类：

有符号整型按长度分为：int8、int16、int32、int64

对应的无符号整型：uint8、uint16、uint32、uint64

类型	最小值	最大值	占用空间	有无符号
int8	-128 (-2⁷)	127 (2⁷ - 1)	1个字节	有
int16	-32,768 (-2¹⁵)	32,767 (2¹⁵ - 1)	2个字节	有
int32	-2,147,483,648 (-2³¹)	2,147,483,647 (2³¹ - 1)	4个字节	有
int64	-9,223,372,036,854,775,808 (-2⁶³)	9,223,372,036,854,775,807 (2⁶³ - 1)	8个字节	有
uint8	0	255 (2⁸ - 1)	1个字节	无
uint16	0	65,535 (2¹⁶ - 1)	2个字节	无
uint32	0	4,294,967,295 (2³² - 1)	4个字节	无
uint64	0	18,446,744,073,709,551,615 (2⁶⁴ - 1)	8个字节	无

package mainimport ("fmt"
)func main() {// 1、定义int类型// var num int = 100// fmt.Printf("num: %v 类型: %T", num, num) // num: 100 类型: int// 2、定义int8类型，范围-128~127// var num int8 = 10// fmt.Printf("num: %v 类型: %T\n", num, num) // num: 10 类型: int8// unsafe.Sizeof()函数可以获取变量的字节大小// fmt.Println(unsafe.Sizeof(num)) // 1// 3、int类型转换，高位向低位转换时要注意不要超过对应int类型的最大值// var num1 int32 = 100// var num2 int16 = 200// fmt.Println(num1 + num2) // 类型不同，相加会报错，需要转换类型// fmt.Println(num1 + int32(num2)) // 300// 4、数字字面量语法  %d 表示十进制整数，%b 表示二进制整数，%o 表示八进制整数，%x 表示十六进制整数num := 100fmt.Printf("%v\n", num) // %v 表示原样输出，输出 100fmt.Printf("%d\n", num) // %d 表示十进制整数，输出 100fmt.Printf("%b\n", num) // %b 表示二进制整数，输出 1100100fmt.Printf("%o\n", num) // %o 表示八进制整数，输出 144fmt.Printf("%x\n", num) // %x 表示十六进制整数，输出 64
}

unsafe.Sizeof()函数可以获取变量的字节大小，字节（Byte）是计算机数据的基本存储单位。8bit(位)=1Byte(字节)、1024Byte=1KB、1024KB=1MB、1024MB=1G、1024G=1TB，在电脑中一个中文字是占两个字节的。

2、浮点型

在Go语言中支持两种浮点型数：float32 和 float64

类型	float32	float64
位数	32 位（1 位符号 + 8 位指数 + 23 位尾数）	64 位（1 位符号 + 11 位指数 + 52 位尾数）
最大正数	≈3.4028234663852886e+38	≈1.7976931348623157e+308
最小正数（非零	≈1.401298464324817e-45	≈4.9406564584124654e-324
精度	约 6~7 位十进制有效数字	约 15~16 位十进制有效数字
常量表示最大值	math.MaxFloat32	math.MaxFloat64
常量表示最小正非零值	math.SmallestNonZeroFloat32	math.SmallestNonZeroFloat64

package mainimport ("fmt""unsafe"
)func main() {// 1、定义float类型var a float32 = 3.14fmt.Printf("a: %v---%f 类型:%T\n", a, a, a) // a: 3.14---3.140000 类型:float32fmt.Println(unsafe.Sizeof(a))             // float32占用4个字节var b float64 = 3.14fmt.Printf("b: %v---%f 类型:%T\n", b, b, b) // b: 3.14---3.140000 类型:float64fmt.Println(unsafe.Sizeof(b))             // float64占用8个字节// 2、 %f 输出float类型	%.2f 保留两位小数var c float32 = 3.1415926fmt.Printf("c: %v---%f 类型:%T\n", c, c, c)   // c: 3.1415925---3.141593 类型:float32fmt.Printf("c: %v---%.2f 类型:%T\n", c, c, c) // c: 3.1415925---3.14 类型:float32// 3、 64位的系统中Go语言的浮点数默认位 float64d := 3.1415926fmt.Printf("d: %v---%f 类型:%T\n", d, d, d) // d: 3.1415926---3.141593 类型:float64// 4、科学计数法表示浮点数类型e := 3.14e2                               // 3.14 * 10的2次方fmt.Printf("e: %v---%f 类型:%T\n", e, e, e) // e: 314---314.000000 类型:float64f := 3.14e-2                              // 3.14 / 10的2次方fmt.Printf("f: %v---%f 类型:%T\n", f, f, f) // f: 0.0314---0.031400 类型:float64
}

浮点数的精度问题

由于计算机的存储机制，浮点数的精度问题是无法完全避免的。

因此，在进行浮点数运算时，需要注意以下几点：

浮点数运算的结果可能与预期不符，原因是由于浮点数的存储机制导致的。
浮点数的精度问题会导致一些微小的误差。
浮点数的运算结果可能因为浮点数的精度问题而产生一些误差。

	g := 1129.6fmt.Println(g * 100) // 打印结果为112959.99999999999，而不是112960

就比如上面这个数，将这个数乘以100并不是我们期望的结果，这就是浮点数的精度问题，不仅仅是Go语言，在其他语言中也是存在的。

在开发过程中精度问题就是一个比较头疼的问题，那有什么解决方案吗？

有的！有的！最简单的就是通过第三方包来解决：https://github.com/shopspring/decimal

下载步骤：

1.进入你的项目目录（确保在包含 .go 文件的目录下运行命令）

2.初始化Go Modules（如果还没有 go.mod 文件）

go mod init your_module_name

3.下载decimal包

go get github.com/shopspring/decimal

如果下载报错可以设置Go Model国内代理

go env -w GOPROXY=https://goproxy.cn,direct

4.引入及使用

import ("fmt""unsafe""github.com/shopspring/decimal"
)

	g := 1129.6fmt.Println(g * 100) // 打印结果为112959.99999999999，而不是112960fmt.Println(decimal.NewFromFloat(g).Mul(decimal.NewFromFloat(100))) // 112960

3、布尔型

Go语言中以bool类型进行声明布尔型数据，布尔值只有 true（真）和 false（假）。

注意：

布尔类型变量的默认值为false。
Go语言中不允许将整型强制转为布尔型
布尔型无法参与数值运算，也无法与其他类型进行转换

package mainimport "fmt"func main() {// 定义bool类型变量var flag bool = truefmt.Printf("flag : %v----%T\n", flag, flag) // flag : true----bool// bool类型默认值var flag2 boolfmt.Println("flag2 :", flag2) // flag2 : false// Go语言中不允许将整型强制转为布尔型var num = 1if num { // 错误写法fmt.Println("num is true")}
}

这里面要注意的点是整型不能转化为bool类型，在JavaScript中1可以转换为true，0可以转换为false，但是在Go语言中是不能进行转换的。

4、字符串

在Go语言中，字符串是不可变的字节序列，采用UTF-8编码。字符串类型的关键字为 string ，其默认值为空字符串" "。

字符串常用操作：

方法	介绍
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPreFix, strings.HasSuffix	前缀/后缀判断
strings.Index(), strings.LastIndex()	字符串查找
strings.Join(a[]string, sep string)	Join操作

package mainimport ("fmt""strings"
)func main() {// 1、定义string类型变量var str string = "Hello, world!"fmt.Printf("str : %v ---- %T\n", str, str) // str : Hello, world! ---- string// 2、多行字符串 使用反引号``str1 := `This is a multi-line string.It can be used to represent a block of text.`fmt.Println(str1)// 3、len()函数获取字符串长度var str2 = "你好"fmt.Println(len(str2)) // 6 一个中文字符占用3个字节// 4、字符串拼接str3 := "Hello "str4 := "world"fmt.Println(str3 + str4)                     // Hello worldfmt.Println(fmt.Sprintf("%v%v", str3, str4)) // Hello world// 5、分割字符串var str5 = "123-456-7890"var arr = strings.Split(str5, "-")fmt.Println(arr) // [123 456 7890] 切片// 6、join()函数合并字符串fmt.Println(strings.Join(arr, "*")) // 123*456*7890// 7、strings.contains()函数判断字符串是否包含子串var str6 = "Hello, world!"var subStr = "world"fmt.Println(strings.Contains(str6, subStr)) // true 返回true表示包含子串 false表示不包含子串// 8、strings.HasPrefix()函数判断字符串是否以指定子串开头 strings.HasSuffix()函数判断字符串是否以指定子串结尾var str7 = "Hello, world!"var prefix = "Hello"var suffix = "world!"fmt.Println(strings.HasPrefix(str7, prefix)) // truefmt.Println(strings.HasSuffix(str7, suffix)) // true// 9、strings.index()函数查找子串的位置 strings.LastIndex()函数查找子串最后一次出现的位置var str8 = "Hello, world!"var subStr2 = "l"fmt.Println(strings.Index(str8, subStr2))     // 2 从开头开始查找 返回子串的位置fmt.Println(strings.LastIndex(str8, subStr2)) // 10 从末尾开始查找 返回子串的位置 空格也算一个字符fmt.Println(strings.Index(str8, "x"))         // -1 表示子串不存在
}