基本数据类型
# 1. 整数类型
# 整数类型介绍
Go语言的数值类型包含不同大小的整数型、浮点数和负数，每种数值类型都有大小范围以及正负符号。
简单的说，就是用于存放整数值的，比如10,-45,6712等等。
# 整数类型
# 有符号整数类型
PS:127怎么算出来的？
01111111 -->二进制 ---》转为十进制：
1*2^6 + 1*2^5 + 1*2^4 + 1*2^3 + 1*2^2 + 1*2^1 + 1*2^0
= 64 + 32 + 16 + 8 + 4 + 2 + 1
= 127
PS：-128怎么算出来的？
10000000 --->二进制 --->一看就是个负数
10000000 --》负数的二进制
减1：01111111
取反：10000000 ---》得到一个正数 2^7 = 128
加负号：-128
package main
import "fmt"
func main() {
// 有符号整数类型
var n1 int8 = 1
var n2 int16 = 1
var n3 int32 = 1
var n4 int64 = 1
fmt.Printf("%T, %d,%d,%d,%d", n1, n1, n2, n3, n4)
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 超出边界报错
package main
import "fmt"
func main() {
// 有符号整数类型
var n1 int8 = 200 // cannot use 200 (untyped int constant) as int8 value in variable declaration (overflows)
fmt.Printf("%T, %d", n1, n1)
}
// int8, 1,1,1,1
2
3
4
5
6
7
8
9
10
11
# 无符号整数类型（大于等于0的正整数）
表数范围的边界计算： 11111111= 2^7+127 = 128 + 127 = 255 00000000 = 0 超出边界报错：
package main
import "fmt"
func main() {
// 超过边界会异常
// 无符号整数类型
var n5 uint8 = 1
var n6 uint16 = 1
var n7 uint32 = 1
var n8 uint64 = 1
fmt.Printf("%T, %d,%d,%d,%d\\n", n5, n5, n6, n7, n8)
}
// uint8, 1,1,1,1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 其他整数类型
package main
import (
"fmt"
"unsafe"
)
func main() {
// 其他整数类型
var n9 int = 60
var n10 uint = 1
var n11 rune = 1 // 类似int32
var n12 byte = 1 // 类型uint8
fmt.Printf("%T, %T,%T,%T\\n", n9, n10, n11, n12)
fmt.Println("变量占用字节数", unsafe.Sizeof(n10))
// int, uint,int32,uint8
// 变量占用字节数 8
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Golang的整数类型，默认声明为int类型
# 这么多整数类型，使用的时候该如何选择呢？
Golang程序中整型变量在使用时,遵守保小不保大的原则, 即:在保证程序正确运行下,尽量使用占用空间小的数据类型
# 2. 浮点数类型
# 浮点数介绍
简单的说，就是用于存放小数值的，比如3.14、0.28、-7.19等等。
# 浮点类型
Go 语言提供了两种精度的浮点数，float32 和 float64，编译器默认声明为float64
小数类型就是存放小数的，如1.2 0.005 -2.32 float64的精度高于float32，golang中默认的浮点类型为：float64
package main
import "fmt"
func main() {
var price float32 = 100.02
fmt.Printf("price类型是：%T，值是%v", price, price)//%T 类型 %v 默认值
}
2
3
4
5
6
# 浮点数形式
浮点类型底层存储：符号位+指数位+尾数位，所以尾数位只是存了 一个大概，很可能会出现精度的损失。
# 代码示例
package main
import (
"fmt"
)
func main() {
// 浮点数定义
var n1 float32 = 1.22
var n2 float64 = 3.11
fmt.Println(n1, n2)
// 浮点数转换 大转小和小转大都不行，需要相同类型才可以赋值 cannot use n1 (variable of type float32) as type float64 in variable declaration
//var n3 float32 = n2
//var n4 float64 = n1
var n3 float32 = float32(n2)
var n4 float64 = float64(n1)
fmt.Printf("%T,%T,%f,%f\\n", n3, n4, n3, n4)
//精度丢失，尾数可能丢失，
var n5 float32 = -123.11111111105 // 精度丢失了
var n6 float64 = -123.11111111105 // float64的精度高于float32，golang中默认的浮点类型为：float64
fmt.Println("num3=", n5, "num4=", n6)
fmt.Printf("%.3f\\n", n6) // 控制输出几位小数
}
/*
1.22 3.11
float32,float64,3.110000,1.220000
num3= -123.111115 num4= -123.11111111105
-123.111
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 3. 字符类型**（byte和rune）**
# 字符介绍
Golang 中没有专门的字符类型，如果要存储单个字符(字母)，一般使用 byte 来保存。
字符串中的每一个元素叫做“字符”，在遍历或者单个获取字符串元素时可以获得字符。
字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出，字母，数字，标点等字符，底层是按照ASCII进行存储
汉字字符，底层对应的是Unicode码值 总结：Golang的字符对应的使用的是UTF-8编码（Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案）
package main
import "fmt"
func main() {
// 字符类型定义
var c1 byte = 'a'
var c2 byte = '2' //字符的2
//直接输出byte的值，也就是输出对应的字符的码值。
//字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出，字母，数字，标点等字符，底层是按照ASCII进行存储。
fmt.Println("c1=", c1)
fmt.Println("c2=", c2)
//输出字符的值，需要格式化输出 %c
fmt.Printf("c1值=%c c2值=%c\\n", c1, c2)
// 汉字字符，底层对应的是Unicode码值
var c5 int = '中'
fmt.Println(c5) // 直接输出Unicode码值，20013 byte类型溢出，能存储的范围：可以用int
fmt.Printf("c5值=%c\\n", c5)
}
/*
c1= 97
c2= 50
c1值=a c2值=2
20013
c5值=中
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 字符类型
Go语言的字符有以下两种：
- 一种是 uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。
- 另一种是 rune 类型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。rune 类型等价于 int32 类型。
# 字符和字符串的区别
Go 的字符串是由单个字节连接起来的。
也 就是说对于传统的字符串是由字符组成的，而 Go 的字符串不同，它是由字节组成的。
Go的字符用单引号表示
Go的字符串用双引号表示
// 字符和字符串的区别
var c3 byte = 'a' // 单引号
var c4 string = "中" // 双引号
fmt.Printf("c3值=%c c4值=%s\\n", c3, c4)
// c3值=a c4值=中
2
3
4
5
6
# ASCII码表
左面是不可见字符 右面是可见字符
# UTF-8 和 Unicode 有何区别？
查看字符编码（UTF-8） (opens new window)
Unicode 与 ASCII 类似，都是一种字符集。
字符集为每个字符分配一个唯一的 ID，我们使用到的所有字符在 Unicode 字符集中都有一个唯一的 ID，例如上面例子中的 a 在 Unicode 与 ASCII 中的编码都是 97。汉字“你”在 Unicode 中的编码为 20320，在不同国家的字符集中，字符所对应的 ID 也会不同。而无论任何情况下，Unicode 中的字符的 ID 都是不会变化的。
UTF-8 是编码规则，将 Unicode 中字符的 ID 以某种方式进行编码，UTF-8 的是一种变长编码规则，从 1 到 4 个字节不等。编码规则如下：
- 0xxxxxx 表示文字符号 0～127，兼容 ASCII 字符集。
- 从 128 到 0x10ffff 表示其他字符。
根据这个规则，拉丁文语系的字符编码一般情况下每个字符占用一个字节，而中文每个字符占用 3 个字节。
广义的 Unicode 指的是一个标准，它定义了字符集及编码规则，即 Unicode 字符集和 UTF-8、UTF-16 编码等。
# 转义字符
\转义字符：将后面的字母表示为特殊含义
fmt.Println("aaa\\nbbb")
//\\b 退格
fmt.Println("aaa\\bbbb")
//\\r 光标回到本行的开头，后续输入就会替换原有的字符
fmt.Println("aaaaa\\rbbb")
//\\t 制表符
fmt.Println("aaaaaaaaaaaaa")
fmt.Println("aaaaa\\tbbbbb")
fmt.Println("aaaaaaaa\\tbbbbb")
//\\"
fmt.Println("\\"Golang\\"")
aaa
bbb
aabbb
bbbaa
aaaaaaaaaaaaa
aaaaa bbbbb
aaaaaaaa bbbbb
"Golang"
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 代码示例
package main
import "fmt"
func main() {
// 字符类型定义
var c1 byte = 'a'
var c2 byte = '2' //字符的2
//直接输出byte的值，也就是输出对应的字符的码值。
//字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出，字母，数字，标点等字符，底层是按照ASCII进行存储。
fmt.Println("c1=", c1)
fmt.Println("c2=", c2)
//输出字符的值，需要格式化输出 %c
fmt.Printf("c1值=%c c2值=%c\\n", c1, c2)
// 字符和字符串的区别
var c3 byte = 'a' // 单引号
var c4 string = "中" // 双引号
fmt.Printf("c3值=%c c4值=%s\\n", c3, c4)
// 汉字字符，底层对应的是Unicode码值
var c5 int = '中'
fmt.Println(c5) // 直接输出Unicode码值，20013 byte类型溢出，能存储的范围：可以用int
fmt.Printf("c5值=%c\\n", c5)
}
/*
c1= 97
c2= 50
c1值=a c2值=2
c3值=a c4值=中
20013
c5值=中
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 4. 布尔类型
# 布尔介绍
一个布尔类型的值只有两种：true 或 false。if 和 for 语句的条件部分都是布尔类型的值，并且 ==
和 < 等比较操作也会产生布尔型的值。一元操作符 ! 对应逻辑非操作，因此 **!true** 的值为 false，更复杂一些的写法是 (!true==false) ==true，实际开发中我们应尽量采用比较简洁的布尔表达式，就像用 x 来表示 x==true
Go语言对于值之间的比较有非常严格的限制，只有两个相同类型的值才可以进行比较，如果值的类型是接口（interface），那么它们也必须都实现了相同的接口。如果其中一个值是常量，那么另外一个值可以不是常量，但是类型必须和该常量类型相同。如果以上条件都不满足，则必须将其中一个值的类型转换为和另外一个值的类型相同之后才可以进行比较。
布尔类型占1个字节,布尔类型适于逻辑运算，一般用于程序流程控制
# 代码示例
package main
import "fmt"
func main() {
// 布尔类型使用
var flag01 bool = true
fmt.Println(flag01)
var flag02 bool = false
fmt.Println(flag02)
var flag03 bool = 50 < 9
fmt.Println(flag03)
// 布尔类型占1个字节,布尔类型适于逻辑运算，一般用于程序流程控制
if flag03 {
fmt.Println("xxx")
} else {
fmt.Println("qqq")
}
}
/*
true
false
false
qqq
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 5. 字符串类型
# 字符串介绍
一个字符串是一个不可改变的字节序列，字符串可以包含任意的数据，但是通常是用来包含可读的文本，字符串是 UTF-8 字符的一个序列（当字符为 ASCII 码表上的字符时则占用 1 个字节，其它字符根据需要占用 2-4 个字节）。
UTF-8 是一种被广泛使用的编码格式，是文本文件的标准编码，其中包括 XML 和 JSON 在内也都使用该编码。由于该编码对占用字节长度的不定性，在Go语言中字符串也可能根据需要占用 1 至 4 个字节，这与其它编程语言如C++ (opens new window)、Java (opens new window)或者Python (opens new window)不同（Java 始终使用 2 个字节）。Go语言这样做不仅减少了内存和硬盘空间占用，同时也不用像其它语言那样需要对使用 UTF-8 字符集的文本进行编码和解码。
字符串是一种值类型，且值不可变，即创建某个文本后将无法再次修改这个文本的内容，更深入地讲，字符串是字节的定长数组。
// 字符串是不可变的：指的是字符串一旦定义好，其中的字符的值不能改变
var s4 string = "abc"
//s4[0] = 't' // cannot assign to s4[0] (value of type byte)
fmt.Println(s4)
2
3
4
# 定义字符串
可以使用双引号""来定义字符串，字符串中可以使用转义字符来实现换行、缩进等效果，常用的转义字符包括：
- \n：换行符
- \r：回车符
- \t：tab 键
- \u 或 \U：Unicode 字符
- \：反斜杠自身
package main
import "fmt"
func main() {
// 定义字符串
var str1 string = "中"
fmt.Println(str1)
}
/*
中
*/
2
3
4
5
6
7
8
9
10
11
12
13
一般的比较运算符（==、!=、<、<=、>=、>）是通过在内存中按字节比较来实现字符串比较的，因此比较的结果是字符串自然编码的顺序。字符串所占的字节长度可以通过函数 len() 来获取，例如 len(str)。
字符串的内容（纯字节）可以通过标准索引法来获取，在方括号 [ ] 内写入索引，索引从 0 开始计数：
- 字符串 str 的第 1 个字节：str[0]
- 第 i 个字节：str[i - 1]
- 最后 1 个字节：str[len(str)-1]
需要注意的是，这种转换方案只对纯 ASCII 码的字符串有效。
注意：获取字符串中某个字节的地址属于非法行为，例如 &str[i]。
# 字符串拼接符“+”
两个字符串 s1 和 s2 可以通过 s := s1 + s2 拼接在一起。将 s2 追加到 s1 尾部并生成一个新的字符串 s。
package main
import "fmt"
func main() {
// 字符串拼接符
var s1 string = "啊啊"
var s2 string = "嗷嗷"
var s = s1 + s2
fmt.Println(s)
}
/*
啊啊嗷嗷
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 字符串实现基于 UTF-8 编码
Go语言中字符串的内部实现使用 UTF-8 编码，通过 rune 类型，可以方便地对每个 UTF-8 字符进行访问。当然，Go语言也支持按照传统的 ASCII 码方式逐字符进行访问。
# 定义多行字符串
在Go语言中，使用双引号书写字符串的方式是字符串常见表达方式之一，被称为字符串字面量（string literal），这种双引号字面量不能跨行，如果想要在源码中嵌入一个多行字符串时，就必须使用```反引号
package main
import "fmt"
func main() {
// 定义多行字符串
var s3 string = `
var s1 string = "啊啊"
var s2 string = "嗷嗷"
var s = s1 + s2
fmt.Println(s)
`
fmt.Println(s3)
}
/*
var s1 string = "啊啊"
var s2 string = "嗷嗷"
var s = s1 + s2
fmt.Println(s)
*
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 字符串其他用法
字符串类型在业务中的应用可以说是最广泛的，读者需要详细了解字符串的常见用法，请猛击下面的文章：
- Go语言计算字符串长度——len()和RuneCountInString() (opens new window)
- Go语言遍历字符串——获取每一个字符串元素 (opens new window)
- Go语言字符串截取（获取字符串的某一段字符） (opens new window)
- Go语言修改字符串 (opens new window)
- Go语言字符串拼接（连接） (opens new window)
- Go语言fmt.Sprintf（格式化输出） (opens new window)
- Go语言Base64编码——电子邮件的基础编码格式 (opens new window)
# 代码示例
package main
import "fmt"
func main() {
// 定义字符串
var str1 string = "中"
fmt.Println(str1)
// 字符串拼接符
var s1 string = "啊啊"
var s2 string = "嗷嗷"
var s = s1 + s2
fmt.Println(s)
// 定义多行字符串
var s3 string = `
var s1 string = "啊啊"
var s2 string = "嗷嗷"
var s = s1 + s2
fmt.Println(s)
`
fmt.Println(s3)
// 字符串是不可变的：指的是字符串一旦定义好，其中的字符的值不能改变
var s4 string = "abc"
//s4[0] = 't' // cannot assign to s4[0] (value of type byte)
fmt.Println(s4)
}
/*
中
啊啊嗷嗷
var s1 string = "啊啊"
var s2 string = "嗷嗷"
var s = s1 + s2
fmt.Println(s)
abc
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# 6. 复数类型
复数是由两个浮点数表示的，其中一个表示实部（real），一个表示虚部（imag）。
Go语言中复数的类型有两种，分别是 complex128（64 位实数和虚数）和 complex64（32 位实数和虚数），其中 complex128 为复数的默认类型。
复数的值由三部分组成 RE + IMi，其中 RE 是实数部分，IM 是虚数部分，RE 和 IM 均为 float 类型，而最后的 i 是虚数单位。
声明复数的语法格式如下所示：
var name complex128 = complex(x, y)
name := complex(x, y) // 简短声明
其中 name 为复数的变量名，complex128 为复数的类型，“=”后面的 complex 为Go语言的内置函数用于为复数赋值，x、y 分别表示构成该复数的两个 float64 类型的数值，x 为实部，y 为虚部。
2
3
4
对于一个复数z := complex(x, y)，可以通过Go语言的内置函数real(z) 来获得该复数的实部，也就是 x；通过imag(z) 获得该复数的虚部，也就是 y。
package main
import "fmt"
func main() {
var x complex128 = complex(1, 2) // 1+2i
var y complex128 = complex(3, 4) // 3+4i
fmt.Println(x * y) // "(-5+10i)"
fmt.Println(real(x * y)) // "-5"
fmt.Println(imag(x * y)) // "10"
}
/*
(-5+10i)
-5
10
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
如果对复数的运算法则不是很了解，可以查阅《复数运算法则 (opens new window)》，其中详细的讲解了复数的加减乘除操作。复数也可以用 == 和 != 进行相等比较，只有两个复数的实部和虚部都相等的时候它们才是相等的。
Go语言内置的 math/cmplx 包中提供了很多操作复数的公共方法，实际操作中建议大家使用复数默认的 complex128 类型，因为这些内置的包中都使用 complex128 类型作为参数。
# 7. 基本数据类型的默认值
在Golang中数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值(默认值又叫零值)。
package main
import "fmt"
func main() {
var n1 int
var n2 float64
var n3 byte
var n4 bool
var n5 string
fmt.Println(n1)
fmt.Println(n2)
fmt.Println(n3)
fmt.Println(n4)
fmt.Println("字符串：", n5)
}
/*
0
0
0
false
字符串：
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 8. 基本数据类型转换
# 转换规则
在必要以及可行的情况下，一个类型的值可以被转换成另一种类型的值。由于Go语言不存在隐式类型转换，因此所有的类型转换都必须显式的声明：
语法
valueOfTypeB = typeB(valueOfTypeA)
// 类型 B 的值 = 类型 B(类型 A 的值)
2
3
表达式T(v)将值v转换为类型T T : 就是数据类型 v : 就是需要转换的变量
# 类型转换规则
类型转换只能在定义正确的情况下转换成功，例如从一个取值范围较小的类型转换到一个取值范围较大的类型（将 int16 转换为 int32）。当从一个取值范围较大的类型转换到取值范围较小的类型时（将 int32 转换为 int16 或将 float32 转换为 int），会发生精度丢失（截断）的情况。
只有相同底层类型的变量之间可以进行相互转换（如将 int16 类型转换成 int32 类型），不同底层类型的变量相互转换时会引发编译错误（如将 bool 类型转换为 int 类型）：
# 相同类型
- 大类型转换小类型（注意数据溢出）
// 大类型转换小类型（注意数据溢出） int64 -> int 8
//将int64转为int8的时候，编译不会出错的，但是会数据的溢出
var n3 int64 = 888888
var n4 int8 = int8(n3)
fmt.Println(n4) //56
var n7 int64 = 12
var n8 int8 = int8(n7) + 127 // 编译通过，但是结果可能会溢出 int8范围(-127-128)，编译器不会先执行int8(n7)的转换
fmt.Println(n8)
//var n9 int8 = int8(n7) + 128 // 编译不会通过
//fmt.Println(n9)
2
3
4
5
6
7
8
9
10
11
- 小类型转换大类型
// 小类型转换大类型（）
var n5 int32 = 12
var n6 int64 = int64(n5) + 30 // 一定要匹配=左右的数据类型
fmt.Println(n6)
2
3
4
# 不同类型
- 转换必须指定类型
// 不同类型转换：Go在不同类型的变量之间赋值时需要显式转换，并且只有显式转换(强制转换，转换时指定类型)。
var n1 int = 100
//var n2 float32 = n1 在这里自动转换不好使，比如显式转换（转换时需要指定类型）
//fmt.Println(n2)
var n2 float32 = float32(n1)
fmt.Println(n2)
//注意：n1的类型其实还是int类型，只是将n1的值100转为了float32而已，n1还是int的类型
fmt.Printf("%T\\n", n1) //int
2
3
4
5
6
7
8
# 代码示例
package main
import "fmt"
func main() {
// 浮点数在转换为整型时，会将小数部分去掉，只保留整数部分。
// 不同类型转换：Go在不同类型的变量之间赋值时需要显式转换，并且只有显式转换(强制转换，转换时指定类型)。
var n1 int = 100
//var n2 float32 = n1 在这里自动转换不好使，比如显式转换（转换时需要指定类型）
//fmt.Println(n2)
var n2 float32 = float32(n1)
fmt.Println(n2)
//注意：n1的类型其实还是int类型，只是将n1的值100转为了float32而已，n1还是int的类型
fmt.Printf("%T\\n", n1) //int
// 相同类型转换
// 大类型转换小类型（注意数据溢出） int64 -> int 8
//将int64转为int8的时候，编译不会出错的，但是会数据的溢出
var n3 int64 = 888888
var n4 int8 = int8(n3)
fmt.Println(n4) //56
var n7 int64 = 12
var n8 int8 = int8(n7) + 127 // 编译通过，但是结果可能会溢出 int8范围(-127-128)，编译器不会先执行int8(n7)的转换
fmt.Println(n8)
//var n9 int8 = int8(n7) + 128 // 编译不会通过
//fmt.Println(n9)
// 小类型转换大类型（）
var n5 int32 = 12
var n6 int64 = int64(n5) + 30 // 一定要匹配=左右的数据类型
fmt.Println(n6)
}
/*
100
int
56
42
-117
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 9. 基本数据类型与string转化
官方函数介绍
https://golang.org/pkg/strconv/
# 基本数据类型和string的转换介绍
在程序开发中，我们经常需要将基本数据类型转成string类型。或者将string类型转成基本数据类型。
# 基本类型转string类型
# 方式一： fmt.Sprintf(“%参数”,表达式)
package main
import "fmt"
func main() {
var num1 int = 66
var num2 float64 = 25.25
var b bool = true
var myChar byte = 'c'
//%q 单引号
//%d 十进制表示
str1 := fmt.Sprintf("%d", num1)
fmt.Printf("str1 type %T str=%q\\n", str1, str1)
//%f 有小数点
str2 := fmt.Sprintf("%f", num2)
fmt.Printf("str2 type %T str2=%q\\n", str2, str2)
//%t 布尔值
str3 := fmt.Sprintf("%t", b)
fmt.Printf("str3 type %T str3=%q\\n", str3, str3)
//%c Unicode码对应的字符
str4 := fmt.Sprintf("%c", myChar)
fmt.Printf("str4 type %T str4=%q\\n", str4, str4)
}
/*
str1 type string str="66"
str2 type string str2="25.250000"
str3 type string str3="true"
str4 type string str4=%!d(string=c)
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 方式二：fmt.Strconv
package main
import (
"fmt"
"strconv"
)
func main() {
// 一、基本类型转string类型
var num1 int = 66
var num2 float64 = 25.25
var b bool = true
var myChar byte = 'c'
var s1 string = strconv.FormatInt(int64(num1), 10) //参数：第一个参数必须转为int64类型 ，第二个参数指定字面值的进制形式为十进制
fmt.Printf("s1对应的类型是：%T ，s1 = %q \\n", s1, s1)
var s2 string = strconv.FormatFloat(num2, 'f', 2, 32)
//第二个参数：'f'（-ddd.dddd） 第三个参数：9 保留小数点后面9位 第四个参数：表示这个小数是float64类型
fmt.Printf("s2对应的类型是：%T ，s2 = %q \\n", s2, s2)
var s3 string = strconv.FormatBool(b)
fmt.Printf("s3对应的类型是：%T ，s3 = %q \\n", s3, s3)
}
/*
s1对应的类型是：string ，s1 = "66"
s2对应的类型是：string ，s2 = "25.25"
s3对应的类型是：string ，s3 = "true"
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# string类型转基本类型
# 使用strconv包的函数
package main
import (
"fmt"
"strconv"
)
func main() {
//string-->bool
var s1 string = "trueaa"
var b bool
//ParseBool这个函数的返回值有两个：(value bool, err error)
//value就是我们得到的布尔类型的数据，err出现的错误
//我们只关注得到的布尔类型的数据，err可以用_直接忽略
b, _ = strconv.ParseBool(s1)
fmt.Printf("b的类型是：%T,b=%v \\n", b, b) // 其他的值都会变成false
//string---》int64
var s2 string = "19"
var num1 int64
num1, _ = strconv.ParseInt(s2, 10, 64)
fmt.Printf("num1的类型是：%T,num1=%v \\n", num1, num1)
//string-->float32/float64
var s3 string = "3.14"
var f1 float64
f1, _ = strconv.ParseFloat(s3, 64)
fmt.Printf("f1的类型是：%T,f1=%v \\n", f1, f1)
//注意：string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果就是按照对应类型的默认值输出
var s4 string = "golang"
var b1 bool
b1, _ = strconv.ParseBool(s4)
fmt.Printf("b1的类型是：%T,b1=%v \\n", b1, b1)
var s5 string = "golang"
var num2 int64
num2, _ = strconv.ParseInt(s5, 10, 64)
fmt.Printf("num2的类型是：%T,num2=%v \\n", num2, num2)
}
/*
b的类型是：bool,b=false
num1的类型是：int64,num1=19
f1的类型是：float64,f1=3.14
b1的类型是：bool,b1=false
num2的类型是：int64,num2=0
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# 10. 字符串string更多用法
# 更多用法
Go语言标准库文档中文版 | Go语言中文网 | Golang中文社区 | Golang中国 (opens new window)
# 代码示例
package main
import (
"fmt"
"strings"
)
func main() {
var str string = "abbbc"
//判断是不是以某个字符串开头，返回布尔值
res0 := strings.HasPrefix(str, "http://")
res1 := strings.HasPrefix(str, "abc")
fmt.Printf("res0 is %v\\n", res0)
fmt.Printf("res1 is %v\\n", res1)
//判断是不是以某个字符串结尾
res3 := strings.HasSuffix(str, "http://")
res4 := strings.HasSuffix(str, "c")
fmt.Printf("res3 is %v\\n", res3)
fmt.Printf("res4 is %v\\n", res4)
//判断字符在字符串中首次出现的索引位置，没有返回-1
res5 := strings.Index(str, "o")
res6 := strings.Index(str, "c")
fmt.Printf("res5 is %v\\n", res5)
fmt.Printf("res6 is %v\\n", res6)
//返回字符最后一次出现的索引位置，没有返回-1
res7 := strings.LastIndex(str, "o")
res8 := strings.LastIndex(str, "b")
fmt.Printf("res7 is %v\\n", res7)
fmt.Printf("res8 is %v\\n", res8)
//字符串替换
res9 := strings.Replace(str, "b", "-golang-", 2)
res10 := strings.Replace(str, "b", "-golang-", 1)
//trings.Replace("原字符串", "被替换的内容", "替换的内容", 替换次数)
//原字符串中有2个world，才能替换2次
fmt.Printf("res9 is %v\\n", res9)
fmt.Printf("res10 is %v\\n", res10)
//求字符在字符串中出现的次数，不存在返回0次
countTime0 := strings.Count(str, "a")
countTime1 := strings.Count(str, "b")
fmt.Printf("countTime0 is %v\\n", countTime0)
fmt.Printf("countTime1 is %v\\n", countTime1)
//重复几次字符串
res11 := strings.Repeat(str, 0)
res12 := strings.Repeat(str, 1)
res13 := strings.Repeat(str, 2)
// strings.Repeat("原字符串", 重复次数)
fmt.Printf("res11 is %v\\n", res11)
fmt.Printf("res12 is %v\\n", res12)
fmt.Printf("res13 is %v\\n", res13)
//字符串改大写
res14 := strings.ToUpper(str)
fmt.Printf("res14 is %v\\n", res14)
//字符串改小写
res15 := strings.ToLower(str)
fmt.Printf("res15 is %v\\n", res15)
//去除首尾的空格
res16 := strings.TrimSpace(str)
fmt.Printf("res16 is %v\\n", res16)
//去除首尾指定的字符,遍历l、d、e然后去除
res17 := strings.Trim(str, "a")
fmt.Printf("res17 is %v\\n", res17)
//去除开头指定的字符
res18 := strings.TrimLeft(str, "c")
fmt.Printf("res18 is %v\\n", res18)
//去除结尾指定的字符,遍历d、l、r
res19 := strings.TrimRight(str, "bc")
fmt.Printf("res19 is %v\\n", res19)
//用指定的字符串将string类型的切片元素结合
str1 := []string{"hello", "world", "hello", "golang"}
res20 := strings.Join(str1, "+")
fmt.Printf("res20 is %v\\n", res20)
}
/*
res0 is false
res1 is false
res3 is false
res4 is true
res5 is -1
res6 is 4
res7 is -1
res8 is 3
res9 is a-golang--golang-bc
res10 is a-golang-bbc
countTime0 is 1
countTime1 is 3
res11 is
res12 is abbbc
res13 is abbbcabbbc
res14 is ABBBC
res15 is abbbc
res16 is abbbc
res17 is bbbc
res18 is abbbc
res19 is a
res20 is hello+world+hello+golang
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110