Go语言实战：猜谜游戏、在线词典｜青训营

ZQDesigned
268 阅读9分钟

在前面的几回中，我们已经学习了Go语言的一些基础。那么我们应该如何运用Go语言来实现我们想要的功能呢？接下来，我们将运用我们前面所学的知识，通过几个实例来深入使用Go语言。

前言：如何运行写好的Go文件？

当使用Go语言开发程序时，我们可以使用go run和go build指令来编译和运行Go代码。

go run指令

  • go run指令用于编译并直接运行Go源代码文件。
  • 使用go run指令时，不会生成可执行文件，而是直接在临时目录中编译并运行代码。
  • 以下是使用go run指令运行Go源代码文件的示例： 
    go run main.go
  • go run指令会自动检测源代码文件的变化，并重新编译运行最新的代码。

go build指令

  • go build指令用于编译Go源代码文件并生成可执行文件。
  • 使用go build指令时，会将Go源代码编译为与操作系统相关的可执行文件（例如，Windows系统上的.exe文件）。
  • 以下是使用go build指令编译Go源代码文件的示例： 
    go build main.go
  • 编译成功后，会在当前目录下生成与Go源代码文件同名的可执行文件（如果指定了输出文件名，将生成指定的文件名）。
  • 可以通过在命令行中运行生成的可执行文件来执行程序。

go build指令的进阶用法介绍

当你想为非本机的系统和ABI打包可执行文件时，以下内容将会对你有所帮助。

go build指令的语法

go build [build flags] [packages]
常用的build flags
  • -o: 指定生成的可执行文件的输出路径和文件名。例如，go build -o myapp将生成名为myapp的可执行文件。
  • -ldflags: 设置链接时的标志。可以使用该标志传递自定义的链接标志，如版本信息、构建时间等。例如，go build -ldflags "-X main.version=1.0.0"将在可执行文件中设置main.version变量为1.0.0。
  • -a: 强制重新编译所有依赖的包，而不仅仅是更新的包。
  • -v: 显示编译过程中的详细信息，包括编译的包和文件。
示例用法

  1. 编译当前目录下的所有Go源代码文件，并生成默认的可执行文件：

    go build

    编译成功后，将在当前目录下生成与主包同名的可执行文件。

  2. 指定输出路径和文件名来生成可执行文件：

    go build -o myapp

    编译成功后，将生成名为myapp的可执行文件。

  3. 设置链接标志来传递自定义信息：

    go build -ldflags "-X main.version=1.0.0 -X main.buildTime=$(date -u '+%Y-%m-%d %H:%M:%S')"

    在可执行文件中设置main.version变量为1.0.0，并设置main.buildTime变量为当前的UTC时间。

  4. 强制重新编译所有依赖的包：

    go build -a

    编译过程中将重新编译所有依赖的包，而不仅仅是更新的包。

  5. 显示编译过程中的详细信息：

    go build -v

    在编译过程中显示详细的信息，包括编译的包和文件。

6.指定打包文件的目标平台和ABI：

Go语言提供了交叉编译的功能，允许在一个平台上编译生成在其他平台上运行的可执行文件。以下是使用方法：

  1. 指定目标平台和系统架构：

    • 使用GOOS和GOARCH环境变量来指定目标平台和系统架构。
    • GOOS用于指定目标操作系统，可以是以下值之一：darwin（Mac OS X）、linux、windows、freebsd等。
    • GOARCH用于指定目标系统架构，可以是以下值之一：amd64、386、arm、arm64等。
    • 例如，要在Linux系统上编译生成Windows平台上运行的可执行文件，可以执行以下命令： 
      GOOS=windows GOARCH=amd64 go build
    • 编译成功后，将生成适用于Windows平台的可执行文件。

  2. 完整示例：

    • 下面是一个完整的示例，展示了如何使用go build指令在不同平台和系统架构上进行交叉编译： 
      # 编译生成适用于Linux的可执行文件
GOOS=linux GOARCH=amd64 go build -o myapp-linux

# 编译生成适用于Windows的可执行文件
GOOS=windows GOARCH=amd64 go build -o myapp-windows.exe

