ch4/ch4-05

[giscus[bot]]

ch4/ch4-05

中文版

https://gopl-zh.github.io/ch4/ch4-05.html

[zhangbest5]

%-5d 最小宽度5，左对齐
%9.9s 最小宽度9，最大宽度9（超了截取）
%.55s 最小宽度无，最大宽度55（超了截取）

[xianren68]

4.10

github.go

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"time"
)

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

// 用户
type User struct {
	// 用户名
	Login string `json:login`
	// 用户id
	Id int `json:id`
	// 用户主页
	HTMLURL string `json:html_url`
}

type Issue struct {
	Number    int
	HTMLURL   string `json:"html_url"`
	Title     string
	State     string
	User      *User
	CreatedAt time.Time `json:"created_at"`
	Body      string    // in Markdown format
}

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

// 获取数据
func SearchIssure(term []string) (*IssuesSearchResult, error) {
	q := url.QueryEscape(strings.Join(term, " "))
	resp, err := http.Get(Base_url + "?q=" + q)
	if err != nil {
		return nil, err
	}
	// 判断状态码
	if resp.StatusCode != http.StatusOK {
		resp.Body.Close()
		return nil, fmt.Errorf("状态码错误：%d", resp.StatusCode)
	}
	var result = &IssuesSearchResult{}
	if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
		resp.Body.Close()
		return nil, err
	}
	resp.Body.Close()
	return result, nil

}

// 处理数据
func Process(data *IssuesSearchResult) {
	// 创建一个hash表
	hash := make(map[string][]*Issue, 3)
	hash["不到一月"] = make([]*Issue, 0)
	hash["不到一年"] = make([]*Issue, 0)
	hash["超过一年"] = make([]*Issue, 0)
	// 遍历数据
	for _, val := range data.Items {
		// 获取现在的时间
		now := time.Now()
		year := now.Year()
		month := now.Month()
		// 创建时间
		create_year := val.CreatedAt.Year()
		create_month := val.CreatedAt.Month()
		if year == create_year && month == create_month {
			hash["不到一月"] = append(hash["不到一月"], val)
		} else if year == create_year {
			hash["不到一年"] = append(hash["不到一年"], val)
		} else {
			hash["超过一年"] = append(hash["超过一年"], val)
		}
	}
	fmt.Printf("数据总条数，%v\n", data.TotalCount)
	for key, val := range hash {
		fmt.Printf("%s:\n", key)
		for _, v := range val {
			fmt.Printf("#%-5d %9.9s %.55s %9.9v\n",
				v.Number, v.User.Login, v.Title, v.CreatedAt)
		}
	}
}

main.go

func main() {
	query := os.Args[1:]
	data, err := test.SearchIssure(query)
	if err != nil {
		fmt.Println(err)
		return
	}
	test.Process(data)
}

[lyb88999]

我觉得判断时间这里逻辑可能有点问题
这样是不是更好点

// 创建一个hash表
	hash := make(map[string][]*Issue, 3)
	hash["不到一月"] = make([]*Issue, 0)
	hash["不到一年"] = make([]*Issue, 0)
	hash["超过一年"] = make([]*Issue, 0)
	for _, val := range data.Items {
		// 计算从创建时间到现在的持续时间
		duration := time.Since(val.CreatedAt)

		if duration.Hours() < 24*30 { // 假设每月30天
			hash["不到一月"] = append(hash["不到一月"], val)
		} else if duration.Hours() < 24*365 { // 假设每年365天
			hash["不到一年"] = append(hash["不到一年"], val)
		} else {
			hash["超过一年"] = append(hash["超过一年"], val)
		}
	}

[xianren68]

确实有问题，想的简单了

[lyb88999]

已经很好了！ 我得看着您的代码我才有思路

[xianren68]

哈哈，咱们互相学习

[xianren68]

4.12

test.go

package test

import (
	"encoding/csv"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
)

// 定义用于接受的结构体
type Xkcd struct {
	// 标题
	Title string
	// 链接
	Link string
	// 封面
	Img string
}

