GO语言是什么
~有和c++、java媲美的性能，语法风格类似C语言
~有类似python的稳定标准库
~各种设备都可运行，无需配置交叉编译环境
GO 入门
- 开发环境——golang的安装
- 配置集成开发环境 download vscode
Go基础语法
- 第一个程序~hello world
import (
"fmt"
)
func main() {
fmt.Println("hello world")
}
-
变量
字符串、整数、浮点型、布尔型
是内置类型，可以直接用加号拼接；运算符优先级与c类似；
变量的声明
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))
}
- if-else
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")
}
- for循环
~continue继续循环；break跳出循环
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
}
}
-
switch分支结构
默认case后不需要加break分支，会自动跳出分支；可以在case后写判断条件；
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")
}
}
- 数组
具有编号的元素固定的序列；
- 切片slice 长度+容量+指针
- 创建切片
s := make([]string, 3)
good := []string{"g", "o", "o", "d"}
2.增加元素，必须把append的结果赋值回原数组
s = append(s, "e", "f")
3.类似python的切片操作
- map（哈希、字典）
key-value，注意：此时遍历顺序是无序的
m := make(map[string]int)
m["one"] = 1
m["two"] = 2
r, ok := m["unknow"]
fmt.Println(r, ok) // 0 false
- range
遍历数组或切片，对于数组返回两个值，索引-对应位置的值
nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
sum += num
if num == 2 {
fmt.Println( "num:", num) // 忽略索引 num: 2
}
}
fmt.Println(sum) // 9
- 函数
最简单的两个变量相加函数如下，注意：变量后置
func add2(a, b int) int {
return a + b
}
func返回两个值，返回值-错误信息
func exists(m map[string]string, k string) (v string, ok bool) {
//这行代码声明了一个名为 exists 的函数，它接受两个参数：一个名为 m 的映射，其键和值的类型都是字符串；
//一个名为 k 的字符串，表示要查找的键。
//函数的返回值是一个字符串 v 和一个布尔值 ok看是否存在
v, ok = m[k]
return v, ok
}
- 指针
指针变量，存放地址的变量；go中主要用于对传入参数进行修改；
func add2ptr(n *int) {
*n += 2
}
func main() {
add2ptr(&n)
fmt.Println(n) // 7
}
- 结构体
带类型的字段的集合；
type user struct {
name string
password string
}
//定义了一个名为 user 的结构体类型，
//该结构体类型包含两个字段：name 和 password，分别用于存储用户的名称和密码
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 (u user) checkPassword(password string) bool {
// 比较用户输入的密码是否与存储的密码相匹配
return u.password == password
}
func (u *user) resetPassword(password string) {
// 将传入的 password 赋值给用户对象的 password 字段
u.password = password
}
func main() {
a := user{name: "wang", password: "1024"}
a.resetPassword("2048")
fmt.Println(a.checkPassword("2048")) // true
}
- 错误处理
使用一个单独的返回值以传递错误信息；
errors.New("not found") 用于创建一个新的错误对象，其中 "not found" 是错误消息。这个函数返回一个实现了 error 接口的对象，该对象包含了指定的错误消息；
type user struct {
name string
password string
}
// findUser 函数接收一个用户切片和一个用户名作为参数，在切片中查找指定用户名的用户
// 如果找到，则返回该用户的指针和 nil 错误；如果未找到，则返回 nil 和一个自定义的错误信息
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
} //err存在，不等于nil，打印err信息，返回函数
fmt.Println(u.name) // wang
//没有err的时候才能打印u.name，不然会出现空指针错误
if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
fmt.Println(err) // not found
return
} else {
fmt.Println(u.name)
}
- 字符串操作
标准库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
// 使用strings包中的Index函数查找字符串a中第一次出现子串"ll"的位置
fmt.Println(strings.Index(a, "ll")) // 2，表示"ll"在字符串a中的位置是索引为2的地方
fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
fmt.Println(strings.Repeat(a, 2)) // hellohello
// 使用 strings 包的 Replace 函数将字符串 a 中的所有字符 "e" 替换为 "E"
fmt.Println(strings.Replace(a, "e", "E", -1)) // hEllo
fmt.Println(strings.Split("a-b-c", "-")) // [a b c]
// 使用strings包中的ToLower函数将字符串a转换为小写形式，并打印结果
fmt.Println(strings.ToLower(a)) // hello
fmt.Println(strings.ToUpper(a)) // HELLO
fmt.Println(len(a)) // 5
b := "你好"
fmt.Println(len(b)) // 6
}
- 字符串标准化操作
type point struct {
x, y int
}//定义了一个名为 `point` 的结构体类型，它包含两个字段x、y，类型均为int。结构体是一种自定义的数据类型，它允许你将不同类型的数据组合在一起，形成一个新的类型。在这个例子中point结构体可以用来表示二维平面上的一个点，其中x、y分别表示该点的横坐标和纵坐标。
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}
- JASON处理
进行序列化及反序列化；
保证已有结构体的字段首字母是大写（可被外部包访问），首字母大写的字段保留原值，进行jason.Marshall序列化后变成数组；
"encoding/json"
"fmt"
)
type userInfo struct {
Name string
// 定义一个名为Age的字段，类型为int，后面是json序列化时的键名为"age"
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 函数抛出错误，程序会停止执行并打印错误信息
panic(err)
}
fmt.Println(buf) // [123 34 78 97...]
fmt.Println(string(buf)) //强制类型转化为字符串 {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
// 使用 json.MarshalIndent 函数将结构体 a 序列化为 JSON 格式，并使用缩进格式进行格式化
buf, err = json.MarshalIndent(a, "", "\t")
if err != nil {
panic(err)
}
fmt.Println(string(buf))
var b userInfo
// 将 JSON 格式的字节切片 buf 解析并存储到空变量 中
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"}}
}
- 时间处理
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
// 使用 time 包中的 Date 函数创建一个时间对象 t，表示 UTC 时间 2022 年 3 月 27 日 1 时 25 分 36 秒
// 使用 time 包中的 Date 函数创建一个时间对象 t2，表示 2022 年 3 月 27 日 2 时 30 分 36 秒，UTC 时区
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
// 打印当前时间的 Unix 时间戳
fmt.Println(now.Unix()) // 1648738080
}
- 数字解析
字符串和数字之间的转换
import (
"fmt"
"strconv"
)
func main() {
// 使用 strconv 包中的 ParseFloat 函数将字符串 "1.234" 转换为 float64 类型
// 第二个参数 64 表示转换的精度，即小数点后的位数
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f) // 1.234
// 调用 strconv 包的 ParseInt 函数，将字符串 "111" 转换为 64 位有符号整数
// 第二个参数 10是十进制数 表示字符串 "111"
// 第三个参数 64 表示转换后返回64位精度的整数，整数类型是 int64
n, _ := strconv.ParseInt("111", 10, 64)
fmt.Println(n) // 111
// 将字符串 "0x1000" 解析为 64 位整数，进制为 0（自动推断进制）
n, _ = strconv.ParseInt("0x1000", 0, 64)
fmt.Println(n) // 4096
// 将字符串 "123" 转换为整数类型，并将结果存储在变量 n2 中
n2, _ := strconv.Atoi("123")
fmt.Println(n2) // 123
n2, err := strconv.Atoi("AAA")
fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
// 将整数 123 转换为字符串类型，并将结果存储在变量 s2 中
s2 := strconv.Itoa(123)
fmt.Println(s2) // 123
- 进程信息
打印当前主函数所在的进行进程信息，比如获取环境变量，执行对应的指令等；
import (
"fmt"
"os"
"os/exec"
)
func main() {
// go run example/20-env/main.go a b c d
//获取进程在执行时的命令行参数，os.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
}
