利用GO语言实现简单的CLI

阅读量

前言

这次的作业对于我这种菜鸡来说难度有点大，虽然老师给的参考资料已经很详细的介绍了，selpg的功能、c和python的实现方法。但是真正轮到自己做的时候，还是会有一种无从下手的感觉。由于自己很多地方理解的不到位，所以如果下面的叙述有问题，希望大家指正。

什么是selpg

简单来说，selpg 就是与 ls 、mkdir 等一样的实用的命令行程序，它可以读取终端输入或文件输入，然后根据给定参数，打印输入的指定位置。其命令的参数包括强制选项和可选选项两个部分，格式如下：

-sstart_page -eend_page [ -f | -l lines_per_page ][ -d dest ] [ in_filename ]

  • 强制选项——要求用户在使用命令时一定要加的参数

    • -s+start_page，start_page表示开始页面的页号，为int类型
    • -e+end_page，end_page表示结束页面的页号，也为int类型
    • 需要确保start_page和end_page均大于1，且start_page <= end_page

  • 可选选项——在使用时不一定要加的参数

    • -l+row_num，row_num表示多少行分为一页
    • -f，代表按照分页符(ASCII 为12)分页
    • -d+Destination，表示选定的页直接发送至打印机
    • filename，表示选取的文件名
    • 当-l与-f命令都不存在时，会将页面长度设置为默认长度（默认长度为10行）
    • -l与-f命令是互斥的，不可以同时存在

点击这里，有更详细的介绍

实现难点

  • 了解flag和Pflag的区别，使用Pflag绑定参数，对命令行参数进行解析

  • 实现文件读取与写入的操作

  • 命令的异常处理

    • 命令的异常处理其实就是对与不同的输入情况，进行if条件的分类。其主要的难度在于要怎样使得用尽可能少的if语句，来实现正确的结果

  • 如何使用 pipe 完成打印输出的任务

    • 其实这个，我自己也不是很会，但是大佬告诉我，使用 exec 库的 command，可以调用子进程执行终端命令。大佬博客在这里，大家可以去看看，肯定比我写的好

代码实现

  • 引入需要的包
1
2
3
4
5
6
7
8
9
10
11
12
import (
   
	"bufio"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"os/exec"
	"strconv"

	flag "github.com/spf13/pflag"
)
  • 创建对应的结构体
1
2
3
4
5
6
7
8
type selpg_args struct {
	start_page  int
	end_page    int
	in_filename string
	dest        string
	page_len    int
	page_type   int
}
  • 利用pflag.Parse()绑定参数并解析