// 地址
const Base_url = `https://xkcd.com/`

// 获取漫画信息并存到csv文件中作为离线索引
func GetSaveInfo() {
	// 创建文件
	f, err := os.Create("./xkcd.csv")
	if err != nil {
		fmt.Println("创建文件失败")
	}
	// 关闭文件
	defer f.Close()
	writer := csv.NewWriter(f)
	// 写入表头
	writer.Write([]string{"title", "link", "img"})
	// 循环获取每条数据
	for i := 1; ; i++ {
		xkcd := &Xkcd{}
		url := fmt.Sprintf("%s%d/info.0.json", Base_url, i)
		resp, err := http.Get(url)
		if err != nil {
			fmt.Println(err)
		}
		// 判断状态码
		if resp.StatusCode != http.StatusOK {
			resp.Body.Close()
			fmt.Println("没有更多了")
			return
		}
		if err = json.NewDecoder(resp.Body).Decode(xkcd); err != nil {
			resp.Body.Close()
			fmt.Println(err)
		}
		resp.Body.Close()
		writer.Write([]string{xkcd.Title, xkcd.Link, xkcd.Img})
		// 将缓存中的内容写入到文件里
		writer.Flush()

	}

}

// 通过关键字返回链接
func ResLink(key string) {
	// 寻找离线索引
	f, err := os.Open("./xkcd.csv")
	if err != nil {
		fmt.Println("打开文件失败，查看是否有离线索引")
	}
	defer f.Close()
	reader := csv.NewReader(f)
	// 循环对比
	for {
		result, err := reader.Read()
		// 到达文件尾部
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Println(err)
		}
		if key == result[0] {
			fmt.Println(result[1])
			return
		}
	}
	fmt.Println("暂时没有此漫画")
}

main.go

func main() {
	// 获取离线列表
	// test.GetSaveInfo()
	key := os.Args[1:]
	test.ResLink(strings.Join(key, " "))

}

[zhaojundu123]

4.13

package main

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

// get movies from omdbapi.com
// http://www.omdbapi.com/?t=Guardians+of+the+Galaxy+Vol.+2&y=2017&apikey=9f693ec9
// movie name: Guardians of the Galaxy Vol. 2
func getMovieData(movieName string) ([]byte, error) {
url := "http://www.omdbapi.com/?t=" + movieName + "&apikey=9f693ec9"
resp, err := http.Get(url)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return ioutil.ReadAll(resp.Body)
}

// get poster url from movies json
func getPosterUrl(movieJson []byte) (string, error) {
var movie struct {
Poster string json:"Poster"
}
err := json.Unmarshal(movieJson, &movie)
if err != nil {
return "", err
}
return movie.Poster, nil
}

// download poster from url
func main(){
movieName := os.Args[1]
movieJson, err := getMovieData(movieName)
if err != nil {
log.Fatal(err)
}
posterUrl, err := getPosterUrl(movieJson)
if err != nil {
log.Fatal(err)
}
fmt.Println(posterUrl)
resp, err := http.Get(posterUrl)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil{
log.Fatal(err)
}
err = ioutil.WriteFile("poster.jpg", body, 0644)
if err != nil {
log.Fatal(err)
}
fmt.Println("poster.jpg downloaded")
}

[zhaojundu123]

需要先申请自己的API KEY，进行替换

[SuperZ3]

从下往上看👁

package main

import (
	"time"
	"encoding/json"
	"fmt"
	"net/http"
    "net/url"
    "strings"
	"log"
    "os"
	"bufio"
	"io/ioutil"
	"regexp"
	"io"
	"flag"
	"os/exec"
)

const IssuesURL = "https://api.github.com/search/issues"

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

type Issue struct {
    Number    int
    HTMLURL   string `json:"html_url"`
    Title     string
    State     string
    User      *User
    CreatedAt time.Time `json:"created_at"`
    Body      string 
}

type User struct {
    Login   string
    HTMLURL string `json:"html_url"`
}

type PosterResp struct {
	Poster string
	Title string
}

