ch4/ch4-06

[giscus[bot]]

ch4/ch4-06

中文版

https://golang-china.github.io/gopl-zh/ch4/ch4-06.html

[xianren68]

4.14

// 网址
const Base_url = "https://api.github.com/search/issues"

// 用户
type User struct {
	// 用户名
	Login   string `json:login`
	HTMLURL string `json:html_url`
}

type Issue struct {
	Number  int
	HTMLURL string `json:"html_url"`
	Title   string
	State   string
	User    *User
}

type IssuesSearchResult struct {
	TotalCount int `json:"total_count"`
	Items      []*Issue
}

// 模板
var temp = `
<h1>{{.TotalCount}} issues</h1>
<table>
<tr style='text-align: left'>
  <th>#</th>
  <th>State</th>
  <th>User</th>
  <th>Title</th>
</tr>
{{range .Items}}
<tr>
  <td><a href='{{.HTMLURL}}'>{{.Number}}</a></td>
  <td>{{.State}}</td>
  <td><a href='{{.User.HTMLURL}}'>{{.User.Login}}</a></td>
  <td><a href='{{.HTMLURL}}'>{{.Title}}</a></td>
</tr>
{{end}}
</table>
`
// web服务
func WebServer() {
	http.HandleFunc("/", Handle)
	// 监听端口
	http.ListenAndServe("127.0.0.1:5000", nil)
}
func Handle(w http.ResponseWriter, r *http.Request) {
	// 解析模板
	var report = template.New("report")
	report, err := report.Parse(temp)
	// 结构体
	var issue = &IssuesSearchResult{}
	if err != nil {
		fmt.Fprintln(w, err)
	}
	// 获取参数
	q := r.URL.Query().Get("key")
	if q == "" {
		fmt.Fprintln(w, "请输入要查询的内容")
		return
	}
	resp, err := http.Get(Base_url + "?q=" + q)
	if err != nil {
		resp.Body.Close()
		fmt.Fprintln(w, err)
		return
	}
	if resp.StatusCode != http.StatusOK {
		resp.Body.Close()
		fmt.Fprintln(w, resp.StatusCode)
		return
	}
	if err = json.NewDecoder(resp.Body).Decode(issue); err != nil {
		fmt.Fprintln(w, err)
		return
	}
	resp.Body.Close()
	report.Execute(w, issue)
}

[Super1Windcloud]

这可比 jS麻烦的不是一点半点啊

[hongjiala]

package github

import (
"encoding/json"
"fmt"
"html/template"
"net/http"
"strings"
)

// GitHub 搜索 Issues 的 URL
const Base_url = "https://api.github.com/search/issues"

// 定义用户信息
type User struct {
Login string json:"login"
HTMLURL string json:"html_url"
}

// 定义 Issue 信息
type Issue struct {
Number int json:"number"
HTMLURL string json:"html_url"
Title string json:"title"
State string json:"state"
User *User json:"user"
}

// GitHub 搜索结果结构体
type IssuesSearchResult struct {
TotalCount int json:"total_count"
Items []*Issue json:"items"
}

// 模板字符串
// 在模板中，我们加入了一个简单的搜索表单，用户可以输入搜索关键字
var temp = `

<title>GitHub Issues 搜索</title> <style> table { border-collapse: collapse; width: 100%; } th, td { border: 1px solid #ddd; padding: 8px; } th { background-color: #f2f2f2; } </style>

GitHub Issues 搜索

{{if .Result}}

共找到 {{.Result.TotalCount}} 个 Issues

{{range .Result.Items}} {{end}}

#	状态	用户	标题
{{.Number}}	{{.State}}	{{.User.Login}}	{{.Title}}

{{end}} `

// PageData 用于传递给模板的数据
type PageData struct {
SearchKey string
Result *IssuesSearchResult
}

// WebServer 启动 HTTP 服务器
func WebServer() {
http.HandleFunc("/", Handle)
fmt.Println("服务器启动，访问地址：http://127.0.0.1:5000/")
http.ListenAndServe("127.0.0.1:5000", nil)
}

// Handle 处理 HTTP 请求
func Handle(w http.ResponseWriter, r *http.Request) {
// 解析模板
tmpl, err := template.New("report").Parse(temp)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}

// 获取 URL 参数 key
key := strings.TrimSpace(r.URL.Query().Get("key"))

// 构造模板数据
data := PageData{
	SearchKey: key,
}

// 如果没有输入 key，则仅显示搜索表单
if key == "" {
	tmpl.Execute(w, data)
	return
}

