综述：此部分内容由example文件夹的示例内容递归延伸，逐步学习Go的语法结构、命令使用方法，运行环境为vscode，以问题列表加GPT回复整理的形式呈现。
[wangkechun/go-by-example (github.com)](https://github.com/wangkechun/go-by-example/)
00-run
run代码的命令：
go run main.py
编译代码的命令：go built main.py
编译后出现exe可执行文件，再运行即可
01-hello：
package main
import (
"fmt"
)
func main() {
fmt.Println("hello world")
}
疑问：
- 为什么Go的第一行要调用package main
- import("fmt") 和 import "fmt"两种形式有什么区别
- fmt是什么，除去fmt，还有什么可以通过import导入，如何导入，需要按照的第三方包的按照命令是什么
- fmt.Println fmt.Printf fmt.Print三者有什么区别
回答：
-
在 Go 语言中，
package main是一个特殊的包声明。这个包声明告诉编译器本文件属于可执行程序的入口点，是一个独立的可执行程序而不是一个库或模块。 在 Go 语言中，如果一个源代码文件的包名为main，并且包含一个名为main的函数，那么该文件就是一个可独立执行的程序的入口点。当我们使用go build命令编译程序时，编译器会从main包的main函数开始执行。因此，package main声明指定了程序的入口点。需要注意的是，在同一个目录下只允许有一个main包，否则会导致编译错误。这是因为编译器无法确定使用哪个main函数作为程序的入口点。所以，每个可执行程序的入口文件都应该有自己的package main声明。 -
在 Go 语言中，
import用于导入其他包以便在当前代码中使用其中定义的函数、类型和变量等。import语句的格式有两种：
- 多行导入形式（使用括号）：
import (...)示例代码：import ( "fmt" "time" ) - 单行导入形式（不使用括号）：
import "..."示例代码：import "fmt" import "time"
这两种导入形式在功能上是完全一样的，都能够成功导入目标包。它们之间的区别在于代码风格和规范。
- Go 语言拥有丰富的标准库以及众多第三方包，可以通过
import语句导入并使用它们。下面是一些常用的标准库和一些知名的第三方包：
标准库：
"fmt"：用于格式化输入输出的包。"os"：提供操作系统功能的包。"io"：提供基本的 I/O 操作函数的包。"net"：提供网络相关功能的包。"http"：用于构建 HTTP 服务器和客户端的包。"encoding/json"：用于 JSON 数据编码和解码的包。"time"：用于时间处理的包。"strconv"：用于字符串和基本数据类型之间的转换的包。"math"：提供数学运算函数的包。"database/sql"：提供数据库访问功能的包。"regexp"：用于正则表达式匹配的包。"bufio"：提供缓冲区读写功能的包。
第三方包（需使用 go get 命令安装）：
"github.com/gin-gonic/gin"：流行的 Web 框架 Gin。"github.com/jinzhu/gorm"：用于对象关系映射 (ORM) 的库。"github.com/go-redis/redis"：用于连接和操作 Redis 数据库的库。"github.com/Shopify/sarama"：用于与 Apache Kafka 消息队列交互的库。"github.com/gorilla/mux"：用于构建 HTTP 路由的库。"github.com/stretchr/testify"：提供测试辅助函数和断言的库。"golang.org/x/crypto"：提供密码学相关功能的库。"google.golang.org/grpc"：用于构建高性能、可扩展的 RPC 服务的库。
要安装第三方包，需要使用 Go 的包管理工具 go get 命令。以下是一个示例命令：
go get -u github.com/gin-gonic/gin
该命令会从 GitHub 上下载并安装最新版本的 Gin 框架。其中：
go get是使用 Go 包管理工具的命令。-u表示更新已安装的包到最新版本。github.com/gin-gonic/gin是要安装的包的导入路径。
请注意，在执行该命令前，确保已正确设置了 Go 的环境变量，并且能够正常访问互联网。执行命令后，Go 会自动下载、编译并将该包安装到指定的位置，使得您可以在自己的代码中通过 import 语句引入并使用该包的功能。
如果要安装特定版本的包，可以使用带有版本号的导入路径，例如：
go get github.com/gin-gonic/gin@v1.6.3
这样可以安装指定版本号的 Gin 框架。
需要注意的是，对于一些非常规的包，可能需要先手动执行 git clone 等操作，然后再使用 go get 安装。此外，还可以使用其他包管理工具，如 Go Modules 或 Glide 等，根据自己的需求进行包管理。
- 在 Go 语言中，
fmt.Print、fmt.Println和fmt.Printf是用于输出格式化文本的函数，它们之间有以下区别：
fmt.Print：该函数用于打印参数列表中的值，不会自动换行。它会按照参数顺序将值转换为字符串，然后依次打印输出。不会使用空格将各个值分隔。fmt.Println：该函数与fmt.Print类似，会使用空格将各个值分开，且末尾自动添加换行符。fmt.Printf：该函数提供了一种类似 C 语言中的printf格式化输出的方式。它接受一个格式化字符串作为第一个参数，根据格式化字符串中的占位符将后续参数转换成相应的字符串，并进行格式化输出。使用占位符%指定要输出的数据类型，并在格式化字符串中可以插入变量的值。
以下是这三个函数的示例使用方式：
package main
import "fmt"
func main() {
name := "Alice"
age := 25
fmt.Print("Name:", name, " Age:", age) // 输出：Name:Alice Age:25
fmt.Println("Name:", name, "Age:", age) // 输出：Name:Alice Age:25（换行）
fmt.Printf("Name: %s Age: %d\n", name, age) // 输出：Name: Alice Age: 25（换行）
fmt.Print("Name:", name, " Age:", age) // 输出：Name:Alice Age:25
}
对应的输出内容如下：
Name:Alice Age:25Name: Alice Age: 25
Name: Alice Age: 25
Name:Alice Age:25
总结一下，fmt.Print 和 fmt.Println 是用于打印值的函数，其中 fmt.Println 还会在添加空格和换行符，而 fmt.Printf 则是使用格式化字符串的方式对值进行格式化输出。根据具体需求选择合适的函数来输出文本。
02-var
此部分代码主要讲解Go的常量与变量的定义方式 字符串是内置类型，可用加号拼接
func main() {
var a = "initial"
var b, c int = 1, 2
var d = true
var e float64
f := float32(e)
g := a + "foo"
fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
fmt.Println(g) // initialapple
const s string = "constant"
const h = 500000000
const i = 3e20 / h
fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}
在Go中，变量的定义有两种方式
-
使用
var关键字定义变量，语法为：var identifier type其中，
identifier是变量的标识符（名称），type是变量的类型。可以选择省略类型，让编译器自动推导类型。变量的值可以通过赋值语句进行初始化，并且可以随时修改。例如：var name string var age int = 25 -
使用短变量声明语法定义变量，语法为：
identifier := value这种方式可以同时定义和初始化一个变量，类型会根据赋给它的值自动推导出来。例如：
name := "Alice" age := 25
在变量的定义时，可以使用多个赋值语句进行批量定义多个变量。例如：
var (
name string = "Bob"
age int = 30
)
疑问：针对var命名方式，如果只制定类型，不赋值，该变量为多少？如果不制定类型，不赋值，该变量为多少？
func main() {
var x int
fmt.Println(x) // 输出：0
var y float64
fmt.Println(y) // 输出：0
var z bool
fmt.Println(z) // 输出：false
var s string
fmt.Println(s) // 输出：""
var arr [3]int
fmt.Println(arr) // 输出：[0 0 0]
var slice []int
fmt.Println(slice) // 输出：[]
var m map[string]int
fmt.Println(m) // 输出：map[]
var person struct {
name string
age int
}
fmt.Println(person) // 输出：{ 0}
}
若不赋值，不注明类型，则编译保错
syntax error: unexpected newline, expected type
常量的定义方式有两种，如下：
-
使用
const关键字定义常量，语法为：const identifier = value其中，
identifier是常量的标识符（名称），value是常量的值。常量在声明后不能被修改，它的值在编译时就确定下来了。例如：const pi = 3.14159 const daysInWeek = 7 -
使用一组括号进行批量定义常量，语法为：
const ( identifier1 = value1 identifier2 = value2 // ... )这种方式适用于同时定义多个相关联的常量。每个常量都可以有自己的值，如果没有赋值，则会使用上一个常量的值作为默认值，并不会依次顺延。例如：
func main() { const ( Monday = 1 Tuesday = 2 Wednesday = 3 Thursday Friday Saturday Sunday ) day := Tuesday fmt.Println(Thursday) // 3 fmt.Println(Friday) // 3 fmt.Println(day) // 2 }
03-for
i := 1
for {
fmt.Println("loop")
break
}
for j := 7; j < 9; j++ {
fmt.Println(j)
}
for n := 0; n < 5; n++ {
if n%2 == 0 {
continue
}
fmt.Println(n)
}
for i <= 3 {
fmt.Println(i)
i = i + 1
}
// 输出为loop 7 8 1 3 1 2 3 (忽略换行标注)
04-if
if 8%4 == 0 {
fmt.Println("8 is divisible by 4")
}
if num := 9; num < 0 {
fmt.Println(num, "is negative")
} else if num < 10 {
fmt.Println(num, "has 1 digit")
} else {
fmt.Println(num, "has multiple digits")
}
05-switch
可以在每个case中去写条件分支，无需像c++一样用break跳出，在内容上更加灵活
a := 2
switch a {
case 1:
fmt.Println("one")
case 2:
fmt.Println("two")
case 3:
fmt.Println("three")
case 4, 5: //并列情况
fmt.Println("four or five")
default:
fmt.Println("other")
}
t := time.Now()
switch {
case t.Hour() < 12:
//case中可以是指也可以是语句
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
06-array
func main() {
var a [5]int
a[4] = 100
fmt.Println("get:", a[2])
fmt.Println("len:", len(a))
b := [5]int{1, 2, 3, 4, 5}
fmt.Println(b)
var twoD [2][3]int
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
//输出如下
get: 0
len: 5
[1 2 3 4 5]
2d: [[0 1 2] [1 2 3]]
//特定：无逗号，语法相似于其他语言
07-slice
可以根据切片灵活设置数组，但不支持负数索引
func main() {
// 定义空数组，并赋值
s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("get:", s[2]) // c
fmt.Println("len:", len(s)) // 3
// 数组长度随意改变
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println(s) // [a b c d e f]
c := make([]string, len(s))
// 将s中的元素复制到c中，如果c容量有限，则只会拷贝s的前len(c)个元素
copy(c, s)
fmt.Println(c) // [a b c d e f]
//经修改及测试，这种拷贝在一维数组上带来的影响，改变一个不影响另一个的结果
// 切片操作左闭右开
fmt.Println(s[2:5]) // [c d e]
fmt.Println(s[:5]) // [a b c d e]
fmt.Println(s[2:]) // [c d e f]
// 定义时顺便赋值的数组
good := []string{"g", "o", "o", "d"}
fmt.Println(good) // [g o o d]
}
// 输出
get: c
len: 3
[a b c d e f]
[a b c d e f]
[c d e]
[a b c d e]
[c d e f]
[g o o d]
08-map
06,07介绍数组及其切片等操作，类似于python，08介绍的map类似于python字典
func main() {
m := make(map[string]int)
m["one"] = 1
m["two"] = 2
fmt.Println(m) // map[one:1 two:2]
fmt.Println(len(m)) // 2
fmt.Println(m["one"]) // 1
fmt.Println(m["unknow"]) // 0
// ok表示是否存在这个map
r, ok := m["unknow"]
r1, ok1 := m["one"]
fmt.Println(r, ok) // 0 false
fmt.Println(r1, ok1) // 1 true
delete(m, "one")
fmt.Println(m)
m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}
fmt.Println(m2, m3)
}
09-range
func main() {
nums := []int{2, 3, 4}
sum := 0
//针对数组，i 是下标，num是具体值
for i, num := range nums {
sum += num
if num == 2 {
fmt.Println("index:", i, "num:", num)
// index: 0 num: 2
}
}
fmt.Println(sum) // 9
m := map[string]string{"a": "A", "b": "B"}
//针对map，k是键，v是值
for k, v := range m {
fmt.Println(k, v) // b B; a A
}
for k := range m {
fmt.Println("key", k) // key a; key b
}
}
10-func
func add(a int, b int) int {
return a + b
}
func add2(a, b int) int {
return a + b
}
//函数的变量名在类型的前边，同时在真实业务中，往往有多个返回值
//多个返回值中一个代表结果，后边表示状态信息
func exists(m map[string]string, k string) (v string, ok bool) {
v, ok = m[k]
return v, ok
}
func main() {
res := add(1, 2)
res1 := add2(1, 2)
fmt.Println(res) // 3
fmt.Println(res1)
v, ok := exists(map[string]string{"a": "A"}, "a")
fmt.Println(v, ok) // A True
}
11-point
指针的主要作用在于对传入的参数值进行修改 需要注意在函数部分的星号位置以及调用时的&书写
func add2(n int) {
n += 2
}
func add2ptr(n *int) {
*n += 2
}
func main() {
n := 5
add2(n)
fmt.Println(n) // 5
add2ptr(&n)
fmt.Println(n) // 7
}
12-struct
//定义结构图user，结构体类型
type user struct {
//结构体的字段，由名称和类型构成
name string
password string
}
func main() {
//创建结构体变量，并赋值
a := user{name: "wang", password: "1024"}
b := user{"wang", "1024"}
c := user{name: "wang"}
c.password = "1024"
//第二种创建变量的方法
var d user
d.name = "wang"
d.password = "1024"
fmt.Println(a, b, c, d) // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
//是否使用指针进行修改，使用指针可以减少大型结构体的开销
fmt.Println(checkPassword(a, "haha")) // false
fmt.Println(checkPassword2(&a, "haha")) // false
}
func checkPassword(u user, password string) bool {
return u.password == password
}
func checkPassword2(u *user, password string) bool {
return u.password == password
}
13-struct-method
通过指针，对结构体内容进行修改
type user struct {
name string
password string
}
//只进行检查，并未进行修改，返回true or false
func (u user) checkPassword(password string) bool {
return u.password == password
}
//修改变量值但没有return返回值
func (u *user) resetPassword(password string) {
u.password = password
}
func main() {
a := user{name: "wang", password: "1024"}
//看定义的函数调用方法
a.resetPassword("2048")
fmt.Println(a.checkPassword("2048")) // true
}
14-error
go语言的error机制可以让其迅速找到是哪个函数出现错误，并通过if..else处理
import (
"errors" //导入errors
"fmt"
)
type user struct {
name string
password string
}
//添加error类型变量，若没问题则返回空nil
func findUser(users []user, name string) (v *user, err error) {
for _, u := range users {
if u.name == name {
return &u, nil
}
}
//若函数有问题，有error返回，函数依旧执行
return nil, errors.New("not found")
}
func main() {
//调用函数，两个返回结果，先看err的情况
u, err := findUser([]user{{"wang", "1024"}}, "wang")
if err != nil {
fmt.Println(err)
return
}
//error有内容就返回了，无err再继续执行这一步
fmt.Println(u.name) // wang
//用一个if..else..串起来
if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
fmt.Println(err) // not found
return
} else {
fmt.Println(u.name)
}
}
15-string
import (
"fmt"
"strings"
)
func main() {
a := "hello"
//判断字符串中是否包含另一个字符串
fmt.Println(strings.Contains(a, "ll") // true
//字符串中字符计数
fmt.Println(strings.Count(a, "l")) // 2
//字符串以这个开始/结束吗？
fmt.Println(strings.HasPrefix(a, "he")) // true
fmt.Println(strings.HasSuffix(a, "llo")) // true
//查找某个字符串在该字符串中的位置
fmt.Println(strings.Index(a, "ll")) // 2
//连接多个字符串Join
fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
//重复某字符串，附重复次数
fmt.Println(strings.Repeat(a, 2)) // hellohello
//在某字符串a中，用大写字母E替换小写字母e，-1表示无限替换
fmt.Println(strings.Replace(a, "e", "E", -1)) // hEllo
//拆分字符串，去掉某拆分符
fmt.Println(strings.Split("a-b-c", "-")) // [a b c]
//字符串的大小写转换
fmt.Println(strings.ToLower(a)) // hello
fmt.Println(strings.ToUpper(a)) // HELLO
fmt.Println(len(a)) // 5
b := "你好"
//这里是因为一个中文对应多个字符
fmt.Println(len(b)) // 6
}
16-fmt
type point struct {
x, y int
}
func main() {
s := "hello"
n := 123
p := point{1, 2}
fmt.Println(s, n) // hello 123
fmt.Println(p) // {1 2}
//一个v%解决所有格式问题，%+v输出详细一点，%#v表示输出再详细一点
fmt.Printf("s=%v\n", s) // s=hello
fmt.Printf("n=%v\n", n) // n=123
fmt.Printf("p=%v\n", p) // p={1 2}
fmt.Printf("p=%+v\n", p) // p={x:1 y:2}
fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2}
//保留两位小数的结果
f := 3.141592653
fmt.Println(f) // 3.141592653
fmt.Printf("%.2f\n", f) // 3.14
}
17-json
import (
"encoding/json" //json相关包
"fmt"
)
type userInfo struct {
//json处理需要保证结构体中变量的首字母大写
Name string
Age int `json:"age"`
Hobby []string
}
func main() {
a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
//将结构体内容序列化
buf, err := json.Marshal(a)
if err != nil {
panic(err)
}
//序列化后得到buf数组，字符串，强制类型转换后得到结果
fmt.Println(buf) // [123 34 78 97...]
fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
buf, err = json.MarshalIndent(a, "", "\t")
if err != nil {
panic(err)
}
fmt.Println(string(buf))
var b userInfo
//反序列化保存
err = json.Unmarshal(buf, &b)
if err != nil {
panic(err)
}
fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}
18-time
import (
"fmt"
"time" // 引入时间
)
func main() {
//获取当前时间
now := time.Now()
fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
//通过date构造一个带有时区的时间
t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
fmt.Println(t) // 2022-03-27 01:25:36 +0000 UTC
fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
//规定一个格式
fmt.Println(t.Format("2006-01-02 15:04:05")) // 2022-03-27 01:25:36
diff := t2.Sub(t)
fmt.Println(diff) // 1h5m0s
fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
if err != nil {
panic(err)
}
fmt.Println(t3 == t) // true
//获取时间戳
fmt.Println(now.Unix()) // 1648738080
}
19-strconv
import (
"fmt"
"strconv" //字符转换数字
)
func main() {
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234
//10表示十进制，64表示位数，64位
n, _ := strconv.ParseInt("111", 10, 64)
fmt.Println(n) // 111
n, _ = strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n) // 4096
// 自动转换
n2, _ := strconv.Atoi("123")
fmt.Println(n2) // 123
n2, err := strconv.Atoi("AAA")
fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}
20-env
import (
"fmt"
"os"
"os/exec" //两个os相关的包
)
func main() {
// go run example/20-env/main.go a b c d
//Args，获取进程在过程中的一些命令行参数
fmt.Println(os.Args) // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
//获取环境变量
fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
fmt.Println(os.Setenv("AA", "BB"))
//执行分析见后文
buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
if err != nil {
panic(err)
}
fmt.Println(string(buf)) // 127.0.0.1 localhost
}
这行代码是使用Go语言中的exec包执行外部命令，并将命令的输出捕获到一个缓冲区（buffer）中。
具体解释如下：
exec.Command函数用于创建一个表示要执行的外部命令的*exec.Cmd对象。在这个例子中，该命令是"grep"，将在"/etc/hosts"文件中搜索字符串"127.0.0.1"。CombinedOutput方法调用*exec.Cmd对象的CombinedOutput方法来执行命令并获取命令的标准输出和标准错误输出。这里将输出结果存储在名为buf的变量中。CombinedOutput方法会返回两个值：一个是命令的输出结果，以字节切片（byte slice）的形式存储在buf中；另一个是可能出现的错误信息，如果命令执行过程中发生了错误。
因此，这行代码的作用是执行grep命令，在/etc/hosts文件中搜索"127.0.0.1"，并将命令的输出结果存储在buf中，同时也可以通过检查err来判断命令执行是否成功。