type XkcdResp struct {
	Img string
	Title string
	Link string
}

func SearchIssues(terms []string) (*IssuesSearchResult, error) {
	q := url.QueryEscape(strings.Join(terms, " "))
	fmt.Println(IssuesURL + "?q=" + q)
	resp, err := http.Get(IssuesURL + "?q=" + q)
	if err != nil {
		return nil, err
	}

	if resp.StatusCode != http.StatusOK {
        resp.Body.Close()
        return nil, fmt.Errorf("search query failed: %s", resp.Status)
    }

	var result IssuesSearchResult
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        resp.Body.Close()
        return nil, err
    }
    resp.Body.Close()
    return &result, nil
}

func CategorizedCreatedAt(issues []*Issue) {
	now := time.Now().UTC()
	var OverYear, LessYear, LessMonth []*Issue

	for _, issue := range issues {
		issueTime := issue.CreatedAt.UTC()
		isOverOneYear := now.Year() - issueTime.Year() > 1
		isLessOneMonth := !isOverOneYear && (now.Month() - issueTime.Month() < 1)
		if isOverOneYear {
			OverYear = append(OverYear, issue)
		} else if !isOverOneYear {
			LessYear = append(LessYear, issue)
		} else if isLessOneMonth {
			LessMonth = append(LessMonth, issue)
		}
	}
	for _, issue := range OverYear {
		fmt.Printf("Over one Year: #%-5d %9.9s %.55s\n", issue.Number, issue.User.Login, issue.Title)
	}
	for _, issue := range LessYear {
		fmt.Printf("Less one Year: #%-5d %9.9s %.55s\n", issue.Number, issue.User.Login, issue.Title)
	}
	for _, issue := range LessMonth {
		fmt.Printf("Less one Month: #%-5d %9.9s %.55s\n", issue.Number, issue.User.Login, issue.Title)
	}

}

func parseBody(response *http.Response) ([]byte, error) {
	body, err := ioutil.ReadAll(response.Body)
	return body, err
}

func queryUrl(url string) ([]byte, error) {
	// 1. query url
	resp, err := http.Get(url)
	if err != nil || resp.StatusCode != http.StatusOK {
		fmt.Printf("query url error: %v", err)
		return nil, err
	}
	// 2. parse response body
	body, err := parseBody(resp)
    if err != nil {
		fmt.Printf("parse response error: %v", err)
        return nil, err
    }
	defer resp.Body.Close()
	return body, nil
}

func Poster() {
	// 1. get movie name
	// you can apply free apiKey
	ImageUrl := "http://www.omdbapi.com/?apikey=[your key]&"
	fmt.Println("---------------- Input move name ----------------------------")
	reader := bufio.NewReader(os.Stdin)
	movieName, _, err := reader.ReadLine()
	if err != nil {
		fmt.Println("cannot get movie name")
		return
	}
	// 2. query movie info
	escapeName := url.QueryEscape(string(movieName))
	movieUrl := ImageUrl + "&plot=full&t=" + escapeName
	movieBody, err := queryUrl(movieUrl)
	if err != nil {
		return
	}
	// 3. download image
	var jsonMovieBody PosterResp
	json.Unmarshal(movieBody, &jsonMovieBody)
	imgUrl := jsonMovieBody.Poster
	imgBody, err := queryUrl(imgUrl)
	if err != nil {
		return
	}
	// 4. write file
	var validSuffix = regexp.MustCompile(`\.(jpe?g|web|png|gif)$`)
	suffix := validSuffix.FindString(imgUrl)
	fileName := string(movieName) + suffix
	fileErr := ioutil.WriteFile(fileName, imgBody, 0644)
	if fileErr != nil {
		log.Fatal(fileErr)
	}
}

