(一)Go基本语法

变量

变量声明

显式声明

• 如果我们未为一个变量初始化，则必须显式指定变量类型

• 如果声明时不指定具体的值，则会被赋值为默认值。

var str string // str的值为""(空字符串)
var num int    // num的值为0

快速声明赋值

• Go 支持变量类型自动推断，也就是说，当我们立即为一个变量进行初始化时，其类型是可以省略的

• 可以通过 := 符号以一种简单的方式（也是实际上最常用的方式）声明一个变量

a, b := 1, 2// Go 支持多个变量在同一行同时声明
str := "我是字符串。"

常量声明

可以使用 const 关键字代替 var 关键字来创建一个常量（不可变变量）

const str string = "我是字符串"
const num int = 1
const a, b = 3, 4

num = 2 // 若更改会报错

流程控制

if

• Go的if语句和C、Java类似，只不过if后面没有括号，但是加上括号也能正确运行
• if后面的开始大括号必须跟if在同一行，不能换行(会报错)。

num1, num2 := 1, 2

if num1 < num2 {
    fmt.Println("num1 < num2")
} else {
    fmt.Println("num1 >= num2")
}

if语句后面也可以定义变量，但只能用一个分号。也支持if-else-if语句。

if num1, num2 := 1, 2; num1 < num2 {
    fmt.Println("num1 < num2")
} else if num1 > num2 {
    fmt.Println("num1 < num2")
} else {
    fmt.Println("num1 = num2")
}

for

在Go里没有while和do-while循环，只有for循环。Go的for循环包含了for和while的功能。

用for定义死循环，相当于while(true)。

for {
    fmt.Println("loop")
}

switch

