共计 4899 个字符,预计需要花费 13 分钟才能阅读完成。
大家好,将梳理出的 Go 语言数据类型内容,分享给大家。请多多指教,谢谢。
类型汇总
Go 语言中,次要分为值类型次要分为三局部:整型、浮点型和其余类型。
// 整型 | |
int int8 int16 int32 int64 | |
uint uint8 uint16 uint32 uint64 uintptr | |
// 浮点型、复数 | |
float32 float64 complex128 complex64 | |
// 其余类型 | |
bool byte rune string error |
整型
Go 语言同时提供了有符号和无符号类型的整数运算。
int int8 int16 int32 有合乎和无符号类型
这里有 int8、int16、int32 和 int64 四种截然不同大小的有符号整数类型,别离对应 8、16、32、64bit 大小的有符号整数,与此对应的是 uint8、uint16、uint32 和 uint64 四种无符号整数类型。
这里还有两种个别对应特定 CPU 平台机器字大小的有符号和无符号整数 int 和 uint;其中 int 是利用最宽泛的数值类型。这两种类型都有同样的大小,32 或 64bit,然而咱们不能对此做任何的假如;因为不同的编译器即便在雷同的硬件平台上可能产生不同的大小。
uintptr 类型
uintptr 是一种无符号的整数类型,没有指定具体的 bit 大小然而足以包容指针。uintptr 类型只有在底层编程时才须要,特地是 Go 语言和 C 语言函数库或操作系统接口相交互的中央。
不论它们的具体大小,int、uint 和 uintptr 是不同类型的兄弟类型。其中 int 和 int32 也是不同的类型,即便 int 的大小也是 32bit,在须要将 int 当作 int32 类型的中央须要一个显式的类型转换操作,反之亦然。
类型值范畴
类型名称 | 大小 | 形容 |
---|---|---|
int | 8 字节 | int 的大小是和操作系统位数相干的,如果是 32 位操作系统,int 类型的大小是 4 字节;如果是 64 位操作系统,int 类型的大小就是 8 个字节 |
int8 | 1 字节 | 无符号整数的所有 bit 位都用于示意非正数,值域是 0 到 $2^n-1$。例如,int8 类型整数的值域是从 -128 到 127,而 uint8 类型整数的值域是从 0 到 255。 |
int16 | 2 字节 | 有符号 int16 类型整数值域是从 -32768 ~ 32767,而无符号 uint16 类型整数值域是从 0 ~ 65535 |
int32 | 4 字节 | 有符号 int32 类型整数值域是从 -2147483648 ~ 2147483647,而无符号 uint32 类型整数值域是从 0 ~ 4294967295 |
int64 | 8 字节 | 有符号 int64 类型整数值域是从 -9223372036854775808 ~ 9223372036854775807,而无符号 uint64 类型整数值域是从 0 ~ 18446744073709551615 |
uintptr | 长度 4 或 8 字节 | 存储指针的 uint32 或 uint64 整数 |
取值范畴示例
package main | |
import ( | |
"fmt" | |
"math" | |
"unsafe" | |
) | |
func main() {fmt.Println("各 int 类型的大小:") | |
var i1 int = 1 | |
var i2 int8 = 2 | |
var i3 int16 = 3 | |
var i4 int32 = 4 | |
var i5 int64 = 5 | |
var i6 uint64 = 6 | |
fmt.Printf("int : %v\n", unsafe.Sizeof(i1)) | |
fmt.Printf("int8 : %v\n", unsafe.Sizeof(i2)) | |
fmt.Printf("int16 : %v\n", unsafe.Sizeof(i3)) | |
fmt.Printf("int32 : %v\n", unsafe.Sizeof(i4)) | |
fmt.Printf("int64 : %v\n", unsafe.Sizeof(i5)) | |
fmt.Printf("uint64: %v\n", unsafe.Sizeof(i6)) | |
// 输入各 int 类型的取值范畴 | |
fmt.Println("int8:", math.MinInt8, "~", math.MaxInt8) | |
fmt.Println("int16:", math.MinInt16, "~", math.MaxInt16) | |
fmt.Println("int32:", math.MinInt32, "~", math.MaxInt32) | |
fmt.Println("int64:", math.MinInt64, "~", math.MaxInt64) | |
fmt.Println() | |
// n 是主动推导类型 | |
n := 1234567890 | |
fmt.Printf("n := 1234567890 的默认类型为: %T\n", n) | |
fmt.Printf("int 类型的字节数为: %v\n\n", unsafe.Sizeof(n)) | |
// 初始化一个 32 位整型值 | |
var a int32 = 987654321 | |
fmt.Println("var a int32 = 987654321") | |
// 输入变量的十六进制模式和十进制 | |
fmt.Printf("int32: 十六进制为 0x%x, 十进制为 %d\n", a, a) | |
// 将 a 转换为 int8 类型, 产生数值截断 | |
b := int8(a) | |
fmt.Printf("int8: 十六进制 0x%x, 十进制为 %d\n", b, b) | |
// 将 a 转换为 int16 类型, 产生数值截断 | |
c := int16(a) | |
fmt.Printf("int16: 十六进制为 0x%x, 十进制 %d\n", c, c) | |
// 将 a 转换为 int64 类型 | |
d := int64(a) | |
fmt.Printf("int64: 十六进制为 0x%x, 十进制 %d\n", d, d) | |
} |
浮点型
浮点数类型的取值范畴能够从很渺小到很微小。浮点数的范畴极限值能够在 math 包找到。常量 math.MaxFloat32 示意 float32 能示意的最大数值,大概是 3.4e38
;对应的 math.MaxFloat64 常量大概是 1.8e308
。它们别离能示意的最小值近似为1.4e-45
和4.9e-324
。
上述值,以迷信计数法示意
列如:e38 就是小数点向右挪动 38 位
e-35 就是小数点向左挪动 35 位
float32、float64 类型
一个 float32 类型的浮点数能够提供大概 6 个十进制数的精度,而 float64 则能够提供约 15 个十进制数的精度;通常应该优先应用 float64 类型,因为 float32 类型的累计计算误差很容易扩散,并且 float32 能准确示意的正整数并不是很大(译注:因为 float32 的无效 bit 位只有 23 个,其它的 bit 位用于指数和符号;当整数大于 23bit 能表白的范畴时,float32 的示意将呈现误差)
complex64、complex128 类型
Go 语言提供了两种精度的复数类型:complex64 和 complex128,别离对应 float32 和 float64 两种浮点数精度。
实际上,complex64 类型的值会由两个 float32 类型的值别离示意复数的实数局部和虚数局部。complex128 类型的值会由两个 float64 类型的值别离示意复数的实数局部和虚数局部。
复数类型的值个别由浮点数示意的实数局部、加号“+”、浮点数示意的虚数局部,以及小写字母“i”组成。比方,3.7E+1 + 5.98E-2i
。正因为复数类型的值由两个浮点数类型值组成,所以其表示法的规定天然需听从浮点数类型的值表示法的相干规定。
举例,内置的 complex 函数用于构建复数,内建的 real 和 imag 函数别离返回复数的实部和虚部:
var x complex128 = complex(1, 2)
类型值范畴
类型名称 | 大小 | 形容 |
---|---|---|
float32 | 4 字节 | 单精度类型,占据 4 个字节 byte,32 个二进制位 bit |
float64 | 8 字节 | 双精度类型比单精度类型更能准确地示意一个小数,然而占用的内存空间也比拟大。 |
complex64 | 8 字节 | 蕴含两个 float32 类型示意复数 |
complex128 | 16 字节 | 蕴含两个 float64 类型示意复数 |
布尔型
介绍
布尔类型的值只有两种:true
和 false
。if 和 for 语句的条件局部都是布尔类型的值,并且 == 和 < 等比拟操作也会产生布尔型的值。一元操作符 !
对应逻辑非操作,因而 !true
的值为false
,更罗嗦的说法是(!true==false)==true
,尽管表达方式不一样,不过咱们个别会采纳简洁的布尔表达式,就像用 x 来示意x==true
。
应用
数字到布尔类型的转换
func itob(i int) bool {return i != 0}
rune 类型
介绍
rune 类型是和 int32 类型等价,在所有方面都等同于 int32
,依照约定,它用于辨别字符值和整数值。
罕用来解决 unicode 或 utf-8 字符,通常用于示意一个 Unicode 码点,这两个名称能够调换应用。
说的艰深一点就是
rune
一个值代表的就是一个Unicode
字符,它的最大特点就是可变长。它能够应用1 - 4
个字节示意一个字符,依据字符的不同变换长度。所以应用int32
类型范畴就能够完满适配。单个中文占 2 个字节,单个英文占 2 个字节。因为 Go 语言中字符串编码为
UTF-8
,英文占1
个字节,中文占3
个字节。占用空间相比之下会更大
应用
计算中文字符
package main | |
import ("fmt") | |
func main() { | |
var data = "帽儿山的枪手" | |
fmt.Println("data length", len(data)) | |
fmt.Println("data word length", len([]rune(data))) | |
} |
程序输入
data length 18 | |
data word length 6 |
具体起因
len()
函数是用来获取字符串的字节长度在
utf-8
编码中,英文占1
个字节,中文占3
个字节
rune
一个值代表的就是一个Unicode
字符,所以求rune
切片的长度就是字符个数。
byte 类型
介绍
同样 byte 也是 uint8 类型 的等价类型,byte 类型个别用于强调数值是一个原始的数据而不是一个小的整数。
应用
字符串和字节 slice 之间能够互相转换
s := "abc" | |
b := []byte(s) | |
s2 := string(b) |
string 类型
介绍
string 是 8 位字节的汇合,通常但不肯定代表 UTF-8
编码的文本。string
能够为空,但不能为nil
。
字符串是一个不可扭转的字节序列。字符串能够蕴含任意的数据,包含 byte 值 0,然而通常是用来蕴含人类刻度的文本。文本字符串通常被解释为采纳 UTF8 编码的 Unicode 码点(rune)序列。
字符串底层是一个 byte 数组,所以能够和[]byte 类型互相转换。字符串是不能批改字符串是由 byte 字节组成,所以字符串的长度是 byte 字节的长度。
Go 语言源文件总是用 UTF8 编码,并且 Go 语言的文本字符串也是以 UTF8 编码的形式解决,因而咱们能够将 Unicode 码点也写到字符串面值中。
应用
拼接字符串:
package main | |
import ("fmt") | |
func main(){ | |
// %d 示意整形数字, %s 示意字符串 | |
var stockcode int = 123 | |
var enddate string = "2022-01-18" | |
var url string = "Code=%d&endDate=%s" | |
var target_url = fmt.Sprintf(url, stockcode, enddate) | |
fmt.Println(target_url) | |
} |
error 类型
介绍
error 类型是 Go 语言的一种内置类型,应用的时候不必特定去 import,它实质上是一个接口。
type error interface{Error() string //Error()是每一个订制的 error 对象须要填充的谬误音讯, 能够了解成是一个字段 Error}
应用
封装自定义谬误类型
package main | |
import ( | |
"fmt" | |
"errors" | |
) | |
type Error struct {err error} | |
func (e Error) MyError() string {return e.err.Error() | |
} | |
func main() { | |
err := Error {errors.New("test error"), | |
} | |
fmt.Println(err.MyError()) | |
} |
技术文章继续更新,请大家多多关注呀~~