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。
package main
import "fmt"
// 整型
func main(){
var i1 = 101
fmt.Printf("%d\n", i1)
fmt.Printf("%b\n", i1) // 把十进制转换成二进制
fmt.Printf("%o\n", i1) // 把十进制转换成八进制
fmt.Printf("%x\n", i1) // 把十进制转换成十六进x
// 八进制
i2 := 077
fmt.Printf("%d\n", i2)
// 十六进制
i3 := 0x1234567
fmt.Printf("%d\n", i3)
// 查看变量的类型
fmt.Printf("%T\n", i3)
// 声明int8类型的变量
i4 := int8(9)// 明确指定int8类型，否则默认int类型
fmt.Printf("%T\n", i4)
}浮点型
Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32 的浮点数的最大范围约为 3.4e38，可以利用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以利用一个常量定义：math.MaxFloat64。
package main
import "fmt"
// 浮点数
func main(){
// math.MaxFloat32 // float32最大值
f1 := 1.23456
fmt.Printf("%T\n", f1) // 默认Go语言中的小数都是float64类型
}
E:\go\src\github.com\qiaopengjun\day01\05float>go build
E:\go\src\github.com\qiaopengjun\day01\05float>05float.exe
float64
package main
import "fmt"
// 浮点数
func main(){
// math.MaxFloat32 // float32最大值
f1 := 1.23456
fmt.Printf("%T\n", f1) // 默认Go语言中的小数都是float64类型
f2 := float32(1.23456)
fmt.Printf("%T\n", f2) // 显示声明float32类型
// f1 = f2 // float32类型的值不能直接赋值给float64类型的变量
}复数
complex64和complex128
var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。
布尔值
Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。
留意：
[*]布尔类型变量的默认值为false。
[*]Go 语言中不允许将整型逼迫转换为布尔型.
[*]布尔型无法参与数值运算，也无法与其他类型进行转换。
package main
import "fmt"
// 布尔类型
func main(){
b1 := true
var b2 bool // 默认是false
fmt.Printf("%T value:%v\n", b1, b1)
fmt.Printf("%T value:%v\n", b2, b2)
}
E:\go\src\github.com\qiaopengjun\day01\06bool>go build
E:\go\src\github.com\qiaopengjun\day01\06bool>06bool.exe
bool value:true
bool value:falsefmt占位符
package main
import "fmt"
// fmt占位符
func main(){
var n = 100
// 查看类型
fmt.Printf("%T\n", n)
fmt.Printf("%v\n", n)
fmt.Printf("%b\n", n)
fmt.Printf("%d\n", n)
fmt.Printf("%o\n", n)
fmt.Printf("%x\n", n)
var s = "Hello 沙河！"
fmt.Printf("字符串：%s\n", s)
fmt.Printf("字符串：%v\n", s)
fmt.Printf("字符串：%#v\n", s)
}
E:\go\src\github.com\qiaopengjun\day01\07fmt>go build
E:\go\src\github.com\qiaopengjun\day01\07fmt>07fmt.exe
int
100
1100100
100
144
64
Hello 沙河！
Hello 沙河！
E:\go\src\github.com\qiaopengjun\day01\07fmt>go build
E:\go\src\github.com\qiaopengjun\day01\07fmt>07fmt.exe
int
100
1100100
100
144
64
字符串：Hello 中国！
字符串：Hello 中国！
字符串："Hello 中国！"
E:\go\src\github.com\qiaopengjun\day01\07fmt>字符串
Go语言中的字符串以原生数据类型出现。 Go 语言里的字符串的内部实现利用UTF-8编码。 字符串的值为双引号(")中的内容，可以在Go语言的源码中直接添加非ASCII码字符
GO语言中字符串是用双引号包裹的
GO语言中单引号包裹的是字符
// 字符串
s := "Hello 中国"
// 单独的字母、汉字、符合表示一个字符
c1 := 'h'
c2 := '1'
c3 := '中'
// 字节：1字节=8Bit(8个二进制位)
// 1个字符'A'=1个字节
// 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操作package main
import (
"fmt"
"strings"
)
// 字符串
func main(){
// \ 本来是具有特殊含义的，告诉程序\就是一个单纯的\
path := "\"E:\\36期Python全栈开发资料\\Administrator(8E5370323193)\\预习(2)\""
path1 := "'E:\\36期Python全栈开发资料\\Administrator(8E5370323193)\\预习(2)'"
fmt.Println(path)
fmt.Println(path1)
s := "I'm ok"
fmt.Println(s)
// 多行的字符串
s2 := `
世情薄
人情恶
雨送黄昏花易落
`
fmt.Println(s2)
s3 := `E:\36期Python全栈开发资料\Administrator(8E5370323193)\预习(2)`
fmt.Println(s3)
// 字符串相关操作
fmt.Println(len(s3))
// 字符串拼接
name := "理想"
world := "远大"
ss := name + world
fmt.Println(ss)
ss1 := fmt.Sprintf("%s%s", name, world)
// fmt.Printf("%s%s", name, world)
fmt.Println(ss1)
// 分割
ret := strings.Split(s3, "\\")
fmt.Println(ret)
// 包含
fmt.Println(strings.Contains(ss, "理想"))
// 前缀
fmt.Println(strings.HasPrefix(ss, "理想"))
// 后缀
fmt.Println(strings.HasSuffix(ss, "理想"))
s4 := "abcded"
fmt.Println(strings.Index(s4, "c"))
fmt.Println(strings.LastIndex(s4, "c"))
fmt.Println(strings.Index(s4, "d"))
fmt.Println(strings.LastIndex(s4, "d"))
// 拼接
fmt.Println(strings.Join(ret, "+"))
}byte和rune类型
字符用单引号（’）包裹起来
Go 语言的字符有以下两种：
[*]uint8类型，大概叫 byte 型，代表了ASCII码的一个字符。
[*]rune类型，代表一个 UTF-8字符。rune类型实际是一个int32
字符串底层是一个byte数组，可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表现utf8字符，一个rune字符由一个或多个byte组成。
修改字符串
要修改字符串，必要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。
类型转换
逼迫类型转换的基本语法如下：
T(表达式)此中，T表现要转换的类型。表达式包罗变量、复杂算子和函数返回值等.
package main
import (
"fmt"
)
func main() {
s := "Hello 中国"
// len()求的是byte字节的数量
n := len(s)
fmt.Println(n)
// for i := 0; i < len(s); i++ {
//fmt.Println(s)
//fmt.Printf("%c\n", s) // %c：字符
// }
// 字符串修改
s2 := "白萝卜" // [白 萝 卜]
s3 := []rune(s2) // 把字符串强制转换成了一个rune切片
s3 = '红' // 单引号表示字符
fmt.Println(string(s3)) // 把rune切片强制转换成字符串
c1 := "红"
c2 := '红' // rune(int32)
fmt.Printf("c1:%T c2:%T\n", c1, c2) // c1:string c2:int32
c3 := "H"
c4 := 'H'
c5 := byte('H')
fmt.Printf("c3:%T c4:%T\n", c3, c4) // c3:string c4:int32
fmt.Printf("c4:%d\n", c4) // c4:72
fmt.Printf("c5:%T\n", c5) // c5:uint8
// 类型转换
n1 := 10 // int
var f float64
f = float64(n1)
fmt.Println(f)
fmt.Printf("%T\n", f) // float64
}总结
本文通过示例代码详细解说了Go语言的基本数据类型及其应用，资助开发者深入理解如何利用这些类型进行高效编程。通过对整型、浮点型、复数、布尔型和字符串等基本数据类型的分析，读者能够更加灵活地选择合适的类型来处置惩罚不同的数据和场景。此外，Go语言还提供了强大的类型转换机制，使得开发者能够在不同的数据类型之间进行转换，进一步提高代码的灵活性和可维护性。把握这些基础知识将为深入学习Go语言和开发高效Go步伐奠定坚实的基础。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]