1、基本数据类型

Go语言中数据类型分为：基本数据类型和复合数据类型
基本数据类型有：整型、 浮点型、 布尔型、 字符串
复合数据类型有：数组、切片、结构体、函数、map、通道(channel)、接口等。

1.1、整形

整型分为以下两个大类：
有符号整形按长度分为：int8、int16、int32、int64。
对应的无符号整型：uint8、uint16、uint32、uint64。

package main
import ("fmt""unsafe"
)
func main() {// 使用unsafe.Sizeof查看存储空间var num int = 20fmt.Printf("num: %v, num类型为: %T, 所占字节数: %d\n", num, num, unsafe.Sizeof(num))var num1 int8 = 111var num2 int16 = 300var num3 int32 = 1000var num4 int64 = 55434fmt.Printf("num1: %v, num类型为: %T, 所占字节数: %d\n", num1, num1, unsafe.Sizeof(num1))fmt.Printf("num2: %v, num类型为: %T, 所占字节数: %d\n", num2, num2, unsafe.Sizeof(num2))fmt.Printf("num3: %v, num类型为: %T, 所占字节数: %d\n", num3, num3, unsafe.Sizeof(num3))fmt.Printf("num4: %v, num类型为: %T, 所占字节数: %d\n", num4, num4, unsafe.Sizeof(num4))
}

两种不同的类型相加，涉及到类型转换问题：

var a1 int32 = 10
var a2 int64 = 20
fmt.Println(int64(a1) + a2) // 将a1转换成int64
fmt.Println(a1 + int32(a2)) // 将a2转换成int32

但是要注意高位向地位转换的情况，可能会发生截断。

数字字面量语法：Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：v := 0b00101101， 代表二进制的101101，相当于十进制的45。 v := 0o377， 代表八进制的377，相当于十进制的255。v := 0x1p-2，代表十六进制的1除以 2²，也就是0.25。而且还允许我们用_来分隔数字，比如说：v := 123_456 等于123456。

var a = 11
fmt.Printf("a=%v\n", a)   // 原样输出
fmt.Printf("a=%d\n", a)   // 十进制输出
fmt.Printf("a=%b\n", a)   // 二进制输出
fmt.Printf("a=%o\n", a)   // 八进制输出
fmt.Printf("a=0x%x\n", a) // 十六进制输出

---

1.2、浮点型

Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准：float32的浮点数的最大范围约为3.4e38，可以使用常量定义：math.MaxFloat32。float64的浮点数的最大范围约为1.8e308，可以使用一个常量定义：math.MaxFloat64。

打印浮点数可以使用%f，默认保留六位小数，使用%v就是原样输出。

package mainimport ("fmt""unsafe"
)func main() {var f1 float32 = 3.1415fmt.Printf("f1: %v--%f--%.2f, 类型为: %T, 所占字节数: %d\n", f1, f1, f1, f1, unsafe.Sizeof(f1))var f2 float64 = 3.1513213fmt.Printf("f2: %v--%f--%.2f, 类型为: %T, 所占字节数: %d\n", f2, f2, f2, f2, unsafe.Sizeof(f2))
}

Golang中浮点数默认是float64：

f3 := 2.12345
fmt.Printf("f3: %v--%f--%.2f, 类型为: %T, 所占字节数: %d\n", f3, f3, f3, f3, unsafe.Sizeof(f3))

Golang中浮点数精度丢失问题：

d := 1129.6
fmt.Println(d * 100)m1 := 8.2
m2 := 3.3
fmt.Println(m1 - m2)

这里我们期望输出的分别是112960和4.9，但是由于精度损失，所以不符合我们预期。
怎么解决呢？可以使用第三方包来解决：https://github.com/shopspring/decimal
这个后面再细说。

Golang科学计数法表示浮点数类型：

f4 := 3.14e2
f5 := 3.14e-2
fmt.Printf("f4: %v--%f\n", f4, f4)
fmt.Printf("f5: %v--%f\n", f5, f5)

---

1.3、布尔值

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true(真)和false(假)两个值。
注意：
1、布尔类型变量的默认值为false。
2、Go语言中不允许将整型强制转换为布尔型。
3、布尔型无法参与数值运算，也无法与其他类型进行转换。

var flag1 bool
flag2 := true
fmt.Printf("flag1: %v\n", flag1)
fmt.Printf("flag2: %v\n", flag2)

另外，整形和浮点型数据不初始化默认为0，string类型不初始化默认为空串。

注意点2、3，bool不行与其他类型转换，也不能用整数转bool，这点与C/C++以示区分。

if flag2 {fmt.Println("true")
} else {fmt.Println("false")
}

所以上面if条件判断里面就不能写一个整数。

---

1.4、字符串

Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型(int、 bool、float32、 float64等)一样。Go语言里的字符串的内部实现使用UTF-8编码。

package mainimport "fmt"func main() {var s1 string = "hello world"s2 := "hello world"fmt.Println(s1, s2)
}

