课程源码：github.com/wangkechun/…

一、Go简介

1. 1 什么是go语言

高性能
语法简单、学习曲线平缓
丰富的标准库
完善的工具链
静态链接
快速编译
跨平台
垃圾回收

1.2 哪些公司在使用Go语言

1.3 字节跳动为什么全面拥抱Go语言

最初使用的 Python，由于性能问题换成了 Go
C++ 不太适合在线 Web 业务
早期团队非 Java 背景
性能比较好
部署简单，学习成本低
内部 RPC 和 HTTP 框架的推广

二、Go入门

2.1 开发环境

Go下载 - Go语言中文网 - Golang中文社区 (studygolang.com)

JetBrains GoLand：不只是 Go IDE

Go - Visual Studio Marketplace（Go插件下载地址）

Go语言环境安装及配置_go语言安装_ThrAvicii的博客-CSDN博客

本人按照该博客配置Go语言环境

注意：本人下载最新版Go，GOPATH的更改无效（原因未知，求大佬赐教），因此下载版本同博客，此时GOPATH修改正常

2.2 基础语法

2.2.1 Hello World

package hello

import (
	"fmt"
)

func main() {
	fmt.Println("hello world")
}

2.2.2 变量

package main

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

2.2.3 if else

package main

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

2.2.4 循环

package main

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
   }
}
//go当中只有for循环

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

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

//go当中，switch默认不需要加break，能自动跳出switch语句

2.2.6 数组

package main

import "fmt"

func main() {

   var a [5]int
   a[4] = 100
   fmt.Println("get:", a[2])
   fmt.Println("len:", len(a))

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

2.2.7 切片

package main

import "fmt"

func main() {

   s := make([]string, 3)
   s[0] = "a"
   s[1] = "b"
   s[2] = "c"
   fmt.Println("get:", s[2])   
   fmt.Println("len:", len(s))

   s = append(s, "d")
   s = append(s, "e", "f")
   fmt.Println(s)

   c := make([]string, len(s))
   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]
}

//可变长度的数组，可以在任意时刻改变其长度

2.2.8 map

package main

import "fmt"

func main() {
   m := make(map[string]int)
   m["one"] = 1
   m["two"] = 2
   fmt.Println(m)
   fmt.Println(len(m))
   fmt.Println(m["one"])
   fmt.Println(m["unknow"])

   r, ok := m["unknow"]
   fmt.Println(r, ok) // 0 false

   delete(m, "one")

   m2 := map[string]int{"one": 1, "two": 2}
   var m3 = map[string]int{"one": 1, "two": 2}
   fmt.Println(m2, m3)
}
//类似与java中的map，按[k:v]来存储数据.存储和读取均为随机

2.2.9 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)
      }
   }
   fmt.Println(sum)

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

//可以用来快速遍历map

2.2.10 函数

package main

import "fmt"

func add(a int, b int) int {
   return a + b
}

func add2(a, 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
}

func main() {
   res := add(1, 2)
   fmt.Println(res)

   v, ok := exists(map[string]string{"a": "A"}, "a")
   fmt.Println(v, ok)
}

2.2.11 指针

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)
   add2ptr(&n)
   fmt.Println(n)
}

//主要用途为对传入的参数进行修改
//相对于C语言的指针简单了很多

2.2.12 结构体

package main

import "fmt"

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)
   fmt.Println(checkPassword(a, "haha"))
   fmt.Println(checkPassword2(&a, "haha"))
}

func checkPassword(u user, password string) bool {
   return u.password == password
}

func checkPassword2(u *user, password string) bool {
   return u.password == password
}

//结构体是带类型的字段的集合

2.2.13 结构体方法

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"))
}
//注意比较和上个代码中user的位置

2.2.14 错误处理

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

func main() {
   u, err := findUser([]user{{"wang", "1024"}}, "wang")
   if err != nil {
      fmt.Println(err)
      return
   }
   fmt.Println(u.name)

   if u, err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
      fmt.Println(err)
      return
   } else {
      fmt.Println(u.name)
   }
}
//

