Go语言基础数据类型详解：整型、浮点型、复数与字符串 ...

Go语言基础数据类型详解：整型、浮点型、复数与字符串

Go语言作为一门静态强类型的语言，其数据类型设计简洁而高效。把握Go的基本数据类型是每个开发者深入理解Go语言的基础。本篇文章将详细介绍Go语言中最常见的基本数据类型，包罗整型、浮点型、复数、布尔型、字符串等，并结合实例代码演示如何在Go中利用这些数据类型。通过对这些类型的深入理解，读者将能够更好地在项目中应用Go语言，提升代码的质量与效率。
Go语言提供了丰富的数据类型支持，涵盖了从简朴的整型到复杂的复数、字符串等多种类型。在整型部分，我们将解说有符号和无符号整型的区别，并展示其在不同平台上的体现。浮点型支持 float32 和 float64 两种类型，遵循IEEE 754标准，实用于不同精度要求的数值盘算。复数类型包罗 complex64 和 complex128，用于处置惩罚复数运算。布尔类型仅包含 true 和 false，且不能与其他类型直接转换或参与运算。字符串则是Go语言的基础数据类型之一，接纳UTF-8编码，并支持各种常见操作如拼接、切割、查找等。
Go语言之基本数据类型

整型

整型分为以下两个大类： 按长度分为：int8、int16、int32、int64 对应的无符号整型：uint8、uint16、uint32、uint64
此中，uint8就是我们熟知的byte型，int16对应C语言中的short型，int64对应C语言中的long型。
类型形貌uint8无符号 8位整型 (0 到 255)uint16无符号 16位整型 (0 到 65535)uint32无符号 32位整型 (0 到 4294967295)uint64无符号 64位整型 (0 到 18446744073709551615)int8有符号 8位整型 (-128 到 127)int16有符号 16位整型 (-32768 到 32767)int32有符号 32位整型 (-2147483648 到 2147483647)int64有符号 64位整型 (-9223372036854775808 到 9223372036854775807)特殊整型

类型形貌uint32位操作系统上就是uint32，64位操作系统上就是uint64int32位操作系统上就是int32，64位操作系统上就是int64uintptr无符号整型，用于存放一个指针留意： 在利用int和 uint类型时，不能假定它是32位或64位的整型，而是思量int和uint可能在不同平台上的差异。
留意事项 获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变革。实际利用中，切片或 map 的元素数量等都可以用int来表现。在涉及到二进制传输、读写文件的结构形貌时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要利用int和 uint。

1. package main
3. import "fmt"
5. // 整型
7. func main()  {
8. var i1 = 101
9. fmt.Printf("%d\n", i1)
10. fmt.Printf("%b\n", i1) // 把十进制转换成二进制
11. fmt.Printf("%o\n", i1) // 把十进制转换成八进制
12. fmt.Printf("%x\n", i1) // 把十进制转换成十六进x
13. // 八进制
14. i2 := 077
15. fmt.Printf("%d\n", i2)
16. // 十六进制
17. i3 := 0x1234567
18. fmt.Printf("%d\n", i3)
19. // 查看变量的类型
20. fmt.Printf("%T\n", i3)
21. // 声明int8类型的变量
22. i4 := int8(9)  // 明确指定int8类型，否则默认int类型
23. fmt.Printf("%T\n", i4)
24. }

复制代码

浮点型

Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32 的浮点数的最大范围约为 3.4e38，可以利用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以利用一个常量定义：math.MaxFloat64。

1. package main
3. import "fmt"
6. // 浮点数
7. func main(){
8. // math.MaxFloat32 // float32最大值
9. f1 := 1.23456
10. fmt.Printf("%T\n", f1) // 默认Go语言中的小数都是float64类型
11. }
14. E:\go\src\github.com\qiaopengjun\day01\05float>go build
16. E:\go\src\github.com\qiaopengjun\day01\05float>05float.exe
17. float64
20. package main
22. import "fmt"
24. // 浮点数
25. func main(){
26. // math.MaxFloat32 // float32最大值
27. f1 := 1.23456
28. fmt.Printf("%T\n", f1) // 默认Go语言中的小数都是float64类型
29. f2 := float32(1.23456)
30. fmt.Printf("%T\n", f2) // 显示声明float32类型
31. // f1 = f2 // float32类型的值不能直接赋值给float64类型的变量
32. }

