## 循环结构

循环结构的语法如下
```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)
}
```

Golang学习（06）：基本数据类型

## 变量、常量的声明

在Go语言中，变量或常量的数据类型必须先声明，才能使用，且无法将不相关的数据赋值给它们。

这是因为Go语言和Java、C、C++等语言一样，属于静态语言，静态语言具有更严谨的结构要求、调试便捷（可通过代码直观地看到数据类型）与确保类型安全（无法使用不同类型的数据赋值）的特点，必须要先做声明。而像PHP、Python、JavaScript等动态语言则没有这个限制。

从根本上说，静态类型和动态类型语言的最大区别就是：**数据类型是否在编译时确定**




### 变量的声明方式

变量使用 `var` 关键字进行声明

- 没有初始化的声明：

```go
// 此处声明了 a，但是没有初始化
var a string

// 为 a赋值
a = "hello"
```

- 带有初始化的声明
```go
var a string = "Hello"
```

- 多重声明
```go
// 方式 1
var a, b string = "hello", "world"

// 方式 2
var (
    a string = "hello"
    b string = "world"
)
```

- 省略类型时，会被自动推断（隐式声明）

```go
// go 语言会自动推断 a 为字符串类型
var a = "hello"
```

- 简写声明

go 语言中，如果想要隐式声明，还想省略 `var` 关键字进行声明

可以使用简写声明 `:=`

```go
a := "hello"
```


:::info{title="相关信息"}

短变量声明只能在函数中使用，在函数外，n1 赋值形式是错误的  
``` go
package main

// n1会报错
n1 := 100

func main()  {
    n2 := 200
}
```
:::

### 常量的声明

常量可以使用 `const` 关键字声明。常量是`无法重新赋值`的固定值

```go
const a = "这个值不能修改"
```

:::tip{title="提示"}
虽然常量不能修改，但是常量的值可以分配给其他常量
```go
const a = 10
const b = a
```
:::


:::warning{title="注意"}
由于常量不能变更，所以不可以将变量分配给常量
```go
var a = 10

// 这里是错误的行为
// a (variable of type int) is not constant (InvalidConstInit)
const b = a
```
:::