这是我参与「第五届青训营」伴学笔记创作活动的第 1 天

入门 Go 语言

开发环境

安装 Go 语言

访问 go.dev/ ，点击 Download ，下载对应平台安装包，安装即可 2.访问studygolang.com/dl 下载安装

3.参考 goproxy.cn/ 里面的描述配置，下载第三方依赖包的速度可以大大加快

配置 Go 语言开发环境

有两种主流 IDE 可选：VSCode 和 GoLand。

VSCode是由微软开发的开源代码编辑器。

2. GoLand则是由 Jetbrains 公司开发，基于著名 Java IDE IntelliJ IDEA 构建的功能强大的 IDE。

3. 此两种 IDE 的区别是，前者更像手动挡，后者则是自动挡。对于进阶需求，VSCode 为你带来的可自定义性会更强；

基础语法

Hello World

package main

import "fmt"

func main() {
   fmt.Println("Hello word")
}

变量与常量

变量的声明

var a="apple"
var b=1
var c int=2

常量的声明

const s string="apple"
const g=11111111
const i =2e22

if else

package main

import "fmt"

func main() {
   if 9%2 == 0 {
      fmt.Println("9是偶数")
   } else {
      fmt.Println("9是奇数")
   }

   if 9%3 == 0 {
      fmt.Println("9可以被3整除")
   }

   if n := 9; n < 0 {
      fmt.Println(n, "是负数")
   } else if n < 10 {
      fmt.Println(n, "是个位数")
   } else {
      fmt.Println(n, "是多位数")
   }
}

循环

循环只有for循环一种

i := 1
//无限循环
for {
   fmt.Println("loop")
   break
}
for j := 7; j < 13; j++ {
   fmt.Println(j)
}
for n := 0; n < 8; n++ {
   if n%2 == 0 {
      continue
   }
   fmt.Println(n)
}
for i <= 5 {
   fmt.Println(i)
   i = i + 1
}

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

你也可以直接省略 `switch` 后的变量

   t := time.Now()
   switch {
   case t.Hour() < 12:
      fmt.Println(t, "It's before noon")
   default:
      fmt.Println(t, "It's after noon")
   }
}

数组，切片和映射

数组

package main

import "fmt"

func main() {
   //声明了一个名为 `a` ，大小为 5 的 `int` 数组，并将其最后一个元素的值设置为 `100`。
   var a [5]int
   a[4] = 100
   fmt.Println("get:", a[2])
   fmt.Println("len:", len(a))
   fmt.Println("a[4]:", a[4])
   //声明了一个名为 `b`，大小为 5，数组内元素初始值为 `1,2,3,4,5` 的 `int` 数组。
   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)
}

切片

package main

import "fmt"

func main() {
//声明了一个长度为 3，容量为 3 的 `string` 切片。
   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
//使用 `append` 方法为数组添加新的元素
   s = append(s, "d")
   s = append(s, "e", "f")
   fmt.Println(s) // [a b c d e f]

   c := make([]string, len(s))
//可以使用 `copy` 方法将一个切片内的元素复制到另一个切片中
   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]
}

映射

声明了一个键（`key`）为 `string` 类型，值（`value`）为 `int` 类型的 Map。

m := make(map[string]int)

来判断该键是否在 `Map` 中存在

r, ok := m["unknow"]

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
//来判断该键是否在 `Map` 中存在
   r, ok := m["unknow"]
   a, b := m["one"]
   fmt.Println(r, ok) // 0 false
   fmt.Println(a, b)  // 1 true
   delete(m, "one")
   fmt.Println(m)
   m2 := map[string]int{"one": 1, "two": 2}
   var m3 = map[string]int{"one": 1, "two": 2}
   fmt.Println(m2, m3)
}

range

`for 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
   }
   for _,k := range m {
      fmt.Println("Value", k) // Value a; Value b
   }
}

函数

声明了一个名为 `add`，拥有两个类型为 `int`，名称分别为 `a` 和 `b` 的形参，返回值为 `int` 的函数。

package main

import "fmt"

func add(a int, b int) int {
   return a + b
}
func main() {
   res := add(1, 2)
   fmt.Println(res) // 3

指针

Go 的方法传参均为传值，而不是传引用，如果不传入指针而直接传入一个值的话，则方法实参会被复制一份再传入。

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
}

结构体

声明结构体

type user struct {
   name     string
   password string
}

初始化结构体

如果未对一个结构体进行初始化，则结构体成员将采用默认值

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"

结构体方法

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
}

错误处理

以下方法试图从一个 `user` 切片中查找是否存在指定名称的 `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")
}

完整代码

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 find")
}
func main() {
   v, u := findUser([]user{{"wang", "1234"}}, "wang")
   if u != nil {
      fmt.Println(u)
   }
   fmt.Println(v.name, v.password)
   if a, b := findUser([]user{{"wang", "1234"}}, "li"); b != nil {
      fmt.Println(b)
   } else {
      fmt.Println(a.name, a.password)
   }
}

字符串

字符串操作

package main

import (
   "fmt"
   "strings"
)

func main() {
   a := "hello"
   fmt.Println("Contains", strings.Contains(a, "ll"))
   fmt.Println("Count", strings.Count(a, "l"))
   fmt.Println("HasPrefix", strings.HasPrefix(a, "he"))
   fmt.Println("HasSuffix", strings.HasSuffix(a, "llo"))
   fmt.Println("Index", strings.Index(a, "ll"))
   fmt.Println("Join", strings.Join([]string{"he", "llo"}, "-"))
   fmt.Println("Repeat", strings.Repeat(a, 2))
   fmt.Println("Replace", strings.Replace(a, "e", "E", -1))
   fmt.Println("Split", strings.Split("a-b-c", "-"))
   fmt.Println("ToLower", strings.ToLower(a))
   fmt.Println("ToUpper", strings.ToUpper(a))
   fmt.Println(len(a))
}

字符串格式化

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操作

序列化 `buf, err := json.Marshal(a)`

反序列化

反序列化之前要新建一个空的结构体 `var b userInfo`然后在反序列化`err = json.Unmarshal(buf, &b)`

用json时结构体的首字母要大写如需小写则需在后面添加`json:"age"`

type userInfo struct {
   Name  string
   Age   int `json:"age"`
   Hobby []string
}

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)
   fmt.Printf("%+v\n", b)
   fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}

时间处理

`time.Now()`获取当前时间

`time.Date()`构造一个带时区的时间`time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)`

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
}

入门Go语言 | 青训营笔记