# 编译生成适用于Mac OS X的可执行文件
GOOS=darwin GOARCH=amd64 go build -o myapp-macos
    • 以上命令分别在Linux、Windows和Mac OS X平台上编译生成不同的可执行文件。

实例一：猜谜游戏

内容介绍

在这个游戏里面，程序首先会生成一个介于 1 到 100 之间的随机整数，然后提示玩家进行猜测。玩家每次输入一个数字，程序会告诉玩家这个猜测的值是高于还是低于那个秘密的随机数，并且让玩家再次猜测。如果猜对了，就告诉玩家胜利并且退出程序。

一些关键点

如何生成随机数？

在Go语言中，生成随机数需要用到math/rand软件包。通过如下方式，我们可以完成对随机数的生成。

maxNum := 100
rand.Seed(time.Now().UnixNano())
secretNumber := rand.Intn(maxNum)

让我们来分析一下以上代码：

  • 第一行，我们定义了maxNum变量，用来指定生成的随机数的上界。
  • 第二行，至关重要的一行：在这一行中，我们用系统时间戳来初始化随机数的种子。注意，这是一个必需操作，如果没有这行代码，将会出现每次运行产生的随机数是相同的数字的情况。
  • 第三行，我们通过调用Intn函数，生成了一个随机数并存储在secretNumber变量中。

如何接收用户的输入？

每个程序执行的时候都会打开几个文件，stdin stdout stderr等，stdin 文件（也就是输入流）可以用 os.Stdin 来得到。

但是，直接操作这个文件很不方便，我们会用 bufio.NewReader 把一个文件转换成一个 reader 变量。 reader 会有很多用来操作流的操作，我们可以用它的 ReadString 方法来读取一行。 如果读取失败，则打印错误并退出。注意，ReadString 返回的结果包含结尾的换行符，我们应当先把它去掉，再转换成数字。如果转换失败，则同样打印错误，退出。

以下是相关的实现代码。

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.Trim(input, "\r\n") //去掉换行符 CR-LF

guess, err := strconv.Atoi(input) //尝试将输入转换为数字
if err != nil {
	fmt.Println("Invalid input. Please enter an integer value")
	return
}

最终成品

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("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.Trim(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. 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
		}
	}
}

由于我们需要实现在用户成功猜出正确答案后程序退出，因此我们可以用先前介绍的for死循环来实现。注意，由于我们是在循环中，所以先前讲述的遇到错误后return需要替换为continue，避免程序意外退出。

实例二：在线词典

内容介绍

通过使用第三方API获取数据，达到读取用户输入的数据并返回其音标、汉译的目的。

示例API来源

彩云翻译

一些关键点

如何从网页中获取API地址？

  1. 首先，我们需要打开浏览器的开发者工具。你可以通过F12或右键网页页面后点击检查选项来打开它。
  2. 在开发者工具中，我们找到网络标签页并打开它。
  3. 以本文示例而言，我们应当在原文文本框输入一个已知存在的单词，并在点击翻译后注意观察网络标签页下记录的网络请求。
  4. 通过筛选网络请求记录，我们很容易找到我们需要的调用API获取翻译结果的请求。其中，General下的Request URL便是我们需要的API地址。

如何将这个请求转换为Go语言的形式？

我们不难看出，这个请求有非常多的请求头，想直接手动转换该请求到Go语言中显然是低效且不现实的。这时，我们可以合理利用开发者工具的功能，来方便快捷的进行代码转换。

  1. 我们在请求列表中右键请求，点击Copy as cURL，此时我们将获得一串很长的命令。打开终端/命令提示符并粘贴命令，执行，如果不出意外的话，我们将获得一串很长的JSON数据。
  2. 打开cURL Converter，将刚刚拿到的命令粘贴到上面的输入框中，即可在下面查看转换后的Go语言代码。注意，由于部分请求头较为复杂，转换后的内容可能存在问题，直接删除报错的行即可。

分析生成的代码

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"strings"
)