复制代码

复数

complex64和complex128

1. var c1 complex64
2. c1 = 1 + 2i
3. var c2 complex128
4. c2 = 2 + 3i
5. fmt.Println(c1)
6. fmt.Println(c2)

复制代码

复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。
布尔值

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

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

1. package main
3. import "fmt"
5. // 布尔类型
7. func main(){
8. b1 := true
9. var b2 bool // 默认是false
10. fmt.Printf("%T value:%v\n", b1, b1)
11. fmt.Printf("%T value:%v\n", b2, b2)
12. }
15. E:\go\src\github.com\qiaopengjun\day01\06bool>go build   
17. E:\go\src\github.com\qiaopengjun\day01\06bool>06bool.exe
18. bool value:true
19. bool value:false

复制代码

fmt占位符

1. package main
3. import "fmt"
5. // fmt占位符
6. func main(){
7. var n = 100
8. // 查看类型
9. fmt.Printf("%T\n", n)
10. fmt.Printf("%v\n", n)
11. fmt.Printf("%b\n", n)
12. fmt.Printf("%d\n", n)
13. fmt.Printf("%o\n", n)
14. fmt.Printf("%x\n", n)
15. var s = "Hello 沙河！"
16. fmt.Printf("字符串：%s\n", s)
17. fmt.Printf("字符串：%v\n", s)
18. fmt.Printf("字符串：%#v\n", s)
20. }
23. E:\go\src\github.com\qiaopengjun\day01\07fmt>go build
25. E:\go\src\github.com\qiaopengjun\day01\07fmt>07fmt.exe
26. int
27. 100
28. 1100100
29. 100
30. 144
31. 64
32. Hello 沙河！
33. Hello 沙河！
35. E:\go\src\github.com\qiaopengjun\day01\07fmt>go build  
37. E:\go\src\github.com\qiaopengjun\day01\07fmt>07fmt.exe
38. int
39. 100
40. 1100100
41. 100
42. 144
43. 64
44. 字符串：Hello 中国！
45. 字符串：Hello 中国！
46. 字符串："Hello 中国！"
48. E:\go\src\github.com\qiaopengjun\day01\07fmt>

复制代码

字符串

