免费的php网站模板,网站建设公司下载,正规的环保行业网站开发,wordpress 国外空间GO 语言的数据类型
Go 语言内置对以下这些基本数据类型的支持#xff1a; 布尔类型#xff1a;bool 整型#xff1a;int8、byte、int16、int、uint、uintptr 等 浮点类型#xff1a;float32、float64 复数类型#xff1a;complex64、complex128 字符串#xff1a;st…GO 语言的数据类型
Go 语言内置对以下这些基本数据类型的支持 布尔类型bool 整型int8、byte、int16、int、uint、uintptr 等 浮点类型float32、float64 复数类型complex64、complex128 字符串string 字符类型rune 错误类型error
GO 语言也支持以下复合类型 指针pointer 数组array 切片slice 字典map 通道chan 结构体struct 接口interface
与其他静态语言相比Go语言新增了通道类型该类型主要用于并发编程时不同协程间的通信。
结构体类似于面向对象编程中的类classGo语言沿用了C语言的该语法Go语言还把接口单独作为一个类型提取出来。
1 布尔类型
布尔类型的关键字为bool可赋值且只可以赋值为预定义常量true和false示例代码如下
var v1 bool
v1 true
v2 : (1 2) // v2 也会被推导为 bool 类型
fmt.Println(布尔类型初始化打印)
fmt.Println(v1, v2)
代码运行测试 Go语言是强类型语言变量类型一旦确定就不能够将其他类型的值赋值给该变量因此布尔类型不能接受其它类型的赋值也不支持自动或强制的类型转换。以下操作会导致Go语言的编译错误
var b bool
b 1
b boo1(1)
Go 语言中不同类型的值不能使用 或 ! 运算符进行比较在编译期就会报错示例代码如下
b : (false 0)
在编译期报错 2 整型和运算符
2.1 整型
整型是所有编程语言中最基础的数据类型Go语言默认支持如下整型类型
类型长度单位字节说明值范围默认值int81带符号8位整型-128~1270uint81无符号8位整型与 byte 类型等价0~2550int162带符号16位整型-32768~327670uint162无符号16位整型0~655350int324带符号32位整型与 rune 类型等价-2147483648~21474836470uint324无符号32位整型0~42949672950int648带符号64位整型-9223372036854775808~92233720368547758070uint648无符号64位整型0~184467440737095516150int32位或64位与具体平台相关与具体平台相关0uint32位或64位与具体平台相关与具体平台相关0uintptr与对应指针相同无符号整型足以存储指针值的未解释位32位平台下为4字节64位平台下为8字节0
Go语言针对整型类型划分较多可以根据需要选择适合的类型以节省内存开支。
注 如未注明整型的类型Go语言默认设置 Go语言中这些整型都是不同的数据类型例如 int 和 int32 在Go语言中被认为是不同的数据类型编译器也不会自动进行类型转换如下类似的操作就会报错
var intValue1 int8
// Go语言会将未声明的数字默认为int类型
intValue2 : 8
intValue1 intValue2 // 编译错误intValue1是int8类型intValue2是int类型
编译运行报错 使用强制类型转换可以解决这个编译错误
var intValue1 int8
// Go语言会将未声明的数字默认为int类型
intValue2 : 8
intValue1 int8(intValue2)
这里出现了一个错误 intValue1 declared and not used如果出现该错误建议在赋值语句前添加 _ 来忽略这个报错。
var intValue1 int8
intValue2 : 8 // Go语言会将未声明的数字默认为int类型
// intValue1 intValue2 // 编译错误intValue1是int8类型intValue2是int类型
_ intValue1 //忽略 declared and not used 错误
intValue1 int8(intValue2) // 正确将intValue2转换为int8类型
fmt.Printf(intValue1:%d, intValue2:%d\n, intValue1, intValue2)
我们还可以通过 intValue : uint8(intValue2) 这种方式同时完成类型转化和赋值操作。
2.2 运算符
2.2.1 算术运算符
GO 语言支持所有常规的整数四则运算、-、*、/ 和 %取余只能用于整数由于 GO 语言是强类型语言不同类型的整型值不能够直接进行运算否则会报错。
intValue3 : intValue1 intValue2 // int int8 intValue3 : int(intValue1) intValue2 // 使用强类型进行转换 此外也需要注意整型的溢出
var intValue1 int8
intValue1 128 // int8 可取值的范围在 -128~127 Go 语言中也支持自增/自减运算符即 、--是只能作为语句不能作为表达式且只能用作后缀不能放到变量前面
intValue1 : 10
intValue1 // 有效intValue1 的值变成 11
intValue1-- // 有效intValue1 的值变成 10
intValue1 intValue1 // 无效编译报错
--intValue1 // 无效编译报错
同样支持、-、*、/、% 这种快捷写法
intValue1, intValue2 : 10, 20
intValue1 intValue2
intValue1 - intValue2
intValue1 * intValue2
intValue1 / intValue2
intValue1 % 3 2.2.2 比较运算符
Go 语言支持以下几种常见的比较运算符 、、、、 和 !比较运算符运行的结果是布尔值。
intValue1, intValue2 : 10, 20if intValue1 intValue2 {fmt.Println(intValue1 intValue2)}
需要注意不同的整型类型同样不能够使用比较运算符但所有的比较运算都可以直接和数字进行比较。
var intValue3 int8 10
if intValue3 10 {fmt.Println(intValue3 10)
}
// 需要注意溢出的问题这里的直接比较是编译自动进行的转换
// 编译报错128 (untyped int constant) overflows int8
if intValue3 128 {fmt.Println(intValue3 128)
}
2.2.3 位运算符
Go 语言支持以下这几种位运算符
运算符含义结果x y按位与把 x 和 y 都为 1 的位设为 1x | y按位或把 x 或 y 为 1 的位设为 1x ^ y按位异或把 x 和 y 一个为 1 一个为 0 的位设为 1^x按位取反把 x 中为 0 的位设为 1为 1 的位设为 0x y左移把 x 中的位向左移动 y 次每次移动相当于乘以 2x y右移把 x 中的位向右移动 y 次每次移动相当于除以 2
位运算符代码测试
var intValue1 uint8
var intValue2 uint8
intValue1 255 // 1111 1111
intValue2 0 // 0000 0000
fmt.Println(intValue1 intValue2:, intValue1intValue2) // 按位与0
fmt.Println(intValue1 | intValue2:, intValue1|intValue2) // 按位或255
fmt.Println(intValue1 ^ intValue2:, intValue1^intValue2) // 按位异或255
fmt.Println(^intValue1:, ^intValue1) // 按位取反 0
fmt.Println(intValue1 1:, intValue11) // 左移1位254
fmt.Println(intValue1 1:, intValue11) // 右移1位127 2.2.3 逻辑运算符
Go语言支持以下逻辑运算符
运算符含义结果x y逻辑与运算符AND如果 x 和 y 都是 true则结果为 true否则结果为 falsex || y逻辑或运算符OR如果 x 或 y 是 true则结果为 true否则结果为 false!x逻辑非运算符NOT如果 x 为 true则结果为 false否则结果为 true
代码运行测试
intValue1, intValue2 : 10, 20
if intValue1 0 intValue2 0 {fmt.Println(intValue1 0 intValue2 0)
}
if intValue1 15 || intValue2 15 {fmt.Println(intValue1 15 || intValue2 15)
}
fmt.Println(!(intValue1 15):, !(intValue1 15)) 2.2.3 运算符优先级
// 优先级自高向低进行排列
^按位取反 !
* / % ^- | ^按位异或! ||
3 浮点型与复数类型
3.1 浮点型
3.1.1 浮点型的表示
浮点型也叫浮点数用于表示包含小数点的数据比如 3.14、1.00 都是浮点型数据。
Go语言中的浮点数采用 IEEE-754 标准的表达式定义了两个类型float32 和 float64其中float32是单精度浮点数可以精确到小数点后7位类似于PHP、Java等语言的float类型float64是双精度浮点数可以精确到小数点后15位类似于PHP、Java等语言的double类型。
Go语言中定义一个浮点型变量的代码如下
var floatValue1 float32
floatValue1 10
floatValue2 : 10.0 // 如果不加小数点floatValue2 会被推导为整型而不是浮点型
floatValue3 : 1.1e-10
对于浮点类型需要被自动推导的变量其类型将被自动设置为 float64而不管赋值给它的数字是否是用 32 位长度表示的。因此对于以上的例子下面的赋值将导致编译错误
floatValue1 floatValue2 floatValue1 float32(floatValue2) // 不同浮点类型的赋值必须要进行类型强制转换
在实际的开发中应该尽可能地使用 float64 类型因为 math 包中所有有关数学运算的函数都会要求接收这个类型。
3.1.2 浮点数的精度
浮点数不是一种精确的表达方式因为二进制无法精确表示所有十进制小数比如 0.1、0.7 这种如下代码进行演示
floatValue4 : 0.1
floatValue5 : 0.7
floatValue6 : floatValue4 floatValue5 // 浮点数的操作同样严格规范类型float32 和 float64不能够直接进行计算 0.1 0.7 输出结果并不是我们所想的0.8这是因为计算机底层将十进制的 0.1 和 0.7 转化为二进制表示时会丢失精度因此在实践中通常会建议避免直接比较浮点数是否相等而是使用一个小的容忍度epsilon来检查它们是否足够接近。
floatValue4 : 0.1floatValue5 : 0.7floatValue6 : floatValue4 floatValue5
epsilon : 1e-10sum : 0.8if math.Abs(sum-floatValue6) epsilon {fmt.Println(sum and c are approximately equal)} else {fmt.Println(sum and c are not equal)} 3.1.3 浮点数的比较
浮点数支持通过算术运算符进行四则运算也支持通过比较运算符进行比较前提是运算符两边的操作数类型一致但是涉及到相等的比较除外因为我们上面提到看起来相等的两个十进制浮点数在底层转化为二进制时会丢失精度因此不能被表象蒙蔽。
如果一定要判断浮点数的相等除去上面提到的精度也可以使用 math.Dim() 方法
floatValue1 : 0.1
floatValue2 : 0.1
p : 0.00001
// 判断 floatValue1 与 floatValue2 是否相等
if math.Dim(float64(floatValue1), floatValue2) p {fmt.Println(floatValue1 和 floatValue2 相等)
} 因此判断两个浮点数是否相同在Go语言中是通过判断两者相差的精度值其他语言中的浮点数判断也是如此。
3.2 复数类型
除了整型和浮点型之外Go 语言还支持复数类型与复数相对我们可以把整型和浮点型这种日常比较常见的数字称为实数复数是实数的延伸可以通过两个实数在计算机中用浮点数表示构成一个表示实部real一个表示虚部imag常见的表达形式如下
z a bi
其中 a、b 均为实数i 称为虚数单位当 b 0 时z 就是常见的实数当 a 0 而 b ≠ 0 时将 z 称之为纯虚数。
在 Go 语言中复数支持两种类型complex6432 位实部和虚部 和 complex12864 位实部与虚部对应的示例如下和数学概念中的复数表示形式一致
var complexValue1 complex64
complexValue1 1.10 10i // 由两个 float32 实数构成的复数类型
complexValue2 : 1.10 10i // 和浮点型一样默认自动推导的实数类型是 float64所以 complexValue2 是 complex128 类型
complexValue3 : complex(1.10, 10) // 与 complexValue2 等价 对于一个复数 z complex(x, y)就可以通过 Go 语言内置函数 real(z) 获得该复数的实部也就是 x通过 imag(z) 获得该复数的虚部也就是 y。
real : real(complexValue1) // 获取复数的实部
imag : imag(complexValue1) // 获取复数的虚部 复数支持和其它数字类型一样的算术运算符。当你使用 或者 ! 对复数进行比较运算时由于构成复数的实数部分也是浮点型需要注意对精度的把握。
更多关于复数的函数请查阅 math/cmplx 标准库的文档。如果你对内存的要求不是特别高最好使用 complex128 作为计算类型因为相关函数大都使用这个类型的参数。
4 字符串及底层字符类型
4.1 字符串
在 Go 语言中字符串是一种基本类型默认是通过 UTF-8 编码的字符序列当字符为 ASCII 码时则占用 1 个字节其它字符根据需要占用 2-4 个字节比如中文编码通常需要 3 个字节。
4.1.1 声明和初始化
var str string // 声明字符串变量
str Hello World // 变量初始化
str2 : Hello World // 也可以同时进行声明和初始化 也能够对这些字符串进行格式化输出
fmt.Printf(The length of \%s\ is %d \n, str, len(str)) 如下表格是格式化所使用的一些参数
动词功能%v按值的本来值输出%v在 % v 基础上对结构体字段名和值进行展开%#v输出 Go 语言语法格式的值%T输出 Go 语言语法格式的类型和值%%输出 % 本体%b整型以二进制方式显示%o整型以八进制方式显示%d整型以十进制方式显示%x整型以十六进制方式显示%X整型以十六进制、字母大写方式显示%UUnicode 字符%f浮点数%p指针十六进制方式显示
虽然可以通过下标访问字符串中的字符但是和数组不同在Go语言中字符串一旦初始化之后不允许被修改。 注意这里只是字符串中的字符不能被修改你可以整体修改字符串。 4.1.2 转义字符
Go 语言的字符串不支持单引号只能通过双引号定义字符串字面值如果要对特定字符进行转义可以通过 \ 实现就像我们上面在字符串中转义双引号和换行符那样常见的需要转义的字符如下所示 \n 换行符 \r 回车符 \t tab 键 \u 或 \U Unicode 字符 \\ 反斜杠自身
此外也可以通过如下方法在字符串中包含引号。
label : Search results for Golang: 多行字符串也可以通过构建。
results : Search results for Golang:- Go- Golang- Golang Programming
fmt.Println(results) 也可以使用 进行字符串的拼接
results Search results for \Golang\:\n - Go\n - Golang\n - Golang Programming\n
fmt.Printf(%s, results) 4.1.3 字符串操作
字符串连接
Go 内置提供了丰富的字符串函数常见的操作包含连接、获取长度和指定字符获取长度和指定字符前面已经介绍过字符串连接只需要通过 连接符即可
str : Hello
str str , World
str , World // 上述语句也可以简写为这样效果完全一样
此外字符串可能过长会出现换行的情况务必保证出现在上一行。
str str , World 字符串切片
在 Go 语言中可以通过字符串切片实现获取子串的功能。
str : hello, world
str1 : str[:5] // 获取索引5不含之前的子串
str2 : str[7:] // 获取索引7含之后的子串
str3 : str[0:5] // 获取从索引0含到索引5不含之间的子串
fmt.Println(str1:, str1)
fmt.Println(str2:, str2)
fmt.Println(str3:, str3) 字符串遍历
Go 语言支持两种方式遍历字符串。
// 方式一字节数组遍历
str : Hello, 世界
n : len(str)
for i : 0; i n; i {ch : str[i] // 依据下标取字符串中的字符ch 类型为 bytefmt.Println(i, ch)
}
// 方式二unicode字符遍历
str : Hello, 世界
for i, ch : range str { fmt.Println(i, ch) // ch 的类型为 rune
} 可以看出这个字符串长度为 13尽管从直观上来说这个字符串应该只有 9 个字符。这是因为每个中文字符在 UTF-8 中占 3 个字节而不是 1 个字节。 这个时候打印的就是 9 个字符了因为以 Unicode 字符方式遍历时每个字符的类型是 rune而不是 byte。
这里的 rune 和 byte 也即Go语言底层字符类型。 byte代表 UTF-8 编码中单个字节的值它也是 uint8 类型的别名两者是等价的因为正好占据 1 个字节的内存空间 rune代表单个 Unicode 字符它也是 int32 类型的别名因为正好占据 4 个字节的内存空间。
5 基本数据类型之间的转化
5.1 整型之间的转化
在进行类型转化时只需要调用要转化的数据类型对应的函数即可
v1 : uint(16) // 初始化 v1 类型为 unit
v2 : int8(v1) // 将 v1 转化为 int8 类型并赋值给 v2
v3 : uint16(v2) // 将 v2 转化为 uint16 类型并赋值给 v3
由高向低转换时需要注意整数的溢出
v1 : uint(-255) // uint 是无符号整型在编译时这里会产生溢出 v4 : int16(-255) // 这里也要注意溢出如这里是int8(-255)就会报错
5.2 整型和浮点数之间的转化
v1 : 99.99
v2 : int(v1) // 浮点数转化为整型小数点后的数字直接被抛弃
v3 : 99
v4 : float64(v3) // 整型转化为浮点数直接调取对应的类型即可 5.3 数值和浮点数的转换
目前 Go 语言不支持将数值类型转化为布尔型需要自己根据需求去实现类似的转化。
5.4 字符串和其他基本类型之间的转化
5.4.1 整型转化成字符串
整型数据可以通过 Unicode 字符集转化为对应的 UTF-8 编码的字符串
v1 : 65
v2 : string(v1) // v2 A
v3 : 30028
v4 : string(v3) 5.4.2 strconv 包
Go 语言默认不支持将字符串类型强制转化为数值类型即使字符串中包含数字也不行。
如果要实现更强大的基本数据类型与字符串之间的转化可以使用 Go 官方 strconv 包提供的函数
v1 : 100
v2, _ : strconv.Atoi(v1) // 将字符串转化为整型v2 100
v3 : 100
v4 : strconv.Itoa(v3) // 将整型转化为字符串, v4 100
v5 : true
v6, _ : strconv.ParseBool(v5) // 将字符串转化为布尔型
v5 strconv.FormatBool(v6) // 将布尔值转化为字符串
v7 : 100
v8, _ : strconv.ParseInt(v7, 10, 64) // 将字符串转化为整型第二个参数表示进制第三个参数表示最大位数
v7 strconv.FormatInt(v8, 10) // 将整型转化为字符串第二个参数表示进制
v9, _ : strconv.ParseUint(v7, 10, 64) // 将字符串转化为无符号整型参数含义同 ParseInt
v7 strconv.FormatUint(v9, 10) // 将无符号整数型转化为字符串参数含义同 FormatInt
v10 : 99.99
v11, _ : strconv.ParseFloat(v10, 64) // 将字符串转化为浮点型第二个参数表示精度
v10 strconv.FormatFloat(v11, E, -1, 64)
q : strconv.Quote(Hello, 世界) // 为字符串加引号
q strconv.QuoteToASCII(Hello, 世界) // 将字符串转化为 ASCII 编码
