前言

　　Go官方编程指南：https://golang.google.cn/doc/tutorial/

　　选择中文阅读go的官方文档。

　　查看官方提供的go的包的函数使用，即API(application program interface)应用程序接口，就是go的各个包的各个函数：https://golang.google.cn/doc/tutorial/getting-started

一、常量

1、语法格式

　　常量，编译阶段已经确定了值，程序在运行时无法改变常量的值。定义一个常量使用const关键字，语法格式如下：

const constantName [type] = value

　　const: 定义常量关键字；

　　constantName: 常量名称；

　　type: 常量类型；

　　value: 常量的值

2、示例代码

 1 package main
 2 
 3 import "fmt"
 4 
 5 /**
 6    声明单个变量：指定类型、类型推导
 7  */
 8 func defineSingleConst() {
 9    // 指定类型
10    const CONST01 int8 = 1
11    fmt.Printf("指定类型：CONST01: %v\n", CONST01)
12 
13    // 类型推导
14    const CONST02 = 3.1415926
15    fmt.Printf("类型推导：CONST02: %v\n", CONST02)
16 }
17 
18 /**
19    const同时声明多个变量，如果省略了值则表示和上面一行的值相同。
20  */
21 func defineMultiConst() {
22    // 批量声明常量
23    const (
24       W = 10
25       H = 20
26    )
27    fmt.Printf("定义多常量：W: %v, H: %v\n", W, H)
28 
29    // 省略了值则表示和上面一行的值相同。
30    const (
31       PRICE01 = 20.00
32       PRICE02 = 30.00
33       //PRICE02
34       PRICE03
35    )
36    fmt.Printf("PRICE01: %v, PRICE02: %v, PRICE03: %v\n", PRICE01, PRICE02, PRICE03)
37 }
38 
39 /**
40    iota关键字，可被编译器修改的常量，默认值为0
41       每次调用常量值加1
42       遇到const关键字，会被重置为0
43  */
44 func iotaKeys() {
45    // 默认值为0，每次调用加 1
46    const (
47       x = iota
48       y = iota
49       z = iota
50    )
51    fmt.Printf("x: %v, y: %v, z: %v\n", x, y, z)
52    fmt.Println("=================================================")
53 
54    // 遇到const关键字，会被重置为0
55    // 使用 '_' 跳过某些值
56    const (
57       a = iota
58       _
59       c = iota
60    )
61    fmt.Printf("a: %v, c: %v\n", a, c)
62    fmt.Println("=================================================")
63 
64    // iota 声明使用中间插队的场景
65    const (
66       q = iota
67       w = 200
68       s = iota
69    )
70    fmt.Printf("q: %v, w: %v, s: %v\n", q, w, s)
71 }
72 
73 
74 func main() {
75    defineSingleConst()
76    defineMultiConst()
77    iotaKeys()
78 }

二、变量

1、语法格式

　　变量：内存中的一块存储区域，该区域中存储 变量名 、数据类型、变量值。定义一个变量使用 var 关键字。声明变量语法结构如下：

var varName [type]

　　var: 定义变量关键字；

　　varName: 变量名称；

　　type: 变量类型

2、示例代码

 1 package main
 2 
 3 import "fmt"
 4 
 5 // ===== 全局变量的声明 =====
 6 // 方式一
 7 var var10 = 10
 8 var var11 = 6.8
 9 var var12 = "jack"
10 // 方式二
11 var (
12    var20 = 80
13    var21 = 5.20
14    var22 = "tom"
15 )
16 
17 // ===== 局部变量的声明 =====
18 /**
19    声明单个变量
20  */
21 func defineSingleLocalVar() {
22    // ===== 指定类型 =====
23    // 声明变量
24    var var01 int
25    // 变量赋值
26    var01 = 3
27    // 使用变量
28    fmt.Println("声明单变量 -> var01 = ", var01)
29 
30    // ===== 类型推导：根据值自行判断数据类型 =====
31    var02 := 3.1415926
32    fmt.Println("声明单变量 -> var02 = ", var02)
33 
34    // 变量不赋值，使用默认值
35    var y int
36    fmt.Println("声明单变量 -> y = ", y)
37 
38    // 变量在同一作用域(在一个函数或者代码)内不能重名
39    //var var10 int = 3
40 
41    // var 与 := 不能一起使用
42    //var x := 3
43    //fmt.Println("声明单变量 -> x = ", x)
44 
45 }
46 
47 /**
48    声明多个变量
49  */
50 func defineMultiLocalVar() {
51    // 指定类型
52    var var01, var02 int
53    var01 = 4
54    var02 = 5
55    fmt.Printf("多局部变量声明方式一 -> var03 = %v, var03 = %v\n", var01, var02)
56 
57    // 类型推导
58    var var03, var04, var05 = 4, "tom", 4.5
59    fmt.Println("多局部变量声明方式二 -> var03 = ", var03, ",var04 = ", var04, ",var05 = ", var05)
60 
61    // 方式三：类型推导
62    var06, var07, var08 := 6, "tuoni", 7.8
63    fmt.Println("多局部变量声明方式三 -> var06 = ", var06, ",var07 = ", var07, ",var08 = ", var08)
64 }
65 
66 /**
67    变量
68  */
69 func main() {
70    fmt.Println("全局变量声明方式一 -> var10 = ", var10, ",var11 = ", var11, ",var12 = ", var12)
71 
72    fmt.Println("全局变量声明方式二 -> var20 = ", var20, ",var21 = ", var21, ",var22 = ", var22)
73 
74    defineSingleLocalVar()
75    defineMultiLocalVar()
76 }

