ch1/ch1-06 #176

2023-01-26T03:49:06Z

giscus[bot]
bot Jan 26, 2023

ch1/ch1-06

中文版

https://gopl-zh.github.io/ch1/ch1-06.html

wlwqq · 2023-01-26T03:49:08Z

wlwqq
Jan 26, 2023 — with giscus

练习 1.10，需要在fetch函数中，创建文件，copy时将数据copy到创建的文件中即可

func fetch(url string, ch chan string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprint(err) // send err to channel
		return
	}
	// 创建文件
	out, err := os.Create(url + ".txt")
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	// nbytes 是拷贝的内容大小
	//nbytes, err := io.Copy(ioutil.Discard, resp.Body)
	nbytes, err := io.Copy(out, resp.Body)
	resp.Body.Close()
	if err != nil {
		ch <- fmt.Sprintf("while reading %s: %v", url, err)
		return
	}

	secs := time.Since(start).Seconds()
	ch <- fmt.Sprintf("%.2fs	%7d	%s", secs, nbytes, url)

}

1 reply

Sherlockfanchen Apr 16, 2023 — with giscus

package main

import (
"fmt"
"io"
"net/http"
"os"
"strconv"
"time"
)

func main() {
statr := time.Now()
ch := make(chan string)
for num, url := range os.Args[1:] {
go fetch(url, ch, num)
}
for range os.Args[1:] {
fmt.Println(<-ch)

}
fmt.Printf("%.2fs elapsed\n", time.Since(statr).Seconds())

}

func fetch(url string, ch chan<- string, num int) {
statr := time.Now()
var utl_fime_name string
resp, err := http.Get(url)
if err != nil {
ch <- fmt.Sprint(err)
return
}
nums := strconv.Itoa(num)
utl_fime_name = nums + ".txt"
dst, err := os.Create(utl_fime_name)
if err != nil {
panic(err)
}
nbytes, err := io.Copy(dst, resp.Body)
resp.Body.Close()
if err != nil {
ch <- fmt.Sprintf("while reading %s: %v", url, err)
return
}

secs := time.Since(statr).Seconds()
ch <- fmt.Sprintf("%.2fs %7d %s", secs, nbytes, url)

}

创建文件，把os.Args的键当文件名参数传入方法fetch中，并根据不同的文件名，写入对应的网页内容。

lanmao0204 · 2023-05-30T04:52:41Z

lanmao0204
May 30, 2023 — with giscus

切片url 使保存文件名字为//后 .前例如 https://godoc.org 保存到文件godoc.txt中
func fetch(url string, ch chan<- string) {
start := time.Now()
resp, err := http.Get(url)
if err != nil {
ch <- fmt.Sprint(err)
return
}
begin := findSubstringIndex(url, "//") // 找到 // 的索引位置
end := findSubstringIndex(url, ".") // 找到 . 的索引位置
if begin != -1 && end != -1 {
slicedStr := url[begin+2 : end]
filesName := slicedStr + ".txt"
dst, err := os.Create(filesName)
if err != nil {
panic(err)
}
//nBytes, err := io.Copy(ioutil.Discard, resp.Body)
nBytes, err := io.Copy(dst, resp.Body)
defer resp.Body.Close()
if err != nil {
ch <- fmt.Sprintf("while reading %s: %v", url, err)
return
}
secs := time.Since(start).Milliseconds()
ch <- fmt.Sprintf("%.2dms %7d %s", secs, nBytes, url)
}

}

func findSubstringIndex(str, substr string) int {
for i := 0; i < len(str)-len(substr)+1; i++ {
if str[i:i+len(substr)] == substr {
return i
}
}
return -1
}

0 replies

CatalinaElf · 2023-06-18T12:33:07Z

CatalinaElf
Jun 18, 2023 — with giscus

练习1.10