// 调用 GitHub 搜索 API
url := Base_url + "?q=" + key
resp, err := http.Get(url)
if err != nil {
	http.Error(w, err.Error(), http.StatusInternalServerError)
	return
}
defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {
	http.Error(w, fmt.Sprintf("GitHub API 错误：%d", resp.StatusCode), resp.StatusCode)
	return
}

var result IssuesSearchResult
if err = json.NewDecoder(resp.Body).Decode(&result); err != nil {
	http.Error(w, err.Error(), http.StatusInternalServerError)
	return
}
data.Result = &result

// 渲染模板并显示结果
tmpl.Execute(w, data)

}

[hongjiala]

package github

import (
	"encoding/json"
	"fmt"
	"html/template"
	"net/http"
	"strings"
)

// GitHub 搜索 Issues 的 URL
const Base_url = "https://api.github.com/search/issues"

// 定义用户信息
type User struct {
	Login   string `json:"login"`
	HTMLURL string `json:"html_url"`
}

// 定义 Issue 信息
type Issue struct {
	Number  int    `json:"number"`
	HTMLURL string `json:"html_url"`
	Title   string `json:"title"`
	State   string `json:"state"`
	User    *User  `json:"user"`
}

// GitHub 搜索结果结构体
type IssuesSearchResult struct {
	TotalCount int      `json:"total_count"`
	Items      []*Issue `json:"items"`
}

// 模板字符串
// 在模板中，我们加入了一个简单的搜索表单，用户可以输入搜索关键字
var temp = `
<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<title>GitHub Issues 搜索</title>
	<style>
		table { border-collapse: collapse; width: 100%; }
		th, td { border: 1px solid #ddd; padding: 8px; }
		th { background-color: #f2f2f2; }
	</style>
</head>
<body>
	<h1>GitHub Issues 搜索</h1>
	<form action="/" method="get">
		<input type="text" name="key" placeholder="请输入搜索关键字" value="{{.SearchKey}}">
		<input type="submit" value="搜索">
	</form>
	{{if .Result}}
		<h2>共找到 {{.Result.TotalCount}} 个 Issues</h2>
		<table>
		<tr>
			<th>#</th>
			<th>状态</th>
			<th>用户</th>
			<th>标题</th>
		</tr>
		{{range .Result.Items}}
		<tr>
			<td><a href="{{.HTMLURL}}">{{.Number}}</a></td>
			<td>{{.State}}</td>
			<td><a href="{{.User.HTMLURL}}">{{.User.Login}}</a></td>
			<td><a href="{{.HTMLURL}}">{{.Title}}</a></td>
		</tr>
		{{end}}
		</table>
	{{end}}
</body>
</html>
`

// PageData 用于传递给模板的数据
type PageData struct {
	SearchKey string
	Result    *IssuesSearchResult
}

// WebServer 启动 HTTP 服务器
func WebServer() {
	http.HandleFunc("/", Handle)
	fmt.Println("服务器启动，访问地址：http://127.0.0.1:5000/")
	http.ListenAndServe("127.0.0.1:5000", nil)
}

// Handle 处理 HTTP 请求
func Handle(w http.ResponseWriter, r *http.Request) {
	// 解析模板
	tmpl, err := template.New("report").Parse(temp)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// 获取 URL 参数 key
	key := strings.TrimSpace(r.URL.Query().Get("key"))

	// 构造模板数据
	data := PageData{
		SearchKey: key,
	}

	// 如果没有输入 key，则仅显示搜索表单
	if key == "" {
		tmpl.Execute(w, data)
		return
	}

	// 调用 GitHub 搜索 API
	url := Base_url + "?q=" + key
	resp, err := http.Get(url)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		http.Error(w, fmt.Sprintf("GitHub API 错误：%d", resp.StatusCode), resp.StatusCode)
		return
	}

	var result IssuesSearchResult
	if err = json.NewDecoder(resp.Body).Decode(&result); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	data.Result = &result

	// 渲染模板并显示结果
	tmpl.Execute(w, data)
}

[celiachu]

4.14

package main

import (
	"encoding/json"
	"fmt"
	"html/template"
	"net/http"
	"net/url"
	"os"
	"strings"
)

// GitHub 搜索 Issues 的 API 地址
const baseURL = "https://api.github.com/search/issues"

// 用户结构体
type User struct {
	Login   string `json:"login"`
	HTMLURL string `json:"html_url"`
}

