Go学习

本文最后更新于:2022年11月19日 晚上

基础语法

先来一手经典开局

1
2
3
4
5
6
7
8
9
10
// 声明main包
package main

// 导入fmt包(一系列可调用的方法)
import "fmt"

// main函数(类C语言)
func main() {
fmt.Println("Hello World!")
}

变量声明

GO语言为强类型语言,没有隐式类型转换

🍕全局变量

1
2
var a int = 1
var b float64 = 1.0

变量有初始值声明时可不加类型GO会自动指定类型(不可更改类型)

1
2
var a = 1 / 3    // 0
var b = 1.0 / 3 // 0.3333333333333333

若不负初值则必须带类型(会赋予该类型的默认值)

1
var gender bool  // false

GO还支持同时声明多变量

1
2
3
4
5
var (
name string = "Jonathan"
gender bool
age = 20
)

🍕局部变量

局部变量指在函数语句块内声明的变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func main() {
var (
name string = "Jonathan"
gender bool = true
age = 20
)

fmt.Println(name, gender, age)
// Jonathan true 20
}

对于局部变量还支持精简的声明方法

1
2
3
4
5
6
7
8
// ...
func main() {
name := "Jonathan"
gender := true
age := 20

fmt.Println(name, gender, age)
}

🍕常量

使用const关键字替换var即可定义常量

类型

☘️基础类型

整数: int, int

默认值0

浮点数:

默认值0

布尔:bool

默认值false

字符串:

默认值""

使用双引号

☘️数组与切片

GO中数组长度不可改变

len()函数可以获取数组长度

1
2
3
4
5
var students [5]string

students[0] = "foo"

fmt.Println(students[0])

初始化数组(字面量声明)

1
students := [5]string{"foo", "bar", "baz", ""}

切片是可以改变长度的数组(长度只可增加)

切片可用make方法创建接受3个参数

  • Type: 存储类型
  • size: 初始化长度
  • add: 可选,可能会增长到的长度(可以在扩容时提升性能,不用重新划分空间)

append方法可以在原数组后添加元素

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
students := make([]string, 5, 7)
students = append(students, "foo", "bar")
fmt.Println(students)
}

cap函数可以获取切片不重新申请空间的可用容量

初始化切片(字面量声明)

1
students := []string{"foo", "bar"}

☘️哈希表

map[type1]type2

使用make函数创建哈希表

1
2
3
4
5
user := make(map[string]string)

user["name"] = "Jonathan"
user["age"] = "20"

初始化map(字面量声明)

1
2
3
4
user := map[string]string{
"name": "Jonathan",
"age": "20",
}

delete函数删除某个键值对

1
delete(user, "age")

☘️结构体

1
2
3
4
5
6
7
8
9
10
11
type User struct {
name string
age int
}

user := User{
name: "Jonathan",
age: 20,
}

fmt.Printf("%+v", user)

使用.运算符获取结构体键值

1
user.name

☘️类型别名

☘️指针

流程控制语句

🛠️选择语句

GO的流程控制语句都不需要括号,但必须有花括号{}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import "fmt"

func main() {
gender := true
var res string

if gender == true {
res = "This is a boy."
} else if gender == false {
res = "This is a girl."
} else {
res = "TypeError"
}

fmt.Println(res)
}

🛠️循环语句

GO只有for关键字

1
2
3
4
5
6
7
8
9
10
package main

import "fmt"

func main() {
for i := 0; i < 10; i++ {
fmt.Print(i, " ")
}
// 0 1 2 3 4 5 6 7 8 9
}

使用for实现while

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
i := 0
for i < 10 {
fmt.Print(i, " ")
i++
}
// 0 1 2 3 4 5 6 7 8 9
}

🛠️switch语句

GO中的switch不在需要break退出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import "fmt"

func main() {
role := "User"

switch role {
case "User":
fmt.Println("Happy Day!")
case "Manager":
fmt.Println("Welcome!")
default:
fmt.Println("Unknown!")
}
}

switch还支持逻辑表达式来选择,也可不写select变量

fallthrough语句会直接执行下一case

使用fallthrough无论下一条case是否成立均会执行

1
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() {
for i := 0; i < 10; i++ {
switch {
case i%2 == 1:
fmt.Println(i, "odd")
case i%4 == 0:
fmt.Println("This is a multiple of 4")
fallthrough
case i%2 == 0:
fmt.Println(i, "even")
default:
fmt.Println("TypeError")
}
}
}

函数

func声明函数

1
2
3
func say(words string) {

}

包管理

第一行有效代码用于声明package

import导入包

其中项目入口文件main.go声明main包,并有一个main函数作为项目执行入口函数

1
2
3
4
5
6
7
package main

import "fmt"

func main() {
fmt.Println("Go!")
}

内置包

fmt

fmt包提供了许多输入输出方法

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
fmt.Print("")
fmt.Println("")
}

time

time包提供了处理时间的相关函数

strings

os


Go学习
https://qingshaner.com/Go学习/
作者
清山
发布于
2022年11月17日
许可协议