func Xkcd() {
	xkcdUrl := "https://xkcd.com/"
	xkcdSuffix := "/info.0.json"
	f, err := os.OpenFile("storage.txt", os.O_RDWR|os.O_CREATE, 0666)
	if err != nil {
		log.Fatal(err)
	}

	var max int
	fmt.Println("------------------- how match you want -----------------------")
	fmt.Scanln(&max)

	for i := 1; i < max; i++ {
		url := xkcdUrl + fmt.Sprint(i) + xkcdSuffix
		fmt.Printf("query url: %v\n", url)
		body, err := queryUrl(url)
		if err != nil {
			fmt.Printf("query url error: %v\n", err)
			break
		}
		var parseBody XkcdResp
		if err := json.Unmarshal(body, &parseBody); err != nil {
			log.Fatalf("JSON unmarshaling failed: %s", err)
			continue
		}
		row := parseBody.Img + parseBody.Title + parseBody.Link + "\n"
		if _, err := f.Write([]byte(row)); err != nil {
			fmt.Printf("write info error: %v\n", err)
		}
	}
	f.Close()

	rf, rErr := os.OpenFile("storage.txt", os.O_RDONLY, 0)
	if rErr != nil {
		log.Fatal(err)
	}

	var order int
	fmt.Println("------------------- want order -----------------------")
	fmt.Scanln(&order)

	reader := bufio.NewReader(rf)
	flag := 0
	for {
		line, err := reader.ReadString('\n')
		if err != nil {
			if err == io.EOF {
				fmt.Printf("EOF: %#v\n", line)
				break
			}
		}
		if flag == order - 1 {
			fmt.Printf("%v", line)
		}
		flag++
	}

	defer f.Close()
}

