## 数组 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
```

Golang学习（07）：go 中的指针

## 数据类型

这里介绍 go 中可用的基本数据类型


字符串类型（string）
布尔类型（bool）
数值类型

- 有符号整数（int 等）和无符号整数（uint 等）
- 整数别名类型（byte 、 rune）
- 浮点类型（float32 、 float64）
- 复数（complex128、complex64）

零值
别名类型
定义类型




### 字符串类型（string）

#### 字符串定义
字符串是一个字节序列。可以使用`双引号("")` 或 `跨越多行的反引号(``)` 声明

双引号：会识别转义内容  
反引号：原生内容，不进行转义，可用于防攻击，输出源码等场景


:::info{title="相关信息"}
go 中的字符串不可以使用 单引号 定义

单引号专用于字符的定义
:::

```go
var a string = "go"

var b string = `one line`

var c string = `two
lines`

var str7 = `\n\\`
var str8 = "\n\\"
println(str7, str8)
```

#### 字符串拼接
```go
// 字符串拼接，使用加号
var str9 = "hello" + "world"
println(str9)

// 字符串拼接的折行会自动识别
var str10 = "11111" + "22222" +
"333333" +
"444444"
println(str10)
```

### 布尔类型（bool）

布尔类型有两种值： true 和 false

```go
var a bool = true

var b bool = false
```

### 数值类型


#### 有符号整数（int）和无符号整数（uint）


- `int` 或 `uint` 不指定 bit 位则默认取当前系统位数。例如 64位系统中 int 就是 int64


- `intx` 和 `uintx` 中 x 表示 x bit 的取值范围。例如 int8 指的是 8bit，即一个字节， 0-255 个值

    - int: 表示有符号，则 int8 就是 -128 ~ 127

    - uint: 表示无符号，则 uint8 就是 0 ~ 255


##### 有符号整数范围
```go
// go 会自动识别该数值大小
var i int = 118323

// -128 to 127
var i8 int8 = 127

// -2^15 to 2^15 - 1
var i16 int16 = 32767

// -2^31 to 2^31 - 1
var i32 int32 = -2147483647

// -2^63 to 2^63 - 1
var i64 int64 = 9223372036854775807
```

##### 无符号整数范围

```go
// go 会自动识别该数值大小
var i int = 118323

// -128 to 127
var i8 int8 = 127

// -2^15 to 2^15 - 1
var i16 int16 = 32767

// -2^31 to 2^31 - 1
var i32 int32 = -2147483647

// -2^63 to 2^63 - 1
var i64 int64 = 9223372036854775807

// 无符号整数指针uintptr类型，用于表示内存地址
var uiptr uintptr 
```

:::info{title="相关信息"}
可以看到有一个 `uintptr` 类型的无符号整数指针。它是内存地址的整数表示。
一般编程中不会使用，所以不用担心
:::


:::tip{title="应该使用哪种整数类型？"}
`int`

建议每当我们需要一个整数值时，我们应该只使用int
除非我们有特定的理由使用大小或无符号整数类型。
:::

#### 整数别名类型（字符类型 byte 、 rune）

Golang 有两个额外的整数类型，分别是：

- byte 表示一个字节的值
    - 英文 1byte， 中文 3byte
- rune 表示一个 Unicode编码的值
    - 英文 1rune，中文 1rune


:::info{title="相关信息"}
1. 双引号括起来的字符串表示的是一个由多个字符组成的文本，而不是单个字符
   
   所以**字符类型只能使用 `单引号`进行定义**
   
2. 字符类型的值实际是 字符码 或 Unicode 码的值，**本质是数值**
:::

```go
// 数据类型`byte` 的别名 `uint8`
type byte = uint8

// 数据类型`rune`的别名 `int32`
type rune = int32
```

```go
// 英文字母
var str1 byte = 'a'
var str2 byte = '0'
// 中文超过一个 byte，只能定义为 int
var str3 int = '张'
var str4 rune = '大'

// byte类型输出的是字符码的值， U+0061
println(str1)
// 需要输出对应字符需要格式化
// %c 是用来格式化和打印一个 Unicode 字符
// %d 则是用来格式化和打印一个十进制整数
println("c%", str2)
println("d%", str3)
println("c%", str4)
```

#### 浮点类型（float32 、 float64）

浮点类型，用于存储带有小数部分的数字。


- 浮点类型分为两种
    - `float32`： 单精度 4 字节，非零整数部分 + 小数部分 共 8 位
    - `float64`： 双精度 8 字节，非零整数部分 + 小数部分共 16 位
- 与 int 不同，不受系统位数影响，默认声明为 float64
- 开发中推荐使用 float64，精度更高，或使用 decimal 包


```go
// float64 精度更高
var num21 float32 = -123.0000901
var num22 float64 = -123.0000901

// -123.00009, -123.0000901
println(num21, num22)
```

#### 复数（complex128、complex64）

Go 中有 2 种复杂类型
- `complex128` 实部和虚部都在`float64`，
- `complex64`实部和虚部都在`float32`。

我们可以使用内置的 complex 函数或文字来定义复数。

```go
// 方法 1
var c1 complex128 = complex(10, 1)

// 方法 2
var c2 complex64 = 12 + 4i
```

### 默认零值

在 Go 中，任何没有显式初始值声明的变量都会被赋予其零值。

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

```go
var i int
var f float64
var b bool
var s string

fmt.Printf("%v %v %v %q\n", i, f, b, s)
```


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


:::info{title="相关信息"}
go 中并不会像大部分语言，将未初始化的变量初始化为 null 或 undefined

如上所见：
`int`，`float` 分配为 `0`
`bool` 为 `false` 
`string` 为 空字符串 `""`
:::


### 别名类型

别名类型是在 Go 1.9 中引入的。它们允许开发人员为现有类型提供`替代名称`，并将其与基础类型互换使用，本质上还是这个类型。

```go
package main

import "fmt"

// 定义了一个类型，他实质还是 string，只是换了个名字
type MyAlias = string

func main() {
        // 使用别名类型
	var str MyAlias = "I am an alias"
        
        // 这里可以看到类型的本质，还是 string
        // Output: string - I am an alias
	fmt.Printf("%T - %s", str, str) 
}
```


### 定义类型

```go
package main

import "fmt"

// 这里没有了 = 号
type MyDefined string

func main() {
	var str MyDefined = "I am defined"
        
        // 这里可以看到，变量的类型，已经不是 string 了
        // Output: main.MyDefined - I am defined
	fmt.Printf("%T - %s", str, str) 
}
```

定义类型不仅仅是为类型命名。

它首先定义了一个具有基础类型的新命名类型。但是，这个定义的类型不同于任何其他类型，包括它的下划线类型。

因此，它不能与基础类型（如别名类型）互换使用。

```go
package main

import "fmt"

type MyAlias = string

type MyDefined string

func main() {
	var a MyAlias
	var b MyDefined

	// ✅ 可以将 MyAlias 类型的 a，分配给 string 类型
	var copy1 string = a

	// ❌ 无法将 MyDefined 类型的 b 分配给 string 类型
	var copy2 string = b

	fmt.Println(copy1, copy2)
}
```