2.2.15 字符串操作

package main

import (
   "fmt"
   "strings"
)

func main() {
   a := "hello"
   fmt.Println(strings.Contains(a, "ll")) //判断是否包含该字符串
   fmt.Println(strings.Count(a, "l"))     //字符串计数
   fmt.Println(strings.HasPrefix(a, "he"))
   fmt.Println(strings.HasSuffix(a, "llo"))
   fmt.Println(strings.Index(a, "ll"))                   //查找某个字符串的位置
   fmt.Println(strings.Join([]string{"he", "llo"}, "-")) //连接多个字符串
   fmt.Println(strings.Repeat(a, 2))                     //重复字符串
   fmt.Println(strings.Replace(a, "e", "E", -1))
   fmt.Println(strings.Split("a-b-c", "-"))
   fmt.Println(strings.ToLower(a))
   fmt.Println(strings.ToUpper(a))
   fmt.Println(len(a))
   b := "你好"
   fmt.Println(len(b)) 
}
//很多和java中字符串的方法类似，看名称也能猜出大概

2.2.16 字符串格式化

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
}

2.2.17 JSON 处理

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)
   fmt.Println(string(buf))

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

2.2.18 时间处理

package main

import (
   "fmt"
   "time"
)

func main() {
   now := time.Now()
   fmt.Println(now)
   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)
   fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute())
   fmt.Println(t.Format("2006-01-02 15:04:05"))
   diff := t2.Sub(t)     //两个时间点之间的时长
   fmt.Println(diff) 
   fmt.Println(diff.Minutes(), diff.Seconds())
   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)
   fmt.Println(now.Unix())  //时间戳
}

2.2.19 数字解析

package main

import (
   "fmt"
   "strconv" //数字和字符串之间的转换
)

func main() {
   f, _ := strconv.ParseFloat("1.234", 64)
   fmt.Println(f)

   n, _ := strconv.ParseInt("111", 10, 64)
   fmt.Println(n)

   n, _ = strconv.ParseInt("0x1000", 0, 64)
   fmt.Println(n)

   n2, _ := strconv.Atoi("123")
   fmt.Println(n2)

   n2, err := strconv.Atoi("AAA")
   fmt.Println(n2, err)
}

2.2.20 进程信息

package main

import (
   "fmt"
   "os"
   "os/exec"
)

func main() {
   fmt.Println(os.Args)
   fmt.Println(os.Getenv("PATH"))
   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))
}
//这个看着运行结果有点懵的感觉

三、实战

3.1 猜谜游戏

步骤：

生成随机数
读取用户输入
实现判断逻辑
实现游戏循环效果
最终代码

package main

import (
   "bufio"
   "fmt"
   "math/rand"
   "os"
   "strconv"
   "strings"
   "time"
)

func main() {
   maxNum := 100
   rand.Seed(time.Now().UnixNano())
   secretNumber := rand.Intn(maxNum)
   //fmt.Println("The secret number is ", secretNumber)

   fmt.Println("Please input your guess")
   reader := bufio.NewReader(os.Stdin)
   for {
      input, err := reader.ReadString('\n')
      if err != nil {
         fmt.Println("An error occured while reading input. Please try again", err)
         return
         continue
      }
      input = strings.TrimSuffix(input, "\r\n")

      guess, err := strconv.Atoi(input)
      if err != nil {
         fmt.Println("Invalid input. Please enter an integer value")
         return
         continue
      }
      fmt.Println("You guess is", guess)
      if guess > secretNumber {
         fmt.Println("Your guess is bigger than the secret number. Please try again")
      } else if guess < secretNumber {
         fmt.Println("Your guess is smaller than the secret number. Please try again")
      } else {
         fmt.Println("Correct, you Legend!")
         break
      }
   }
}

课后作业

package main

import (
   "fmt"
   "math/rand"
   "strconv"
   "time"
)

