入门篇：Go 语言基础语法 | 豆包MarsCode AI刷题
go语言简介
Go语言（也称为Golang）是一种静态类型、编译型语言，具有简洁的语法和高效的性能，广泛用于开发高性能的应用程序，特别是在网络服务、分布式系统和云计算等领域。Golang具有很强的表达能力，得益于其并发机制，用它编写的程序能够非常有效地利用多核与联网的计算机，其新颖的类型系统则使程序结构变得灵活而模块化。 Go 代码编译成机器码不仅非常迅速，还具有方便的垃圾收集机制和强大的运行时反射机制。对于高性能分布式系统领域而言，Go 语言无疑比大多数其它语言有着更高的开发效率。它提供了海量并行的支持，这对于游戏服务端的开发而言是再好不过了。
1. hello
”hello world“可以说说是学习每门语言的入门必备，go语言当然也不例外，接下来，让我们学习一下go语言如何实现打印“hello world”。
package main
import (
"fmt"
)
func main() {
fmt.Println("hello world")
}
-
package main 定义包名，如果包名为 main ，其应该包含 func main() {} 否则不该包含。
-
import 有两种用法：
import "fmt"import ( "fmt" )
2. var
fmt包。这个包主要是用来向屏幕输入输出字符串、格式化字符串。
package main
import (
"fmt"
"math"
)
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 <变量名> = <值>
<变量名> := <值>
在go语言中无需声明变量类型，golang会根据上下文自动推断类型。
常量
把var改成cost就是常量了
在go语言中大部分运算符的使用和优先级都和C或者C++类似。
在go语言中字符串是内置类型，可以直接通过加号拼接，也能够直接用等于号去比较两个字符串。
3. for
package main
import "fmt"
func main() {
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
}
}
在go语言中，没有while循环、do-while循环，只有for循环。for循环后什么都不写代表死循环，for循环后面也可以加C风格的条件，也可以只加一个类似if一样的判断，如同while一样。for循环，可以用break或者continue来跳出或者继续循环。
4. if
package main
import "fmt"
func main() {
if 7%2 == 0 {
fmt.Println("7 is even")
} else {
fmt.Println("7 is odd")
}
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")
}
}
if-else的写法和C或者C++类似。
但需要注意以下几点：
- if后面没有括号。如果加上了括号，那么在保存的时候你的编辑器会自动把你去掉。
- if后面必须接大括号，不能像C或者C++一样，直接把if里面的语句同一行或者直接换行。
5. switch
package main
import (
"fmt"
"time"
)
func main() {
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:
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
}
- 在switch后面的变量名，并不要括号。
- 在c或者c++里面，case分支如果不加break的话，会然后会继续往下跑完所有的case分支。但是在go语言里中，case分支后无需加break语句，Go语言会自动帮你加上break。
- go语言里面的switch功能很强大。在switch可以使用任意的变量和结构体；switch后面也可以什么都不加，而是在case后面进行判断，可以用来取代任意的if-else语句，这样相比于if-else更加简明易懂。
6. arry
package main
import "fmt"
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)
}
数组的长度是固定的，灵活性不足，因此在实际应用中很少使用数组，更多的是使用切片。
7. slice
package main
import "fmt"
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))
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]
}
切片是可变长度的数组，可以用make来创建一个切片，使用 append() 和 copy() 操作。
使用append来向切片中添加值。需要注意的是，你必须将append添加后的返回值再赋值给你原来的切片，因为在append的过程中如果容量不足会重新创建一个切片，因此你必须把这个新的切片再赋值回去。
slice在初始化的时候也可以指定长度。slice拥有像python一样的切片操作，不过不同于python,这里不支持负数索引。
8. map
package main
import "fmt"
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
r, ok := m["unknow"]
fmt.Println(r, ok) // 0 false
delete(m, "one")
m2 := map[string]int{"one": 1, "two": 2}
var m3 = map[string]int{"one": 1, "two": 2}
fmt.Println(m2, m3)
}
map在其他语言中可能叫做哈希表或者字典。
用make来创建一个空map，需要两个类型声明， m := make(map[string]int) 第一个是key类型，这里是string；另一个是value的类型，这里是int。
可以从里面去存储或者取出键值对。可以用delete从里面删除键值对。
golang的map是完全无序的，遍历的时候不会按照字母顺序，也不会按照插入顺序输出，而是随机顺序。
9. range
package main
import "fmt"
func main() {
nums := []int{2, 3, 4}
sum := 0
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"}
for k, v := range m {
fmt.Println(k, v) // b 8; a A
}
for k := range m {
fmt.Println("key", k) // key a; key b
}
}
对于一个map或slice，可以用range来快速遍历，这样可以使代码更加简洁。
遍历数组时，会返回两个值，第一个是索引，第二个是对应位置的值。如果不需要索引可以用下划线来忽略。遍历map时，第一个值是key，第二个值是value。
10. func
package main
import "fmt"
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)
fmt.Println(res) // 3
v, ok := exists(map[string]string{"a": "A"}, "a")
fmt.Println(v, ok) // A True
}
在go语言中参数的变量类型是后置的。
在go语言中函数原生支持返回多个值。在实际的业务逻辑代码里面几乎所有的函数都返回两个值，第一个是真正的返回结果，第二个值是一个错误信息。
11. point
package main
import "fmt"
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
}
Go语言中的指针不像C中的指针那么万能，Go语言中指针仅仅是为了对某个变量进行修改。
指针的一个主要用途就是对于传入参数进行修改。这个函数试图把一个变量+2。但是单纯像上面这种写法其实是无效的。为了类型匹配，调用的时候会加一个&符号，进行地址传递而非值传递。
12. struct
package main
import "fmt"
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, "1024")) // false
fmt.Println(checkPassword2(&a, "2004")) // false
fmt.Println(checkPassword(a, "2004"))
}
func checkPassword(u user, password string) bool {
return u.password == password
}
func checkPassword2(u *user, password string) string {
u.password = password
return u.password
}
可以用字段的名称去初始化一个字段，也可以按照顺序直接写值，对于没有明文初始化的值，会自动初始化为0。结构体也可以作为函数的参数来使用，也有指针操作。
可以用结构体的名称去初始化一个结构体变量，构造的时候需要传入每个字段的初始值。也可以用键值对的方式去指定初始值，这样可以只对一部分字段进行初始化。结构体也能支持指针。
13. struct-method
package main
import "fmt"
type user struct {
name string
password string
}
func (u user) checkPassword(password string) bool {
return u.password == password
}
func (u *user) resetPassword(password string) {
u.password = password
}
func resetPassword(u *user, password string) string {
u.password = password
return u.password
}
func main() {
a := user{name: "wang", password: "1024"}
//这写法6
a.resetPassword("2048")
resetPassword(&a, "2004")
fmt.Println(a.checkPassword("2048")) // true
}
使用结构体方法，用户就可以使用<结构体名>.<方法名>的方式调用方法。注意的是，将结构体参数提前。可以为结构体去定义一些方法。会有一点类似其他语言里面的类成员函数。比如上面例子的checkPassword的实现，从一个普通函数，改成了结构体方法。这样用户可以像a.checkPassword("XX")去调用。具体的代码修改，就是把第一个参数，加上括号，写到函数名称前面。
在实现结构体的方法的时候也有两种写法，一种是带指针，一种是不带指针。性质同地址传递和值传递。
14. error
package main
import (
"errors"
"fmt"
)
type user struct {
name string
password string
}
func findUser(users []user, name string) (v *user, err error) {
for _, u := range users {
if u.name == name {
return &u, nil
}
}
return nil, errors.New("not found")
}
func main() {
u, err := findUser([]user{{"wang", "1024"}}, "wang")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(u.name) // wang
if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
fmt.Println(err) // not found
return
} else {
fmt.Println(u.name)
}
}
可以在方法的返回值里面加一个error类型的参数，代表这个函数可能会返回错误，这时需要return两个值。
使用一个单独的返回值来传递错误信息。能够很清晰地知道哪个函数返回了错误，并且能用简单的if-else来处理错误。
在函数里面，可以在那个函数的返回值类型里面，后面加一个err,就代表这个函数可能会返回错误。
在函数实现的时候，return需要同时return两个值，如果出现错误，可以return nil和一个error。没有就返回原本的结果和nil。
15. string
package main
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
fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
fmt.Println(strings.Repeat(a, 2)) // hellohello
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
}
Contains用于判断一个字符串里面是否有包含另一个字符串
Count是字符串计数
HasPrefix是检查字符串是不是以某个字符串为开头
HasSuffix是检查字符串是不是以某个字符串为结尾
Index查找某个字符在字符串中的位置
Join是把两个字符串切片用指定的字符连接起来
Repeat是把字符串重复两次
Replace是把字符串中所有某个字符替换成另一个字符
Split是把字符串，按照某个字符分割为多个切片
ToLower是把字符串中所有的某个字母都变成小写
ToUpper是把字符串中所有的某个字母都变成大写
len是获取字符串的长度
16. fmt
package main
import "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}
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
}
字符串格式化：
%v来打印任意类型的变量，而不需要区分数字字符串
%+v来得到更加详细的结构
用%#v来得到最为详细的结构
17. json
package main
import (
"encoding/json"
"fmt"
)
type userInfo struct {
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)
}
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"}}
}
结构体要保证每个字段的第一个字母是大写，那么这个结构体就能用JSON.marshaler序列化，变成一个JSON的字符串。序列化之后的字符串也能够用JSON.unmarshaler去反序列化到一个空的变量里面。
18. time
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
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
}
time.Now()获取当前时间
time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)构造一个带时区的时间
用.Sub()去对两个时间进行减法，得到一个时间段
可以用.UNX来获取时间戳
19. strconv
package main
import (
"fmt"
"strconv"
)
func main() {
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234
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
}
字符串与数字之间的转换
字符串和数字类型之间的转换都在strconv这个包下，是string convert这两个单词的缩写。
可以用parselnt或者parseFloat来解析一个字符串。
可以用Atoi把一个十进制字符串转成数字。可以用itoA把数字转成字符串。如果输入不合法，那么这些函数都会返回error。
例如：strconv.ParseFloat("1.234", 64)中，"1.234"代表要转换的字符串，64表示64位数据；strconv.ParseInt("111", 10, 64)中，“111”代表要转换的字符串，第二个参数表示进制，传0的话则自动推算，第三个参数表示位数，64表示64位数据
20. env
package main
import (
"fmt"
"os"
"os/exec"
)
func main() {
// go run example/20-env/main.go a b c d
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
}
进程信息
os.Args来获取进程在执行时的命令行参数
os.Getenv("PATH)来获取环境变量
os.Setenv()来设置环境变量
exec.Command()来快速启动子进程并获取输入输出
