Go语言
- 高性能、高并发
- 语法简单、学习曲线平缓
- 丰富的标准库
- 完善的工具链
- 静态链接
- 快速编译
- 跨平台
- 垃圾回收
Go的基础语法
1. 变量
package main
import (
"fmt"
)
func main() {
var a int = 10
fmt.Println(a)
var b = "Hello"
fmt.Println(b)
var c int = 1
fmt.Println(c)
d := 10
fmt.Println(d)
}
2. 输出 （Golang在输出方面相比部分语言更加便捷）
var a, b, c, d, e, f = "a", "b", "c", "d", "e", "f"
fmt.Print(a, b, c, d, e, f)
3. if else (没有圆括号包围条件表达式）
a := 10
if a < 10 {
} else if a == 10 {
} else {
}
4. 循环（只有一种for循环）
4.1. 死循环
i := 1
for {
}
4.2. 循环
for i := 0; i < 10; i++ {
}
5. switch语句
不需要在每个case后加上break;
6. 数组（实际中很少用数组，因为数组的长度是固定的，更多使用切片）
var a [5]int
fmt.Println(a, len(a))
b := [5]int{1, 2, 3, 445, 5}
fmt.Println(b)
7. 切片(make)
g := []string{"a"}
g = append(g, "a")
fmt.Println(g, len(g))
s := make([]string, 3)
s[0], s[1], s[2] = "", "b", "c"
fmt.Println(s, len(s))
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println(s, len(s))
c := make([]string, 4)
copy(c, s)
fmt.Println(c, len(c))
7.1. 用append拼接
7.2. s[left : right]左边不写默认为0，右边不写默认到最后，两边都写则遵循左闭右开
8. map（使用次数较多的数据结构）
m := make(map[string]int)
m["one"] = 0
m["two"] = 2
// target 用来接收key的value，flag用来接收是否有这个key
target, flag := m["one"]
fmt.Println(target, flag)
8.1. map是采取键值对的形式存储
8.2. 如果用不存在的key去获取，得到的值是0
8.3. 通过a, b := m[key] 的方式去判断是否有该key，b为boolean值
8.4. delete(m, key) 去删除
8.5. m := map[string]int{"one": 1, "two": 2} 去初始化并赋值
8.6. map是无序的
9. range（遍历）
9.1. for 变量1, 变量2 := 数组名变量1为下标， 变量2为数组中的值
sum := 0
for i, num := range arr {
sum += num
fmt.Printf("arr[%d] = %d\n", i, num)
}
fmt.Print(sum)
9.2. 遍历map
m := map[int]int{1: 100, 2: 200, 3: 300}
for k, v := range m {
fmt.Printf("m[%d]: %d\n", k, v)
}
10. 函数
func add(a int, b int) int {
return a + b
}
10.1.函数关键字func
10.2.函数返回值类型在形参括号后
10.3.Go中函数一般返回多个值
func add(a, b, c, d int, e string) (int, string) {
return a + b + c + d, e
}
func main() {
sum, ok := add(1, 2, 3, 4, "s")
fmt.Println(sum, ok)
}
传入一个map和key，返回key的value并且知道是否存在key
func add(m map[int]int, k int) (int, bool) {
val, ok := m[k]
return val, ok
}
func main() {
m := map[int]int{1: 100}
val, ok := add(m, 1)
fmt.Println(val, ok)
}
11. 指针
....
12. 结构体
12.1. 定义一个结构体
type 结构体名 struct {
属性1 属性类型
属性2 属性类型
...
}
12.2. 初始化一个结构体
a := 结构体名{属性1: xxx, 属性2: xxx}
var b 结构体名
b.属性1 = xxx
b.属性2 = xxx
12.3. 声明结构体后再使用，都采取结构体变量名.属性
13. 结构体方法
package main
import "fmt"
type student struct {
name string
age int
}
// 年龄比较
func (stu student) checkAge(age int) bool {
return stu.age == age
}
// 更改名字
func (stu *student) resetName(name string) {
stu.name = name
}
func main() {
stu := student{name: "xzhh", age: 20}
stu.resetName("xzh")
fmt.Println(stu.checkAge(20), stu.name)
}
13.1.上面用到指针，指针在Go一般用在修改值
14. 错误处理
package main
import (
"errors"
"fmt"
)
type user struct {
name string
password string
}
// 如果users里面有传入的name 则把该user返回
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"}}, "wangl")
if err != nil {
fmt.Println(err)
return
}
fmt.Println(u.name)
// 两种写法
if u, err := findUser([]user{{"w", "2"}}, "w"); err != nil {
fmt.Print(err)
return
} else {
fmt.Println(u.name)
}
}
15. 字符串操作
15.1. 引入strings库
15.2. strings.函数()
15.3. 包含Contains()
a := "hello"
strings.Contains(a, "e")
15.4. 计数Count()
a := "password"
strings.Count(a, "s")
15.5. 位置Index()
15.6. 插入Join()
15.7. 重复Repeat()
15.8. 替换Replace()
15.9. 分隔Split()
15.10. 变小写ToLower() 变大写ToUpper()
...
16. 字符串格式化
type point struct {
x, y int
}
func main() {
p := point(1, 2)
fmt.Printf("p=%v) // 正常输出 p={1 2}
fmt.Printf("%+v") // p={x:1 y:2}
fmt.Printf("%#v") // p=main.point{x:1 y:2}
}
在Go中格式化输出只需要%v一种方式即可
num := 1.232323
fmt.Printf("%.2f", 1.23) // 保留小数
fmt.Printf("%.2v", 1.23) // 保留位数
17. JSON处理
17.1. 要保证字段的首字母大写
...
