这是我参与「第五届青训营 」伴学笔记创作活动的第 1 天
go语言的特点：
- 高性能，高并发
- 语法简单，学习曲线平缓
- 丰富的标准库
- 完善的工具链
- 静态编译
- 快速编译
- 跨平台
- 垃圾回收
golong的安装 The Go Programming Language
开发环境 为 Go 开发配置Visual Studio Code | Microsoft Learn
变量
Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
声明变量的一般形式是使用 var 关键字
1.指定变量类型，如果没有初始化，则变量默认为零值（系统默认设置的值）。
2.根据值自行推导变量类型。
3.使用 := 声明变量
package main
import (
"fmt"
)
func main() {
var a = "list"
var b, c int = 1, 2
var d = float32(1.2)
e:= 500
fmt.Println(a, b, c, d,e)
}
条件语句
1.它的条件语句不像其它编程语言一样需要括号（如果加上的话编辑器在保存的时候则则会去掉）
2.它的花括号必须和if关键字的同一行
3.它还支持先赋值，再判断
package main
import (
"fmt"
)
func main() {
if num := 1; num > 0 {
fmt.Println("Yes")
} else {
fmt.Println("No")
}
}
循环语句
在go语言中只有for循环，没有while和do while循环，不过它也像c/c++可以使用continut和break语句
package main
import (
"fmt"
)
func main(){
for a:=1;a<10;a++{
fmt.Println("hello")
}
}
swtich结构
1.go语言switch后面可以是任意的变量类型，甚至可以什么都不加，可以通过在case中写条件语句进行逻辑判断
2.其它语言如果不显示的加break的话则会跑完后面所有的case，而go语言的swtich结构在每个case后面不需要加break，当执行完后则会退出switch结构
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now()
switch {
case t.Hour() > 1:
fmt.Println(">")
default:
fmt.Println("<=")
}
}
数组
package main
import (
"fmt"
)
func main(){
arr:=[2][3]int {{1,2,3},{4,5,6}}
fmt.Println(arr)
}
切片
1.切片可以任意改变长度
2.它也支持append操作，不过我们必须把append的结果赋值给原数组 （因为 slice的原理实际上是它有一个它存储了一个长度和一个容量，加一个指向一个数组的指针，在你执行append 操作的时候，如果容量不够的话，会扩容并且返回新的slice）
3.它也像python一样支持切片操作，不过它不支持负数索引
package main
import(
"fmt"
)
func main(){
s:=make([]string ,3)
s[0]="a"
s[1]="b"
s[2]="c"
s = append(s, "d")
c:=make([]string,2)
copy(c,s)
fmt.Println(s,c)
fmt.Println(s[1:3])
}
map
我们可以直接存储键值对，也可以通过delete删除键值对。
golang的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(m["one"]) // 1
fmt.Println(m["unknow"]) // 0
r, ok := m["unknow"]
fmt.Println(r, ok) // 0 false
delete(m, "one")
fmt.Println(m)
m2 := map[string]int{"one": 1, "two": 2}
fmt.Println(m2)
}
range
我们可以通过使用range来对数组,silce,map快速遍历，遍历时，range会返回两个值，第一个是索引，第二个是该索引对应的元素
当我们不需要索引时，我们就可以用下划线来忽略
package main
import (
"fmt"
)
func main() {
nums := []int{1, 2, 3}
for i, num := range nums {
fmt.Println("index=", i, "num=", num)
}
for _, num := range nums {
fmt.Println( "num=", num)
}
}
函数
1.与其它编程语言不同，go的函数的返回类型是后置的
2.而且函数原生支持返回多个值。在实际的业务逻辑代码里面几乎所有的函数都返回两个值，第一个是真正的返回结果，第二个值是一个错误信息。
package main
import (
"fmt"
)
func add( a int ,b int )(int ,string){
return a+b,"hello"
}
func main(){
a,str:=add(1,2)
fmt.Print(a," ",str)
}
指针
相比C和C+＋里面的指针，支持的操作很有限。它的一个主要用途就是对于传入参数进行修改。 当一个指针被定义后没有分配到任何变量时，它的值为 nil。 nil在概念上和其它语言的null、None、nil、NULL，nullptr一样，都指代零值或空值。
package main
import "fmt"
func add(a *int ){
*a+=1
}
func main(){
a:=1
add(&a)
fmt.Print(a)
}
结构体
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：
type struct_variable_type struct {
member definition
member definition
...
member definition
}
1.我们可以在构造时通过传入每个字段的值来构造。
2.我们也可以使用键值对的方式来构造，也可以只对一部分初始化。
3.我们也可以使用结构体指针，这样可以避免拷贝带来的开销
4.访问结构体成员的时候通过"."来访问
package main
import (
"fmt"
)
type usr struct{
name string
passworrd string
}
func main(){
a:=usr{"小李","abc"}
b:=usr{name:"小王"}
fmt.Println(a,b)
fmt.Println(b.name)
}
结构体方法
在go里面可以为结构体定义方法，类似于其它语言中的成员函数。 实现结构体方法的时候也有两种方式，一种带指针，一种不带指针(带指针的话可以修改结构体)
package main
import (
"fmt"
)
type usr struct{
name string
password string
}
func (u usr) checkPassword( password string) bool {
return u.password == password
}
func (u *usr) setPassword( password string) {
u.password = password
}
func main(){
a:=usr{"abc","123"}
fmt.Print(a.checkPassword("456"))
a.setPassword("789")
fmt.Print(a)
}
错误处理
Go 错误处理
Go 语言通过内置的错误接口提供了非常简单的错误处理机制。
error类型是一个接口类型，这是它的定义：
type error interface {
Error() string
}
我们可以在编码中通过实现 error 接口类型来生成错误信息。
函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息。
在函数里面，
我们可以在那个函数的返回值类型里面，后面加一个error，就代表这个函数可能会返回错误。
那么在函数实现的时候，retum需要同时returm两个值，要么就是如果出现错误的话，那么可以retum nil和一个error。如果没有的话，那么返回原本的结果和ni。
package main
import (
"fmt"
"errors"
)
type usr struct{
name string
password string
}
func (u usr) checkPassword( password string) (bool,error) {
if u.password == password{
return true,nil
}else{
return false,errors.New("!=")
}
}
func main(){
a:=usr{"abc","123"}
if b,err:=a.checkPassword("456");err!=nil{
fmt.Print(b,err)
}
}
字符串处理
在标淮库stings包里面有很多常用的字符串工具
contains判断一个字符用里面是否有包含另一个字符串，count计数，index查找某个字符串的位置，join连接多个字符串，repeat重复多个字符串，replace替换字符串。
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
}
字符串格式化
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
}
JSON处理
只要保证这个结构体的每个字段的第一个字母都是大写，那么它就通过json.Marshal来序列化，变成一个JSON字符串
当序列化后，我们可以通过json.Unmarshal来反序列化
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"}}
}
时间处理
通过time.Now()获取当前时间
通过time.data去构造一个带时区的时间，再通过.Year()/.Month()/.Day()/.Hour()/.Minute来获取年/月/日/时/分
当于某些系统交互时，我们可以使用.UNIX来获取时间戳
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
}
数字解析
使用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
}
进程信息
使用os中的方法
Getenv：获取环境变量Setenv：设置环境变量Command：执行一些命令
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
}