switch语句也和C、Java的``switch语句类似，只不过switch后面不需要加括号，case里也不需要加break，Go的switch 默认情况下 case最后自带break语句，匹配成功后就不会执行其他case，如果我们需要执行后面的 case，可以使用 fallthrough` 。

num := 2
switch num {
case 1:
    fmt.Println("one")
case 2, 3:
    fmt.Println("two or three")
default:
    fmt.Println("other")
}

Go的switch可以匹配任意类型，也可以实现if-else的功能，在switch后面不加匹配条件，可以在case里进行匹配。

t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("It's before noon")
default:
    fmt.Println("It's after noon")
}

数组

一维数组

// 声明一个长度为5的数组
var a [5]int
a[4] = 100
fmt.Println("get:", a[2])
fmt.Println("len:", len(a))

// 声明并初始化
b := [5]int{1, 2, 3, 4, 5}
fmt.Println(b)

多维数组

var twoD [2][3]int
for i := 0; i < 2; i++ {
    for j := 0; j < 3; j++ {
        twoD[i][j] = i + j
    }
}
fmt.Println("2d: ", twoD)

切片

声明

• 有点像Java的List

• 切片声明需要通过make来进行，需要指定切片的类型以及长度

// 声明一个空切片，长度为3，容量为10
s1 := make([]string, 3, 10)
// 声明并初始化
s2 :=[] int {1,2,3,4,5,6} 

操作

对切片元素的操作，可以像数组一样操作：

s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"

添加

可以通过append方法向切片中添加元素，因为切片会涉及到扩容，所以需要一个变量来接收返回值

s = append(s, "d")
s = append(s, "e", "f")

复制

可以通过copy方法对切片进行复制，复制后是两个独立的切片，更改元素值相互不影响。

go复制代码c := make([]string, len(s))
copy(c, s)
fmt.Println(c) // [a b c d e f]

切片

相当于Java中的substring

go复制代码// 返回下标2到4的值
fmt.Println(s[2:5]) // [c d e]
// 返回下标0到4的值
fmt.Println(s[:5])  // [a b c d e]
// 返回下标2到最后一个元素
fmt.Println(s[2:])  // [c d e f]

Map

无序

声明

声明一个key为string，value为int的空Map

m := make(map[string]int)

声明的同时对其进行初始化操作：

m2 := map[string]int{"one": 1, "two": 2}

访问和操作

m["one"] = 1
m["two"] = 2
fmt.Println(m["one"])    // 1
fmt.Println(m["unknow"]) // 0

Go在查询key时返回了两个值，一个是value，另一个是bool类型的值代表是否存在

r, ok := m["unknow"]
fmt.Println(r, ok) // 0 false

可以使用delete函数来删除Map中的键值对

Goland中可以通过map.delete快速生成

delete(m, "one")

range

有点像JavaScript的解构赋值

数组、切片、Map都可以使用range来遍历，通过range可以得到索引和对应的值

nums := []int{2, 3, 4}
sum := 0
// 遍历切片
for i, num := range nums {
    fmt.Println("index:", i, "num:", num)
}
// 遍历Map
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
    fmt.Println(k, v) // b 8; a A
}
// 只获取key
for k := range m {
    fmt.Println("key", k) // key a; key b
}
// 只获取value
for _, v := range m {
    fmt.Println("value", v) // value A; value B
}

函数

Go函数不同于Java，返回值写在最后面，而且可以同时返回多个值

一般来说，第一个是函数的返回值，第二个是错误信息

func exists(m map[string]string, k string) (v string, ok bool) {
    v, ok = m[k]
    return v, ok
}

指针

Go支持指针，相对于C语言，Go的指针功能十分简单，当然功能也很有限，主要用途就是对函数传入的参数进行修改。

默认情况下，Go函数的参数传参是值传递，也就是拷贝了一个副本，对其修改不会影响原来的值，如果要对原来的值也要变的话，需要使用指针。

func add2(n int) {
    n += 2
}
func add2ptr(n *int) {
    *n += 2
}
func main() {
    n := 5
    add2(n)
    fmt.Println(n) // 5
    add2ptr(&n)
    fmt.Println(n) // 7
}

结构体

结构体变量

和C语法差不多，相当于Java的对象

type user struct {
    name     string
    password string
}

结构体的初始化，可以指定字段初始化，也可以全部初始化。

a := user{name: "wang", password: "1024"}
b := user{"wang", "1024"}
c := user{name: "wang"}

对于结构体内部成员的访问可以通过.操作符来进行访问或赋值。

var d user
d.name = "wang"
d.password = "1024"
fmt.Println(d.password)

结构体方法

相当于Java类的成员函数

在一个普通方法的func关键字后面加上对应结构体信息，就代表这个方法是属于结构体的。

为user结构体添加一个检查密码的函数：

func (u user) checkPassword(password string) bool {
    return u.password == password
}

为user结构体添加一个重置密码的函数，因为要修改结构体内部的值，所以要使用指针类型：

func (u *user) resetPassword(password string) {
    u.password = password
}

结构体方法的调用：

a := user{name: "wang", password: "1024"}
a.resetPassword("2048")
fmt.Println(a.checkPassword("2048")) // true

错误处理

Go内置的错误接口提供了非常简单的错误处理机制，error类型是一个接口类型，其定义如下：

type error interface {
    Error() string
}

Go函数可以返回多个值，通常函数的最后一个值用来代表错误信息，在函数内部可以使用errors.New 可返回一个错误信息：

func findUser(users []user, name string) (v *user, err error) {
    for _, u := range users {
        if u.name == name {
            return &u, nil
        }
    }
    return nil, errors.New("not found")
}

如果函数不出现错误的话，可以直接返回nil。

在调用函数的时候，需要用多个变量来接收函数的返回值，我们可以通过函数的返回值来判断是否发生了异常。

u, err := findUser([]user{{"wang", "1024"}}, "wang")
if err != nil {
    fmt.Println(err)
    return
}

标准库

Go内置了非常丰富的标准库工具，包括字符串操作、字符串格式化、json处理、时间处理等

字符串操作

a := "hello"
// 是否包含
fmt.Println(strings.Contains(a, "ll"))                // true
// 字符统计
fmt.Println(strings.Count(a, "l"))                    // 2
// 判断字符串开头
fmt.Println(strings.HasPrefix(a, "he"))               // true
// 判断字符串结尾
fmt.Println(strings.HasSuffix(a, "llo"))              // true
// 查找字符串
fmt.Println(strings.Index(a, "ll"))                   // 2
// 字符串拼接
fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
// 复制字符串指定次数
fmt.Println(strings.Repeat(a, 2))                     // hellohello
// 字符串替换
fmt.Println(strings.Replace(a, "e", "E", -1))         // hEllo
// 字符串分割
fmt.Println(strings.Split("a-b-c", "-"))              // [a b c]
// 转为小写
fmt.Println(strings.ToLower(a))                       // hello
// 转为大写
fmt.Println(strings.ToUpper(a))                       // HELLO
// 字符串长度
fmt.Println(len(a))                                   // 5

字符串格式化

Println最为常用作用为打印并换行，Printf可以按指定格式打印字符串。

+v可以打印字段和值详细信息。

#v可以打印出整个结构体的构造以及详细信息。

go复制代码s := "hello"
n := 123
p := point{1, 2}
fmt.Println(s, n) // hello 123
fmt.Println(p)    // {1 2}

fmt.Printf("s=%v\n", s)  // s=hello
fmt.Printf("n=%v\n", n)  // n=123
fmt.Printf("p=%v\n", p)  // p={1 2}
fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}

f := 3.141592653
fmt.Println(f)          // 3.141592653
fmt.Printf("%.2f\n", f) // 3.14

json处理

Go在处理json时十分简单，只需要将结构体中的字段第一个字母变成大写就能用内置的JSON工具进行处理。

Go中一些特殊的类型，比如Channel、complex、function是不能被解析成JSON的。

Go中JSON对象只支持string作为key，对于map，那么必须是map[string]T这种类型，T可以是Go语言中任意的类型。

Go的json处理是通过Marshal、Unmarshal方法来进行处理的。

Marshal 用于自定义编码json的方法，也就是将变量、对象转成json，转换之后需要用string方法强转一下，否则会打印出的是16进制字符串。

Unmarshal用于自定义解码json方法，也就是将json转为对象。

type userInfo struct {
    Name  string
    Age   int `json:"age"` // 自定义json输出的字段
    Hobby []string
}

func main() {
    a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
    buf, err := json.Marshal(a)
    if err != nil {
        panic(err)
    }
    fmt.Println(buf)         // [123 34 78 97...]
    fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}

    buf, err = json.MarshalIndent(a, "", "\t")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(buf))

    var b userInfo
    err = json.Unmarshal(buf, &b)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}

时间处理

Go提供了很多常用的时间处理函数，例如Now、解析字符串、转字符串、获取时间戳等。在操作时间相关的方法时，需要导入time包。

// 获取当前时间
now := time.Now()
fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
fmt.Println(t)                                                  // 2022-03-27 01:25:36 +0000 UTC
// 获取时间的年月日
fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
// 时间转字符串
fmt.Println(t.Format("2006-01-02 15:04:05"))                    // 2022-03-27 01:25:36
// 获取时间差
diff := t2.Sub(t)
fmt.Println(diff)                           // 1h5m0s
fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
// 解析字符串
t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
if err != nil {
        panic(err)
}
fmt.Println(t3 == t)    // true
// 获取时间戳
fmt.Println(now.Unix()) // 1648738080