func queryIssue(address, method string) {
	// 1. generator template
	f, err := os.OpenFile("template.txt", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
	if err != nil {
		log.Fatal(err)
		return
	}
	template := "title:\nbody:\nstate:\n"
	_, wErr := f.WriteString(template)
	if err != nil {
		fmt.Printf("generator template error: %v", wErr)
		return
	}
	f.Close()

	// 2. open template, waiting for user write
	// Attention: use case run on mac os
	cmd := exec.Command("open", "template.txt")
	if err := cmd.Run(); err != nil {
		os.Exit(1)
		log.Fatal(err)
		return
	}

	var moveOn string
	fmt.Println("-- waiting fo input title, body and state, type continue to move on --")
	fmt.Scanln(&moveOn)
	for moveOn != "continue" {}

	// 3. read template, get title body etc.
	f, ferr := os.OpenFile("template.txt", os.O_RDONLY, 0666)
	if ferr != nil {
		log.Fatal(ferr)
		return
	}
	reader := bufio.NewReader(f)
	lines := make(map[string]string)
	for {
		line, _, err := reader.ReadLine()
		if err != nil {
			if err == io.EOF {
				break
			}
			return
		}
		parseLine := string(line)
		if strings.Contains(parseLine, ":") {
			arr := strings.Split(parseLine, ":")
			if arr[1] != "" {
				lines[arr[0]] = arr[1]
			}
		}
	}
	defer f.Close()

	if len(lines) > 0 {
		jsonBytes, err := json.MarshalIndent(lines, "", " ")
		if err != nil {
			log.Fatal(err)
		}

		client := &http.Client{}
		req, err := http.NewRequest(method, address, strings.NewReader(string(jsonBytes)))
		req.Header.Add("Content-Type", "application/json")
		// https://docs.github.com/en/rest/overview/authenticating-to-the-rest-api?apiVersion=2022-11-28
		req.Header.Add("Authorization", "Bearer [your token]")
		resp, err := client.Do(req)
		body, _ := ioutil.ReadAll(resp.Body)
		fmt.Printf("%v \n %v \n %v", address, string(body), strings.NewReader(string(jsonBytes)))
		if err != nil {
			fmt.Printf("Error: %v\n", err)
			return
		}
		if resp.StatusCode == http.StatusOK {
			fmt.Printf("Success: %v", string(body))
		}
		defer resp.Body.Close()
	} else {
		fmt.Println("nothing input, quit")
	}
}

func IssueOperation() {
	var owner string
	var repo string
	var issueNumber string
	var operationType int
	const OperationURL = "https://api.github.com/repos/"
	flag.IntVar(&operationType, "operation", 0, "Specify operation type: 1 -- create; 2 -- get; 3 -- update; 4 -- delete")
	flag.StringVar(&owner, "owner", "", "The account owner of the repository. The name is not case sensitive.")
	flag.StringVar(&repo, "repo", "", "The name of the repository without the .git extension. The name is not case sensitive.")
	flag.StringVar(&issueNumber, "issue_n", "", "The number that identifies the issue.")
	flag.Parse()
	
	if owner != "" && repo != "" && operationType != 0 {
		var queryAddress string

		switch operationType {
			case 1:
				// command: go run hello.go -operation=1 -owner=[your owner] -repo=[your repo]
				queryAddress = OperationURL + owner + "/" + repo + "/issues"
				queryIssue(queryAddress, "POST")
			case 2:
				// command go run hello.go -operation=2 -owner=golang -repo=go -issue_n=5680
				queryAddress = OperationURL + owner + "/" + repo + "/issues/" + issueNumber
				body, err := queryUrl(queryAddress)
				if err != nil {
					fmt.Printf("get issue error: %v\n", err)
					return
				}
				var result Issue
				parseErr := json.Unmarshal(body, &result)
				if parseErr != nil {
					fmt.Printf("parse body error: %v", parseErr)
					return
				}
				fmt.Println(result)
			case 3:
				// command: go run hello.go -operation=3 -owner=[your owner] -repo=[your repo] -issue_n=1
				queryAddress = OperationURL + owner + "/" + repo + "/issues/" + issueNumber
				queryIssue(queryAddress, "PATCH")
			case 4:
				// command: go run hello.go -operation=4 -owner=[your owner] -repo=[your repo] -issue_n=1
				// set state -> 4
				queryAddress = OperationURL + owner + "/" + repo + "/issues/" + issueNumber
				queryIssue(queryAddress, "PATCH")
		}
	} else {
		fmt.Println("application need correct input")
	}
}

func main() {
	result, err := SearchIssues(os.Args[1:])
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%d issues:\n", result.TotalCount)
	for _, item := range result.Items {
        fmt.Printf("#%-5d %9.9s %.55s\n",
            item.Number, item.User.Login, item.Title)
    }

	// Remember to comment other code
	fmt.Println("---------------- 4.10 Categorized by time start -----------------")
	CategorizedCreatedAt(result.Items)
	fmt.Println("---------------- 4.10 Categorized by time end -------------------")

	// Remember to comment other code
	fmt.Println("---------------- 4.11 Issue start -----------------")
	IssueOperation()
	fmt.Println("---------------- 4.11 Issue end -------------------")

	// Remember to comment other code
	fmt.Println("---------------- 4.12 xkcd start -----------------")
	Xkcd()
	fmt.Println("---------------- 4.12 xkcd end -------------------")

	// Remember to comment other code
	fmt.Println("---------------- 4.13 Poster start -----------------")
	Poster()
	fmt.Println("---------------- 4.13 Poster end -------------------")
}

[lyb88999]

4.13

func Poster(filmName string) (*Film, error) {
	// 安全地编码电影名称
	safeFilmName := url.QueryEscape(filmName)
	requestURL := fmt.Sprintf("%s?apikey=9f693ec9&t=%s", BaseUrl, safeFilmName)

	resp, err := http.Get(requestURL)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("search query failed: %s", resp.Status)
	}

	var film Film
	if err := json.NewDecoder(resp.Body).Decode(&film); err != nil {
		return nil, err
	}

	if film.Poster == "" {
		return &film, fmt.Errorf("no poster URL found")
	}

	// 获取海报图像
	resp, err = http.Get(film.Poster)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("failed to get poster image")
	}

	img, err := jpeg.Decode(resp.Body)
	if err != nil {
		return nil, err
	}

	filePath := "./pic/" + film.Title + ".jpg"
	file, err := os.Create(filePath)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	if err = jpeg.Encode(file, img, &jpeg.Options{Quality: 75}); err != nil {
		return nil, err
	}

	fmt.Println("Poster saved to", filePath)
	return &film, nil
}