## 获取元素个数

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)

Golang学习（08）：运算符与占位符

## 指针与变量的关系

如果说`变量名`是数据的“代号”，那么`指针`存放的则是数据的“实际地址”。
我们可以通过这个地址获取或修改存放于这个地址的变量的值。

当然，指针的存储位置也是用值记录的，存放指针值的变量称为`指针变量`。


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



## 指针类型

Go语言中的指针，它主要由两大核心概念构成：`类型指针`和`切片指针`。

- `类型指针`：
  go 会根据变量对应的数据类型，完成相应的内存分配，并创建一个指针，指向该内存空间。


    :::info{title="相关信息"}
  在传递数据时直接使用指针，可以避免创建数据的副本，节约内存开销。
  类型指针不能进行偏移和运算，可以避免非法修改为其它数据的风险，也更有利于垃圾回收机制及时找到并回收 
    :::

- `切片指针`：
  切片由指向起始元素的指针、元素数量和总容量构成。适用于切片类数据


## 通过指针获取：内存地址、变量的值


> **使用指针更有利于程序运行的性能和稳定性。**
在某些操作中，如使用反射修改变量的值，必须使用可寻址的变量（通过指针）。

指针的操作最常用的就是：
- 获取变量的内存地址，`&`运算符
- 获取某个地址对应的值，`*`运算符


```go
//exampleNumberA变量（整数型变量）声明和赋值
var exampleNumberA int = 10

// 空指针，默认初始化的值为 nil
// nil 是 Go 中预先声明的标识符，表示指针、接口、通道、映射和切片的零值。
var p *int
fmt.Println(p)

// & 运算符
//获取exampleNumberA的地址，并赋值给exampleNumberAPtr变量（exampleNumberAPtr的类型是指针类型）
exampleNumberAPtr := &exampleNumberA

//输出exampleNumberAPtr变量的值（将输出内存地址）
fmt.Println(exampleNumberAPtr)

// * 运算符
//获取exampleNumberAPtr（指针变量）表示的实际数据值，并赋值给exampleNumberAPtrValue变量（整数型变量）
exampleNumberAPtrValue := *exampleNumberAPtr
//输出exampleNumberAPtrValue变量（整数型变量）的值
fmt.Println(exampleNumberAPtrValue)
```

## 通过指针创建：没有变量名的变量

我们还可以使用`new()`函数直接创建指针变量，相当于在内存中创建了没有变量名的某种类型的变量。

也就是直接分配一个内存地址，但并不与变量名关联


new()函数的使用格式如下：
```go
// type是所在地址存放的数据类型，一旦创建，就会完成内存分配，即使没有赋值
new(type)
```

```go
//使用new()函数创建名为exampleNumberAPtr指针类型变量，表示int64型值
exampleNumberAPtr := new(int64)
//修改exampleNumberAPtr表示的实际数据值
*exampleNumberAPtr = 100
//获取exampleNumberAPtr表示的实际数据值
fmt.Println(*exampleNumberAPtr)


// 运行后，结果为100
```