一、Go配置

1.Linux安装Go

下载最新的Go：https://golang.google.cn/doc/install
Go 1.16.5版本的下载地址：https://golang.org/dl/go1.16.5.linux-amd64.tar.gz ```powershell sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.16.5.linux-amd64.tar.gz

vim ~/.bashrc

export PATH=$PATH:/usr/local/go/bin

sourch ~/.bashrc

sudo vi /etc/profile.d/go.sh if [[ -z “${GOROOT}” ]]; then export GOROOT=/usr/local/go export GOPATH=/home/xu/go export PATH=${PATH}:${GOROOT}/bin export GO111MODULE=on export GOPROXY=https://goproxy.cn,direct fi source /etc/profile.d/go.sh

<a name="qTcUt"></a>
### 2. 下载vscode
- 安装以下插件
![image.png](https://cdn.nlark.com/yuque/0/2021/png/2788129/1624459651534-bc72ae82-3615-4764-af36-2ba7314647f1.png#align=left&display=inline&height=302&margin=%5Bobject%20Object%5D&name=image.png&originHeight=302&originWidth=245&size=20052&status=done&style=none&width=245)
- 按ctrl+shift+p 输入：`>Go:Install/Update Tools` ，全选后安装
![image.png](https://cdn.nlark.com/yuque/0/2021/png/2788129/1624459760284-b6516d30-0440-4687-aed0-52660f004719.png#align=left&display=inline&height=123&margin=%5Bobject%20Object%5D&name=image.png&originHeight=123&originWidth=708&size=8812&status=done&style=none&width=708)<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/2788129/1624459779644-a2da3e20-54e0-42e2-a5c0-a4a47e70dae5.png#align=left&display=inline&height=311&margin=%5Bobject%20Object%5D&name=image.png&originHeight=311&originWidth=704&size=40590&status=done&style=none&width=704)
<a name="xPbkL"></a>
# 二、基本组成元素
<a name="49QOQ"></a>
## 编译&运行
-  go build: 用于编译&链接程序或包 
   - go build -work -x -o helloworld.exe main.go
-  go run：用于直接运行程序
   - go run -work -x main.go 
- go clean：清除编译文件 
- 常用参数：
   - -x: 打印编译过程执行的命令，并完成编译或运行 
   - -n: 只打印编译过程执行命令
   - -work：打印编译过程的临时目录
   - -o: 指定编译结果文件 
<a name="zTLpy"></a>
## 1. 标识符
- 标识符是编程时所使用的名字，用于给变量、常量、函数、类型、接口、包名等进行命名，以建立名称和使用之间的关系。
- Go语言标识符的命名规则：
1. 只能由非空字母(Unicode)、数字、下划线(_)组成
1. 只能以字母或下划线开
1. 不能Go语言关键字
1. 避免使用Go语言预定义标识
1. 建议使用驼峰式
1. 标识符区分大小写
- Go语言提供一些预先定义的标识符用来表示内置的常量、类型、函数。
- 在自定义标识符时应避免使用：
7. 内置常量：`true、false、nil、iota`
7. 内置类型：`bool、byte、rune、int、int8、int16、int32、int64、uint、uint8、unit16、unit32、unit64、uintptr、float32、float64、complex64、complex128、string、error`
7. 内置函数：`make、len、cap、new、append、copy、close、delete、complex、real、imag、panic、recover`
7. 空白标识符:_
<a name="UdX4y"></a>
## 2. 关键字
- 关键字用于特定的语法结构
- Go语言定义25关键字：
   - 声明：`import、package`
   - 实体声明和定义：`char、const、func、interface、map、struct、type、var`
   - 流程控制：`break、case、continue、default、defer、else、fallthrough、for、go、goto、if、range、return、select、switch`
<a name="rVaXN"></a>
## 3. 操作符
- 算术运算符：`+、-、*、/、%、++、--`
- 关系运算符：`>、>=、<、<=、==、!=`
- 逻辑运算符：`&&、||、!`
- 位运算符：`&、|、^、<<、>>、&^`
- 赋值运算符：`=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=`
- 其他运算符：`&(单目)、*(单目)、.(点)、-(单目)、…、<-`
<a name="7LCiO"></a>
## 4. 分隔符
- 小括号 `()`, 中括号 `[]`，大括号 `()`，分号 `;`，逗号 `,`
<a name="cwBbq"></a>
## 5. 声明
- 声明语句用于定义程序的各种实体对象，主要有：
1. 声明变量的 `var`
1. 声明常量的 `const`
1. 声明函数的 `func`
1. 声明类型的 `type`
<a name="w1Yrp"></a>
## 6. 变量
- 变量是指对一块存储空间定义名称，通过名称对存储空间的内容进行访问或修改，使用var进行变量声明，常用的语法为:
1. var 变量名 变量类型 = 值
   1. 定义变量并进行初始化，例如：`var name string ="silence"`
2. var 变量名 变量类型
   1. 定义变量使用零值进行初始化，例如：`var age int`
3. var 变量名 = 值
   1. 定义变量，变量类型通过值类型进行推导 例如： `var isBoy = true`
4. var 变量名1, 变量名2 , …, 变量名n 变量类型
   1. 定义多个相同类型的变量并使用零值进行初始化 例如：`var prefix, suffix string`
5. var变量名1, 变量名2 , …, 变量名n 变量类型 = 值1, 值2, …, 值n
   1. 定义多个相同类型的变量并使用对应的值进行初始化，例如：`var prev, next int = 3, 4`
6. var变量名1, 变量名2 , …, 变量名n = 值1, 值2, …, 值n
   1. 定义多个变量并使用对应的值进行初始化，变量的类型使用值类型进行推导，类型可不相同，例如：`var name, age ="silence", 30`
7. 批量定义
```go
var (
    变量名1 变量类型1 = 值1
    变量名2 变量类型2 = 值2
)

定义多个变量并进行初始化，批量复制中变量类型可省略。例如：
```
var (
  name string ="silence“
  age int = 30
)
```
```go package main

import “fmt”

func main() { var v0 int var v1 int = 1 var v2 = 2

var v3, v4 int = 3, 4
var v5, v6 = "5", 6

var (
    v7 int = 2 + 5
    v8 int = v2 + v6
)
fmt.Println(v0, v1, v2, v3, v4, v5, v6, v7, v8)

}

[root@i-vzozw11z test]# go run main.go 0 1 2 3 4 5 6 7 8

<a name="ZBhLP"></a>
## 7. 赋值

- 可以通过赋值运算=更新变量的值，Go语言支持通过元组赋值同时更新多个变量的值。
- 例如：n1, n2 = 1, 2，可用于两个变量的交换x, y =y, x
```go
func main() {
    n1, n2 := 1, 2
    fmt.Println(n1, n2)
    n1, n2 = 2, 1
    fmt.Println(n1, n2)
}
[root@i-vzozw11z test]# go run main.go 
1 2
2 1

8. 常量

常量用于定义不可被修改的的值，需要在编译过程中进行计算，只能为基础的数据类型布尔、数值、字符串，使用const进行常量声明，常用语法：

const 常量名类型 = 值
1. 定义常量并进行初始化，例如：const pi float64 = 3.1415926
const 常量名 = 值
1. 定义常量，类型通过值类型进行推导，例如：const e = 2.7182818

批量定义

const (
 常量名1 类型1 = 值1
 常量名2 类型2 = 值2
)

定义多个变量并进行初始化，批量复制中变量类型可省略，并且除了第一个常量值外其他常量可同时省略类型和值，表示使用前一个常量的初始化表达式。
常量之间的运算，类型转换，以及对常量调用函数len、cap、real、imag、complex、unsafe.Sizeof得到的结果依然为常量
```
const (
  name string = "silence" 
  age int = 30
)
const (
  name string = "silence" 
  desc
)
```
9. 作用域
作用域指变量可以使用范围。go语言使用大括号{}显示的标识作用域范围，大括号内包含一连串的语句，叫做语句块。语句块可以嵌套，语句块内定义的变量不能在语句块外使用
作用域内定义变量只能被声明一次且变量必须使用，否则编译错误。在不同作用域可定义相同的变量，此时局部将覆盖全局
常见隐式语句块：
- 全语句块
- 包语句块
- 文件语句块
- if、switch、for、select、case语句块

10. 注释

Go支持两种注释方式，行注释和块注释：

行注释：以//开头，例如： //我是行注释
块注释：以/开头，以/结尾，例如：/我是块注释/

Go语言教程

1、Go配置和基本元素组成