1
2
3
4
5
6
pflag.IntVarP(&sa.start_page,"start", "s", 0, "Start page of file")
pflag.IntVarP(&sa.end_page,"end","e", 0, "End page of file")
pflag.IntVarP(&sa.page_len,"linenum", "l", 20, "lines in one page")
pflag.StringVarP(&sa.page_type,"printdes","f", "l", "flag splits page")
pflag.StringVarP(&sa.dest, "destination","d", "", "name of printer")
pflag.Parse()
  • 输入参数处理
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
func process_args(args []string) {
	//参数数量不够
	if len(args) < 3 {
		fmt.Fprintf(os.Stderr, "%s: not enough arguments\n", progname)
		Usage()
		os.Exit(1)
	}
	//处理第一个参数
	if args[1][0] != '-' || args[1][2] != 's' {
		fmt.Fprintf(os.Stderr, "%s: 1st arg should be -sstart_page\n", progname)
		Usage()
		os.Exit(1)
	}
	//提取开始页数
	sp, _ := strconv.Atoi(args[1][2:])
	if sp < 1 {
		fmt.Fprintf(os.Stderr, "%s: invalid start page %d\n", progname, sp)
		Usage()
		os.Exit(1)
	}
	sa.start_page = sp
	//处理第二个参数
	if args[2][0] != '-' || args[2][3] != 'e' {
		fmt.Fprintf(os.Stderr, "%s: 2nd arg should be -eend_page\n", progname)
		Usage()
		os.Exit(1)
	}
	//提取结束页数
	ep, _ := strconv.Atoi(args[2][2:])
	if ep < 1 || ep < sp {
		fmt.Fprintf(os.Stderr, "%s: invalid end page %d\n", progname, ep)
		Usage()
		os.Exit(1)
	}
	sa.end_page = ep

	//其他参数处理
	argindex := 3
	for {
		if argindex > argcount-1 || args[argindex][0] != '-' {
			break
		}
		switch args[argindex][4] {
		case 'l':
			//获取一页的长度
			pl, _ := strconv.Atoi(args[argindex][2:])
			if pl < 1 {
				fmt.Fprintf(os.Stderr, "%s: invalid page length %d\n", progname, pl)
				Usage()
				os.Exit(1)
			}
			sa.page_len = pl
			argindex++
		case 'f':
			if len(args[argindex]) > 2 {
				fmt.Fprintf(os.Stderr, "%s: option should be \"-f\"\n", progname)
				Usage()
				os.Exit(1)
			}
			sa.page_type = 'f'
			argindex++
		case 'd':
			if len(args[argindex]) <= 2 {
				fmt.Fprintf(os.Stderr, "%s: -d option requires a printer destination\n", progname)
				Usage()
				os.Exit(1)
			}
			sa.dest = args[argindex][2:]
			argindex++
		default:
			fmt.Fprintf(os.Stderr, "%s: unknown option", progname)
			Usage()
			os.Exit(1)
		}
	}

	if argindex <= argcount-1 {
		sa.in_filename = args[argindex]
	}
}
  • 文件读取处理
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
func process_input() {
	var cmd *exec.Cmd
	var cmd_in io.WriteCloser
	var cmd_out io.ReadCloser
	if sa.dest != "" {
		cmd = exec.Command("bash", "-c", sa.dest)
		cmd_in, _ = cmd.StdinPipe()
		cmd_out, _ = cmd.StdoutPipe()
		//执行设定的命令
		cmd.Start()
	}
	if sa.in_filename != "" {
		inf, err := os.Open(sa.in_filename)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
		line_count := 1
		page_count := 1
		fin := bufio.NewReader(inf)
		for {
			//读取输入文件中的一行数据
			line, _, err := fin.ReadLine()
			if err != io.EOF && err != nil {
				fmt.Println(err)
				os.Exit(1)
			}
			if err == io.EOF {
				break
			}
			if page_count >= sa.start_page && page_count <= sa.end_page {
				if sa.dest == "" {
					//打印到屏幕
					fmt.Println(string(line))
				} else {
					//写入文件中
					fmt.Fprintln(cmd_in, string(line))
				}
			}
			line_count++
			if sa.page_type == 'l' {
				if line_count > sa.page_len {
					line_count = 1
					page_count++
				}
			} else {
				if string(line) == "\f" {
					page_count++
				}
			}
		}
		if sa.dest != "" {
			cmd_in.Close()
			cmdBytes, err := ioutil.ReadAll(cmd_out)
			if err != nil {
				fmt.Println(err)
			}
			fmt.Print(string(cmdBytes))
			//等待command退出
			cmd.Wait()
		}
	} else {
		//从标准输入读取内容
		ns := bufio.NewScanner(os.Stdin)
		line_count := 1
		page_count := 1
		out := ""

		for ns.Scan() {
			line := ns.Text()
			line += "\n"
			if page_count >= sa.start_page && page_count <= sa.end_page {
				out += line
			}
			line_count++
			if sa.page_type == 'l' {
				if line_count > sa.page_len {
					line_count = 1
					page_count++
				}
			} else {
				if string(line) == "\f" {
					page_count++
				}
			}
		}
		if sa.dest == "" {
			fmt.Print(out)
		} else {
			fmt.Fprint(cmd_in, out)
			cmd_in.Close()
			cmdBytes, err := ioutil.ReadAll(cmd_out)
			if err != nil {
				fmt.Println(err)
			}
			fmt.Print(string(cmdBytes))
			//等待command退出
			cmd.Wait()
		}
	}
}
  • 主函数
1
2
3
4
5
6
7
8
9
10
11
func main() {
   args := os.Args
	sa.start_page = 1
	sa.end_page = 1
	sa.in_filename = ""
	sa.dest = ""
	sa.page_len = 10
	sa.page_type = 'l'
	argcount = len(args)
	process_args(args)
	process_input()}

部分程序测试截图

  • 由于程序测种类较多，下面只有部分测试，有兴趣的话，可以来这里自己运行一下

  • ./selpg -s1 -e1 test.txt - 缺省行数控制


    缺省情况

  • ./selpg -s2 -e2 -l15 test.txt - 控制每页15行


    带参数的情况

  • ./selpg -s1 -e1 -f test.txt - 以分页符作为分页标准


    分页符号

分页输出

  • ./selpg -s1 -e1 -l15 test.txt > out.txt- 将输出定向到 out.txt 文件中


    输出命令

输出文件

  • ./selpg -s1 test.txt 2> error.txt - 将错误输出定向到error.txt 中


    错误命令

错误文件

  • ./selpg -s2 -e2 -dcat test.txt - cat命令


    dcat

体会

  • 这次作业对我来说的挑战，不仅包括作业本身的难度，还有对go语言语法的不够熟悉。所以花费了很多时间，在go语言的语法上。
  • 看了很多大佬的实现，和他们还是有很大的差距。不管是功能实现还是异常处理上，都还有很大的差距
  • 不过自己能做完这次作业已经很开心了，嘿嘿
赏

谢谢你请我吃糖果

 本文总阅读量次

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

<ul > <li> 这里是一个代码功底很差 <li> 但希望变强的小菜鸡 <li> 也许这里刚开始会很简陋 <li> 但一定会渐渐变好^-^ </ul>