走进Go语言基础语法

什么是Go语言？

高性能、高并发
语法简单、学习曲线平缓
丰富的标准库
完善的工具链
静态链接
快速编译
跨平台
垃圾回收

开发环境安装

安装Golang

官网网址：go.dev/

Mac踩坑：m1芯片以后的需要装arm64而不是amd64，否则vs code无法调试运行。

在vs code中安装Go插件

需要在GOPATH指定的空间中编写go代码，否则无法运行。

基础语法 - Hello World

GOPATH: /Users/ldbb/go

2、在src文件夹下新建一个文件夹HelloWorld并使用go mod init 文件夹名字进行初始化生成go.mod文件

3、在HelloWorld文件夹中新建hello.go文件

hello.go代码如下：

package main //程序入口

import (
  "fmt"      //go的标准库，在屏幕上输入输出，格式化字符串
)

func main() {
	fmt.Println("hello world")   //打印helloworld
}

程序运行：

1、直接运行：

go run src/HelloWorld/hello.go

2、编译后运行：

go build src/HelloWorld/hello.go
./hello

输出结果：

hello world

在src根目录下同时有多个文件，可以使用go work（工作空间）进行文件管理。

基础语法 - 变量

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)                // initialfoo

	const s string = "constant"
	const h = 500000000
	const i = 3e20 / h
	fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}

变量声明的三种方式：

1、var 变量名 = 变量值，如var a = "initial"

2、var 变量名指定类型 = 变量值，如var b, c int = 1, 2

3、变量名 := 值，如f := float32(e)

常量声明与变量类似，自动判断类型

输出结果：

initial 1 2 true 0 0
initialfoo
constant 500000000 6e+11 -0.28470407323754404 0.7591864109375384

基础语法 - if else

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")
	}
}

与其他语言的区别：

1、if后条件判断没有括号

2、条件执行程序不能单独成行，必须使用{ }

输出结果：

7 is odd
8 is divisible by 4
9 has 1 digit

基础语法 - for

GoLang中只有for循环，没有while和do_while循环。

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
	}
}

输出结果：

loop
7
8
1
3
1
2
3

基础语法 - 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")
	}
}

GoLang中switch与其他语言相比最大的不同点：

1、没有break语句，不会一直执行下去，找到对应的case执行完以后直接跳出switch

2、功能更加强大，变量类型可以是字符串、结构体等。

输出结果：

two
It's after noon

基础语法 - 数组

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)
}

数组声明形式：

1、var 数组名 [元素个数]变量类型

2、变量名 := [元素个数]变量类型

输出结果：

get: 0
len: 5
[1 2 3 4 5]
2d:  [[0 1 2] [1 2 3]]

基础语法 - 切片

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(切片名, 添加的元素)

输出结果：

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]

基础语法 - 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映射，相当于python中的字典。

创建map映射的三种方式：

1、创建空映射：map_name := make(map[key_type]value_type)

2、map_name := map[key_type]value_type{"key_name1": value_name1, "key_name2": value_name2}

3、var map_name = map[key_type]value_type{"key_name1": value_name1, "key_name2": value_name2}

ok：判断map中是否有key。

map中各个键值对没有顺序，输出时顺序随机。

输出结果：

map[one:1 two:2]
2
1
0
0 false
map[one:1 two:2] map[one:1 two:2]

基础语法 - 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 B; a A
	}
	for k := range m {
		fmt.Println("key", k) // key a; key b
	}
}

range可以对数组、切片、map进行遍历。

对于数组来说，for循环第一个参数是表示数组的下标，第二个参数表示数组的值。

输出结果：

index: 0 num: 2
9
b B
a A
key a
key b

基础语法 - 函数

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
}

函数格式：

func 函数名(形参1 形参1变量类型，形参2 形参2变量类型)(返回值1 返回值1变量类型，返回值2 返回值2变量类型){

函数体

return 返回值1，返回值2

}

一般来说函数只有1个返回值，如果有第2个返回值，一般是ok，代表是否存在。

输出结果：

3
A true

基础语法 - 指针

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
}

第一个函数不会改变n的值，第二个函数传入指针，所以n的值被修改。

输出结果：

5
7

基础语法 - 结构体方法

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, "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
}

类的定义：

type 类名 struct {

成员函数1 成员函数1变量类型

成员函数2 成员函数2变量类型

}

类的实例化的4种方法：

1、实例1 := 类名{成员函数1: 值1，成员函数2: 值2}

2、实例2 := 类名{值1，值2}

3、实例3 := 类名{成员函数1: 值1}

实例3.成员函数2 = 值2

4、var 实例4 类名

实例4.成员函数1 = 值1

实例4.成员函数2 = 值2

输出结果：

{wang 1024} {wang 1024} {wang 1024} {wang 1024}
false
false

类的成员函数：

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 main() {
	a := user{name: "wang", password: "1024"}
	a.resetPassword("2048")
	fmt.Println(a.checkPassword("2048")) // true
}

类的成员函数的定义：

func (形参1，类) 函数名(形参2，形参2变量类型)(返回值返回值变量类型){

函数体

return 返回值

}

输出结果：

true

基础语法 - 错误

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是接口类型。error类型可能是nil或者non-nil。nil意味着函数运行成功，non-nil表示失败。对于non-nil的error类型，我们可以通过调用error的Error函数或者输出函数获得字符串类型的错误信息。

输出结果：

wang
not found

基础语法 - 字符串操作

对应的包：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
}

常见字符串操作：

1、Contains：判断原字符串中是否包含子字符串；