func main() {
	client := &http.Client{}
	var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
	req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Connection", "keep-alive")
	req.Header.Set("DNT", "1")
	req.Header.Set("os-version", "")
	req.Header.Set("sec-ch-ua-mobile", "?0")
	req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36")
	req.Header.Set("app-name", "xy")
	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
	req.Header.Set("Accept", "application/json, text/plain, */*")
	req.Header.Set("device-id", "")
	req.Header.Set("os-type", "web")
	req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
	req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
	req.Header.Set("Sec-Fetch-Site", "cross-site")
	req.Header.Set("Sec-Fetch-Mode", "cors")
	req.Header.Set("Sec-Fetch-Dest", "empty")
	req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
	req.Header.Set("Cookie", "_ym_uid=16456948721020430059; _ym_d=1645694872")
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	bodyText, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s\n", bodyText)
}
  1. 第12行我们创建了一个 HTTP Client，创建的时候可以指定很多参数，包括请求的超时时间，是否使用Cookie 等。
  2. 在第14行，我们构造了一个 HTTP 请求，这是一个POST请求，然后会用到http.NewRequest，第一个参数是 HTTP请求方法POST， 第二个参数是URL， 最后一个参数是RequestBody。由于RequestBody可能很大，为了支持流式发送，它是一个只读流。我们用了strings.NewReader来把字符串转换成一个流，这样我们就成功构造了一个 HTTP Request。
  3. 18～35行，我们对这个 HTTP Request设置了一些Request Header。 接下来我们把我们调用client.Do，就能得到Response。

Response有它的 HTTP 状态码， Response Header和Body。 Body同样是一个流，在golang里面，为了避免资源泄露，我们需要加一个 defer 来手动关闭这个流，这个 defer 会在当前函数运行结束之后去执行。接下来我们使用ioutil.ReadAll来读取这个流，就能得到整个Body。

生成根据参数变化的RequestBody

此时我们需要使用到json序列化和反序列化软件包，并编写对应的结构体。

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"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)
    ...
}

在示例代码中，我们可以注意到结构体多了一样东西json:"trans_type"，这个标签用于指定JSON序列化/反序列化时对应的名称。通过这种方法，我们便可以根据传入的参数动态生成RequestBody。

解析ResponseBody

前面我们提到了，如果请求正确的话，我们应该可以拿到一个很长的JSON数据。对于如此庞大且没有被格式化的JSON数据，人工分析显然是不可能的，这时候就要借助另一个工具：OKTools的 JSON转Go Struct功能。通过该方法，我们可以很便捷的拿到反序列化所需的结构体。

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

取得该结构体后，我们便可以以如下方式对请求返回的JSON数据进行反序列化：

var dictResponse DictResponse
err = json.Unmarshal(bodyText, &dictResponse)
if err != nil {
    log.Fatal(err)
}

打印结果

该部分即简单的访问变量内容并进行打印，不再赘述。

最终成品

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 query(word string) {
	client := &http.Client{}
	request := DictRequest{TransType: "en2zh", Source: word}
	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("Connection", "keep-alive")
	req.Header.Set("DNT", "1")
	req.Header.Set("os-version", "")
	req.Header.Set("sec-ch-ua-mobile", "?0")
	req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36")
	req.Header.Set("app-name", "xy")
	req.Header.Set("Content-Type", "application/json;charset=UTF-8")
	req.Header.Set("Accept", "application/json, text/plain, */*")
	req.Header.Set("device-id", "")
	req.Header.Set("os-type", "web")
	req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
	req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
	req.Header.Set("Sec-Fetch-Site", "cross-site")
	req.Header.Set("Sec-Fetch-Mode", "cors")
	req.Header.Set("Sec-Fetch-Dest", "empty")
	req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
	req.Header.Set("Cookie", "_ym_uid=16456948721020430059; _ym_d=1645694872")
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	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))
	}
	var dictResponse DictResponse
	err = json.Unmarshal(bodyText, &dictResponse)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
	for _, item := range dictResponse.Dictionary.Explanations {
		fmt.Println(item)
	}
}

func main() {
    if len(os.Args) != 2 {
        fmt.Fprintf(os.Stderr, `usage: simpleDict WORD example: simpleDict hello`)
        os.Exit(1)
    }
    word := os.Args[1]
    query(word)
}

高能预警

下一个实战案例为sock5代理实现，有一定难度，请做好准备哦！

avatar
文章
阅读
粉丝