# Golang-Concept

**Repository Path**: simonck666/golang-concept

## Basic Information

- **Project Name**: Golang-Concept
- **Description**: Basic Golang Concept
- **Primary Language**: Go
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2022-05-05
- **Last Updated**: 2022-05-08

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

<!--
 * @Author: SimonCK666 SimonYang223@163.com
 * @Date: 2022-05-05 15:35:43
 * @LastEditors: SimonCK666 SimonYang223@163.com
 * @LastEditTime: 2022-05-06 13:54:29
 * @FilePath: \golang-concept\README.md
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
-->
# Golang-Concept

## 介绍
Basic Golang Concept


## Golang 安装教程

### 1. 下载安装并配置环境变量
下载地址：`https://golang.google.cn/dl/`，这里提供了不同平台的go版本，根据自己的平台选择下载。

这里注意，安装路径选择一个比较好找的路径，例如：`c:/go`，其他安装都选择”下一步“即可。

安装完成后，把 `C:\go\bin` 目录添加到环境变量，这里就可以使用 go 了，在命令行输入  `go version` 查看版本，输出结果如下所示
```go
go version go1.16.6 windows/amd64
```
### 2. 更改 Go 环境
在 `powershell` 中输入如下命令修改
```sh
$env:GOPROXY = "http://goproxy.cn"
$env:GO111MODULE = "on"
```
### 3. goroot & gopath
`goroot` 就是 Go 的安装目录，`gopath` 就是 Go 项目所在目录。高版本 Go 不再需要 `gopath` 进行项目管理。之后都是通过 `go mode` 进行项目管理。

### 4. Linux 平台
如果不是要在 Linux 平台敲 Go 代码，就不需要再 Linux 平台安装 Go，我们开发机器上写好的 Go 代码只需要跨平台编译好之后就可以拷贝到 Linux 服务器上运行了，这也是 Go 跨平台易于部署的优势。

## Go 常用命令

### 1. 查看可用命令
直接在终端中输入 `go help` 即可显示所有的 `go` 命令以及相应命令功能简介
- `build`: 编译包和依赖
    - `go build main.go` 会生成 `main.exe`
    - 与 `go run main.go` 效果一致
- `clean`: 移除对象文件
- `doc`: 显示包或者符号的文档
- `env`: 打印 go 的环境信息
- `bug`: 启动错误报告
- `fix`: 运行 `go tool fix`
- `fmt`: 运行 `gofmt` 进行格式化
- `generate`: 从 `processing source` 生成 go 文件
- `get`: 下载并安装包和依赖 
- `install`: 编译并安装包和依赖
- `list`: 列出包
- `test`: 运行测试
- `tool`: 运行 go 提供的工具
- `version`: 显示 go 的版本
- `vet`: 运行 `go tool vet`

## Go 常用命令

### 1. 代码组织
go 应用使用 **包** 和 **模块** 来组织代码，包对应到文件系统就是文件夹，模块就是 **.go** 的 go 源文件。一个包中会有多个模块，或者多个子包。

### 2. go 项目管理工具
从 golnag 1.11 开始使用 `gomod` 管理项目，当然还有第三方模块例如 `govendor`。

### 3. 实现步骤
1. 创建项目
2. 初始化项目
3. 创建包
4. 创建模块
5. 相互调用
```sh
mkdir go_proj
cd go_proj
go mod init go_proj // 初始化项目
mkdir user
cd user
touch user.go
cd ../
touch main.go
```
> code is in L0_goenv/

## Go 变量

### 1. 正确的标识符的命名
```go
package main

import "fmt"

func main() {
    var name string
    var age int
    var _sys int
}
```
> Go 语言是一门区分大小写的语言。包名称都是小写的，不适用下划线。文件名称，用小写单词，使用下划线分隔各个单词。结构体明明，驼峰命名法。接口明明，与结构体类似，单个函数的结构名以 “er” 作为后缀，如： Reader， Writer。测试用例的函数名必须以 Test 开头。

### 2. 声明变量
**Go 语言变量声明之后必须使用**