func main() {
	start := time.Now()
	//创建一个字符串类型的channel通道，用来在并发协程之间传递数据
	ch := make(chan string)
	//获取传入的url参数
	for _, path := range os.Args[1:] {
		//判断该path是否以http://开头，如果不是则进行拼接
		if !strings.HasPrefix(path, "http://") {
			path = "http://" + path
		}
		//使用goroutine进行调用方法，计算获取的数据量已经执行时间
		go fetch(path, ch)
	}
	//遍历传递进来参数的次数
	//1.10从通道内获取内容并输出到文件中
	file, err := os.OpenFile("D://testfile.txt", os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Printf("错误信息1：%s\r\n", err)
		os.Exit(1)
	}
	for range os.Args[1:] {
		_, err = io.WriteString(file, <-ch)
		if err != nil {
			fmt.Printf("错误信息2：%s\r\n", err)
		}
		if err != nil {
			fmt.Printf("错误信息3：%s\r\n", err)
		}
	}
	_, err = io.WriteString(file, "=====华丽的分隔符=====\r\n")
	//关闭资源
	_ = file.Close()
	//打印从开始到现在总耗时
	fmt.Printf("%.2fs elapsed\r\n", time.Since(start).Seconds())
}

func fetch(path string, ch chan string) {
	//设置单个协程的开始时间
	start := time.Now()
	//获取response
	resp, err := http.Get(path)
	//处理错误信息,将错误信息放入通道内
	if err != nil {
		ch <- fmt.Sprint(err)
		return //发生错误结束该函数
	}
	//将resp中获取的内容放入垃圾箱
	written, err := io.Copy(io.Discard, resp.Body)
	//关闭资源
	_ = resp.Body.Close()
	//处理错误信息，将错误信息放入通道内
	if err != nil {
		ch <- fmt.Sprint(err)
		return //发生错误结束该函数
	}
	//获取单个协程的执行耗时
	secs := time.Since(start).Seconds()
	//将需要返回的信息放到ch通道中
	ch <- fmt.Sprintf("访问网址为：%s的耗时时间(保留两位小数)为：%.2fs，读取的字节数为：%d\r\n", path, secs, written)
}

保存到文件后的结果

访问网址为：http://www.baidu.com的耗时时间(保留两位小数)为：0.11s，读取的字节数为：385223
访问网址为：http://gopl-zh.github.com的耗时时间(保留两位小数)为：0.17s，读取的字节数为：9587
访问网址为：http://godoc.org的耗时时间(保留两位小数)为：0.87s，读取的字节数为：31436
访问网址为：http://gopl.io的耗时时间(保留两位小数)为：1.10s，读取的字节数为：4154
=====华丽的分隔符=====
访问网址为：http://www.baidu.com的耗时时间(保留两位小数)为：0.09s，读取的字节数为：385281
访问网址为：http://gopl-zh.github.com的耗时时间(保留两位小数)为：0.14s，读取的字节数为：9587
访问网址为：http://godoc.org的耗时时间(保留两位小数)为：0.83s，读取的字节数为：31436
访问网址为：http://gopl.io的耗时时间(保留两位小数)为：1.08s，读取的字节数为：4154
=====华丽的分隔符=====

1 reply

windqiu Aug 23, 2024 — with giscus

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

func main() {
	//实例化一个当前时间戳对象
	start := time.Now()
	//声明一个双通道类型
	ch := make(chan string)
	//获取除 ./main 之外的参数，并开启go协程执行
	for _, url := range os.Args[1:] {
		go fetch(url, ch)
	}
	//读取指定一个文件，获得文件句柄实例
	fd, err := os.OpenFile("resources/diffdiff.txt", os.O_APPEND|os.O_WRONLY, 0644)
	//defer在程序终止前释放文件实例资源
	defer fd.Close()
	if err != nil {
		//文件打开失败，则终止程序
		panic(err)
	}
	for range os.Args[1:] {
		_, err = io.WriteString(fd, "\n"+<-ch)
		if err != nil {
			fmt.Println("Error writing to file:", err.Error())
		}
	}

	_, err = io.WriteString(fd, "================== split =============== ")
	fmt.Printf("总耗时： %.2fs elapsed \r\n", time.Since(start).Seconds())
}

func fetch(url string, ch chan<- string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprint("\r\n" + err.Error())
		return
	}
	//os.Stdout 会把body的信息输出到控制台上
	nbytes, err := io.Copy(io.Discard, resp.Body)
	_ = resp.Body.Close()
	if err != nil {
		ch <- fmt.Sprintf("while reading %s: %v \r\n", url, err.Error())
		return
	}
	secs := time.Since(start).Seconds()
	ch <- fmt.Sprintf("访问网址 [ %s ], %.2fs %7d \r\n", url, secs, nbytes)
	return
}