Golang中定义一个多行字符串时，需要使用到反引号字符`：

s3 := `hello 鹏哥,
hello 杭哥,
hello 蛋哥。`
fmt.Println(s3)

// 1.len计算字符串长度
var str1 = "hello golang"
fmt.Println(len(str1))// 2.fmt.Sprintf拼接字符串
var str2 = "hello C++"
str3 := str1 + " " + str2
str4 := fmt.Sprintf("%v %v", str1, str2)
fmt.Println(str3)
fmt.Println(str4)// 3.strings.Split分割字符串
str5 := "123-456-789"
arr := strings.Split(str5, "-") // 返回值是一个切片
fmt.Println(arr)// 4.strings.contains判断是否包含
str6 := "this is string"
var flag = strings.Contains(str6, "this")
fmt.Println(flag)// 5.前缀/后缀判断 strings.HasPrefix/strings.HasSuffix
var flag1 = strings.HasPrefix(str6, "is")
var flag2 = strings.HasSuffix(str6, "string")
fmt.Printf("flag1: %v, flag2: %v\n", flag1, flag2)// 6.获取字串的下标 strings.Index() / strings.LastIndex()
pos1 := strings.Index(str6, "is")
pos2 := strings.LastIndex(str6, "ing")
fmt.Printf("pos1: %v, pos2: %v\n", pos1, pos2) // 找不到返回-1// 7.strings.Join操作，将切片转换成字符串
str7 := strings.Join(arr, "-")
fmt.Println(str7)

---

1.5、byte和rune类型

组成每个字符串的元素叫做“字符”， 可以通过遍历字符串元素获得字符。 字符用单引号（’）包裹起来。

var a = 'a'
fmt.Printf("值: %v, 字符: %c, 类型: %T\n", a, a, a)
var str = "this is string"
fmt.Printf("值: %v, 字符: %c, 类型: %T\n", str[2], str[2], str[2])

golang中定义字符属于int类型，可以看到上面a的类型是int32，字符串中字符类型是uint8。

如果要计算字符串占用字节数呢？可以使用unsafe.Sizeof吗？

var str = "this is string"
fmt.Printf("str所占字节数为: %d\n", unsafe.Sizeof(str))

实际上str字符串所占字节数应该是14个字节，但是计算出来的确实16。所以不能使用unsafe.Sizeof来计算，需要使用len函数来计算。

var str1 = "hello world"
var str2 = "你好golang"
fmt.Printf("str1所占字节数为: %d\n", len(str1))
fmt.Printf("str2所占字节数为: %d\n", len(str2))

str2所占字节数为12，这是因为golang中汉字采用的是utf8编码，所以一个汉字占3个字节，英文字母占一个字节，所以算下来总共12字节。

var ch = '你'
fmt.Printf("值: %v, 字符: %c, 类型: %T\n", ch, ch, ch)

Go 语言的字符有以下两种：
1、uint8类型，或者叫byte型，代表了ASCII码的一个字符。
2、rune类型，代表一个UTF-8字符。
当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。
Go使用了特殊的rune类型来处理Unicode，让基于Unicode的文本处理更为方便，也可以使用byte型进行默认字符串处理，性能和扩展性都有照顾。

下面看遍历字符串：

var str = "hello 你好"
for i := 0; i < len(str); i++ {fmt.Printf("%v(%c) ", str[i], str[i])
}

这样遍历对于纯英文数字的字符串是没有问题的，但是对于有中文汉字的字符串就不行了。因为这样遍历每次是取一个字节出来，所以对于有汉字的字符串不能这样遍历。

而应该采下面rune的遍历方式：

var str = "hello 你好"
for _, ch := range str { // runefmt.Printf("%v(%c) ", ch, ch)
}

---

1.6、修改字符串

要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

var str1 = "hello golang"
byteStr := []byte(str1)
byteStr[0] = 'H'
fmt.Println(string(byteStr))var str2 = "你好 golang"
runeStr := []rune(str2)
runeStr[0] = '哈'
fmt.Println(string(runeStr))

---

2、基本数据类型之间的转换

2.1、数值类型之间的相互转换

注意：golang中只有强制类型转换，没有隐式类型转换。

// 1.整形和整形之间的转换
var a int8 = 20
var b int16 = 111
fmt.Println(int16(a) + b)// 2.浮点型和浮点型之间的转换
var f1 float32 = 3.1415
var f2 float64 = 3.2131
fmt.Println(float64(f1) + f2)// 3.整形和浮点型之间的转换
var x int = 30
var y float64 = 3.154
fmt.Println(float64(x) + y)

一般是从低位向高位进行转换，高位向低位转换可能会溢出。

---

2.2、其他类型转换成string类型

1、sprintf把其他类型转换成string类型。

package mainimport "fmt"func main() {var i int = 20var f float64 = 3.1415var b bool = truevar ch = 'a'str := fmt.Sprintf("%d %f %t %c", i, f, b, ch)fmt.Printf("值: %v, 类型: %T\n", str, str)
}

注意：Sprintf使用中需要注意转换的格式int为%d、float为%f、bool 为%t、byte为%c。

2、使用strconv包里面的几种转换方法进行转换。

func FormatInt(i int64, base int) string
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
func FormatBool(b bool) string
func FormatUint(i uint64, base int) string

1、FormatInt的第一个参数就是要转换的数值，第二个参数表示进制数。
2、FormatFloat第一个参数表示要转换的数值，第二参数是格式化类型，第三个参数表示保留的小数位数，第四个参数表示格式化的类型（32/64）。
格式化类型：
‘f’（-ddd.dddd）、
‘b’（-ddddp±ddd，指数为二进制）、
‘e’（-d.dddde±dd，十进制指数）、
‘E’（-d.ddddE±dd，十进制指数）、
‘g’（指数很大时用’e’格式，否则’f’格式）、
‘G’（指数很大时用’E’格式，否则’f’格式）。
3、FormatBool直接传对应的bool类型即可。
4、FormatUint用于将字符转换成字符串，第一个参数表示字符需要强转成Uint64，第二个参数表示进制数。

var a int = 10
str1 := strconv.FormatInt(int64(a), 10)
fmt.Printf("值: %v, 类型: %T\n", str1, str1)var f float32 = 3.14159
str2 := strconv.FormatFloat(float64(f), 'f', 6, 64)
fmt.Printf("值: %v, 类型: %T\n", str2, str2)str3 := strconv.FormatBool(true)
fmt.Printf("值: %v, 类型: %T\n", str3, str3)x := 'x'
str4 := strconv.FormatUint(uint64(x), 10)
fmt.Printf("值: %v, 类型: %T\n", str4, str4)

---

2.3、string类型转换成数值类型

func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseFloat(s string, bitSize int) (float64, error)
func ParseBool(str string) (bool, error)

以上四个函数用户将字符串类型string转换成对应的类型。
1、ParseInt第一个参数字符串，第二参数表示进制数，第三个参数表示转换后的位数——32/64。
2、ParseFloat第一个参数字符串，第二个参数表示转换的位数。
可以注意到它们的返回值都是两个，第一个返回值表示结果，第二个表示出错，而当我们调用函数接收返回值时可以把error省略掉，直接用前面说的_来表示即可。

str1 := "123456"
num1, _ := strconv.ParseInt(str1, 10, 64)
fmt.Printf("值: %v, 类型: %T\n", num1, num1)str2 := "1233.1415926"
num2, _ := strconv.ParseFloat(str2, 64)
fmt.Printf("值: %v, 类型: %T\n", num2, num2)str3 := "true"
flag, _ := strconv.ParseBool(str3)
fmt.Printf("值: %v, 类型: %T\n", flag, flag)

上面的string类型转bool类型其实没什么意义。

注意：在go语言中数值类型没法直接转换成bool类型bool类型也没法直接转换成数值类型。

---

3、Golang中的运算符

Golang运算符包括：算数运算符、关系运算符、逻辑运算符、赋值运算符、位运算符。

3.1、算数运算符

这边最主要是%运算：求余=被除数 -（被除数/除数）*除数

fmt.Println(10%3, -10%3)

注意：在golang中，++和--只能独立使用，且不存在前置++/--，错误写法如下

正确写法：

var x int = 1
x++
fmt.Println(x)

---

3.2、关系运算符

例如：

var a = 10
var b = 9
fmt.Println(a > b)  // true
fmt.Println(a >= b) // true
fmt.Println(a == b) // false
fmt.Println(a < b)  // false
fmt.Println(a <= b) // false
fmt.Println(a != b) // true

---

3.3、逻辑运算符

这里演示一下使用：

var a = 10
var b = 5
if a >= 10 && b < 10 {fmt.Println("hhahaha")
}

最主要在于逻辑运算符的短路问题：
先来看正常的情况，所有条件满足的情况下执行if语句内的代码

package mainimport "fmt"func test() bool {fmt.Println("test...")return true
}func main() {var x int = 10if x > 5 && test() {fmt.Println("ok...")}
}

对于&&运算符，只要第一个条件不满足，就不会再去判断后面的条件了，因此在下面没有输出任何信息：

package mainimport "fmt"func test() bool {fmt.Println("test...")return true
}func main() {var x int = 10if x > 10 && test() {fmt.Println("ok...")}
}

对于||运算符，只要第一个条件满足，就无需再判断后面的条件了，所以下面的代码只输出ok：

package mainimport "fmt"func test() bool {fmt.Println("test...")return true
}func main() {var x int = 10if x > 5 || test() {fmt.Println("ok...")}
}

---

3.4、赋值运算符

---

3.5、位运算符

package mainimport "fmt"func main() {var x int = 10      // 1010var y int = 2       // 0010fmt.Println(x << y) // 40fmt.Println(x >> y) // 2fmt.Println(x & y)  // 0010->2fmt.Println(x | y)  // 1010->10fmt.Println(x ^ y)  // 1000->8
}