Go语言中的字符串以原生数据类型出现。 Go 语言里的字符串的内部实现利用UTF-8编码。 字符串的值为双引号(")中的内容，可以在Go语言的源码中直接添加非ASCII码字符
GO语言中字符串是用双引号包裹的
GO语言中单引号包裹的是字符

1. // 字符串
2. s := "Hello 中国"
3. // 单独的字母、汉字、符合表示一个字符
4. c1 := 'h'
5. c2 := '1'
6. c3 := '中'
7. // 字节：1字节=8Bit(8个二进制位)
8. // 1个字符'A'=1个字节
9. // 1个utf8编码的汉字'中'= 一般占3个字节

复制代码

字符串转义符

转义符含义\r回车符（返回行首）\n换行符（直接跳到下一行的同列位置）\t制表符\'单引号\"双引号\\反斜杠字符串的常用操作

方法介绍len(str)求长度+或fmt.Sprintf拼接字符串strings.Split分割strings.contains判定是否包含strings.HasPrefix,strings.HasSuffix前缀/后缀判定strings.Index(),strings.LastIndex()子串出现的位置strings.Join(a[]string, sep string)join操作

1. package main
3. import (
4. "fmt"
5. "strings"
6. )
8. // 字符串
10. func main(){
11. // \ 本来是具有特殊含义的，告诉程序\就是一个单纯的\
12. path := ""E:\\36期Python全栈开发资料\\Administrator(8E5370323193)\\预习(2)""
13. path1 := "'E:\\36期Python全栈开发资料\\Administrator(8E5370323193)\\预习(2)'"
14. fmt.Println(path)
15. fmt.Println(path1)
17. s := "I'm ok"
18. fmt.Println(s)
20. // 多行的字符串
21. s2 := `
22. 世情薄
23. 人情恶
24. 雨送黄昏花易落
25. `
26. fmt.Println(s2)
27. s3 := `E:\36期Python全栈开发资料\Administrator(8E5370323193)\预习(2)`
28. fmt.Println(s3)
30. // 字符串相关操作
31. fmt.Println(len(s3))
33. // 字符串拼接
34. name := "理想"
35. world := "远大"
36. ss := name + world
37. fmt.Println(ss)
38. ss1 := fmt.Sprintf("%s%s", name, world)
39. // fmt.Printf("%s%s", name, world)
40. fmt.Println(ss1)
41. // 分割
42. ret := strings.Split(s3, "\")
43. fmt.Println(ret)
45. // 包含
46. fmt.Println(strings.Contains(ss, "理想"))
47. // 前缀
48. fmt.Println(strings.HasPrefix(ss, "理想"))
49. // 后缀
50. fmt.Println(strings.HasSuffix(ss, "理想"))
52. s4 := "abcded"
53. fmt.Println(strings.Index(s4, "c"))
54. fmt.Println(strings.LastIndex(s4, "c"))
55. fmt.Println(strings.Index(s4, "d"))
56. fmt.Println(strings.LastIndex(s4, "d"))
57. // 拼接
58. fmt.Println(strings.Join(ret, "+"))
60. }

复制代码

byte和rune类型

字符用单引号（’）包裹起来
Go 语言的字符有以下两种：

• uint8类型，大概叫 byte 型，代表了ASCII码的一个字符。
  
• rune类型，代表一个 UTF-8字符。rune类型实际是一个int32
  

字符串底层是一个byte数组，可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表现utf8字符，一个rune字符由一个或多个byte组成。
修改字符串

要修改字符串，必要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。
类型转换

逼迫类型转换的基本语法如下：

1. T(表达式)

复制代码

此中，T表现要转换的类型。表达式包罗变量、复杂算子和函数返回值等.

1. package main
3. import (
4. "fmt"
5. )
7. func main() {
8. s := "Hello 中国"
9. // len()求的是byte字节的数量
10. n := len(s)
11. fmt.Println(n)
13. // for i := 0; i < len(s); i++ {
14. //  fmt.Println(s[i])
15. //  fmt.Printf("%c\n", s[i]) // %c：字符
16. // }
18. // 字符串修改
19. s2 := "白萝卜" // [白 萝 卜]
20. s3 := []rune(s2) // 把字符串强制转换成了一个rune切片
21. s3[0] = '红' // 单引号表示字符
22. fmt.Println(string(s3)) // 把rune切片强制转换成字符串
24. c1 := "红"
25. c2 := '红' // rune(int32)
26. fmt.Printf("c1:%T c2:%T\n", c1, c2) // c1:string c2:int32
27. c3 := "H"
28. c4 := 'H'
29. c5 := byte('H')
30. fmt.Printf("c3:%T c4:%T\n", c3, c4) // c3:string c4:int32
31. fmt.Printf("c4:%d\n", c4) // c4:72
32. fmt.Printf("c5:%T\n", c5) // c5:uint8
34. // 类型转换
35. n1 := 10 // int
36. var f float64
37. f = float64(n1)
38. fmt.Println(f)
39. fmt.Printf("%T\n", f) // float64
42. }

复制代码

总结

本文通过示例代码详细解说了Go语言的基本数据类型及其应用，资助开发者深入理解如何利用这些类型进行高效编程。通过对整型、浮点型、复数、布尔型和字符串等基本数据类型的分析，读者能够更加灵活地选择合适的类型来处置惩罚不同的数据和场景。此外，Go语言还提供了强大的类型转换机制，使得开发者能够在不同的数据类型之间进行转换，进一步提高代码的灵活性和可维护性。把握这些基础知识将为深入学习Go语言和开发高效Go步伐奠定坚实的基础。


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。