这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记

简介

入门（开发环境基础语法标准库）

实战（猜谜游戏命令行词典 SOCKS5代理）

01简介

1.1什么是go语言

高性能，高并发
语法简单，学习曲线平缓

package main

import "net/http"

/**
可以承载静态文件访问的 支持高并发的高性能的服务器
 */
func main() {
   //在标准的http包里面内建的路由 把/这个路由指向静态文件处理的实现
   http.Handle("/", http.FileServer(http.Dir(".")))

   //监听8080端口并且启动服务器
   http.ListenAndServe(":8080", nil)
}

丰富的标准库
完整的工具链
静态链接
快速编译
跨平台
垃圾回收

1.2哪些公司在使用Go语言

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

02入门

2.1开发环境

安装Golang 官网：go.dev/
配置集成开发环境 vscode/Goland
基于云的开发环境 gitpod.io/#github.com…

2.2基础语法

1.hello world

//这个文件属于main包的一部分 main包也就是程序的入口包
package main

//导入了标准库里面的fmt包，这个包主要是用来往屏幕输入输出字符串、格式化字符串
import "fmt"

func main() {
   //调用fmt.Println输出hello world
   fmt.Println("hello world")
}

2.变量

package main

import (
   "fmt"
   "math"
)

/**
go语言是一门强类型语言
常见变量类型：字符串 整型 浮点型 布尔型
*/
func main() {

   var a = "initial" //声明方式1 会自动推导变量的类型

   var b, c int = 1, 2 //如果有需要 可以显示地写出变量的类型

   var d = true

   var e float64

   f := float32(e) //声明方式2

   //字符串是内置类型 可以直接通过+拼接 能用=直接比较两个字符串
   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))
}

3.if else

package main

import "fmt"

func main() {

   //if后面没有括号（） 如果写括号的话 在保存的时候编译器会自动去掉
   //if 后面必须有大括号{} 不能直接把if里面的语句同一行
   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")
   }
}

4.循环

package main

import "fmt"

/**
只有唯一的一种for循环
*/
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
   }
}

5.switch

package main

import (
   "fmt"
   "time"
)

func main() {

   a := 2
   switch a { //switch后的变量不需要括号（）
   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 { //可以取代 if else
   case t.Hour() < 12:
      fmt.Println("It's before noon")
   default:
      fmt.Println("It's after noon")
   }
}

6.数组

package main

import "fmt"

/**
数组 长度固定
*/
func main() {

   var a [5]int //可以存放5个元素的数组A
   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)
}

7.切片

package main

import "fmt"

/**
切片 可以任意改变长度
原理 它存储了一个长度和容量，加一个指向数组的指针 在执行append的时候，如果容量不够的话，会扩容并且返回新的slice
*/
func main() {

   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

   s = append(s, "d") //追加元素 必须把append的结果赋值为原数组（因为可能扩容返回新的slice）
   s = append(s, "e", "f")
   fmt.Println(s) // [a b c d e f]

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

8.map

package main

import "fmt"

/**
map 哈希 字典
*/
func main() {
   m := make(map[string]int) //创建一个空map [key]value
   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

   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) //无序
}

9.range

package main

import "fmt"

/**
range 快速遍历
*/
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) //  a A; b B;
   }
   for k := range m {
      fmt.Println("key", k) // key a; key b
   }
}

10.函数

package main

import "fmt"

/**
函数 变量后置 支持多个返回值
在实际的业务逻辑代码里面几乎所有函数都返回两个值 第一个是真正的返回结果 第二个值是一个错误信息
*/
func add(a int, b int) int {
   return a + b
}

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

// 返回value 是否存在
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) // 3

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

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) // 5
   add2ptr(&n)    //为了类型匹配 调用的时候加一个&符号
   fmt.Println(n) // 7
}

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

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

func checkPassword2(u *user, password string) bool { //支持指针 实现对于结构体的修改  也可以在某些情况下避免一些大结构体的拷贝开销
   return u.password == password
}

13.结构体方法

package main

import "fmt"

/**
结构体方法 类似类成员函数
*/
type user struct {
   name     string
   password string
}

// 用户可以 像a.checkPassword("xx") 调用
// 把第一个参数 加上括号（） 写到函数名称前面
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
}

14.错误处理

package main

import (
   "errors"
   "fmt"
)

/**
错误处理 使用一个单独的返回值来传递错误信息
*/
type user struct {
   name     string
   password string
}

//返回值加一个err 就代表这个函数可能会返回错误
func findUser(users []user, name string) (v *user, err error) {
   for _, u := range users {
      if u.name == name {
         return &u, nil //没有错误 返回 原本结果 nil
      }
   }
   return nil, errors.New("not found") //出现错误 返回 nil error
}

