Go从入门到放弃之数据类型

　　　　　　　　　　　　　　　　　　数据类型概述

Go 支持的数据类型

基本数据类型

布尔类型：bool
整型：int8、byte、int16、int、uint、uintptr 等
浮点类型：float32、float64
复数类型：complex64、complex128
字符串：string
字符类型：rune
错误类型：error

复合类型　　

指针（pointer）
数组（array）
切片（slice）
字典（map）
通道（chan）
结构体（struct）
接口（interface）

一、变量、作用域、常量和枚举

变量声明和命名规则

纯粹的变量声明，Go 语言引入了关键字 var，并且将类型信息放在变量名之后，此外，变量声明语句不需要使用分号作为结束符，比如我们要声明一个类型为 int 的变量 v1，示例如下：

var v1 int

声明多个的变量　

var (
    v1 int 
    v2 string
    ......
）

变量在声明之后，系统会自动将变量值初始化为对应类型的零值　　

注意事项:如果变量名包含多个单词，Go 语言变量命名规则遵循驼峰命名法，即首个单词小写，每个新单词的首字母大写，如 userName，但如果你的全局变量希望能够被外部包所使用，则需要将首个单词的首字母也大写

变量初始化

 声明变量时想要同时对变量值进行初始化，可以通过以下这些方式：

var v1 int = 10   // 方式一，常规的初始化操作
var v2 = 10       // 方式二，此时变量类型会被编译器自动推导出来
v3 := 10          // 方式三，可以省略 var，编译器可以自动推导出v3的类型

变量赋值与多重赋值

i, j = j, i

匿名变量

 匿名变量通过下划线 _ 来声明，任何赋予它的值都会被丢弃。

func GetName() (userName, nickName string) { 
    return "nonfu", "学院君"
}

_, nickName := GetName()

变量的作用域

如果一个变量在函数体外声明，则被认为是全局变量，可以在整个包甚至外部包（变量名以大写字母开头）使用，
不管你声明在哪个源文件里或在哪个源文件里调用该变量。在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，
函数的参数和返回值变量也是局部变量

二、常量

常量定义

 通过 const 关键字定义常量时，可以指定常量类型，也可以省略（底层会自动推导），常见的常量定义方式如下：

const Pi float64 = 3.14159265358979323846 
const zero = 0.0 // 无类型浮点常量 
const (          // 通过一个 const 关键字定义多个常量，和 var 类似
    size int64 = 1024
    eof = -1  // 无类型整型常量 
) 
const u, v float32 = 0, 3  // u = 0.0, v = 3.0，常量的多重赋值 
const a, b, c = 3, 4, "foo" // a = 3, b = 4, c = "foo", 无类型整型和字符串常量

预定义常量

 Go 语言预定义了这些常量：true、false 和 iota

前面两个熟悉其他语言的应该都很熟悉，是布尔类型的真假值，iota 比较特殊，可以被认为是一个可被编译器修改的常量，

在每一个 const 关键字出现时被重置为 0，然后在下一个 const 出现之前，每出现一次 iota，其所代表的数字会自动增 1

从以下的例子可以基本理解 iota 的用法：

package main

const (    // iota 被重置为 0
    c0 = iota   // c0 = 0
    c1 = iota   // c1 = 1
    c2 = iota   // c2 = 2
)

const (
    u = iota * 2;  // u = 0
    v = iota * 2;  // v = 2
    w = iota * 2;  // w = 4
)

const x = iota;  // x = 0
const y = iota;  // y = 0

如果两个 const 的赋值语句的表达式是一样的，那么还可以省略后一个赋值表达式。因此，上面的前两个 const 语句可简写为：　　

const ( 
    c0 = iota 
    c1 
    c2 
)

const ( 
    u = iota * 2 
    v 
    w 
)

枚举

枚举中包含了一系列相关的常量，比如下面关于一个星期中每天的定义。Go 语言并不支持其他语言用于表示枚举的 enum 关键字，而是通过在 const 后跟一对圆括号定义一组常量的方式来实现枚举。

下面是一个常规的 Go 语言枚举表示法，其中定义了一系列整型常量：

const (
    Sunday = iota 
    Monday 
    Tuesday 
    Wednesday 
    Thursday 
    Friday 
    Saturday 
    numberOfDays
)

常量的作用域

和函数体外声明的变量一样，以大写字母开头的常量在包外可见,函数体内声明的常量只能在函数体内生效。　　

三、布尔类型

Go 语言中的布尔类型与其他主流编程语言差不多，类型关键字为 bool，可赋值且只可以赋值为预定义常量 true 和 false。示例代码如下：

var v1 bool 
v1 = true 
v2 := (1 == 2) // v2 也会被推导为 bool 类型

通过表达式计算得到的布尔类型结果可以赋值给 Go 布尔类型变量：

var b bool 
b = (1!=0) // 编译正确 
fmt.Println("Result:", b) // 打印结果为Result: true

由于强类型的缘故，Go 语言在进行布尔值真假判断时，对值的类型有严格限制，以下这些值在进行布尔值判断的时候（使用非严格的 == 比较符）都会被认为是 false　　

布尔值 FALSE 本身
整型值 0（零）
浮点型值 0.0（零）
空字符串，以及字符串 “0”
不包括任何元素的数组
特殊类型 NULL（包括尚未赋值的变量）
从空标记生成的 SimpleXML 对象

 Go 语言中不同类型的值不能使用 == 或 != 运算符进行比较　　

四、整型

Go 语言默认支持如下这些整型类型：

五、运算符

算术运算符

 Go 语言支持所有常规的整数四则运算：+、-、*、/ 和 %（取余运算只能用于整数）

由于强类型的关系，在 Go 语言中，不同类型的整型值不能直接进行算术运算，比如下面这样计算就会报编译错误：

intValue3 := intValue1 + intValue2

类型转化之后就好了：

intValue3 := intValue1 + int8(intValue2)

在 Go 语言中，也支持自增/自减运算符，即 ++/--，但是只能作为语句，不能作为表达式，且只能用作后缀，不能放到变量前面　

intValue1++  // 有效，intValue1 的值变成 9
intValue1 = intValue1++ // 无效，编译报错
--intValue1  // 无效，编译报错

还支持 +=、-=、*=、/=、%= 这种快捷写法：　　

intValue1 += intValue1 // 18
intValue1 -= intValue1 // 0
intValue1 *= intValue1 // 81
intValue1 /= intValue1 // 1
intValue1 %= intValue1 // 0

比较运算符

Go 语言支持以下几种常见的比较运算符： >、<、==、>=、<= 和 !=

比较运算符运行的结果是布尔值 ，不同类型的值不能放在一起比较，否则会报编译出错，如下：

if intValue1 == intValue2 {
    fmt.Println("intValue1 和 intValue2 相等")
}

相同类型的值才可以：

if intValue1 < intValue3 {
    fmt.Println("intValue1 比 intValue3 小")
}

位运算符

位运算符对整数在内存中的二进制位进行操作，Go 语言支持以下这几种位运算符：

 一些简单的测试

var intValueBit uint8
intValueBit = 255
intValueBit = ^intValueBit // 按位取反
fmt.Println(intValueBit)   // 0
intValueBit = 1
intValueBit = intValueBit << 3 // 左移 3 位，相当于乘以 2^3 = 8
fmt.Println(intValueBit)       // 8

赋值运算符

逻辑运算符

逻辑运算符计算的结果也是布尔值，通常我们可以组合使用逻辑运算符和比较运算符：

if intValue1 < intValue3 && intValue1 == 8 {
    fmt.Println("条件为真")
}

运算符优先级

 上面介绍的 Go 语言运算符优先级如下所示（由上到下表示优先级从高到低，或者数字越大，优先级越高）：

6      ^（按位取反） !
5      *  /  %  <<  >>  &  &^
4      +  -  |  ^（按位异或）
3      ==  !=  <  <=  >  >=
2      &&
1      ||

# ++ 或 -- 只能出现在语句中，不能用于表达式，故不参与优先级判断。

六、浮点型与复数类型

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

打印浮点数时，可以使用fmt包配合动词%f，代码如下：

package main
import (
        "fmt"
        "math"
)
func main() {
        fmt.Printf("%f\n", math.Pi)
        fmt.Printf("%.2f\n", math.Pi)
}

定义一个浮点型变量的代码如下：

var floatValue1 float32

floatValue1 = 10
floatValue2 := 10.0 // 如果不加小数点，floatValue2 会被推导为整型而不是浮点型
floatValue3 := 1.1E-10

在实际开发中，应该尽可能地使用 float64 类型，因为 math 包中所有有关数学运算的函数都会要求接收这个类型。

浮点数的精度

浮点数不是一种精确的表达方式，因为二进制无法精确表示所有十进制小数，比如 0.1、0.7 这种，下面我们通过一个示例来给大家直观演示下：

floatValue4 := 0.1
floatValue5 := 0.7
floatValue6 := floatValue4 + floatValue5

浮点数的比较

 浮点数支持通过算术运算符进行四则运算，也支持通过比较运算符进行比较,但是涉及到相等的比较除外，看起来相等的两个十进制浮点数，在底层转化为二进制时会丢失精度,

如果一定要判断相等，下面是一种替代的解决方案：

p := 0.00001
// 判断 floatValue1 与 floatValue2 是否相等
if math.Dim(float64(floatValue1), floatValue2) < p {
    fmt.Println("floatValue1 和 floatValue2 相等")
}

七、字符串及底层字符类型

字符串

 在 Go 语言中，字符串是一种基本类型，默认是通过 UTF-8 编码的字符序列，当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节，比如中文编码通常需要 3 个字节。

声明和初始化

var str string         // 声明字符串变量
str = "Hello World"    // 变量初始化
str2 := "你好，学院君"   // 也可以同时进行声明和初始化

字符串转义符

多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号字符：

s1 := `第一行
第二行
第三行
`
fmt.Println(s1)

字符串的常用操作

字符串连接

字符串连接只需要通过 + 连接符即可

str = str + ", 学院君"
str += ", 学院君"  // 上述语句也可以简写为这样，效果完全一样

如果字符串长度较长，需要换行，则 + 连接符必须出现在上一行的末尾

str = str +
        ", 学院君"

字符串切片

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)