Rexoen · 2023-07-02T12:49:46Z

Rexoen
Jul 2, 2023 — with giscus

Exercise 1.1

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"strings"
	"time"
)

const TIMES int = 2

func main() {
	fd, err := os.Create("fetch.log")
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	start := time.Now()
	ch := make(chan string)
	for i := 0; i < TIMES; i++ {
		io.WriteString(fd, fmt.Sprintf("---Start fetch for the %d time---\n", i+1))
		for _, url := range os.Args[1:] {
			go fetch(url, ch)
		}
		for range os.Args[1:] {
			io.WriteString(fd, <-ch)
			io.WriteString(fd, "\n")
		}
		io.WriteString(fd, fmt.Sprintf("%.2fs elapsed\n", time.Since(start).Seconds()))
	}
	fd.Close()
	dirs, err := os.ReadDir("./")
	for _, dir := range dirs {
		dirname := dir.Name()
		if strings.HasSuffix(dirname, ".html") {
			os.Remove(dirname)
		}
	}
}

func fetch(url string, ch chan<- string) {
	var full_url string = url
	if !strings.HasPrefix(url, "http") {
		full_url = "http://" + url
	}
	start := time.Now()
	resp, err := http.Get(full_url)
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	curSiteContent, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	fileName := url + ".html"
	if _, err := os.Stat(fileName); err == nil {
		// when file has already exits
		fd, _ := os.Open(fileName)
		prevSiteContent, _ := ioutil.ReadAll(fd)
		if string(prevSiteContent) != string(curSiteContent) {
			ch <- url + ": site content has changed"
			return
		}
	}
	// save reponse body
	fd, err := os.Create(fileName)
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	nbytes, err := io.WriteString(fd, string(curSiteContent))
	resp.Body.Close()
	fd.Close()
	if err != nil {
		ch <- fmt.Sprintf("while reading %s: %v", url, err)
		return
	}
	secs := time.Since(start).Seconds()

	ch <- fmt.Sprintf("%.2fs\t%7d\t%s", secs, nbytes, url)

}

0 replies

SuperZ3 · 2023-07-12T05:52:14Z

SuperZ3
Jul 12, 2023 — with giscus

package main

import (
    "fmt"
    "io"
	"io/ioutil"
    "net/http"
    "os"
	"strings"
	"time"
)

func main() {
	start := time.Now()
    ch := make(chan string)
	file, err := os.OpenFile("./text.txt", os.O_RDWR|os.O_CREATE,0)
	if err != nil {
		fmt.Printf("open file failed: %s", err)
		return
	}
    for _, url := range os.Args[1:] {
		if !strings.HasPrefix("http://", url) {
			url = "http://" + url
		}
		go fetch(url, ch, file)
		go fetch(url, ch, file)
	}
	for range os.Args[1:] {
		file.WriteString(<-ch)
		file.WriteString(<-ch)
		fmt.Printf("%.2fs elapsed\n", time.Since(start).Seconds())
	}
	file.Close()
}

func fetch(url string, ch chan<- string, file *os.File) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	nbytes, err := io.Copy(ioutil.Discard, resp.Body)
	if err != nil {
		ch <- fmt.Sprint("while reading %s: %v", url, err)
		return
	}
	secs := time.Since(start).Seconds()
    ch <- fmt.Sprintf("%.2fs  %7d  %s \r\n", secs, nbytes, url)
}

text 内容
0.04s 386077 http://www.baidu.com
0.04s 385920 http://www.baidu.com
0.10s 1255 http://www.bilibili.com
0.70s 1255 http://www.bilibili.com
Get "http://www.youtube.com": dial tcp 31.13.94.23:80: i/o timeoutGet "http://www.youtube.com": dial tcp 31.13.94.23:80: i/o timeout
与参数顺序无关，先响应的先写入，没有回应的会一直等待

0 replies

corgier · 2023-11-13T13:03:33Z

corgier
Nov 13, 2023 — with giscus

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

