Go语言基础与实战 ｜ 青训营笔记

程序员王不错
40 阅读4分钟

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

今天主要为大家总结了Go语言的基础语法，并设计了三个项目来练手，巩固下今天的学习内容。

1、Go语言基础

1.1 什么是Go语言

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

1.2 安装Golang

1、安装go

go.dev/

studygolang.com/dl

goproxy.cn/

2、配置集成开发环境

常见Go的IDE为Goland。

3、基于云的开发环境

gitpod.io/#github.com…

1.3 变量

变量的声明有以下三种方式：

var a = “hello world”

var b int = 1

f := “hello”

1.4 if else

Go条件判断的写法：

if xxx {

       } else if xxx {       

} else {       

}

1.5 循环

在go里面没有while循环，do while循环，只有唯一的一种for循环。

for i := 0; i < n; i++ {       

}

在循环里，可以用break或者continue来跳出或者继续循环。

1.6 switch

switch分支结构：

switch xxx {

case A:

case B:

default:

}

1.7 数组和切片

1、数组是一个具有编号且长度固定的元素序列。

声明数组：var 变量名 [size] 变量类型

数组初始化：

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果数组长度不确定，可以使用 ... 代替数组的长度，编译器会根据元素个数自行推断数组的长度：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

 

2、切片

切片可以任意更改长度，可以通过make来创建一个切片，可以使用append来追加元素。

slice的原理是它存储了一个长度和一个容量，加一个指向数组的指针，在执行追加操作时容量不够的话会扩容并返回给新的slice，s=append(s, “d”)，所以追加后需要重新赋值回去。

1.8 range

可以用range来遍历切片或数组

for i, num := range nums {

       // i为map的key或者数组下标

       // num为map的值或者数组值

}

1.9 函数

func 函数名(变量名 类型, …) 返回值类型 {

}

1.10 结构体

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

可以为结构体定义一些方法，类似于其他语言中的类成员函数。

在实现结构体的方法的时候有两种写法，一种是带指针，一种是不带指针。带指针的话，你就可以对这个结构体去做修改，不带指针的话，实际操作的是一个拷贝，无法对结构体进行修改。

1.11 错误处理

在go中，错误处理就是使用一个单独的返回值来传递错误信息。

1.12 JSON处理

json.Marshal：结构体序列化为json

json.Unmarshal：json反序列化为结构体

1.13 时间处理

time.Now()：当前时间

1.14 数字解析

1、string转Int

strconv.Atoi(string)

2、int 转 string

strconv.Itoa(int)

2、实战

2.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)
			continue
		}
		input = strings.TrimSuffix(input, "\r\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.")
		} else if guess < secretNumber {
			fmt.Println("Your guess is smaller than the secret number.")
		} else {
			fmt.Println("Correct, you legend!")
			break
		}
	}
	
}

 

2.2 在线词典

命令行词典，调用时查询一个单词，输出单词的翻译。这里会调用第三方API的翻译，并打印出来。这个案例会帮助我们学习到发送http请求以及json处理。

1、选择彩云小译作为翻译第三方。

第三方API：彩云小译：fanyi.caiyunapp.com/

进入到第三方网站，随意翻译一个单词，抓一个dict包，注意这个包的method为POST。

image.png

右键dict这个位置，选择copy->copy as curl(bash)

image.png

粘贴到下面这个位置，会将curl命令转换为Go语言。

image.png

因为响应结果为json格式，需要转换成struct结构体。

用到这个工具：oktools.net/json2go

完整代码如下：

package main

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

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

type DictResponse struct {
	Rc int `json:"rc"`
	Wiki struct {
		KnownInLaguages int `json:"known_in_laguages"`
		Description struct {
			Source string `json:"source"`
			Target interface{} `json:"target"`
		} `json:"description"`
		ID string `json:"id"`
		Item struct {
			Source string `json:"source"`
			Target string `json:"target"`
		} `json:"item"`
		ImageURL string `json:"image_url"`
		IsSubject string `json:"is_subject"`
		Sitelink string `json:"sitelink"`
	} `json:"wiki"`
	Dictionary struct {
		Prons struct {
			EnUs string `json:"en-us"`
			En string `json:"en"`
		} `json:"prons"`
		Explanations []string `json:"explanations"`
		Synonym []string `json:"synonym"`
		Antonym []string `json:"antonym"`
		WqxExample [][]string `json:"wqx_example"`
		Entry string `json:"entry"`
		Type string `json:"type"`
		Related []interface{} `json:"related"`
		Source string `json:"source"`
	} `json:"dictionary"`
}