它是一个左闭右开的区间，比如上述 str[0:5] 对应到字符串元素的区间是 [0,5)，str[:5] 对应的区间是 [0,5)（数组索引从 0 开始），str[7:] 对应的区间是 [7:len(str)]（这是闭区间，是个例外，因为没有指定区间结尾）。

字符串遍历

字节数组的方式遍历：

str := "Hello, 世界" 
n := len(str) 
for i := 0; i < n; i++ {
    ch := str[i]    // 依据下标取字符串中的字符，ch 类型为 byte
    fmt.Println(i, ch) 
}

 Unicode 字符遍历：

str := "Hello, 世界" 
for i, ch := range str { 
    fmt.Println(i, ch)    // ch 的类型为 rune 
}

将 Unicode 编码转化为可打印字符

str := "Hello, 世界" 
for i, ch := range str { 
    fmt.Println(i, string(ch))
}

八、基本数据类型之间的转化

数值类型之间的转化

整型之间的转化

进行类型转化时只需要调用要转化的数据类型对应的函数即可：

v1 := uint(16)   // 初始化 v1 类型为 unit
v2 := int8(v1)   // 将 v1 转化为 int8 类型并赋值给 v2
v3 := uint16(v2) // 将 v2 转化为 uint16 类型并赋值给 v3

数值和布尔类型之间的转化

目前 Go 语言不支持将数值类型转化为布尔型，你需要自己根据需求去实现类似的转化。

字符串和其他基本类型之间的转化

将整型转化为字符串

整型数据可以通过 Unicode 字符集转化为对应的 UTF-8 编码的字符串：

v1 := 65
v2 := string(v1)  // v2 = A

v3 := 30028
v4 := string(v3)  // v4 = 界


// 还可以将 byte 数组或者 rune 数组转化为字符串，因为字符串底层就是通过这两个基本字符类型构建的
v1 := []byte{'h', 'e', 'l', 'l', 'o'}
v2 := string(v1) // v2 = hello
 
v3 := []rune{0x5b66, 0x9662, 0x541b}
v4 := string(v3) // v4 = 学院君

byte 是 uint8 的别名，rune 是 int32 的别名，所以也可以看做是整型数组和字符串之间的转化

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 编码

参考链接：https://pkg.go.dev/strconv　　

"一劳永逸" 的话，有是有的，而 "一劳永逸" 的事却极少