3、变量使用注意事项

　　1、声明的变量不赋值，变量使用默认值；

　　2、变量在同一作用域(在一个函数或者代码)内不能重名

　　3、关键字 var 与 := 不能一起使用

三、数据类型

　　Go中的数据类型整体分为两大类型：基本数据类型、复杂数据类型。详情如下：

　　先介绍Go中的基本数据类型，复杂数据类型后面再做详细描述。

1、整型

　　整型，也被称为整数型。分为有符号整数、无符号整数。有符号整数：int8 [-2^7, (2^7) - 1]、int16、int32、int64。无符号整数：uint8[0, 2^7 - 1]、uint16、uint32、uint64。

　　Go语言中，不指定整型类型，默认为int类型，默认值为0，占8字节。验证代码如下：

 1 package main
 2 
 3 import (
 4    "fmt"
 5    "unsafe"
 6 )
 7 /**
 8    变量占用字节的大小和数据类型
 9  */
10 func main() {
11 
12    // 整型默认为int型，占8个字节
13    n := 10
14    fmt.Printf("n 的类型 %T ，n占用的字节数是 %d \n", n, unsafe.Sizeof(n))
15    
16    // 默认值为 0 
17    var int01 int
18    fmt.Printf("int01 = %v \n", int01)
19    
20    // 占1字节
21    var n1 int8 = 10
22    fmt.Printf("n1 的类型 %T ，n1占用的字节数是 %d \n", n1, unsafe.Sizeof(n1))
23 
24    // 占2字节
25    var n2 int16 = 10
26    fmt.Printf("n2 的类型 %T ，n2占用的字节数是 %d \n", n2, unsafe.Sizeof(n2))
27 
28    // 占4字节
29    var n3 int32 = 10
30    fmt.Printf("n3 的类型 %T ，n3占用的字节数是 %d \n", n3, unsafe.Sizeof(n3))
31 
32    // 占8字节
33    var n4 int64 = 10
34    fmt.Printf("n4 的类型 %T ，n4占用的字节数是 %d \n", n4, unsafe.Sizeof(n4))
35 
36    // 占1字节
37    var m1 uint8 = 10
38    fmt.Printf("m1 的类型 %T ，m1占用的字节数是 %d \n", m1, unsafe.Sizeof(m1))
39 
40    // 占2字节
41    var m2 uint16 = 10
42    fmt.Printf("m2 的类型 %T ，m2占用的字节数是 %d \n", m2, unsafe.Sizeof(m2))
43 
44    // 占4字节
45    var m3 uint32 = 10
46    fmt.Printf("m3 的类型 %T ，m3占用的字节数是 %d \n", m3, unsafe.Sizeof(m3))
47 
48    // 占8字节
49    var m4 uint64 = 10
50    fmt.Printf("m4 的类型 %T ，m4占用的字节数是 %d \n", m4, unsafe.Sizeof(m4))
51 }

2、浮点型

　　浮点型：单精度 - float32、双精度 - float64。验证代码如下：

 1 package main
 2 
 3 import (
 4    "fmt"
 5    "unsafe"
 6 )
 7 
 8 /**
 9    浮点型
10  */
11 func main() {
12    // 浮点型默认为float型，8个字节
13    float := 3.14159
14    fmt.Printf("float 的类型 %T ，float占用的字节数是 %d \n", float, unsafe.Sizeof(float))
15    
16    // 4字节
17    var float01 float32 = 3.14159
18    fmt.Printf("float01 的类型 %T ，float01占用的字节数是 %d \n", float01, unsafe.Sizeof(float01))
19    
20    // 8字节
21    var float02 float64 = 3.14159
22    fmt.Printf("float02 的类型 %T ，float02占用的字节数是 %d \n", float02, unsafe.Sizeof(float02))
23 
24    // 默认值为 0.000000
25    var float04 float64
26    fmt.Printf("float04 = %f \n", float04)
27 }

　　Go语言中不指定浮点型类型，默认为float64类型，默认值为0.000000，占8个字节，float64位精度比float32精度的要准确。

3、布尔型

