因为花钱买了本GO语言圣经，但是因为懒惰一直没看，因此打算最近好好学习一下Go的基础，至少有点事情干，哈哈哈哈

os.args

go语言中使用os.args来表示命令行参数，os.args本质上是一个slice

os.args[0]是这个命令行本身的名字，os.args[1:]表示的是程序执行时的参数

实操：

  • 版本一
1
2
3
4
5
6
7
8
9
10
11
12
//版本一
func main() {
	var s, sep string  // s,sep 取默认值为空
	for i := 1; i < len(os.Args); i++ {  
		s += sep + os.Args[i]  // 
		sep = " "
	}
	fmt.Println(s)
}
---  输入形式 go run 命令行的名字 参数1，参数2，参数3......
输入：go run main.go hello world guys
输出：hello world guys
  • 版本二

使用for range形式来操作

1
2
3
4
5
6
7
8
9
10
11
12
13
版本二
func main() {
	s, sep := " ", " "
	for _, arg := range os.Args {
		s += sep + arg
		sep = " "
	}
	fmt.Println(s)
}
--
输入：  go run main.go hello world girls 
输出：  C:\Users\何一川\AppData\Local\Temp\go-build1467222032\b001\exe\main.exe 
（前面是命令行本身的名字）	hello world girls （后面是输入的参数）

  • 版本三

    由于’+’连接字符有其缺陷-当新内容传给旧的内容，旧的内容不使用，就会实行垃圾回收，如果数据庞大，就会产生很大的代价，所以可以使用strings.Join（我也第一次见）

1
2
3
4
5
6
7
8
9
10
11
版本三
func main() {
	fmt.Println(strings.Join(os.Args[1:], " "))
}
输出命令的名字
func main() {
	fmt.Println(os.Args[0])
}
--
输入：go run main.go hello world boys
输出：hello world boys

作业

1
2
3
4
5
6
7
8
// 1. 输出命令的名字
func main() {
	fmt.Println(os.Args[0])
}
--
输入： ...
输出： ... 详见上面的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 2. 输出参数的索引和值 , 每行一个
func main() {
	for i, arg := range os.Args {
		fmt.Println(i, " ", arg)
	}
}
--
输入：  go run main.go hello world boys
输出： 
0   C:\Users\何一川\AppData\Local\Temp\go-build2135273963\b001\exe\main.exe
1   hello
2   world
3   boys

知识点

  1. slice 左闭右开
  2. 习惯上，在一个包的声明前，使用注释对其进行描述
  3. 如果变量没有明确的初始化，它将隐式初始化为这个类型的空值
  4. ‘+’这个可以进行数字和字符类型的添加
  5. strings.join 的 连接使用
  6. for是go的唯一循环语句，for{}就可以为无限循环
  7. 多使用s:=” “, var s string ，别使用 var s string = “ “
  8. strings.Join(elems[]string,str string) 传入slice，用str相隔

删除多余行

版本一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	counts := make(map[string]int) 
    // bufio.NewScanner返回的是Scanner对象
	input := bufio.NewScanner(os.Stdin)
	count := 0
    //Scan()方法每一行每一行的输入
	for input.Scan() {
        // input.Text()就是把Scan的拿出来
		counts[input.Text()]++
		count++
        //限定一下条件，不然会一直输入没有输出
		if count == 8 {
			break
		}
	}
	//忽略input.err中的错误
	for line, n := range counts {
		if n > 1 {
			fmt.Printf("%d\t%s\n", n, line)
		}
	}
}
/* --------------------------------------------------------
输出
abcdef
abcdef
abcdef
abcdef
asdf
asdf
ae
ae
4       abcdef
2       asdf
2       ae
*/

版本二

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package main

import (
	"bufio"
	"fmt"
	"os"
)

func countLines(f *os.File, counts map[string]int) {
	input := bufio.NewScanner(f)
	count := 0
	for input.Scan() {
		counts[input.Text()]++
		count++
		if count == 8 {
			break
		}
	}
}

func main() {
	counts := make(map[string]int)
	files := os.Args[1:]
	if len(files) == 0 {
		countLines(os.Stdin, counts) // os.stdin是标准输入
	} else {
		for _, arg := range files {
			f, err := os.Open(arg)  //返回的是*os.file是文件噢
			if err != nil {
				fmt.Fprintf(os.Stderr, "dup2:%v\n", err)//标准输出到命令行
                // os.stderr就是标准输出错误
				continue
			}
			countLines(f, counts)
			f.Close()
		}
	}
	for line, n := range counts {
		if n > 1 {
			fmt.Printf("%d\t%s\n", n, line)
		}
	}
}
/* -------------------------------------------------
首先要在同一目录中 创建一个try.txt
里面的内容是  \n表示换行
okokok\nokokok\nokokok\nokok\nokok\nok\nk
go run main.go try.txt
3       okokok
2       okok
*/
/*----------------------------------------------------
错误示范
 go run main.go hello hello hello he he hh hh hh h
dup2:open hello: The system cannot find the file specified.
dup2:open hello: The system cannot find the file specified.
dup2:open hello: The system cannot find the file specified.
dup2:open he: The system cannot find the file specified.
dup2:open he: The system cannot find the file specified.
dup2:open hh: The system cannot find the file specified.
dup2:open hh: The system cannot find the file specified.
dup2:open hh: The system cannot find the file specified.
dup2:open h: The system cannot find the file specified.
*/ //命令行后要输入文件名而不是字符串

版本三

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"strings"
)

func main() {
	counts := make(map[string]int)
	for _, filename := range os.Args[1:] {
		data, err := ioutil.ReadFile(filename)
		if err != nil {
			fmt.Fprintf(os.Stderr, "dup3:%v")
			continue
		}
		for _ , line := range strings.Split(string(data),"\n"){
			counts[line]++
		}
	}
	for line ,n:= range counts{
		if n>1{
			fmt.Printf("%d\t%s\n",n,line)
		}
	}
}