func main() {
	if len(os.Args) != 2 {
		fmt.Fprintf(os.Stderr, `usage: simpleDict WORD example: simpleDict hello`)
		os.Exit(1)
	}
	word := os.Args[1]
	// 创建httpClient，可以指定参数，比如超时控制
	client := &http.Client{}
	// 将字符串转换成一个流，只需要占用很少内存
	//var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
	request := DictRequest{TransType: "en2zh", Source: word}
	buf, err := json.Marshal(request)
	if err != nil {
		log.Fatal(err)
	}
	// ?
	var data = bytes.NewBuffer(buf)
	// 建立http请求：method，Url,data（是一个流）
	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,en;q=0.9,zh-CN;q=0.8,zh-HK;q=0.7")
	req.Header.Set("app-name", "xy")
	req.Header.Set("content-type", "application/json;charset=UTF-8")
	req.Header.Set("device-id", "")
	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="8", "Chromium";v="108", "Google Chrome";v="108"`)
	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/108.0.0.0 Safari/537.36")
	req.Header.Set("x-authorization", "token:qgemv4jr1y38jyq6vhvi")
	// 真正发起请求
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	// 返回的body也是一个流，防止缓存泄露，第一时间要关闭
	defer resp.Body.Close()
	// 转成Byte数组
	bodyText, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	// 防御式编程
	if resp.StatusCode != 200 {
		log.Fatal("bad statusCode:", resp.StatusCode, "body", string(bodyText))
	}
	//fmt.Printf("%s\n", bodyText)
	// 返回的结果只需要翻译和音标
	var dictResponse DictResponse
	err = json.Unmarshal(bodyText, &dictResponse)
	if err != nil {
		log.Fatal(err)
	}
	//fmt.Printf("%#v\n", dictResponse)
	fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
	for _, item := range dictResponse.Dictionary.Explanations {
		fmt.Println(item)
	}
}

2.3 SOCKS5代理服务器

image.png

package main

import (
	"bufio"
	"context"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"log"
	"net"
)

const socks5Ver = 0x05
const cmdBind = 0x01
const atypIPV4 = 0x01
const atypeHOST = 0x03
const atypeIPV6 = 0x04

// Server
func main() {
	// 监听请求
	server, err := net.Listen("tcp", "127.0.0.1:1080")
	if err != nil {
		panic(err)
	}
	for {
		// 接收一个请求
		client, err := server.Accept()
		if err != nil {
			log.Printf("Accept failed %v", err)
			continue
		}
		// 启动一个协程处理连接
		go process(client)
	}
}

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	err := auth(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
		return
	}
	log.Println("auth success")
	err = connect(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed: %v", conn.RemoteAddr(), err)
		return
	}
}

// 认证阶段
func auth(reader *bufio.Reader, conn net.Conn) (err error) {
	ver, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read ver failed:%w", err)
	}
	if ver != socks5Ver {
		return fmt.Errorf("%v", ver)
	}
	methodSize, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read methodSize failed:%w", err)
	}
	method := make([]byte, methodSize)
	_, err = io.ReadFull(reader, method)
	if err != nil {
		return fmt.Errorf("read method failed:%w", err)
	}
	log.Println("ver", ver, "method", method)
	_, err = conn.Write([]byte{socks5Ver, 0x00})
	if err != nil {
		return fmt.Errorf("write failed: %w", err)
	}
	return nil
}

func connect(reader *bufio.Reader, conn net.Conn) (err error) {
	buf := make([]byte, 4)
	_, err = io.ReadFull(reader, buf)
	if err != nil {
		return fmt.Errorf("read header failed:%w", err)
	}
	ver, cmd, atyp := buf[0], buf[1], buf[3]
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver: %v", ver)
	}	
	if cmd != cmdBind {
		return fmt.Errorf("not supported cmd: %v", ver)
	}
	addr := ""
	switch atyp {
	case atypIPV4:
		_, err = io.ReadFull(reader, buf)
		if err != nil {
			return fmt.Errorf("read atyp failed:%w", err)
		}
		addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
	case atypeIPV6:
		return errors.New("IPV6: no supported yet")
	case atypeHOST:
		hostSize, err := reader.ReadByte()
		if err != nil {
			return fmt.Errorf("read hostSize failed: %w", err)
		}
		host := make([]byte, hostSize)
		_, err = io.ReadFull(reader, host)
		if err != nil {
			return fmt.Errorf("read hostSize failed:%w", err)
		}
		addr = string(host)
	default:
		return errors.New("invalid atyp")
	}
	_, err = io.ReadFull(reader, buf[:2])
	if err != nil {
		return fmt.Errorf("read port failed:%w", err)
	}
	port := binary.BigEndian.Uint16(buf[:2])
	dest, err := net.Dial("tcp", fmt.Sprintf("%v:%v", addr, port))
	if err != nil {
		return fmt.Errorf("dial dst failed:%w", err)
	}
	defer dest.Close()
	log.Println("dial", addr, port)
	_, err = conn.Write([]byte{0x05,0x00,0x00,0x01,0,0,0,0,0,0})
	if err != nil {
		return fmt.Errorf("write failed: %w", err)
	}
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	go func() {
		_, _ = io.Copy(dest, reader)
		cancel()
	}()
	go func() {
		_, _ = io.Copy(conn, dest)
		cancel()
	}()
	<-ctx.Done()
	return nil
}
avatar
文章
阅读
粉丝