func main() {
	start := time.Now()
	ch := make(chan string)
	for _, url := range os.Args[1:] {
		go fetch(url, ch)
	}
	for range os.Args {
		fmt.Println(<-ch)
	}
	fmt.Printf("%.2fs elapsed\n", time.Since(start).Seconds())
}

func fetch(url string, ch chan<- string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	defer resp.Body.Close()
	file, err := os.OpenFile(fmt.Sprintf("%s", time.Now())+".txt", os.O_RDWR|os.O_APPEND|os.O_CREATE, 0644)
	nbytes, err := io.Copy(file, resp.Body)
	if err != nil {
		ch <- fmt.Sprintf("while reading %s: %v", url, err)
		return
	}
	secs := time.Since(start).Seconds()
	ch <- fmt.Sprintf("%.2fs %7d", secs, nbytes)
}

0 replies

Fi-tang · 2024-04-04T11:40:28Z

Fi-tang
Apr 4, 2024 — with giscus

// 练习 1.10: 找一个数据量比较大的网站，用本小节中的程序调研网站的缓存策略，
// 对每个 URL 执行两遍请求，查看两次时间是否有较大的差别，
// 并且每次获取到的响应内容是否一致
// 修改本节中的程序，将响应结果输出到文件，以便于进行对比

// 1. 提示1，输入到文件可以使用 file, err := os.Create(fileName), nbytes, err := io.Copy(file, response.Body) 得到
// 2. 一般在文件名中，. 符号是被严格禁止的

package main

import (
	"fmt"
	"os"
	"io"
	"net/http"
	"time"
	"strings"
)

func main(){
	start := time.Now()
	channel := make(chan string)

	for _, url := range os.Args[1:]{
		go fetchToFile(url, channel, 1)
		go fetchToFile(url, channel, 2)
	}

	for range os.Args[1:]{
		fmt.Println(<- channel)
		fmt.Println(<- channel)
	}

	fmt.Printf("time elaseped: %.2f\n", time.Since(start).Seconds())
}

func fetchToFile(url string, channel chan <- string, number int){
	start := time.Now()

	// 1. getting url's response
	response, urlError := http.Get(url)
	if urlError != nil{
		channel <- fmt.Sprintf("Exec_1.10: %v\n", urlError)
		return
	}

	// 2. Creating output file
	preString := url
	nextSlice := strings.Split(preString, ".")
	outputfileName := nextSlice[1]  // https://www . baidu . com

	if number == 1{
		outputfileName += "_1.html"
	}else{
		outputfileName += "_2.html"
	}

	outputfile, outputfileErr := os.Create(outputfileName)
	if outputfileErr != nil{
		channel <- fmt.Sprintf("Exec_1.10: Creating %s: %v\n", outputfileName, outputfileErr)
		return
	}

	// 3. Copy response's Body to outputfile
	nbytes, copyErr := io.Copy(outputfile, response.Body)
	response.Body.Close()

	if copyErr != nil{
		channel <- fmt.Sprintf("Exec_1.10: Copying %s:[%d] %v\n", url, number, copyErr)
		return
	}

	channel <- fmt.Sprintf("%.2f %7d %s [%d]", time.Since(start).Seconds(), nbytes, url, number)
}

0 replies

xianxianghuang · 2024-04-17T12:59:35Z

xianxianghuang
Apr 17, 2024 — with giscus

$ ./curl_plus_pra_1_10 golang~https://golang.org gopl~http://gopl.io godoc~https://godoc.org
3.14	  32378	https://godoc.org
3.14	   4154	http://gopl.io
4.07	  61860	https://golang.org
4.07 elapsed%                                                                                                                               

$ diff gopl20240417204517.dat gopl20240417205303.dat

//curl_plus_pra_1_10
package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
	"time"
)

func main() {
	start := time.Now()
	ch := make(chan string)
	for _, urlinf := range os.Args[1:] {
		inf := strings.Split(urlinf, "~")
		urlflag := inf[0]
		url := inf[1]
		go fetch(urlflag, url, ch)
	}
	for range os.Args[1:] {
		fmt.Println(<-ch)
	}
	fmt.Printf("%.2f elapsed", time.Since(start).Seconds())
}