func main() {
   maxNum := 100
   rand.Seed(time.Now().UnixNano())
   secretNumber := rand.Intn(maxNum)
   var input string

   for {
      fmt.Println("Please input your guess: ")
      fmt.Scanf("%v", &input)
      fmt.Scanln() //注意！！使用Scanln处理换行符
      guess, err := strconv.Atoi(input)
      if err != nil {
         fmt.Println("Invalid input. Please enter an integer value")
         continue
      }
      fmt.Println("You guess is", guess)
      if guess > secretNumber {
         fmt.Println("Your guess is bigger than the secret number. Please try again")
      } else if guess < secretNumber {
         fmt.Println("Your guess is smaller than the secret number. Please try again")
      } else {
         fmt.Println("Correct, you Legend!")
         break
      }
   }
}
第19行注意需要对换行符的处理！！！

3.2 在线词典介绍

步骤：

抓包（此处我选择的是复制为cURL(bash)，复制后可放入Convert curl to Go (curlconverter.com)中获取代码，复制为cURL(cmd)则报错）
代码生成

package main

import (
   "bytes"
   "encoding/json"
   "fmt"
   "io"
   "log"
   "net/http"
)

type DictRequest struct {
   TransType string `json:"trans_type"`
   Source    string `json:"source"`
   UserID    string `json:"user_id"`
}

func main() {
   client := &http.Client{}
   request := DictRequest{TransType: "en2zh", Source: "good"}
   buf, err := json.Marshal(request)
   if err != nil {
      log.Fatal(err)
   }
   var data = bytes.NewReader(buf)
   req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
   if err != nil {
      log.Fatal(err)
   }
   req.Header.Set("authority", "api.interpreter.caiyunai.com")
   req.Header.Set("accept", "application/json, text/plain, */*")
   req.Header.Set("accept-language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6")
   req.Header.Set("app-name", "xy")
   req.Header.Set("content-type", "application/json;charset=UTF-8")
   req.Header.Set("device-id", "a61f198f47ce7849027a230cba06ece9")
   req.Header.Set("origin", "https://fanyi.caiyunapp.com")
   req.Header.Set("os-type", "web")
   req.Header.Set("os-version", "")
   req.Header.Set("referer", "https://fanyi.caiyunapp.com/")
   req.Header.Set("sec-ch-ua", `"Not/A)Brand";v="99", "Microsoft Edge";v="115", "Chromium";v="115"`)
   req.Header.Set("sec-ch-ua-mobile", "?0")
   req.Header.Set("sec-ch-ua-platform", `"Windows"`)
   req.Header.Set("sec-fetch-dest", "empty")
   req.Header.Set("sec-fetch-mode", "cors")
   req.Header.Set("sec-fetch-site", "cross-site")
   req.Header.Set("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.183")
   req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
   resp, err := client.Do(req)
   if err != nil {
      log.Fatal(err)
   }
   defer resp.Body.Close()
   bodyText, err := io.ReadAll(resp.Body)
   if err != nil {
      log.Fatal(err)
   }
   fmt.Printf("%s\n", bodyText)
}

生成代码解读
生成 request body
解析 reponse body
打印结果

（这部分真的是一言难尽，也不知道学会了什么，人都懵了）

总结：到后面人都是懵逼的，后面也不知道学的什么太晕了

GO语言快速上手——第一天学习笔记

一、Go简介

1. 1 什么是go语言

1.2 哪些公司在使用Go语言

1.3 字节跳动为什么全面拥抱Go语言

二、Go入门

2.1 开发环境

2.2 基础语法

2.2.1 Hello World

2.2.2 变量

2.2.3 if else

2.2.4 循环

2.2.5 switch

2.2.6 数组

2.2.7 切片

2.2.8 map

2.2.9 range

2.2.10 函数

2.2.11 指针

2.2.12 结构体

2.2.13 结构体方法

2.2.14 错误处理

2.2.15 字符串操作

2.2.16 字符串格式化

2.2.17 JSON 处理

2.2.18 时间处理

2.2.19 数字解析

2.2.20 进程信息

三、 实战

3.1 猜谜游戏

课后作业

3.2 在线词典介绍

三、实战