// issue 结构体
type Issue struct {
	Number  int    `json:"number"`
	HTMLURL string `json:"html_url"`
	Title   string `json:"title"`
	State   string `json:"state"`
	User    *User  `json:"user"`
}

// 搜索结果结构体
type IssuesSearchResult struct {
	TotalCount int      `json:"total_count"`
	Items      []*Issue `json:"items"`
}

// 页面数据结构体（用于模板渲染）
type PageData struct {
	SearchKey string
	Result    *IssuesSearchResult
	Error     string
}

// HTML 模板
var tmpl = `
<!DOCTYPE html>
<html>
<head>
	<title>GitHub Issues 搜索</title>
	<style>
		body { font-family: Arial, sans-serif; padding: 20px; }
		table { border-collapse: collapse; width: 100%; margin-top: 20px; }
		th, td { border: 1px solid #ddd; padding: 8px; }
		th { background-color: #f2f2f2; }
	</style>
</head>
<body>
	<h1>GitHub Issues 搜索</h1>
	<form method="GET">
		<input type="text" name="key" placeholder="例如 repo:golang/go is:open" value="{{.SearchKey}}" style="width: 300px;" />
		<button type="submit">搜索</button>
	</form>

	{{if .Error}}
		<p style="color: red;">{{.Error}}</p>
	{{end}}

	{{if .Result}}
		<h2>共找到 {{.Result.TotalCount}} 个 Issues</h2>
		<table>
			<tr>
				<th>#</th>
				<th>状态</th>
				<th>用户</th>
				<th>标题</th>
			</tr>
			{{range .Result.Items}}
			<tr>
				<td><a href="{{.HTMLURL}}" target="_blank">#{{.Number}}</a></td>
				<td>{{.State}}</td>
				<td><a href="{{.User.HTMLURL}}" target="_blank">{{.User.Login}}</a></td>
				<td>{{.Title}}</td>
			</tr>
			{{end}}
		</table>
	{{end}}
</body>
</html>
`

// 启动 Web 服务
func main() {
	http.HandleFunc("/", handle)
	fmt.Println("🚀 服务器已启动：http://127.0.0.1:5000/")
	http.ListenAndServe("127.0.0.1:5000", nil)
}

// 请求处理函数
func handle(w http.ResponseWriter, r *http.Request) {
	// 解析模板
	t := template.Must(template.New("webpage").Parse(tmpl))

	// 获取参数
	key := strings.TrimSpace(r.URL.Query().Get("key"))
	data := PageData{SearchKey: key}

	if key == "" {
		// 初始页只渲染搜索框
		t.Execute(w, data)
		return
	}

	// 构造 GitHub API URL（加上 URL 编码）
	query := url.QueryEscape(key)
	apiURL := baseURL + "?q=" + query

	// 构造请求并添加必要头
	req, err := http.NewRequest("GET", apiURL, nil)
	if err != nil {
		data.Error = "创建请求失败: " + err.Error()
		t.Execute(w, data)
		return
	}
	req.Header.Set("User-Agent", "Go-GitHub-Issue-Searcher")
	if token := os.Getenv("GITHUB_TOKEN"); token != "" {
		req.Header.Set("Authorization", "token "+token)
	}

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		data.Error = "请求失败: " + err.Error()
		t.Execute(w, data)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		data.Error = fmt.Sprintf("GitHub API 错误：%d", resp.StatusCode)
		t.Execute(w, data)
		return
	}

	// 解析响应
	var result IssuesSearchResult
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		data.Error = "解析响应失败: " + err.Error()
		t.Execute(w, data)
		return
	}

	data.Result = &result
	t.Execute(w, data)
}

[Fr3rty]

这个代码很不错，但似乎有点低效，每个请求都创建并解析了模板：

t := template.Must(template.New("webpage").Parse(tmpl))

事实上，这个 Template 是线程安全的，只需要创建一次即可。

Once parsed, a template may be executed safely in parallel, although if parallel executions share a Writer the output may be interleaved.
Ref: https://pkg.go.dev/text/template#pkg-overview

html/template 仅仅对 text/template 做了一层包装以防止 HTML Inject 等安全问题

Package template (html/template) implements data-driven templates for generating HTML output safe against code injection. It provides the same interface as text/template and should be used instead of text/template whenever the output is HTML.
Ref: https://pkg.go.dev/html/template#pkg-overview

所以，改为这样可能会更好些

import (
	"html/template"
)

var t *template.Template

func init() {
	t = template.Must(template.New("webpage").Parse(tmpl))
}