func fetch(urlflag string, url string, ch chan<- string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	if resp == nil {
		ch <- (url + "resp is nil")
		return
	}
	//在Go语言中，`time.Format`方法的输入字符串是通过一个特定的格式来决定的，这个格式是Go设计者选择的一个固定的时间点：`Mon Jan 2 15:04:05 MST 2006`（go诞生的时间点）。
	filename := urlflag + start.Format("20060102150405") + ".dat"
	filestream, err := os.Create(filename)
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	defer filestream.Close()
	defer resp.Body.Close()
	bytes, err := io.Copy(filestream, resp.Body)
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	ch <- fmt.Sprintf("%.2f\t%7d\t%s", time.Since(start).Seconds(), bytes, url)
}

0 replies

Wizarder54088 · 2024-10-24T09:55:19Z

Wizarder54088
Oct 24, 2024 — with giscus

练习一

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"time"
)

func main() {
	start := time.Now()
	ch := make(chan string)
	for _, url := range os.Args[1:] {
		url = "https://" + url
		go fetch(url, ch) // start a goroutine
	}
	// 创建一个文件，默认在工程文件路径下 hellodemo下，如果存在就会删除重新创建
	// 文件如果已经写入，会清空（截断）
	file, err := os.Create("a.txt")
	if err != nil {
		fmt.Println("创建文件失败")
		return
	}
	// defer关键字确保方法结束前关闭
	defer file.Close()
	for range os.Args[1:] {
		// channel只能调用一次，写入一次调用一次，一个循环多调用会导致channel阻塞
		_, err := file.WriteString(<-ch + "\n")
		if err != nil {
			fmt.Println("写入文件失败")
			return
		}
	}
	fmt.Printf("%.2fs elapsed\n", time.Since(start).Seconds())
}

func fetch(url string, ch chan<- string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprint(err) // send to channel ch
		return
	}
	nbytes, err := io.Copy(ioutil.Discard, resp.Body)
	resp.Body.Close() // don't leak resources
	if err != nil {
		ch <- fmt.Sprintf("while reading %s: %v", url, err)
		return
	}
	secs := time.Since(start).Seconds()
	fmt.Printf("%.2fs  %7d  %s\n", secs, nbytes, url)
	ch <- fmt.Sprintf("%.2fs  %7d  %s", secs, nbytes, url)
}

0 replies

lhy985 · 2024-11-06T08:00:44Z

lhy985
Nov 6, 2024 — with giscus

为什么会出现下面的错误：
go run .\main.go https://golang.org http://gopl.io https://godoc.org
1.10s 32284 https://godoc.org
1.20s 4154 http://gopl.io
Get "https://golang.org": dial tcp 172.217.163.49:443: connectex: A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond.
21.03s elapsed

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

ch1/ch1-06 #176

{{title}}

Replies: 10 comments 2 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

ch1/ch1-06 #176

giscus[bot] bot Jan 26, 2023

ch1/ch1-06

Replies: 10 comments · 2 replies

wlwqq Jan 26, 2023 — with giscus

Sherlockfanchen Apr 16, 2023 — with giscus

lanmao0204 May 30, 2023 — with giscus

CatalinaElf Jun 18, 2023 — with giscus

windqiu Aug 23, 2024 — with giscus

Rexoen Jul 2, 2023 — with giscus

Exercise 1.1

SuperZ3 Jul 12, 2023 — with giscus

corgier Nov 13, 2023 — with giscus

Fi-tang Apr 4, 2024 — with giscus

xianxianghuang Apr 17, 2024 — with giscus

Wizarder54088 Oct 24, 2024 — with giscus

lhy985 Nov 6, 2024 — with giscus

giscus[bot]
bot Jan 26, 2023

Replies: 10 comments 2 replies

wlwqq
Jan 26, 2023 — with giscus

lanmao0204
May 30, 2023 — with giscus

CatalinaElf
Jun 18, 2023 — with giscus

Rexoen
Jul 2, 2023 — with giscus

SuperZ3
Jul 12, 2023 — with giscus

corgier
Nov 13, 2023 — with giscus

Fi-tang
Apr 4, 2024 — with giscus

xianxianghuang
Apr 17, 2024 — with giscus

Wizarder54088
Oct 24, 2024 — with giscus

lhy985
Nov 6, 2024 — with giscus