Golang 基本数据类型

目录

介绍：

1、整型

2、浮点型

浮点数的精度问题

3、布尔型

4、字符串

结语：

介绍：

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

基本数据类型有：

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

复合数据类型有：

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

1、整型

        整形分为以下两大类：

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

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

package main

import (
	"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 := 100
	fmt.Printf("%v\n", num) // %v 表示原样输出，输出 100
	fmt.Printf("%d\n", num) // %d 表示十进制整数，输出 100
	fmt.Printf("%b\n", num) // %b 表示二进制整数，输出 1100100
	fmt.Printf("%o\n", num) // %o 表示八进制整数，输出 144
	fmt.Printf("%x\n", num) // %x 表示十六进制整数，输出 64
}

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

2、浮点型

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

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	// 1、定义float类型
	var a float32 = 3.14
	fmt.Printf("a: %v---%f 类型:%T\n", a, a, a) // a: 3.14---3.140000 类型:float32
	fmt.Println(unsafe.Sizeof(a))             // float32占用4个字节

	var b float64 = 3.14
	fmt.Printf("b: %v---%f 类型:%T\n", b, b, b) // b: 3.14---3.140000 类型:float64
	fmt.Println(unsafe.Sizeof(b))             // float64占用8个字节

	// 2、 %f 输出float类型	%.2f 保留两位小数
	var c float32 = 3.1415926
	fmt.Printf("c: %v---%f 类型:%T\n", c, c, c)   // c: 3.1415925---3.141593 类型:float32
	fmt.Printf("c: %v---%.2f 类型:%T\n", c, c, c) // c: 3.1415925---3.14 类型:float32

	// 3、 64位的系统中Go语言的浮点数默认位 float64
	d := 3.1415926
	fmt.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 类型:float64

	f := 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.6
	fmt.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.6
	fmt.Println(g * 100) // 打印结果为112959.99999999999，而不是112960
	fmt.Println(decimal.NewFromFloat(g).Mul(decimal.NewFromFloat(100))) // 112960

3、布尔型

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

注意：

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

package main

import "fmt"

func main() {
	// 定义bool类型变量
	var flag bool = true

	fmt.Printf("flag : %v----%T\n", flag, flag) // flag : true----bool

	// bool类型默认值
	var flag2 bool

	fmt.Println("flag2 :", flag2) // flag2 : false

	// Go语言中不允许将整型强制转为布尔型
	var num = 1

	if num { // 错误写法
		fmt.Println("num is true")
	}
}

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

4、字符串

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

字符串常用操作：

package main

import (
	"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 world
	fmt.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)) // true
	fmt.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 表示子串不存在
}

结语：

        本文分享了Golang基本数据类型的学习心得，作为入门阶段的知识点总结。由于篇幅限制，后续会继续深入探讨更复杂的语法特性。

        学习编程语言需要循序渐进，建议新手从基础数据类型开始练习，逐步掌握核心概念。欢迎在评论区交流学习经验或提出疑问。