## 函数的声明

```go
func function_name([params_list])([return_values_list]){
    // 函数体
}
```

- `func`关键字表示定义一个函数
- function_name是函数名
- params_list表示参数列表
- return_values_list表示函数的返回值列表
- 使用大括号包裹起来的部分称为函数体，是函数内部要执行的代码。





其中，参数列表和返回值列表是可选的。有些函数无需参数，有些参数运行后并不会有任何返回值，有些函数则无需参数也无需返回值


:::warning{title="注意"}
go 语言不允许函数的嵌套，因此函数应各自独立定义
:::


```go
func fn_a(a string) string{
    // do something
    return a
}

// 如果连续参数具有相同的类型，我们也可以进行速记声明
func fn_b(p1, p2 string) {}

// 没有参数和返回值的函数
func fn_c(){
    // do something
}

// 在别的函数调用一个函数
func main(){
    rst := fn_a("123")
    fmt.Println(rst)
}


// 123
```

## 返回值

```go
// go 中支持返回多个值
func fn_a()(string, int){
    return "123", 5
}

// go 还可以在函数体定义返回值的变量
// 不建议这么使用，会降低可读性
func fn_b()(s string, i int){
    var s string = "123"
    var i int = 5
    return 
}
```

:::warning{title="注意"}
1.  如果函数没有返回值，那么就是真的没有返回值，而不是默认返回一个值
:::
![image.png](https://oss.silon.vip/img/ba81c1599590c4e4d0d1a1acf24bc47d.image.png)


## 函数参数值的传递


:::warning{title="注意"}
直接传递一个变量名到另一个函数中，属于值传递
值传递不会修改原变量
:::
```go
func fn_a (num1 int, num2 int) {
    // 值传递
    num1 = num1 + num2
}

func main(){
    var a int = 5
    fn_a(a, 10)
    
    // 5
    fmt.Println(a)
}
```

如果想要修改原有的值，可以通过引用传递的方式实现（传递内存地址）
```go
func main(){
    var a int = 5
    // 传递了内存地址
    fn_a(&a, 10)
    
    // 15
    fmt.Println(a)
}

func fn_a (num1 *int, num2 int) {
    // 引用传递，这里直接修改了 a 内存中存储的值
    *num1 = *num1 + num2
}
```

还可以直接定义一个全局变量，这样可以直接操作修改

```go
// 所有函数都能修改这个全局变量，数据存在一定的安全风险。
A int = 5

main (){
    A += 10
}
```


## 作为值的函数（匿名函数）

go 中的函数可以直接作为一个值，类似 js 中的函数


```go
func myFunction() {
    // 这里实际是创建了一个匿名函数，赋给了 fn
    fn := func() {
	fmt.Println("inside fn")
    }

    // 调用
    fn()
}
```

匿名函数可以直接运行，所以上面的代码可以进行简化

```go
func myFunction() {
    // 这里实际是创建了一个匿名函数，直接调用，注意最后的括号
    func() {
	fmt.Println("inside fn")
    }()
}

```

## 闭包

闭包是指：
一个函数`fn_a`，是另一个函数`fn_b`的返回值

闭包意味着定义函数 `fn_a` 时访问 `fn_b` 范围内的值。

```go
func fn_b() func(int) int {
    sum := 0
    
    return func fn_a(v int) int {
        sum += v
        return sum
    }
}


add := fn_b()

add(5)


// 15
fmt.Println(add(10))
```



:::tip{title="解析"}
可以根据结果看到，sum 变量并不在 fn_a 的作用域内，但是被绑定到 fn_a 上了

好处是，这里的 sum 其实并不在外部作用域中，而是在 fn_b 中。
所以每次调用 add，都能拿到上次修改后的 sum 值
:::


:::info{title="使用闭包和使用普通函数的最大区别在于："}

如果是普通函数，那就是一次性买卖，函数执行完毕后就无法再更改函数中变量的值

- 使用闭包，函数就成为了一个变量的值。
  只要变量还在，函数就会一直处于存活并独享内部状态。方便后期更改函数中变量的值。
- 闭包还能起到一定的数据保护作用，比如这里的 sum 是不能再外部进行修改的
:::

利用闭包的特性，可以进行工厂模式相关的设计



## 可变参数

函数中，可以使用`...`省略号运算符接受零个或多个参数的函数

```go
func main() {
    sum := add(1,2,3,5)
    fmt.Println(sum)
}


// 注意这里的参数
func add(values ...int) int {
    sum := 0
    
    for _, v := range values {
        sum += v
    }
    
    return sum
}
```

## 初始化函数（init）

> init是在main函数之前执行的特殊生命周期函数。
> 与 类似main，该init函数不接受任何参数，也不返回任何值

```go
package main

import "fmt"

// 如果有多个 init 函数，则是按照定义顺序进行执行
func inti() {
    fmt.Println("初始化函数，先执行")
}

func main() {
    fmt.Println("main 函数，后执行")
}


/*
$ go run main.go
初始化函数，先执行
main 函数，后执行
*/
```


:::info{title="相关信息"}
init函数是可选的

适用于程序可能必不可少的任何全局设置，例如建立数据库连接、获取配置文件、设置环境变量等。
:::

## 延迟调用 （defer）


`defer` 关键字，它可以让我们推迟一个函数的执行，直到周围的函数返回

```go
func main() {
    defer fmt.Println("123")
    fmt.Println("234")
}
```

![image.png](https://oss.silon.vip/img/29717ea5c54cf391009d67aca9d05ff4.image.png)


如果有多个 defer，则会进入一个 defer stack（堆，先入后出）
即，先声明的后执行

```go
func main() {
    defer fmt.Println("123")
    defer fmt.Println("234")

    fmt.Println("345")
    fmt.Println("456")
}
```


![image.png](https://oss.silon.vip/img/48e40ca41da6674fe45f0ffe5d5d1807.image.png)


:::info{title="相关信息"}
defer 语句以后进先出的方式堆叠和执行。

因此，Defer 非常有用，通常用于进行清理或错误处理。


:::

Golang学习（12）：函数及应用

## 获取元素个数

Go语言内置了获取容器内元素个数的函数，这个函数对`数组`、`切片`和`集合`都有效，用法相同

```go
len(variable)
```

- len()表示调用函数，是固定写法
- variable为变量
- 调用后，函数将返回元素个数，返回值的类型是int




```go
var a []int

a = append(a, 1)
a = append(a, 3)
a = append(a, 5)
a = append(a, 7)

// 4
len(a)
```


## 修改元素

- 修改数组、切片和集合中的值，方法与赋值相同；
- 获取数组或切片的值，格式为variable[index]。
    - variable表示数组或切片的变量名
    - index表示索引值。
- 获取集合的值，格式为variable[key_value]。
    - variable表示集合的变量名
    - key_value表示键的值。
```go
var a[3]int
// 修改数组
a[0] = 5


var b[]int
b = append(b, 1)
b = append(b, 3)
// 修改切片
b[1] = 5


var c = make(map[int]string)
// 修改集合
c[1] = "5"
```

## 遍历

除了`for`循环外，Go语言还提供了`range`关键字。与for结合，也可以实现循环遍历。

**for-range结构同样适用于数组和切片**

其使用格式如下：

```go
for index, value := range variable {
    // 循环体
}
```
- index表示索引或键的值
- value表示元素的值
- variable表示数组、切片或集合变量
- 由大括号包裹的部分是循环体，可以使用index和value变量

```go
var c = make(map[int]string)
// 修改集合
c[1] = "5"
c[2] = "好"
c[3] = "a"

for key, value := range c {
    fmt.Print("键：", key, "值:", value)
}
```

Golang学习（11）：数组、切片、集合的使用

## 数组 arr (指定元素个数)


:::info{title="相关信息"}
数组中的元素并不限制值的类型，但要求所有元素均为相同的类型
:::

Go语言中声明数组的一般格式为：

```go
var array_name [quantity]Type
```

- array_name表示数组名
- quantity表示数组元素个数
- Type表示元素类型。





```go
// 声明一个长度为 4 ，元素类型为 int 的数组
var  a [4]int

// 给第 3 个元素赋值
a[2] = 5
```

```go
// 默认情况下 数组中每个元素初始化时候 根据元素的类型 对应该数据类型的零值
// [1,2,0]
arr1 := [3]int{1,2}
fmt.Println(arr1[2]) //下标为2的元素没有, 默认取int类型的零值

// 数组创建方式1 创建时 直接将值赋到数组里
// [1,2,3,4,0]
arr2 := [5]int{1,2,3,4}    //值可以少 默认是0  但是不能超过定长

// 在指定位置上存储值
// [0,2,0,5,0]
arr3 := [5]int{1:2,3:5} //在下标为1的位置存储2，在下标为3的位置存储5
```

```go
//长度可以用...代替  根据数值长度程序自动填充数值的大小
arr4 :=  [...]int{1,2,3,4}

//简短声明方式
arr5 := [...]int{2:3,6:3}//在固定位置存储固定的值
```

:::warning{title="注意"}
数组的索引从0开始，因此索引的取值范围应该是从0至数组元素个数减1为止。如本例则为0、1、2、3。

超出范围的赋值和取值将引发下标越界错误，导致程序出错。
对某一索引位置的元素重复赋值将导致旧值被新值替换。
:::

### 多维数组

```txt
// 语法
arr:=[总共多少个一维数组][每个一维数组的长度]数据类型{{默认值}，{}，{}} 

// 示例
arr:=[3][4]int{{1,2,3,4},{},{}}
```

```go
//声明一个二维数组
var arr [3][8]int

//给二维数组赋值
arr[0]=[8]int{1,2,3,4,5,6,7,8}

// [[1 2 3 4 5 6 7 8] [0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0]]
fmt.Println(arr) 

// [[1 2 3 4 5 6 7 8] [0 0 0 9 0 0 0 0] [0 0 0 0 0 0 0 0]]
arr[1][3]=9
fmt.Println(arr) 
```



## 切片 slice （不定元素个数）

如果使用数组来存放结果的话，很容易引发下标越界错误。
和数组相对，Go语言还提供了一种专门存放**不定元素个数**的数据结构——切片。

**在实际项目中，切片的使用其实更为广泛。**

例如：
当用户发起搜索，搜索的结果个数往往会根据搜索关键字的不同而发生变化。
在不确定总数的前提下，使用数组显然是不合适的。



:::info{title="相关信息"}
切片和数组一样，元素并不限制值的类型，但要求所有元素均为相同的类型
:::

切片的声明一般格式为：`var slice_name []Type`

```go
//声明一个切片slice
var slice []int

// 通过 make 声明变量
// 长度为3 容量为5  容量如果省略 则默认与长度相等也为3
s1:=make([]int,0,5)

```

- slice_name表示切片名
- Type表示元素类型。


### 切片的扩充 (append)

与数组不同，为切片赋值可以理解为 **扩充**， 需要使用 `append` 关键词一个个添加


使用格式如下：
```go
slice_name2 = append(slice_name1, value)
```

- slice_name表示已声明的切片变量名
- value表示具体的数据值


:::warning{title="注意"}
append()函数本身并不会改变原有切片，只是将切片“扩容”后的结果作为函数返回值。

因此，需要将“扩容”后的结果再次（即函数返回值）赋值给slice_name，才能真正使slice_name发生改变。
:::

```go
// 声明一个切片
var a []int

// 扩充切片 a，添加一个为 2 的值
a = append(a, 2)

// 将扩容结果赋给 b
b = append(a, 2) 
```

```go
//使用make函数创建切片
s1:=make([]int,0,5)
s2:=make([]int,0,3)

//添加一组切片到另一切片中
//...表示将另一个切片数组完整加入到当前切片中
s2=append(s2,s1...)
```

### 切片扩充的原理
```go
s1 := make([]int, 0, 3)
fmt.Printf("地址%p,长度%d,容量%d\n", s1, len(s1), cap(s1))
s1 = append(s1, 1, 2)
fmt.Printf("地址%p,长度%d,容量%d\n", s1, len(s1), cap(s1))
s1 = append(s1, 3, 4, 5)
fmt.Printf("地址%p,长度%d,容量%d\n", s1, len(s1), cap(s1))
    
    
//地址0xc000010540,长度0,容量3
//地址0xc000010540,长度2,容量3
//地址0xc00000e4b0,长度5,容量6
```

## 集合 map

集合的元素都是由若干“键-值对”数据构成的。

所谓“键”，相当于“唯一ID”；“值”，相当于单条数据，键不允许重复。

Go语言中声明集合的一般格式为：
```
var map_name = make(map[key_type]value_type)
```

- map_name 表示集合的变量名
- key_type 表示键的类型
- value_type 表示值的类型。

:::info{title="相关信息"}
集合中的键和值均不限制数据类型，且键和值可分别使用不同的类型。

但要求所有`键`均为**相同的类型**，所有`值`均为**相同类型**
:::

```go
// 声明一个集合
var a = make(map[string]string)

// 创建一条数据
a["001"] = "小红"
a["100"] = "小绿"


// 对已经存在的键再次赋值，原有的数据会被覆盖
a["001"] = "小黑"
```

## 获取元素个数

Go语言内置了获取容器内元素个数的函数，这个函数对`数组`、`切片`和`集合`都有效，用法相同

```go
// 获取实际存储的数据量
len(variable)

// 容器中能够存储的最大数据量  因为数组是定长的 所以长度和容量是相同的
cap(variable)

// 调用后，函数将返回元素个数，返回值的类型是int
```



```go
var a [5]int

// 0
len(a)
// 5
cap(a)

a = append(a, 1)
a = append(a, 3)
a = append(a, 5)
a = append(a, 7)

// 4
len(a)
```


## 修改元素

- 修改数组、切片和集合中的值，方法与赋值相同；
- 获取数组或切片的值，格式为variable[index]。
    - variable表示数组或切片的变量名
    - index表示索引值。
- 获取集合的值，格式为variable[key_value]。
    - variable表示集合的变量名
    - key_value表示键的值。
```go
var a[3]int
// 修改数组
a[0] = 5


var b[]int
b = append(b, 1)
b = append(b, 3)
// 修改切片
b[1] = 5


var c = make(map[int]string)
// 修改集合
c[1] = "5"
```

## 遍历

除了`for`循环外，Go语言还提供了`range`关键字。与for结合，也可以实现循环遍历。

**for-range结构同样适用于数组和切片**

其使用格式如下：

```go
for index, value := range variable {
    // 循环体
}
```
- index表示索引或键的值
- value表示元素的值
- variable表示数组、切片或集合变量
- 由大括号包裹的部分是循环体，可以使用index和value变量

```go
var c = make(map[int]string)
// 修改集合
c[1] = "5"
c[2] = "好"
c[3] = "a"

for key, value := range c {
    fmt.Print("键：", key, "值:", value)
}
```

Golang学习（10）：数组、切片、集合的创建

## 循环结构

循环结构的语法如下
```go
for init; condition; post {
    //循环体代码块
}
```
- `for`表明接下来的代码是for循环结构；
- `init`是初始化语句；
- `condition`是关系或逻辑表达式，值为false时则会停止循环；
- `post`是每次循环结束后执行的语句；
- `循环体代码块`就是要重复执行的代码了。





:::info{title="相关信息"}
```go
// 终止本次循环，执行下一个循环
continue
    
// 终止整个循环
break
```
:::


举例说明：
```go
n := 7
for i := 1; i <= n; i++ {
    for j := 0; j < n-i; j++ {
       fmt.Print(" ")
    }
    for k := 0; k < 2*i-1; k++ {
       fmt.Print("*")
    }
    fmt.Println()
}
```

`Init` 和 `post` 语句是可选的，因此我们也可以使我们的for循环表现得像一个 while 循环
```go
i := 0

for ;i < 10; {
    i += 1
}
```


```go
// 死循环
for {
    // do something
}
```

## 条件分支结构

### if else

条件分支结构语法如下

`condition`是关系或逻辑表达式

```go
if condition {
    //条件成立时要执行的语句
}else{
    //条件不成立时要执行的语句
}
```

```go
// 如无必要，else是可以省略的

if condition {
    //条件成立时要执行的语句
}
```

```go
// 如有必要，还可追加更多的判断条件

if condition1 {
    //条件condition1成立时要执行的语句
}else if condition2 {
    //条件condition2成立时要执行的语句
}else if condition3 {
    //条件condition3成立时要执行的语句
}else{
    //以上三种条件都不成立时要执行的语句
}
```

举例说明：

```go
var a int = 10
var b int = 5
var c int = 20

if a > b || a > c {
    fmt.Print("ok")
}
```


### switch case

> switch 的本质是：将 case 与 condition 判等，若为 true 则执行

:::info{title="相关信息"}
在 Go 中，switch case 只运行第一个值等于条件表达式的 case，而不是后面的所有 case。
因此，与其他语言不同，`break`语句会自动添加到每个案例的末尾。
:::


```go
func main() {
    day := "monday"

    switch day {
    case "monday":
	fmt.Println("time to work!")
    case "friday":
	fmt.Println("let's party")
    default:
	fmt.Println("browse memes")
    }
}

// time to work
```


如果需要执行其他 case，则需要使用 `fallthrough` 关键字来进行

```go
switch day := "monday"; day {
case "monday":
    fmt.Println("time to work!")
    //这里使用了 fallthrough
    fallthrough
case "friday":
    fmt.Println("let's party")
default:
    fmt.Println("browse memes")
}

// time to work!
// let's party
```


:::warning{title="注意"}
如果不填入条件，默认为 `switch true`
:::

```go
x := 10

switch {
    case x > 5:
        fmt.Println("yes")
    default:
	fmt.Println("no")
}

// yes
```

```go
x := 1

switch {
    case x > 5:
        fmt.Println("yes")
    default:
	fmt.Println("no")
}

// no
```

## 跳转 goto

`goto` 可以跳转到程序中指定的行

和嵌套循环里的break标签是一样的，不管后面还有多少代码都不再执行。

```go
TestLabel: 
for a := 20; a < 35; a++ {
    if a == 25 {
        a += 1
        goto TestLabel
    }
    fmt.Println(a)
    a++
}
```

Golang学习（09）：流程控制

## 运算符

Go语言总共提供了6种常用的运算符
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 指针运算符




###  算数运算符


![image.png](https://oss.silon.vip/img/7d1d41fa9b837d6823945ed7f1514d83.image.png)


:::warning{title="注意"}
在做除法的时候，结果类型是 `int` 时，只保留整数结果。
抹去小数部分，而不是四舍五入
:::

### 关系运算符


![image.png](https://oss.silon.vip/img/c33ca1cb1121a5746ba40095a4cc2d8a.image.png)


### 逻辑运算符

![image.png](https://oss.silon.vip/img/0ce71874958ecf956d6b354e0cb2a51b.image.png)

### 位运算符

位运算符运用在`整数型变量`。在进行运算时
1. 将其它进制的数值转换为二进制的数值
2. 使用二进制数值进行运算
3. 以原始进制类型返回计算结果。

![image.png](https://oss.silon.vip/img/87cb65786b36a52f1f42c5f1d62e9cad.image.png)

```go
//十进制7转二进制结果为0111
var exampleNumA int = 7
//十进制5转二进制结果为0101
var exampleNumB int = 5

// 0101
fmt.Println(exampleNumA & exampleNumB)
```

由注释中的内容可知，7和5的按位与运算实际上就是0111和0101的按位与运算。当前后两个数对应位的数字都是1时，计算结果对应位的数字为1，否则为0。


![image.png](https://oss.silon.vip/img/e1f6bafc017e22ba4a88a1b795dd86dd.image.png)
### 赋值运算符


![image.png](https://oss.silon.vip/img/4db2a972a1348a297629e6de7a90d2dd.image.png)

### 指针运算符


![image.png](https://oss.silon.vip/img/c7d471dcb6cb04186fa53aa3851dac20.image.png)

### 运算符优先级

:::tip{title="提示"}
为了保证代码的可阅读性，优先级复杂的表达式，可以手动显性的加上`()`
:::
下图中，优先级值越大，优先级别越高

![image.png](https://oss.silon.vip/img/5f1aad5e128d3bca1af7fd2f1aa1b335.image.png)


## 占位符

占位符表示在程序中输出一行字符串时候，或者格式化输出字符串的时候使用。

go内置包 `fmt` 中 `Printf()`方法可以在控制台格式化打印出用户输入的内容。
```go
fmt.Printf("%T",x)
```

### 普通占位符


![image.png](https://oss.silon.vip/img/86b346a66e0f2285c2eaa3a51702fc6f.image.png)

### 布尔占位符


![image.png](https://oss.silon.vip/img/80735dabdaea495854b5fe26439fbd21.image.png)

### 整数占位符


![image.png](https://oss.silon.vip/img/6f61f2eecaf9cf5a993eec345bd11c19.image.png)

### 浮点数和复数的组成部分（实部和虚部）


![image.png](https://oss.silon.vip/img/5a94b0d2ee08847c2ae2443d7a8b3fa6.image.png)

### 字符串与字节切片

![image.png](https://oss.silon.vip/img/e7eb878501f6aa3f44829e1658119411.image.png)

### 指针占位符

![image.png](https://oss.silon.vip/img/5038436049f246841177190c7b088eca.image.png)