Golang 基础赋能（一）

### Golang介绍

Go 是一个开源的编程语言，它能让构造简单、可靠且高效，让编程变得容易。

Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 的第一个稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。

### go语言特色

- 静态编译，强类型语言
- 内存安全，GC（垃圾自动回收）
- 语法简单，速度直逼C语言
- 天生高并发
- 跨平台（Linux、Windows、Mac os）

### go语言安装

1.官网地址：https://go.dev/doc/install

![](https://static.cloudcare.cn/cloudcare-mrdoc/img/2024-09-23_142108_1319650.9088845084514514.png)

### 结构

```go
package main /* 当前文件所在的包名 */

import "fmt" /* 包导入 */

func main() {
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")
}
```

在每一个go程序项目中必须存在一个main包、一个main函数，标志这是整个项目的启动函数

go项目的启动命令：go run 文件名

注意事项：

- 每行程序结束后不需要撰写分号（;）。
- 大括号（{）不能单独放在一行。
- if判断式和for循环不需要以小括号包覆起来。

### 数据类型

go语言的数据类型大体可以分成四种

1.布尔型：布尔型的值只可以是常量 true 或者 false

2.数字类型

| 类型           | 描述                                                         |
| -------------- | ------------------------------------------------------------ |
| **uint8**      | 无符号 8 位整型 (0 到 255)                                   |
| **uint16**     | 无符号 16 位整型 (0 到 65535)                                |
| **uint32**     | 无符号 32 位整型 (0 到 4294967295)                           |
| **uint64**     | 无符号 64 位整型 (0 到 18446744073709551615)                 |
| **int8**       | 有符号 8 位整型 (-128 到 127)                                |
| **int16**      | 有符号 16 位整型 (-32768 到 32767)                           |
| **int32**      | 有符号 32 位整型 (-2147483648 到 2147483647)                 |
| **int64**      | 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) |
| **float32**    | 32位浮点型数                                                 |
| **float64**    | 64位浮点型数                                                 |
| **complex64**  | 32 位实数和虚数                                              |
| **complex128** | 64 位实数和虚数                                              |
| **byte**       |                                                              |
| **rune**       | 类似 int32                                                   |
| **uint**       | 32 或 64 位                                                  |
| **int**        | 与 uint 一样大小                                             |
| **uintptr**    | 无符号整型，用于存放一个指针                                 |

ps:

rune 官方对他的解释是这样的：rune其实就是int32的别名，主要是用于区分字符值和整数值的。返回采用 UTF-8 编码的 Unicode 码点。Go 语言通过`rune`处理中文，支持国际化多语言

下面是示例

```go
package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "hello 中国"
	fmt.Println(len(s))
	fmt.Println(utf8.RuneCountInString(s))
	fmt.Println(len([]rune(s)))
}

```

3.字符串类型

4.派生类型

- (a) 指针类型（Pointer）
- (b) 数组类型
- (c) 结构化类型(struct)
- (d) Channel 类型
- (e) 函数类型
- (f) 切片类型
- (g) 接口类型（interface）
- (h) Map 类型

### 变量声明

```go
/* 声明一个变量 */
var identifier type
1. 不进行赋值的方式
ex：
	var a int

2.根据赋值自行判断类型
	var a = 1

3.简写（最常用）
	a := 1
	
/* 多变量声明 */
var identifier1, identifier2 type
1.多变量同类型声明
ex:
	var a,b int

2.多变量类型自动推断
ex:
	var a, b = 1, ""

3.简写
ex:
	a, b := 1, ""

4.多行  // 这种因式分解关键字的写法一般用于声明全局变量
ex:
  var (
      a int
      b string
  )
```

### 常量声明

```go
/* 声明一个常量,类型一般可以省略 */
const identifier [type] = value
ex:
	const a = 1

/* 特殊的常量 */
iota
iota是go当中预设的一个特殊常量。它只能被使用在const关键字出现的时候，并且在初次设定的时候值是0，一般常用于设置常量的枚举值当中

ex:
  package main

import "fmt"

const (
    Cancelled = iota //订单已取消 0
    NoPay //未支付 1
    PendIng // 未发货 2
    Delivered // 已发货 3
    Received // 已收货 4
  )

func main() {
    fmt.Println(Cancelled, NoPay) // 打印:0,1
  }
```

### 运算符

#### 算术运算符

| **运算符** | **描述** |
| ---------- | -------- |
| +          | 加       |
| -          | 减       |
| *          | 乘       |
| /          | 除       |
| %          | 求余     |
| ++         | 自增     |
| --         | 自减     |
|            |          |

#### 关系运算符

| **运算符** | **描述**                                                     |
| ---------- | ------------------------------------------------------------ |
| ==         | 检查两个值是否相等，如果相等返回 True 否则返回 False         |
| !=         | 检查两个值是否不相等，如果不相等返回 True 否则返回 False     |
| >          | 检查左边值是否大于右边值，如果是返回 True 否则返回 False     |
| <          | 检查左边值是否小于右边值，如果是返回 True 否则返回 Fals      |
| >=         | 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False |
| <=         | 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False |
|            |                                                              |

#### 逻辑运算符

| **运算符** | **描述**                                                     |
| ---------- | ------------------------------------------------------------ |
| &&         | 逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。 |
| \|\|       | 逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。 |
| !          | 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。 |
|            |                                                              |

#### 位运算符

| **运算符** | **描述**                                                     |
| ---------- | ------------------------------------------------------------ |
| &          | 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。 |
| \|         | 其功能是参与运算的两数各对应的二进位相或                     |
| ^          | 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 |
| <<         | 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 |
| \>>        | 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。 |
|            |                                                              |

ps:

假设有A和B两个二进制数，进行下列运算

相与:A和B两个二进制位子上的都是1结果才是1

相或:A和B两个二进制位子上有一个是1结果才是1

相异:A和B两个二进制位子上相反结果才是1

#### 赋值运算符

| 运算符 | 描述                                           |
| :----- | :--------------------------------------------- |
| =      | 简单的赋值运算符，将一个表达式的值赋给一个左值 |
| +=     | 相加后再赋值                                   |
| -=     | 相减后再赋值                                   |
| *=     | 相乘后再赋值                                   |
| /=     | 相除后再赋值                                   |
| %=     | 求余后再赋值                                   |
| <<=    | 左移后赋值                                     |
| >>=    | 右移后赋值                                     |
| &=     | 按位与后赋值                                   |
| ^=     | 按位异或后赋值                                 |
| \|=    | 按位或后赋值                                   |
|        |                                                |

### 条件语句

#### if语句

```go
if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}
```

![](https://static.cloudcare.cn/cloudcare-mrdoc/img/2024-09-23_142139_9370550.33680171256281066.png)

#### switch语句

```go
switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}
```

![](https://static.cloudcare.cn/cloudcare-mrdoc/img/2024-09-23_142154_7702790.3899066556839176.png)

#### select语句

```go
select {
  case <- channel1:
    // 执行的代码
  case value := <- channel2:
    // 执行的代码
  case channel3 <- value:
    // 执行的代码

// 你可以定义任意数量的 case

default:
    // 所有通道都没有准备好，执行的代码
}

注意事项：
每个 case 都必须是一个channel
所有 channel 表达式都会被求值
所有被发送的表达式都会被求值
如果任意某个通道可以进行，它就执行，其他被忽略。
如果有多个 case 都可以运行，select 会随机公平地选出一个执行，其他不会执行。
如果有 default 子句，则执行该语句。
如果没有 default 子句，select 将阻塞，直到某个通道可以运行；Go 不会重新对 channel 或值进行求值。
```