2、Count：子字符串计数；

3、HasPrefix：判断原字符串是否以子字符串为前缀；

4、HasSuffix：判断原字符串是否以子字符串为后缀；

5、Index：找出子字符串在原字符串中的起始位置；

6、Join：将两个字符串连接；

7、Repeat：重复原字符串；

8、Replace：将原字符串中前n个不重叠子串都替换为新字符串，如果n<0会替换所有old子串；

9、Split：将字符串切分为数组；

10、ToLower：所有字母小写；

11、ToUpper：所有字母大写；

12、len：统计字符串的字符数量。

注意：len统计中文字符时1个字符不一定用一个字节来表示。

输出结果：

true
2
true
true
2
he-llo
hellohello
hEllo
[a b c]
hello
HELLO
5
6

基础语法 - 字符串格式化

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
}

在fmt包中Println和Printf的区别：

1、Println：打印并换行；

2、Printf：类似C语言中的Printf，但Go中%v可以输出所有类型的变量，不需要区分变量类型。%+v和%#v可以输出结果的类型等详细信息。

输出结果：

hello 123
{1 2}
s=hello
n=123
p={1 2}
p={x:1 y:2}
p=main.point{x:1, y:2}
3.141592653
3.14

基础语法 - JSON处理

package main

import (
	"encoding/json"
	"fmt"
)

type userInfo struct {
	Name  string
	Age   int `json:"age"`       //以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文件处理：

导入包：“encoding/json”

能够json序列化的条件：每个自定义类中每个成员函数名开头大写

打印json格式时需要转换为string类型输出，否则就是一串十六进制的数字

json编码（编组）：json.Marshal

json.MarshalIndent：产生整齐缩进的输出

json.Unmarshal：解码

输出结果：

hello 123
{1 2}
s=hello
n=123
p={1 2}
p={x:1 y:2}
p=main.point{x:1, y:2}
3.141592653
3.14

基础语法 - 时间处理

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包的常用函数：

1、time.Now()：获取当前时间

2、time.Date()：创建时间，time.UTC表示所用时区为UTC时区

3、time.Format()：时间类型有一个自带的 Format 方法进行格式化，需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S 而是使用Go语言的诞生时间 2006 年 1 月 2 号 15 点 04 分 05 秒。

4、计算时间差：t.Sub(u)返回一个时间段t - u的值

5、解析字符串格式的时间：Parse 函数可以解析一个格式化的时间字符串并返回它代表的时间。

t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")

6、获取时间戳：时间戳是自 1970 年 1 月 1 日（08:00:00GMT）至当前时间的总毫秒数，它也被称为 Unix 时间戳（UnixTimestamp）。now.Unix()

输出结果：

2023-08-02 20:04:18.147558 +0800 CST m=+0.000088667
2022-03-27 01:25:36 +0000 UTC
2022 March 27 1 25
2022-03-27 01:25:36
1h5m0s
65 3900
true
1690977858

基础语法 - 数字解析

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
}

数字与字符串之间的转换：

1、字符串转化为数字：

导入包：“strconv"

strconv.ParseFloat(待解析的字符串，位数)

strconv.ParseInt(待解析的字符串，进制，位数)

strconv.Atoi(待解析的字符串)自动识别转换

2、数字转换为字符串：

strconv.Itoa(int)

输出结果：

1.234
111
4096
123
0 strconv.Atoi: parsing "AAA": invalid syntax

基础语法 - 进程信息

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 包中提供了操作系统函数的接口，常用的函数：

1、os.Args：包含临时生成的执行目录等进程信息；

2、os.Getenv()：Getenv 函数会检索并返回环境变量的值。如果不存在该环境变量则会返回空字符串；

3、os.Setenv()：Setenv 函数可以设置环境变量，如果出错会返回该错误；

4、exec.Command.CombinedOutput()：快速启动子进程并获取输入输出。

输出结果：

[/Users/ldbb/go/src/go-by-example/example/20-env/__debug_bin254923695]
/Users/ldbb/anaconda3/bin:/Users/ldbb/anaconda3/condabin:/opt/homebrew/bin:/opt/homebrew/sbin:/Library/Frameworks/Python.framework/Versions/3.6/bin:/opt/local/bin:/opt/local/sbin:/Library/Frameworks/Python.framework/Versions/3.9/bin:/usr/local/bin:/System/Cryptexes/App/usr/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Users/ldbb/mongodb/bin:/Library/TeX/texbin:/usr/local/go/bin:/usr/local/share/dotnet:/opt/X11/bin:~/.dotnet/tools:/Library/Apple/usr/bin:/Library/Frameworks/Mono.framework/Versions/Current/Commands:/usr/local/git/bin:/usr/local/go/bin
<nil>
127.0.0.1	localhost

Go 语言入门指南：基础语法和常用特性解析 ｜青训营

走进Go语言基础语法

什么是Go语言？

开发环境安装

安装Golang

在vs code中安装Go插件

基础语法 - Hello World

基础语法 - 变量

基础语法 - if else

基础语法 - for

基础语法 - switch

基础语法 - 数组

基础语法 - 切片

基础语法 - map

基础语法 - range

基础语法 - 函数

基础语法 - 指针

基础语法 - 结构体方法

基础语法 - 错误

基础语法 - 字符串操作

基础语法 - 字符串格式化

基础语法 - JSON处理

基础语法 - 时间处理

基础语法 - 数字解析

基础语法 - 进程信息

Go 语言入门指南：基础语法和常用特性解析｜青训营