所谓整型,主要用来表示现实世界中整型数量,比如年龄,分数,排名等等
Go 语言整型可以分为平台无关整型和平台相关整型这两种,它们的区别主要就在,这些整数类型在不同 CPU 架构或操作系统下面,它们的长度是否是一致的。
平台无关的整型也可以分成两类:
(int8~int64)
使用最高位(最左边的位)作为符号位,表示正数和负数。有符号整型的取值范围是从负数到正数,因此可以表示负数、零和正数。
(uint8~uint64)
不使用符号位,因此只能表示非负数(零和正数)。无符号整型的取值范围是从零到正数最大值。
类型 | 长度 | 取值范围 | |
---|---|---|---|
有符号整型 | int8 | 1个字节 | [-128, 127] |
int16 | 2个字节 | [-32768, 32767] | |
int32 | 4个字节 | [- 2147483648, 2147483647] | |
int64 | 8个字节 | [ -9223372036854775808, 9223372036854775807] | |
无符号整型 | uint8 | 1个字节 | [0, 255] |
uint16 | 2个字节 | [0, 65535] | |
uint32 | 4个字节 | [0, 4294967295] | |
uint64 | 8个字节 | [0, 18446744073709551615] |
有符号整型(int8int64)和无符号整型(uint8uint64)两者的本质差别在于最高二进制位(bit
位)是否被解释为符号位,这点会影响到无符号整型与有符号整型的取值范围。
以下图中的这个 8 比特(一个字节)的整型值为例,当它被解释为无符号整型 uint8 时,和它被解释为有符号整型 int8 时表示的值是不同的:
在同样的比特位表示下,当最高比特位被解释为符号位时,它代表一个有符号整型(int8),它表示的值为 -127;当最高比特位不被解释为符号位时,它代表一个无符号整型 (uint8),它表示的值为 129。
即便最高比特位被解释为符号位,上面的有符号整型所表示值也应该为 -1 啊,怎么会是 -127 呢?
这是因为 Go 采用 2 的补码(Two’s Complement)作为整型的比特位编码方法。因此,我们不能简单地将最高比特位看成负号,把其余比特位表示的值看成负号后面的数值。Go 的补码是通过原码逐位取反后再加 1 得到的,比如,我们以 -127 这个值为例,它的补码转换过程就是这样的:
类型 | 32位长度 | 64位长度 | |
---|---|---|---|
默认的有符号整型 | int | 32位(4字节) | 64位(8字节) |
默认的无符号整型 | unit | 32位(4字节) | 64位(8字节) |
无符号整型 | uintptr | “”“大到足以存储任意一个指针的值”“(Go规范描 述)” |
在这里我们要特别注意一点,由于这三个类型的长度是平台相关的,所以我们在编写有移植性要求的代码时,千万不要强依赖这些类型的长度。
如果你不知道这三个类型在目标运行平台上的长度,可以通过 unsafe
包提供的 SizeOf
函数来获取
比如在 x86-64 平台上,它们的长度均为 8:
var a, b = int(5), uint(6)
var p uintptr = 0x12345678
fmt.Println("signed integer a's length is", unsafe.Sizeof(a)) // 8
fmt.Println("unsigned integer b's length is", unsafe.Sizeof(b)) // 8
fmt.Println("uintptr's length is", unsafe.Sizeof(p)) // 8
无论哪种整型,都有它的取值范围,也就是有它可以表示的值边界。如果这个整型因为参与某个运算,导致结果超出了这个整型的值边界,我们就说发生了整型溢出的问题。由于整型无法表示它溢出后的那个“结果”,所以出现溢出情况后,对应的整型变量的值依然会落到它的取值范围内,只是结果值与我们的预期不符,导致程序逻辑出错。
var s int8 = 127
s += 1 // 预期128,实际结果-128
var u uint8 = 1
u -= 2 // 预期-1,实际结果255
你看,有符号整型变量 s
初始值为 127,在加 1 操作后,我们预期得到 128,但由于 128 超出了 int8
的取值边界,其实际结果变成了 -128。无符号整型变量 u
也是一样的道理,它的初值为 1,在进行减 2 操作后,我们预期得到 -1,但由于 -1 超出了 uint8 的取值边界,它的实际结果变成了 255。
这个问题最容易发生在循环语句的结束条件判断中,因为这也是经常使用整型变量的地方。无论无符号整型,还是有符号整型都存在溢出的问题,所以我们要十分小心地选择参与循环语句结束判断的整型变量类型,以及与之比较的边界值。
Go 语言在设计开始,就继承了 C 语言关于**数值字面值(Number Literal)**的语法形式。早期 Go 版本支持十进制、八进制、十六进制的数值字面值形式,比如:
a := 53 // 十进制
b := 0700 // 八进制,以"0"为前缀
c1 := 0xaabbcc // 十六进制,以"0x"为前缀
c2 := 0Xddeeff // 十六进制,以"0X"为前缀
Go 1.13 版本中,Go 又增加了对二进制字面值的支持和两种八进制字面值的形式,比如:
d1 := 0b10000001 // 二进制,以"0b"为前缀
d2 := 0B10000001 // 二进制,以"0B"为前缀
e1 := 0o700 // 八进制,以"0o"为前缀
e2 := 0O700 // 八进制,以"0O"为前缀
为提升字面值的可读性,Go 1.13 版本还支持在字面值中增加数字分隔符“_”,分隔符可以用来将数字分组以提高可读性。比如每 3 个数字一组,也可以用来分隔前缀与字面值中的第一个数字:
a := 5_3_7 // 十进制: 537
b := 0b_1000_0111 // 二进制位表示为10000111
c1 := 0_700 // 八进制: 0700
c2 := 0o_700 // 八进制: 0700
d1 := 0x_5c_6d // 十六进制:0x5c6d
不过,这里你要注意一下,Go 1.13 中增加的二进制字面值以及数字分隔符,只在 go.mod 中的 go version 指示字段为 Go 1.13 以及以后版本的时候,才会生效,否则编译器会报错。
反过来,我们也可以通过标准库 fmt 包的格式化输出函数,将一个整型变量输出为不同进制的形式。比如下面就是将十进制整型值 59,格式化输出为二进制、八进制和十六进制的代码:
var a int8 = 59
fmt.Printf("%b\n", a) //输出二进制:111011
fmt.Printf("%d\n", a) //输出十进制:59
fmt.Printf("%o\n", a) //输出八进制:73
fmt.Printf("%O\n", a) //输出八进制(带0o前缀):0o73
fmt.Printf("%x\n", a) //输出十六进制(小写):3b
fmt.Printf("%X\n", a) //输出十六进制(大写):3B
IEEE 754
标准IEEE 754 是 IEEE 制定的二进制浮点数算术标准,它是 20 世纪 80 年代以来最广泛使用的浮点数运算标准,被许多 CPU 与浮点运算器采用。现存的大部分主流编程语言,包括 Go 语言,都提供了符合 IEEE 754 标准的浮点数格式与算术运算。
IEEE 754 标准规定了四种表示浮点数值的方式:单精度(32 位)、双精度(64 位)、扩展单精度(43 比特以上)与扩展双精度(79 比特以上,通常以 80 位实现)。后两种其实很少使用,我们重点关注前面两个就好了。
Go语言支持两种浮点型数:float32
和float64
。这两种浮点型数据格式遵循IEEE 754
标准。
浮点类型与前面的整型相比,Go 提供的浮点类型都是平台无关的。
float32
与float64
这两种浮点类型有什么异同点呢?无论是 float32
还是 float64
,它们的变量的默认值都为 0.0,不同的是它们占用的内存空间大小是不一样的,可以表示的浮点数的范围与精度也不同。那么浮点数在内存中的二进制表示究竟是怎么样的呢?
浮点数在内存中的二进制表示(Bit Representation)要比整型复杂得多,IEEE 754 规范给出了在内存中存储和表示一个浮点数的标准形式,见下图:
我们看到浮点数在内存中的二进制表示分三个部分:符号位、阶码(即经过换算的指数),以及尾数。这样表示的一个浮点数,它的值等于:
其中浮点值的符号由符号位决定:当符号位为 1 时,浮点值为负值;当符号位为 0 时,浮点值为正值。公式中 offset 被称为阶码偏移值,这个我们待会再讲。
**我们首先来看单精度(float32)与双精度(float64)浮点数在阶码和尾数上的不同。**这两种浮点数的阶码与尾数所使用的位数是不一样的,你可以看下 IEEE 754 标准中单精度和双精度浮点数的各个部分的长度规定:
我们看到,单精度浮点类型(float32)为符号位分配了 1 个 bit,为阶码分配了 8 个 bit,剩下的 23 个 bit 分给了尾数。而双精度浮点类型,除了符号位的长度与单精度一样之外,其余两个部分的长度都要远大于单精度浮点型,阶码可用的 bit 位数量为 11,尾数则更是拥有了 52 个 bit 位。
**接着,我们再来看前面提到的“阶码偏移值”,我想用一个例子直观地让你感受一下。**在这个例子中,我们来看看如何将一个十进制形式的浮点值 139.8125,转换为 IEEE 754 规定中的那种单精度二进制表示。
步骤一:我们要把这个浮点数值的整数部分和小数 部分,分别转换为二进制形式(后缀 d 表示十进制数,后缀 b 表示二进制数):
这样,原浮点值 139.8125d 进行二进制转换后,就变成 10001011.1101b。
**步骤二:移动小数点,直到整数部分仅有一个 1,也就是 10001011.1101b => 1.00010111101b。**我们看到,为了整数部分仅保留一个 1,小数点向左移了 7 位,这样指数就为 7,尾数为 00010111101b。
步骤三:计算阶码。
IEEE754 规定不能将小数点移动得到的指数,直接填到阶码部分,指数到阶码还需要一个转换过程。对于 float32 的单精度浮点数而言,阶码 = 指数 + 偏移值。偏移值的计算公式为 2^(e-1)-1,其中 e 为阶码部分的 bit 位数,这里为 8,于是单精度浮点数的阶码偏移值就为 2^(8-1)-1 = 127。这样在这个例子中,阶码 = 7 + 127 = 134d = 10000110b。float64 的双精度浮点数的阶码计算也是这样的。
**步骤四:将符号位、阶码和尾数填到各自位置,得到最终浮点数的二进制表示。**尾数位数不足 23 位,可在后面补 0。
这样,最终浮点数 139.8125d 的二进制表示就为 0b_0_10000110_00010111101_000000000000。
最后,我们再通过 Go 代码输出浮点数 139.8125d 的二进制表示,和前面我们手工转换的做一下比对,看是否一致。
func main() {
var f float32 = 139.8125
bits := math.Float32bits(f)
fmt.Printf("%b\n", bits)
}
在这段代码中,我们通过标准库的 math 包,将 float32 转换为整型。在这种转换过程中,float32 的内存表示是不会被改变的。然后我们再通过前面提过的整型值的格式化输出,将它以二进制形式输出出来。运行这个程序,我们得到下面的结果:
1000011000010111101000000000000
我们看到这个值在填上省去的最高位的 0 后,与我们手工得到的浮点数的二进制表示一模一样。这就说明我们手工推导的思路并没有错。
而且,你可以从这个例子中感受到,阶码和尾数的长度决定了浮点类型可以表示的浮点数范围与精度。因为双精度浮点类型(float64)阶码与尾数使用的比特位数更多,它可以表示的精度要远超单精度浮点类型,所以在日常开发中,我们使用双精度浮点类型(float64)的情况更多,这也是 Go 语言中浮点常量或字面值的默认类型。
而 float32 由于表示范围与精度有限,经常会给开发者造成一些困扰。比如我们可能会因为 float32 精度不足,导致输出结果与常识不符。比如下面这个例子就是这样,f1 与 f2 两个浮点类型变量被两个不同的浮点字面值初始化,但逻辑比较的结果却是两个变量的值相等。至于其中原因,我将作为思考题留给你,你可以结合前面讲解的浮点类型表示方法,对这个例子进行分析:
var f1 float32 = 16777216.0
var f2 float32 = 16777217.0
fmt.Println(f1 == f2) // true
看到这里,你是不是觉得浮点类型很神奇?和易用易理解的整型相比,浮点类型无论在二进制表示层面,还是在使用层面都要复杂得多。
这一类,我们通过字面值就可直接确定它的浮点值,比如:
3.1415
.15 // 整数部分如果为0,整数部分可以省略不写
81.80
82. // 小数部分如果为0,小数点后的0可以省略不写
采用科学计数法表示的浮点字面值,我们需要通过一定的换算才能确定其浮点值。而且在这里,科学计数法形式又分为十进制形式表示的,和十六进制形式表示的两种。
使用十进制科学计数法形式的浮点数字面值,这里字面值中的 e/E 代表的幂运算的底数为 10:
6674.28e-2 // 6674.28 * 10^(-2) = 66.742800
.12345E+5 // 0.12345 * 10^5 = 12345.000000
接着是十六进制科学计数法形式的浮点数:
0x2.p10 // 2.0 * 2^10 = 2048.000000
0x1.Fp+0 // 1.9375 * 2^0 = 1.937500
这里,我们要注意,十六进制科学计数法的整数部分、小数部分用的都是十六进制形式,但指数部分依然是十进制形式,并且字面值中的 p/P 代表的幂运算的底数为 2。
知道了浮点型的字面值后,和整型一样,fmt 包也提供了针对浮点数的格式化输出。我们最常使用的格式化输出形式是 %f
。通过 %f
,我们可以输出浮点数最直观的原值形式。
var f float64 = 123.45678
fmt.Printf("%f\n", f) // 123.456780
我们也可以将浮点数输出为科学计数法形式,如下面代码:
fmt.Printf("%e\n", f) // 1.234568e+02
fmt.Printf("%x\n", f) // 0x1.edd3be22e5de1p+06
其中 %e 输出的是十进制的科学计数法形式,而 %x 输出的则是十六进制的科学计数法形式。
math
包是Go语言标准库中的一个核心包,它提供了各种数学函数和常量,用于进行各种数学操作。
在Go语言中,数字类型的极值常量通常存储在math
包中。这些常量用于表示浮点数和整数类型的最大值和最小值,以及其他数学常量。
int
和 uint
族都有最大值和最小值。float32
和 float64
只有最大值和最小正数, 没有最小值。以下是一些常见的math
包中的数字类型极值常量:
math.MaxInt8
: int8
类型的最大值。math.MinInt8
: int8
类型的最小值。math.MaxInt16
: int16
类型的最大值。math.MinInt16
: int16
类型的最小值。math.MaxInt32
: int32
类型的最大值。math.MinInt32
: int32
类型的最小值。math.MaxInt64
: int64
类型的最大值。math.MinInt64
: int64
类型的最小值。math.MaxFloat32
: float32
类型的最大正有限值。math.SmallestNonzeroFloat32
: float32
类型的最小正非零值。math.MaxFloat64
: float64
类型的最大正有限值。math.SmallestNonzeroFloat64
: float64
类型的最小正非零值。math.Pi
: 圆周率 π 的近似值。math.E
: 自然对数的底数 e 的近似值。math.Sqrt2
和 math.SqrtE
:平方根的近似值。这些常量可以在你的Go程序中使用,以便在算法和数学计算中引用数字类型的极值和常量。例如,你可以使用 math.MaxInt64
来表示 int64
类型的最大值,以便进行整数计算时进行比较或限制数值范围。同样,math.Pi
可用于计算圆的周长或面积等数学运算。
package main
import (
"fmt"
"math"
)
func main() {
// 整数类型的极值
fmt.Println("int8 Max:", math.MaxInt8)
fmt.Println("int8 Min:", math.MinInt8)
fmt.Println("int16 Max:", math.MaxInt16)
fmt.Println("int16 Min:", math.MinInt16)
fmt.Println("int32 Max:", math.MaxInt32)
fmt.Println("int32 Min:", math.MinInt32)
fmt.Println("int64 Max:", math.MaxInt64)
fmt.Println("int64 Min:", math.MinInt64)
// 浮点数类型的极值
fmt.Println("float32 Max:", math.MaxFloat32)
fmt.Println("float32 Smallest Non-zero:", math.SmallestNonzeroFloat32)
fmt.Println("float64 Max:", math.MaxFloat64)
fmt.Println("float64 Smallest Non-zero:", math.SmallestNonzeroFloat64)
// 其他数学常量
fmt.Println("Pi:", math.Pi)
fmt.Println("E:", math.E)
fmt.Println("Sqrt(2):", math.Sqrt2)
fmt.Println("Sqrt(E):", math.SqrtE)
}
int
家族:int8
、int16
、int32
、int64
、int
。在内存中分别用 1、2、4、8 个字节来表达,而 int 用几个字节则取决于CPU。目前大多数 int 都是 8 字节。 如果犹豫不决,就优先使用int
,特殊情况除外。
uint
家族:uint8
、uint16
、uint32
、uint64
、 uint
。无符号整数,类似于 int 家族,优先使用 uint。
float
家族:float32、float64。浮点数,优先使用 float64
。
数学课本上将形如 z=a+bi
(a、b 均为实数,a 称为实部,b 称为虚部)的数称为复数。
Go 语言则原生支持复数类型。
和整型、浮点型相比,复数类型在 Go 中的应用就更为局限和小众,主要用于专业领域的计算,比如矢量计算等。我们简单了解一下就可以了。
Go 提供两种复数类型,它们分别是 complex64
和 complex128
。
complex64
的实部与虚部都是 float32
类型,而 complex128
的实部与虚部都是 float64
类型。
如果一个复数没有显示赋予类型,那么它的默认类型为 complex128
。
关于复数字面值的表示,我们其实有三种方法。
第一种,我们可以通过复数字面值直接初始化一个复数类型变量:
var c = 5 + 6i
var d = 0o123 + .12345E+5i // 83+12345i
第二种,Go 还提供了 complex 函数,方便我们创建一个 complex128 类型值:
var c = complex(5, 6) // 5 + 6i
var d = complex(0o123, .12345E+5) // 83+12345i
第三种,你还可以通过 Go 提供的预定义的函数 real 和 imag,来获取一个复数的实部与虚部,返回值为一个浮点类型:
var c = complex(5, 6) // 5 + 6i
r := real(c) // 5.000000
i := imag(c) // 6.000000
复数形式的格式化输出的问题,由于 complex 类型的实部与虚部都是浮点类型,所以我们可以直接运用浮点型的格式化输出方法,来输出复数类型,以下是一个示例:
package main
import "fmt"
func main() {
// 创建复数
z := complex(3, 4) // 3 + 4i
// 获取复数的实部和虚部,并使用浮点型格式化输出
realPart := real(z)
imagPart := imag(z)
fmt.Printf("Real Part: %f\n", realPart)
fmt.Printf("Imaginary Part: %f\n", imagPart)
}
在Go语言中,可以使用bool
关键字来声明布尔类型变量,这些变量只能取 true
(真)或 false
(假)这两个值。
var isTrue bool = true
var isFalse bool = false
默认值:布尔类型变量的默认值为false
。
var a bool
fmt.Println(a) // 输出为false
强制类型转换:Go语言不允许将整数或其他数据类型强制转换为布尔型。只有布尔类型的值可以被用于布尔表达式中,比如条件语句。
var x string = "2222"
// 错误,cannot convert x (variable of type string) to type bool
var isTrue bool = bool(x)
fmt.Println(isTrue)
数值运算和转换:布尔型无法直接参与数值运算,也无法与其他数据类型进行数值转换。这是因为布尔类型只有两个可能的值,不适合数学运算或数值转换。
var b bool = true
var i int = 10
// 错误,无法将布尔型和整数相加
// var result = b + i
// 错误,无法将整数转换为布尔型
// var b2 bool = bool(i)
运算符 | 说明 | 示例 | 结果 |
---|---|---|---|
! (非) | 取反,将真变假,假变真 | !true | false |
&& (与) | 两边都为真,结果为真,否则为假 | true && false | false |
|| (或) | 两边任意一边为真,结果为真,两边都为假,结果为假 | true || false | true |
== (等于) | 两边相等,结果为真;不相等,结果为假 | 1 == 1 | true |
!= (不等于) | 两边不相等,结果为真;相等,结果为假 | 1 != 2 | true |
package main
import "fmt"
func main() {
var isTrue bool = true
var isFalse bool = false
// 布尔值的逻辑运算
andResult := isTrue && isFalse // 与运算,结果为 false
orResult := isTrue || isFalse // 或运算,结果为 true
notResult := !isTrue // 非运算,结果为 false
fmt.Println("AND result:", andResult)
fmt.Println("OR result:", orResult)
fmt.Println("NOT result:", notResult)
}
使用双引号" "来定义:
s1 := "This is a string"
使用反引号 `` 来定义:
var s string = ` ,_---~~~~~----._
_,,_,*^____ _____*g*\"*,--,
/ __/ /' ^. / \ ^@q f
[ @f | @)) | | @)) l 0 _/
\/ \~____ / __ \_____/ \
| _l__l_ I
} [______] I
] | | | |
] ~ ~ |
| |
| |`
fmt.Println(s)
多行字符串中可以直接加入换行,并且会原样保留换行符。
多行字符串常用于需要编写包含换行的长文本。
需要注意:
Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等,如下表所示。
转义符 | 含义 |
---|---|
\r |
回车符(返回行首) |
\n |
换行符(直接跳到下一行的同列位置) |
\t |
制表符 |
\' |
单引号 |
\" |
双引号 |
\\ |
反斜杠 |
举个例子,我们要打印一个Windows平台下的一个文件路径:
package main
import (
"fmt"
)
func main() {
fmt.Println("str := \"c:\\Code\\lesson1\\go.exe\"")
}
Go 语言规定,字符串类型的值在它的生命周期内是不可改变的。这就是说,如果我们声明了一个字符串类型的变量,那我们是无法通过这个变量改变它对应的字符串值的,但这并不是说我们不能为一个字符串类型变量进行二次赋值。
什么意思呢?我们看看下面的代码就好理解了:
var s string = "hello"
s[0] = 'k' // 错误:字符串的内容是不可改变的
s = "gopher" // ok
在这段代码中,我们声明了一个字符串类型变量 s。当我们试图通过下标方式把这个字符串的第一个字符由 h 改为 k 的时候,我们会收到编译器错误的提示:字符串是不可变的。但我们仍可以像最后一行代码那样,为变量 s 重新赋值为另外一个字符串。
Go 这样的“字符串类型数据不可变”的性质给开发人员带来的最大好处,就是我们不用再担心字符串的并发安全问题。这样,Go 字符串可以被多个 Goroutine(Go 语言的轻量级用户线程)共享,开发者不用因为担心并发安全问题,使用会带来一定开销的同步机制。
另外,也由于字符串的不可变性,针对同一个字符串值,无论它在程序的几个位置被使用,Go 编译器只需要为它分配一块存储就好了,大大提高了存储利用率。
UTF-8
编码Go 语言源文件默认采用的是 Unicode 字符集,Unicode 字符集是目前市面上最流行的字符集,它囊括了几乎所有主流非 ASCII 字符(包括中文字符)。Go 字符串中的每个字符都是一个 Unicode 字符,并且这些 Unicode 字符是以 UTF-8 编码格式存储在内存当中的。
使用+操作符拼接字符串
s := "hello" + " world"
println(s)
通过fmt.Sprintf
进行格式化拼接
println(fmt.Sprintf("hello %d", 123))
使用len()
获取字符串字节长度:
println(len("你好")) // 输出6
println(len("你好abc")) // 输出9
使用utf8.RuneCountInString()
函数获取字符个数:
println(utf8.RuneCountInString("你好abc")) // 输出5
在字符串的实现中,真正存储数据的是底层的数组。字符串的下标操作本质上等价于底层数组的下标操作。可以通过索引下标访问字符串中每个字符:
var s = "中国人"
fmt.Printf("0x%x\n", s[0]) // 0xe4:字符“中” utf-8编码的第一个字节
我们可以看到,通过下标操作,我们获取的是字符串中特定下标上的字节,而不是字符。
Go 有两种迭代形式:常规 for
迭代与 for range
迭代。你要注意,通过这两种形式的迭代对字符串进行操作得到的结果是不同的。
通过常规 for 迭代对字符串进行的操作是一种字节视角的迭代,每轮迭代得到的的结果都是组成字符串内容的一个字节,以及该字节所在的下标值,这也等价于对字符串底层数组的迭代,比如下面代码:
var s = "中国人"
for i := 0; i < len(s); i++ {
fmt.Printf("index: %d, value: 0x%x\n", i, s[i])
}
运行这段代码,我们会看到,经过常规 for 迭代后,我们获取到的是字符串里字符的 UTF-8 编码中的一个字节:
index: 0, value: 0xe4
index: 1, value: 0xb8
index: 2, value: 0xad
index: 3, value: 0xe5
index: 4, value: 0x9b
index: 5, value: 0xbd
index: 6, value: 0xe4
index: 7, value: 0xba
index: 8, value: 0xba
像下面这样使用 for range 迭代,我们得到的又是什么呢?我们继续看代码:
var s = "中国人"
for i, v := range s {
fmt.Printf("index: %d, value: 0x%x\n", i, v)
}
同样运行一下这段代码,我们得到:
index: 0, value: 0x4e2d
index: 3, value: 0x56fd
index: 6, value: 0x4eba
我们看到,通过 for range 迭代,我们每轮迭代得到的是字符串中 Unicode 字符的码点值,以及该字符在字符串中的偏移值。我们可以通过这样的迭代,获取字符串中的字符个数,而通过 Go 提供的内置函数 len,我们只能获取字符串内容的长度(字节个数)。当然了,获取字符串中字符个数更专业的方法,是调用标准库 UTF-8 包中的 RuneCountInString 函数。
Go 字符串类型支持各种比较关系操作符,包括 = =、!= 、>=、<=、> 和 <。在字符串的比较上,Go 采用字典序的比较策略,分别从每个字符串的起始处,开始逐个字节地对两个字符串类型变量进行比较。
当两个字符串之间出现了第一个不相同的元素,比较就结束了,这两个元素的比较结果就会做为串最终的比较结果。如果出现两个字符串长度不同的情况,长度比较小的字符串会用空元素补齐,空元素比其他非空元素都小。
以下是Go 字符串比较的示例:
func main() {
// ==
s1 := "世界和平"
s2 := "世界" + "和平"
fmt.Println(s1 == s2) // true
// !=
s1 = "Go"
s2 = "C"
fmt.Println(s1 != s2) // true
// < and <=
s1 = "12345"
s2 = "23456"
fmt.Println(s1 < s2) // true
fmt.Println(s1 <= s2) // true
// > and >=
s1 = "12345"
s2 = "123"
fmt.Println(s1 > s2) // true
fmt.Println(s1 >= s2) // true
}
你可以看到,鉴于 Go string 类型是不可变的,所以说如果两个字符串的长度不相同,那么我们不需要比较具体字符串数据,也可以断定两个字符串是不同的。但是如果两个字符串长度相同,就要进一步判断,数据指针是否指向同一块底层存储数据。如果还相同,那么我们可以说两个字符串是等价的,如果不同,那就还需要进一步去比对实际的数据内容。
在这方面,Go 支持字符串与字节切片、字符串与 rune 切片的双向转换,并且这种转换无需调用任何函数,只需使用显式类型转换就可以了。我们看看下面代码:
var s string = "中国人"
// string -> []rune
rs := []rune(s)
fmt.Printf("%x\n", rs) // [4e2d 56fd 4eba]
// string -> []byte
bs := []byte(s)
fmt.Printf("%x\n", bs) // e4b8ade59bbde4baba
// []rune -> string
s1 := string(rs)
fmt.Println(s1) // 中国人
// []byte -> string
s2 := string(bs)
fmt.Println(s2) // 中国人
strings包提供了Go语言字符串操作的常用API:
函数 | 说明 |
---|---|
strings.Contains(s, substr) | 判断字符串s是否包含子串substr |
strings.Index(s, substr) | 返回子串substr在s中首次出现的索引 |
strings.Join(a[]string, sep) | 将字符串数组a通过sep连接起来 |
strings.Repeat(s, count) | 重复s字符串count次 |
strings.Replace(s, old, new, n) | 将s中的old子串替换为new,最多n次 |
strings.Split(s, sep) | 通过sep分割s字符串,返回子串数组 |
strings.ToLower(s) | s全部转为小写 |
strings.ToUpper(s) | s全部转为大写 |
strings.Fields(s) | 将字符串s按空格分解为子串数组 |
strings.TrimSpace(s) | 去除s头尾空白字符 |
组成每个字符串的元素叫做“字符”,可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号(’)包裹起来,如:
var a = '中'
var b = 'x'
byte
类型代表了ASCII
码的一个字符。字节的值范围是0到255。是 uint8
的别名。例如:
var a byte = 'A'
rune
是 int32
的别名,它用于表示32位的Unicode字符,范围从0到65535,。rune
类型通常用于处理文本和字符串,特别是当需要支持多语言字符集(如UTF-8编码的Unicode字符)时。比如:需要处理中文、日文或者其他复合字符时,则需要用到rune
类型。例如:
var a rune = '国'
以下是一些示例,演示了byte
和 rune
类型的用法:
package main
import "fmt"
func main() {
// 使用 byte 表示单个 ASCII 字符
var ch byte = 'A'
fmt.Printf("byte: %c\n", ch)
// 使用 rune 表示 Unicode 字符
var ru rune = '你'
fmt.Printf("rune: %c\n", ru)
// 使用 rune 处理字符串中的 Unicode 字符
str := "你好,世界!"
for _, char := range str {
fmt.Printf("rune: %c\n", char)
}
}
在上述示例中,我们首先使用 byte
和 rune
分别表示单个ASCII字符和Unicode字符。然后,我们使用 rune
处理包含多个Unicode字符的字符串。
总之,byte
和 rune
类型在Go语言中用于处理字符和字节,其中 byte
主要用于处理ASCII字符和字节数据,而 rune
用于处理Unicode字符,特别是用于处理多语言文本。
Go语言中只有强制类型转换,没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。
强制类型转换的基本语法如下:
T(expression)
其中,T
表示要转换的目标类型,expression
是要转换的表达式。这个语法只能在两种数据类型之间支持相互转换的情况下使用。
以下是一些示例,演示了不同数据类型之间的强制类型转换:
package main
import "fmt"
func main() {
// 整数到浮点数的转换
var x int = 42
y := float64(x)
fmt.Printf("x: %d, y: %f\n", x, y)
// 浮点数到整数的转换(截断小数部分)
var a float64 = 3.14
b := int(a)
fmt.Printf("a: %f, b: %d\n", a, b)
// 类型不匹配,需要显式转换
var c int = 10
var d int64 = int64(c)
fmt.Printf("c: %d, d: %d\n", c, d)
// 字符串到字节切片的转换
str := "Hello, Go!"
bytes := []byte(str)
fmt.Printf("str: %s, bytes: %v\n", str, bytes)
}
要注意的是,强制类型转换必须在相互兼容的类型之间进行,且需要明确指定目标类型,不会自动进行隐式转换。
如果我们要通过 Go
提供的类型定义语法,来创建自定义的数值类型,我们可以通过 type
关键字基于原生内置类型来声明一个新类型。
下面我们就来建立一个名为 MyInt 的新的数值类型看看:
type MyInt int32
这里,因为 MyInt 类型的底层类型是 int32,所以它的数值性质与 int32 完全相同,但它们仍然是完全不同的两种类型。根据 Go 的类型安全规则,我们无法直接让它们相互赋值,或者是把它们放在同一个运算中直接计算,这样编译器就会报错。
var m int = 5
var n int32 = 6
var a MyInt = m // 错误:在赋值中不能将m(int类型)作为MyInt类型使用
var a MyInt = n // 错误:在赋值中不能将n(int32类型)作为MyInt类型使用
要避免这个错误,我们需要借助显式转型,让赋值操作符左右两边的操作数保持类型一致,像下面代码中这样做:
var m int = 5
var n int32 = 6
var a MyInt = MyInt(m) // ok
var a MyInt = MyInt(n) // ok
我们也可以通过 Go 提供的类型别名(Type Alias)语法来自定义数值类型。和上面使用标准 type 语法的定义不同的是,通过类型别名语法定义的新类型与原类型别无二致,可以完全相互替代。我们来看下面代码:
type MyInt = int32
var n int32 = 6
var a MyInt = n // ok
你可以看到,通过类型别名定义的 MyInt 与 int32 完全等价,所以这个时候两种类型就是同一种类型,不再需要显式转型,就可以相互赋值。
运算符 | 描述 | 示例 |
---|---|---|
+ | 加法 | x + y |
- | 减法 | x - y |
* | 乘法 | x * y |
/ | 除法 | x / y |
% | 求余 | x % y |
++ | 自增 | x++ |
– | 自减 | x– |
在Go语言中,数字类型(包括整数和浮点数)支持基本的数学运算,包括加法、减法、乘法和除法。以下是这些运算的示例:
package main
import "fmt"
func main() {
// 整数运算
var a, b int = 10, 5
// 加法
sum := a + b
fmt.Printf("a + b = %d\n", sum)
// 减法
difference := a - b
fmt.Printf("a - b = %d\n", difference)
// 乘法
product := a * b
fmt.Printf("a * b = %d\n", product)
// 除法
quotient := a / b
fmt.Printf("a / b = %d\n", quotient)
// 浮点数运算
var x, y float64 = 3.14, 1.5
// 加法
sumFloat := x + y
fmt.Printf("x + y = %f\n", sumFloat)
// 减法
differenceFloat := x - y
fmt.Printf("x - y = %f\n", differenceFloat)
// 乘法
productFloat := x * y
fmt.Printf("x * y = %f\n", productFloat)
// 除法
quotientFloat := x / y
fmt.Printf("x / y = %f\n", quotientFloat)
}
下面例子中 f1
为何会与 f2
相等?
package main
import "fmt"
func main() {
var f1 float32 = 16777216.0
var f2 float32 = 16777217.0
fmt.Println(f1 == f2) // true
}
欢迎在留言区留下你的答案。