GO语言工程实践课后作业：实现思路、代码以及路径记录|青训营

用户2721155462586
88 阅读5分钟

猜数字

这部分的内容比较简单，理解代码，熟悉一下go的语法即可

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

这段代码是一个简单的猜数字游戏，程序会生成一个随机的秘密数字，然后让用户猜这个数字是多少，直到用户猜中为止。

  1. maxNum := 100

    • 定义一个变量 maxNum，表示随机生成的秘密数字的上限，这里设置为100。

  2. rand.Seed(time.Now().UnixNano())

    • 使用当前时间的纳秒数作为随机数种子，确保每次运行程序时生成的随机数都是不同的。

  3. secretNumber := rand.Intn(maxNum)

    • 使用 rand.Intn(maxNum) 生成一个0到maxNum-1之间的随机整数，并将其赋值给 secretNumber 变量，作为秘密数字。

  4. fmt.Println("Please input your guess")

    • 输出提示消息，提示用户输入猜测的数字。

  5. reader := bufio.NewReader(os.Stdin)

    • 创建一个用于读取用户输入的 bufio.Reader 对象。

  6. 进入 for 循环：

    • input, err := reader.ReadString('\n')
      • 使用 reader.ReadString('\n') 从标准输入读取一行用户输入，并将其赋值给 input 变量。如果读取过程中出现错误，会被记录在 err 变量中。
    • input = strings.Trim(input, "\r\n")
      • 去除输入字符串中的回车符和换行符，确保输入不含额外的空白字符。
    • guess, err := strconv.Atoi(input)
      • 将输入的字符串转换成整数，并将其赋值给 guess 变量。如果转换过程中出现错误，会被记录在 err 变量中。
    • fmt.Println("You guess is", guess)
      • 输出用户猜测的数字。
    • 进行猜测结果判断：
      • 如果 guess 大于 secretNumber，输出提示信息 "Your guess is bigger than the secret number. Please try again"。
      • 如果 guess 小于 secretNumber，输出提示信息 "Your guess is smaller than the secret number. Please try again"。
      • 如果 guess 等于 secretNumber，输出 "Correct, you Legend!"，并结束 for 循环，游戏结束。

    如果用户的猜测不正确，程序会继续循环等待用户输入，直到猜中秘密数字为止。

小结

这段代码实现了一个简单的猜数字游戏，程序生成一个随机的秘密数字，用户通过输入猜测的数字，根据提示不断猜测直到猜中为止。

在线词典

![[Pasted image 20230728104249.png]] 右键dict ![[Pasted image 20230728104338.png]] 复制为cURL（bash） Convert curl commands to Go (curlconverter.com) json形式的代码

复制转换完的代码，CTRL+s保存，编译运行 ![[Pasted image 20230728112829.png]]

将json转换为go语言，生成结构体，解析 API 响应 JSON转Golang Struct - 在线工具 - OKTools

最终生成代码如下：

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

  1. 首先，代码定义了两个结构体 DictRequest 和 DictResponse 来处理请求和响应的数据格式。

  2. 然后，定义了一个名为 query 的函数，用于发送请求并解析响应，然后输出查询结果。

  3. 在 main 函数中，首先检查命令行参数的数量，确保用户输入了一个要查询的单词。

  4. 获取用户输入的单词，并调用 query 函数进行查询。

  5. query 函数的主要流程如下：

    • 创建一个 http.Client 客户端用于发送 HTTP 请求。
    • 使用 json.Marshal 将查询请求结构体 DictRequest 编码为 JSON 格式的字节数据。
    • 创建一个 http.NewRequest 对象，设置请求方法为 POST，请求地址为 https://api.interpreter.caiyunai.com/v1/dict，并将 JSON 数据放入请求体中。
    • 设置请求头部信息，包括 User-Agent，Content-Type，和其他自定义的头部。
    • 发送 HTTP 请求并获得响应 resp。
    • 解析响应的 JSON 数据到 dictResponse 变量中，该变量是结构体 DictResponse 的实例。
    • 输出查询结果，包括单词的英式和美式发音（UK 和 US）以及单词的中文释义（来自 DictResponse.Dictionary.Explanations 字段）。
小结

这段代码通过调用 https://api.interpreter.caiyunai.com/v1/dict 接口，将输入的英文单词翻译成中文，并输出对应的释义。可以通过命令行输入一个英文单词，然后得到该单词的中文释义和发音。

avatar
文章
阅读
粉丝