　　布尔型只有两个值：true 和 false。布尔型的默认值为false，占1个字节。常用在条件控制语句、逻辑表达式中。验证代码如下：

 1 package main
 2 
 3 import (
 4    "fmt"
 5    "unsafe"
 6 )
 7 
 8 /**
 9    布尔数据类型
10  */
11 func main() {
12    // 默认值为false
13    var bool01 bool
14    fmt.Printf("bool01: %v \n", bool01)
15 
16    // 占 1 字节
17    bool02 := false
18    fmt.Printf("bool02: %v %T %d\n", bool02, bool02, unsafe.Sizeof(bool02))
19 
20    // 条件控制语句、逻辑表达式
21    count := 10
22    r := count >= 18
23    if r {
24       fmt.Println("===== 已成年 =====")
25    }else {
26       fmt.Println("===== 未成年 =====")
27    }
28 
29    // 循环语句
30    for i := 0; i < count; i++ {
31       if i == count - 1 {
32          fmt.Printf("i = %v \n", i)
33       }else {
34          fmt.Printf("i = %v ", i)
35       }
36    }
37 }

4、byte类型

　　Go语言中，byte默认值为0，占用1个字节。byte与uint8等价，当要存储字符时，建议选用byte。验证代码如下：

 1 package main
 2 
 3 import (
 4    "fmt"
 5    "unsafe"
 6 )
 7 
 8 func main() {
 9    // byte 默认值是 0 , 占用1个字节
10    var b byte
11    fmt.Printf("b 默认值 %v ，b占用的字节数是 %d \n", b, unsafe.Sizeof(b))
12 
13    // byte 类型不可以用类型推导，默认int类型
14    b01 := 1
15    fmt.Printf("b01 默认值 %T ，b01占用的字节数是 %d \n", b01, unsafe.Sizeof(b01))
16 
17    // 两个byte相加，类型变为uint8，可得出结论byte与uint8等价，当要存储字符时，建议byte
18    var b02 byte
19    b02 = 3
20    var b03 byte
21    b03 = b + b02
22    fmt.Printf("b03 默认值 %T ，b03占用的字节数是 %d \n", b03, unsafe.Sizeof(b03))
23 
24 }

5、字符串类型

　　Go语言中，string类型默认值为 空字符串，占16个字节，可通过双引号、反引号来创建字符串。注意：反引号不支持转义字符。验证代码如下：

 1 package main
 2 
 3 import (
 4    "bytes"
 5    "fmt"
 6    "strings"
 7    "unsafe"
 8 )
 9 
10 // 字符串拼接
11 func stringBond() {
12    var str string = "hello "
13    var str1 = "world!"
14    // 拼接方式一 ： +
15    fmt.Println("content: ", str+str1)
16 
17    // 拼接方式二：Sprintf
18    content1 := fmt.Sprintf("%s%s", str, str1)
19    fmt.Printf("content1: %v\n", content1)
20 
21    // 拼接方式三 ： 数组 + join函数
22    content2 := strings.Join([]string{str, str1}, " ")
23    fmt.Printf("content2: %v\n", content2)
24 
25    // 拼接方式四： buf.WriteString
26    var buf bytes.Buffer
27    buf.WriteString("hello")
28    buf.WriteString(" ")
29    buf.WriteString("world！")
30    fmt.Printf("buf: %v\n", buf.String())
31 }
32 
33 // 字符串截取
34 func stringCutout() {
35    str := "yfghchafydsaduaigdaiugkauekagdjasdyadiadhjaf"
36    start := 6
37    end := 14
38 
39    // 获取字符串索引位置为start的原始字节
40    fmt.Println(str[start])
41    // 获取字符串索引位置从 start 到 end - 1 的字符串
42    fmt.Println(str[start:end])
43    // 获取字符串索引位置从 start 到 len(s) - 1 的字符串
44    fmt.Println(str[start:])
45    // 获取字符串索引位置从 0 到 end - 1 的字符串
46    fmt.Println(str[:end])
47 }
48 
49 // 热点方法
50 func hotMethod() {
51    str := "hello world"
52    // 字符串长度
53    fmt.Printf("len(str): %v\n", len(str))
54    // 字符串分割
55    fmt.Printf("strings.Split(str, \" \"): %v\n", strings.Split(str, " "))
56    // 字符串包含
57    fmt.Printf("strings.Contains(str, \"lo\"): %v\n", strings.Contains(str, "lo"))
58    // 字符串前缀
59    fmt.Printf("strings.HasPrefix(\"he\"): %v\n", strings.HasPrefix(str, "he"))
60    // 字符串后缀
61    fmt.Printf("strings.HasSuffix(\"ld\"): %v\n", strings.HasSuffix(str, "ld"))
62    // 字符串索引
63    fmt.Printf("strings.Index(str, wo): %v\n", strings.Index(str, "wo"))
64    // 字符串字母小写转大写
65    fmt.Printf("strings.ToUpper(str): %v\n", strings.ToUpper(str))
66 }
67 
68 func main() {
69 
70    // string类型默认值为 空字符串，占16个字节
71    var str string
72    fmt.Printf("str: %v, %d \n", str, unsafe.Sizeof(str))
73 
74    // 字符串可通过 双引号 、反引号创建，反引号创建的字符串不支持转义字符
75    var str01 = "hello world!\n"
76    var str02 = `hello world!\n`
77    var str03 = "hello world!"
78    fmt.Printf("%v, %v, %v", str01, str02, str03)
79 
80    // 拼接
81    stringBond()
82    // 截取
83    stringCutout()
84    // 热点方法
85    hotMethod()
86 }