不想测试了，回寝室了，好困

获取一个URL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package main

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

func main() {
	for _, url := range os.Args[1:] {
		resp, err := http.Get(url)  // 查源码可知，输入一个字符串，返回一个*response
		if err != nil {
			fmt.Fprintf(os.Stderr, "fetch: %v\n", err)
			os.Exit(1) //查源码可知0为成功，非0为失败
		}
		b, err := ioutil.ReadAll(resp.Body)
		resp.Body.Close()  //看看yuanma，为了不泄露资源，body是报文的响应主体
		if err != nil {
			fmt.Fprintf(os.Stderr, "fetch:reading:%s:%v\n", url, err)
			os.Exit(1)
		}
		fmt.Printf("%s", b)
	}
}

/* ---------------------------------------------------------------
go build main.go
./mian.go https://chat.jarvis73.com/
出来一堆乱码看不懂反正*/

Web服务器（迷你）

版本一

1
2
3
4
5
6
7
8
9
10
//实现输出Path
func main() {
	// 这个函数是将处理函数handle和特定URL关联起来
	http.HandleFunc("/", handle)
	log.Fatal(http.ListenAndServe("localhost:8080", nil)) // 特别的写法，返回一个错误
}
func handle(w http.ResponseWriter, r *http.Request) { // http.ReponseWriter代表了一个响应对象（接口），request是请求，有http报文中的各种信息
	fmt.Fprintf(w, "URL.Path = %q \n", r.URL.Path)   // 让其在相应的客户端输出（不一定是浏览器）
}
// 输出为 /Path

版本二

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
实现在输出Path的同时输出访问数量count
var mu sync.Mutex  //锁
var count int  //计数器

func main() {
	http.HandleFunc("/", handle)
	http.HandleFunc("/count", counter)
	log.Fatal(http.ListenAndServe("localhost:8080", nil))
}
func handle(w http.ResponseWriter, r *http.Request) {
	mu.Lock() //用一个锁来保证有多个URL申请时，能够一致的增加
	count++
	mu.Unlock()
	fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
}
func counter(w http.ResponseWriter, r *http.Request) {
	mu.Lock()
	fmt.Fprintf(w, "Count = %d\n", count)
	mu.Unlock()
}
输出  /   path
输出  /count count = n

版本三

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// 实现 报告它接收到的消息头和表单数据
func main() {
	http.HandleFunc("/", handle)
	log.Fatal(http.ListenAndServe("localhost:8080", nil))
}

// Go 的 HTTP 服务器会负责创建一个适当的 `http.ResponseWriter` 对象，并将其传递给你的 `handle` 函数。
// 实际上，HTTP 服务器会创建一个与客户端连接相关联的 `http.ResponseWriter` 对象，然后将其传递给你的 `handle` 函数。
func handle(w http.ResponseWriter, r *http.Request) {
    // 这里表明r中 有报文数据存储
	fmt.Fprintf(w, "%s %s %s\n", r.Method, r.URL, r.Proto)
	for k, v := range r.Header {
		fmt.Fprintf(w, "Header[%q]= %q\n", k, v)
	}
	fmt.Fprintf(w, "Host= %q \n", r.Host)
	fmt.Fprintf(w, "RemoteAddr= %q \n", r.RemoteAddr)
	if err := r.ParseForm(); err != nil {
		log.Println(err)
	}
	for k, v := range r.Form {
		fmt.Fprintf(w, " Form[%q] = %q \n ", k, v)
	}
}
-----------------------------------------------
输出，我使用浏览器执行的
GET / HTTP/1.1
Header["Sec-Ch-Ua"]= ["\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Microsoft Edge\";v=\"120\""]
Header["User-Agent"]= ["Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0"]
Header["Accept-Language"]= ["zh-CN,zh;q=0.9"]
Header["Sec-Fetch-User"]= ["?1"]
Header["Connection"]= ["keep-alive"]
Header["Sec-Ch-Ua-Mobile"]= ["?0"]
Header["Sec-Ch-Ua-Platform"]= ["\"Windows\""]
Header["Accept"]= ["text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7"]
Header["Sec-Fetch-Mode"]= ["navigate"]
Header["Sec-Fetch-Dest"]= ["document"]
Header["Upgrade-Insecure-Requests"]= ["1"]
Header["Sec-Fetch-Site"]= ["none"]
Header["Accept-Encoding"]= ["gzip, deflate, br"]
Host= "localhost:8080"
RemoteAddr= "127.0.0.1:60690"

注意

1
2
3
4
http.HandleFunc("/", func(w http.ResponseWriter,r *http.Request) {
		// 功能实现
	})
// 通过匿名函数来实现功能也是可行的

最后

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//控制流
switch coinflip(){
case "heads":
	heads++
case "tails":
	tails++
default:
	fmt.Println("landed on edge!")
}
---
switch {
case x>0:
	return 0
case x<0:
	return -1
default:
	return 1
}// 不需要加上变量，可以直接当作比较来使用
1
2
3
4
5
//命名类型
type point struct{
	x,y int
}
var p point
1
2
//指针
//可以查询，引用，但是不能算术运算
1
2
3
4
//方法与接口
// 一个关联了命名类型的函数称为方法
// 接口就是基于这些类型所包含的方法
// 包 库

这一篇博客写了好几天，主要是断断续续的，有时间就看看Go圣经，首选是先看Mysql了，但是往往是没有这么多时间空余下来的，因此Go的进度异常的缓慢，过两周又要期末考，估计也没多少时间进行自主学习了，期望寒假多做点事情。