func main() {
   u, err := findUser([]user{{"wang", "1024"}}, "wang")
   if err != nil {
      fmt.Println(err)
      return
   }
   //只有没有error的时候才能去取真正的返回值 否则可能出现空指针错误
   fmt.Println(u.name) // wang

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

15.字符串操作

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 中文可能一个中文对应多个
}

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 %v可以打印任意类型的变量
   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} %+v得到更加详细的结构
   fmt.Printf("p=%#v\n", p) // p=main.point{x:1, y:2} %#v进一步详细

   f := 3.141592653
   fmt.Println(f)          // 3.141592653
   fmt.Printf("%.2f\n", f) // 3.14 %.2f打印出保留两位小数的浮点数
}

17.JSON处理

package main

import (
   "encoding/json"
   "fmt"
)

/**
json操作
*/

//保证每个字段的第一个字母是大写 也就是公开字段
//那么这个结构体就能用JSON.marshaler去序列化 变成一个JSON的字符串
//序列化之后的字符串也能够用JSON.unmarshaler去反序列化到一个空的变量里面
//这样默认序列化出来的字符串的话，它的风格是大写字母开头，而不是下划线。
//我们可以在后面用json tag等语法来去修改输出JSON结果里面的字段名。
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) //序列化 成一个（byte？？）数组
   if err != nil {
      panic(err)
   }
   fmt.Println(buf)         // [123 34 78 97...] 16进制编码
   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"}}
}

18.时间处理

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 获取时间戳
}

19.数字解析

package main

import (
   "fmt"
   "strconv" //string convert
)

func main() {
   //解析一个字符串
   f, _ := strconv.ParseFloat("1.234", 64)
   fmt.Println(f) // 1.234

   //字符串 进制（0：自动推测）返回64精度的整数
   n, _ := strconv.ParseInt("111", 10, 64)
   fmt.Println(n) // 111

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

   //把一个十进制字符串转成数字
   //itoA 把数字转成字符串
   n2, _ := strconv.Atoi("123")
   fmt.Println(n2) // 123

   //输入不合法 返回error
   n2, err := strconv.Atoi("AAA")
   fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}

20.进程信息

package main

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

func main() {
   //os.Args 得到程序执行的时候的指定的命令行参数 so.getenv 读取环境变量
   // 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"))

   //exec.Command快速启动此（子？？）进程 并且获取其输入输出
   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
}

03实战

3.1猜谜游戏介绍

生成随机数

package main

import (
   "fmt"
   "math/rand"
)

/**
生成随机数
一直是同一个数字 ？？
*/
func main() {
   maxNum := 100
   secretNumber := rand.Intn(maxNum)
   fmt.Println("The secret number is ", secretNumber)
}

设置随机种子

package main

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

/**
设置随机种子
*/
func main() {
   maxNum := 100
   rand.Seed(time.Now().UnixNano())
   secretNumber := rand.Intn(maxNum)
   fmt.Println("The secret number is ", secretNumber)
}

读取用户输入

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)
   input, err := reader.ReadString('\n')
   if err != nil {
      fmt.Println("An error occured while reading input. Please try again", err)
      return
   }
   input = strings.TrimSuffix(input, "\n")

   guess, err := strconv.Atoi(input)
   if err != nil {
      fmt.Println("Invalid input. Please enter an integer value")
      return
   }
   fmt.Println("You guess is", guess)
}

实现判断逻辑

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)
   input, err := reader.ReadString('\n')
   if err != nil {
      fmt.Println("An error occured while reading input. Please try again", err)
      return
   }
   input = strings.TrimSuffix(input, "\n")

   guess, err := strconv.Atoi(input)
   if err != nil {
      fmt.Println("Invalid input. Please enter an integer value")
      return
   }
   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!")
   }
}

实现游戏循环

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)
         continue
      }
      input = strings.TrimSuffix(input, "\n")

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

3.2在线字典介绍

用Go语言来发送http请求，解析json，使用代码生成来提高开发效率

Go语言上手-基础语言｜青训营笔记

01简介

1.1什么是go语言

1.2哪些公司在使用Go语言

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

02入门

2.1开发环境

2.2基础语法

1.hello world

2.变量

3.if else

4.循环

5.switch

6.数组

7.切片

8.map

9.range

10.函数

11.指针

12.结构体

13.结构体方法

14.错误处理

15.字符串操作

16.字符串格式化

17.JSON处理

18.时间处理

19.数字解析

20.进程信息

03实战

3.1猜谜游戏介绍

3.2在线字典介绍

3.3SOCKS5代理介绍

Go语言上手-基础语言 ｜ 青训营笔记

01简介

1.1什么是go语言

1.2哪些公司在使用Go语言

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

02入门

2.1开发环境

2.2基础语法

1.hello world

2.变量

3.if else

4.循环

5.switch

6.数组

7.切片

8.map

9.range

10.函数

11.指针

12.结构体

13.结构体方法

14.错误处理

15.字符串操作

16.字符串格式化

17.JSON处理

18.时间处理

19.数字解析

20.进程信息

03实战

3.1猜谜游戏介绍

3.2在线字典介绍

3.3SOCKS5代理介绍

Go语言上手-基础语言｜青训营笔记