Go语言实战案例｜ 青训营

用户7241001031549
54 阅读4分钟

Go语言实战案例

猜谜游戏

生成随机数

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

注：

func (*Rand) Intn

func (r *Rand) Intn(n int) int

返回一个取值范围在[0,n)的伪随机int值，如果n<=0会panic。

读取用户输入

func main() {  
maxNum := 1002  
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 occurred while reading input. Please try again", err)  
return  
}  
input = strings.Trim(input, "\r\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)  
}

注：

func NewReader 

func NewReader(rd io.Reader) *Reader

NewReader创建一个具有默认大小缓冲、从r读取的*Reader。

func (*Reader) ReadString

func (b *Reader) ReadString(delim byte) (line string, err error)

ReadString读取直到第一次遇到delim字节，返回一个包含已读取的数据和delim字节的字符串。如果ReadString方法在读取到delim之前遇到了错误，它会返回在错误之前读取的数据以及该错误（一般是io.EOF）。当且仅当ReadString方法返回的切片不以delim结尾时，会返回一个非nil的错误。

func Trim

func Trim(s string, cutset string) string

返回将s前后端所有cutset包含的utf-8码值都去掉的字符串。 ex：

fmt.Printf("[%q]", strings.Trim(" !!! Achtung! Achtung! !!! ", "! "))

Output:

["Achtung! Achtung"]

Atoi

Atoi（字符串到 int）和 Itoa（int 到字符串） ex:

i, err := strconv.Atoi("-42")
s := strconv.Itoa(-42)

实现逻辑判断

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

实现游戏循环

func main() {  
maxNum := 100  
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 //return改为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  
}  
  
}  
}

在线字典

生成代码解读

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("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", "d9fd5819531f9b4ac8a627635c68d0c9")  
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.188")  
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)  
}

注：

要管理HTTP客户端的头域、重定向策略和其他设置，创建一个Client：

client := &http.Client{
	CheckRedirect: redirectPolicyFunc,
}
resp, err := client.Get("http://example.com")
// ...
req, err := http.NewRequest("GET", "http://example.com", nil)
// ...
req.Header.Add("If-None-Match", `W/"wyzzy"`)
resp, err := client.Do(req)
// ...

func NewRequest

func NewRequest(method, urlStr string, body io.Reader) (*Request, error)

NewRequest使用指定的方法、网址和可选的主题创建并返回一个新的*Request。

如果body参数实现了io.Closer接口，Request返回值的Body 字段会被设置为body，并会被Client类型的Do、Post和PostFOrm方法以及Transport.RoundTrip方法关闭。

client.Do(req)

这行代码发送了一个HTTP请求，并返回一个响应对象和一个错误对象。client是一个预先定义好的HTTP客户端对象，req是一个表示请求的对象。

defer resp.Body.Close()

这行代码使用延迟关闭的方式关闭响应体，确保在函数返回之前资源得到释放

完善代码

package main  
  
import (  
"bufio"  
"bytes"  
"encoding/json"  
"fmt"  
"io"  
"log"  
"net/http"  
"os"  
"strings"  
)  
  
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 {  
} `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("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", "d9fd5819531f9b4ac8a627635c68d0c9")  
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.188")  
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)  
}  
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() {  
  
fmt.Println("请输入要查询的内容:")  
reader := bufio.NewReader(os.Stdin)  
word, _ := reader.ReadString('\n')  
word = strings.Trim(word, "\r\n")  
  
query(word)  
  
}

1、首先定义了两个结构体类型：DictRequest、DictResponse,用于表示字典请求和响应的数据结构。

2、query函数是主要的执行逻辑，它接受一个单词作为参数，并返回该单词在英文和中文下的翻译结果。

3、在query函数中，首先创建了一个HTTP客户端对象client,用于发送HTTP请求。

4、然后构建了一个DictRequest对象request,其中包含了一些必要的请求参数，如trans_type(翻译类型)、source(源语言)和user_id(用户ID)。

5、接下来将request对象转换为JSON格式的字节数组，并通过bytes.NewReader创建一个可读的字节流对象data,用于后续的HTTP请求数据传输。

6、使用http.NewRequest函数创建了一个HTTP POST请求对象req,指定了请求的URL、请求头信息和请求体数据。

7、最后通过client.Do方法发送HTTP请求，并获取到服务器的响应结果。

8、将响应结果读取到一个字符串变量bodyText中，然后使用json.Unmarshal函数将JSON格式的响应数据解析为一个DictResponse对象。

最后打印出查询单词的英文和中文翻译结果，以及相关的解释信息。

avatar
文章
阅读
粉丝