关于golang:Go-专栏｜基础数据类型整数浮点数复数布尔值和字符串

原文链接： Go 专栏|根底数据类型：整数、浮点数、复数、布尔值和字符串

Go 专栏的第三篇，本文内容仍旧很根底，很简略。如果有编程教训的话，可能扫一眼就了然于胸了。但如果刚开始接触编程，倡议还是好好看看，把文中的代码 demo 都本人跑一遍。只有根底打好了，能力向更高的指标迈进。

话不多说，走起～

本文所有代码基于 go1.16.6 编写。

Go 的数据类型分四大类：

1. 根底类型： 数字 number，字符串 string 和布尔型 boolean。
2. 聚合类型： 数组 array 和构造体 struct。
3. 援用类型： 指针 pointer，切片 slice，字典 map，函数 func 和通道 channel。
4. 接口类型： 接口 interface。

其中，根底类型又分为：

1. 整型： int8、uint8、byte、int16、uint16、int32、uint32、int64、uint64、int、uint、uintptr。
2. 浮点型： float32，float64。
3. 复数类型： complex64、complex128。
4. 布尔型： bool。
5. 字符串： string。
6. 字符型： rune。

整数

整数一共有 12 种类型，分为有符号整数和无符号整数，为了不便查看，我在这里整顿了一个表格：

个别咱们在开发的时候，应用 int 和 uint 即可。除非有明确须要指定长度的需要，才用 int8 这种类型。

类型转换

不论是算术运算，还是逻辑运算，Go 要求操作数的类型必须统一，如果不统一的话，会报错。

var a int = 10
var b int32 = 20

// fmt.Println(a + b)    // 报错 invalid operation: a + b (mismatched types int and int32)

这一点在写代码的时候，开发工具就会揭示了，而且还会把强制类型转换的代码给写好，还是很棒的。

var a int = 10
var b int32 = 20
fmt.Println(a + int(b)) // 输入 30

但有一点须要留神，当浮点型转整型的话，可能会有精度损失。

var c float32 = 10.23
fmt.Println(int(c)) // 输入 10

数值运算

算数运算符包含：+、-、*、/ 和 %。

% 取模运算符只能用于整数，取模余数的正负号与被除数统一。

// 取模
fmt.Println(5 % 3)   // 输入 2
fmt.Println(-5 % -3) // 输入 -2

/ 除法运算符，如果操作数都是整数，则后果也是整数。

// 除法
fmt.Println(5 / 3)     // 输入 1
fmt.Println(5.0 / 3.0) // 输入 1.6666666666666667

比拟运算

比拟运算符包含：>、>=、<、<=、== 和 !=。

不同类型之间不可比拟，但整型能够与字面量间接比拟。

// 比拟运算
var i int32
var j int64
i, j = 1, 2

// if i == j {// 报错 invalid operation: i == j (mismatched types int32 and int64)
//     fmt.Println("i and j are equal.")
// }
if i == 1 || j == 2 {fmt.Println("equal.")
}

位运算

位运算符包含：&、|、^、&^、<< 和 >>。

这个就不过多介绍了，平时开发过程中用到的也比拟少。

浮点数

浮点类型包含两种，别离是 float32 和 float64。

浮点数字面量会被主动推断为 float64。

f := 10.0   // 主动推断为 float64

当对浮点数进行比拟运算时，不能间接应用 == 和 !=，后果会不稳固。应该应用 math 规范库。

复数

复数类型包含两种，别离是 complex64 和 complex128。

操作复数的内置函数一共有 3 个，别离是：

1. complex：结构一个复数。
2. real：获取复数的实部。
3. imag：获取复数的虚部。

// 复数
var x complex64 = 3 + 5i
var y complex128 = complex(3.5, 10)
// 别离打印实部和虚部
fmt.Println(real(x), imag(x)) // 输入 3 5
fmt.Println(real(y), imag(y)) // 输入 3.5 10

布尔值

布尔类型的关键字是 bool，有两个值，别离是：true 和 false。

ok := true
fmt.Println(ok)

布尔型和整型不能互相转换。

var e bool
e = bool(1)    // 报错  cannot convert 1 (type untyped int) to type bool

if 和 for 语句的条件局部肯定是布尔类型的值或表达式。如果之前写 Python 比拟多的话，肯定要留神这点，我就在这翻过车。

m := 1
// if m {// 报错 non-bool m (type int) used as if condition
//     fmt.Println("is true")
// }
if m == 1 {fmt.Println("m is 1")
}

字符串

字符串关键字是 string，也属于一种根本类型。

字符串能够间接通过字面量来初始化：

// 字符串
s1 := "hello"
s2 := "world"

应用 ` 定义不做本义的原始字符串，反对换行：

// 原始字符串
s := `row1\r\n
row2`
fmt.Println(s)

拼接字符串：

// 字符串拼接
s3 := s1 + s2
fmt.Println(s3)

获取字符串长度：

// 取字符串长度
fmt.Println(len(s3))

按索引下标来获取字符：

 // 取单个字符
fmt.Println(s3[4])

字符串切片：

 // 字符串切片
fmt.Println(s3[2:4])
fmt.Println(s3[:4])
fmt.Println(s3[2:])
fmt.Println(s3[:])

字符串是不可批改的，所以如果给字符串赋值的话，会报错：

 // 批改报错
s3[0] = "H"    // cannot assign to s3[0] (strings are immutable)

遍历字符串：

 s4 := "hello 世界"

// 遍历字节数组
for i := 0; i < len(s4); i++ {fmt.Println(i, s4[i])
}

// 输入
// 0 104
// 1 101
// 2 108
// 3 108
// 4 111
// 5 32
// 6 228
// 7 184
// 8 150
// 9 231
// 10 149
// 11 140

// 遍历 rune 数组
for i, v := range s4 {fmt.Println(i, v)
}

// 输入
// 0 104
// 1 101
// 2 108
// 3 108
// 4 111
// 5 32
// 6 19990
// 9 30028

从后果能够看出两者的区别，第一种是以字节数组形式遍历；第二种是以 Unicode 字符形式遍历。

以字节数组形式遍历，字符类型是 byte，长度是 1。尽管字符串直观上看长度是 8，但中文字符在 UTF-8 编码中占 3 个字符，所以总长度是 12。

以 Unicode 形式遍历，字符类型是 rune。

Go 中反对两种字符类型，一个是 byte，uint8 的别名，示意 UTF-8 字符串的单个字节的值；另一个是 rune，int32 的别名，示意单个 Unicode 字符。

最初再说一点，Go 的源文件是按 UTF-8 编码的，所以咱们在抉择编码格局上肯定要选 UTF-8，否则可能会有一些莫名其妙的谬误呈现。

总结

本文次要介绍了五种根底数据类型，别离是：整数，浮点数，复数，布尔值和字符串。

其中复数用的比拟少，整数和浮点数次要用在须要数值类型的场景，布尔值大多用在条件语句。

字符串的应用还是挺多的，而且也有一些规范库的反对，比方 bytes、strings、strconv、unicode。

有工夫的话还是要多学学规范库才行。

文章中的脑图和源码都上传到了 GitHub，有须要的同学可自行下载。

地址： https://github.com/yongxinz/g…

关注公众号 AlwaysBeta，回复「goebook」支付 Go 编程经典书籍。

Go 专栏文章列表：

1. 开发环境搭建以及开发工具 VS Code 配置
2. 变量和常量的申明与赋值