1.数组

定义一个数组：(很少使用数组，因为他的长度是固定的，更多的时候用的是切片)

var a [5]int 
b := [5]int{1,2,3,4,5}

2.切片

定义一个切片：

s := make([]string)
s[0] = "a"
s[1] = "b"
//可以用append去追加值
s = append(s,"d"); 

3.map

创建一个map：

//map[key](value)
m := make(map[string](int))
m["one"] = 1
m["two"] = 2
//可以通过delete删除键值对
delete(m, "one")
//读取键值对的时候，在后面添加一个ok，用来获取map中是否存在该key
r, ok := m["two"]
fmt.println(r, ok)  //2 true

4.range

range可以用来快速遍历数组和map

//遍历数组
nums := []int{2, 3, 4}
for i, num := range nums {
//i是下标
   fmt.Println(num)
}

//遍历map
m := map[string]string{"a": "A", "b": "B"}
for k, v := range m {
   fmt.Println(k, v) // b 8; a A
}
for k := range m {
   fmt.Println("key", k) // key a; key b
}

5.函数

go中的函数原生支持返回多个值，第一个值返回真正的返回结果，第二个值返回错误信息

//正常函数
func add(a int, 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
}

6.指针

go中的指针非常有限，常用的操作就是对传递的参数进行修改

func add2(n int) {
   n += 2
}

func add2ptr(n *int) {
   *n += 2
}

func main() {
   n := 5
   add2(n) //无效加2
   fmt.Println(n) // 5
   add2ptr(&n) //有效加2
   fmt.Println(n) // 7
}

7.结构体

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

8.结构体方法

type user struct {
   name     string
   password string
}
//结构体方法
func (u user) checkPassword(password string) bool {
   return u.password == password
}
//正常函数 和上面的结构体函数对比
func add(a int, b int) int { 
    return a + b 
}
//带指针才能对结构体修改
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
}

9.错误处理

go中错误信息的处理方式是用一个单独的返回值来返回错误，并且能够用简单if else来处理错误

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 {//如果这里不进行判断的话，那么下面的u.name可能会出现空指针异常
      fmt.Println(err)
      return
   }
   fmt.Println(u.name) // wang
}

10.字符串操作

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
}

11.字符串格式化输出

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
}

12.JSON 处理

type userInfo struct {
   Name  string
   Age   int 
   //Age   int `json:"age"`  //这样的话序列化后输出的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)
   }
   //不加强制类型转化就会输出16进制
   fmt.Println(buf)         // [123 34 78 97...]
   fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}


   var b userInfo
   //json反序列化
   err = json.Unmarshal(buf, &b)
   if err != nil {
      panic(err)
   }
   //输出该变量的详细信息，那就是一个userInfo的结构体
   fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}

13.时间处理

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
   //Parse解析格式化的字符串并返回它表示的时间值。 简单来说就是参考前面的layout的格式解析后面的value
   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
}

13.数字解析

func main() {
   //将字符串转换为64位精度的float
   f, _ := strconv.ParseFloat("1.234", 64)
   fmt.Println(f) // 1.234
   
   //将当前字符串转化为十进制整数，精度为64位
   n, _ := strconv.ParseInt("111", 10, 64)
   fmt.Println(n) // 111
   
   //0代表自动判断转换位几进制
   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
}