#### 声明变量的语法
```go
var identifier type
```
#### 批量声明
使用一个 `var` 关键字，把一些变量写在一个括号 `()` 里
```go
var  (
    name string
    age int
    ok bool
)
var name, site, age = "Simon", "www.simon.com", 21
```

#### 短变量声明
**在函数内部**，可以使用 `:=` 运算符对变量进行声明和初始化
```go
package main

func main() {
    name := "Simon"
    site := "www.simon.com"
    age := 20
}
```
> 这种方法只适用于函数内部，函数外部不能使用

#### 匿名变量
如果接受到多个变量，有一些变量使用不到，可以使用下划线 `_` 表示变量名称。这种变量叫做匿名变量。
```go
package main

import "fmt"

func getNameAndAge() (string, int) {
    return "Simon", 21
}

func main() {
    name, _ := getNameAndAge()
    fmt.Printf("name: \n", name)
}
```

## Go 常量
### 1. 定义常量的语法
```go
const constantName [type]= value
```
Example
```go
package main

func main() {
    const PI float64 = 3.14

    const (
        width = 100
        height = 200
    )

    const i, j = 1, "fo"
}
```
### **2. iota**
iota 比较特殊，可以被认为是一个可被编译器修改的常量，它默认开始值为 0，每调用一次加 1，遇到 `const` 关键词时被重置为 0.

```go
package main

import "fmt"

func main() {
    const (
        a1 = iota
        a2 = iota
        a3 = iota
    )

    fmt.Printf("a1: ", a1)
    fmt.Printf("a2: ", a2)
    fmt.Printf("a3: ", a3)
}
```
```sh
res:
a1: 0
a2: 1
a3: 2
```
### 3. 使用 _ 跳过某些值
```go
package main

import "fmt"

func main() {
    const (
        a1 = iota   // 0
        _           // 1
        a2 = iota   // 2
    )

    fmt.Printf("a1: ", a1)
    fmt.Printf("a2: ", a2)
}
```
```sh
res:
a1: 0
a2: 2
```
```go
package main

import "fmt"

func main() {
    const (
        a1 = iota   // 0
        a = 100     // 100
        a2 = iota   // 2
    )

    fmt.Printf("a1: ", a1)
    fmt.Printf("a: ", a)
    fmt.Printf("a2: ", a2)
}
```
```sh
res:
a1: 0
a: 100
a2: 2
```

## Go Data Type
```go
package main

import (
    "fmt"
    "strings"
)

func a() {

}

func main() {
    // int 类型
    age := 20

    // bool 类型
    b := true

    // 字符串类型
    var s string = "hello Go"
    s1 := "Go"
    s2 := `
        line 1
        line 2
        line 3
    `
    // 字符串连接
    msg := s1 + s3
    msg1 := fmt.Sprintf("%s, %s", s1, s2)
    name := "Simon"
    age := 21
    msg2 := strings.Join([]string(name, age), ",")
    var buffer bytes.Buffer
    buffer.WriteString("Simon")
    buffer.WriteString(" 21")
    fmt.Printf("buffer.String(): ", buffer.string())

    // 字符串切片 -- 类似于 python
    fmt.Println(s[n:m])     // 截取字符串索引位置为 n 到 m - 1 的原始字节

    // 字符串函数
    fmt.Printf("s Length: ", len(s))
    fmt.Printf("contain hello or not: ", strings.Contains(s, "hello"))
    fmt.Printf("To Lower: ", strings.ToLower(s))
    fmt.Printf("To Upper: ", strings.ToUpper(s))
    fmt.Printf("l Index: ", strings.Index(s, "l"))


    // 指针类型
    p := &a

    // 数组类型
    a := [2]int{1, 2}
    fmt.Printf("%T\n", a)

    // 切片类型: 动态数组
    a := []int{1, 2, 3}
    fmt.Print("%T\n", a)
}
```

## 参与贡献

1.  Fork 本仓库
2.  新建 Feat_xxx 分支
3.  提交代码
4.  新建 Pull Request