使用Golang开发一个简易版shell_Golang

之前看到 github 有个 build-your-own-x 的仓库，觉得挺有意思的，有不少有趣的实现。我就想着多尝试实现些这样的小项目，看看不同的领域。一方面提升我的编程能力，另外，也希望能发现一些不错的项目。

今天的项目在 build-your-own-x 中也能找到，即 build your own shell。这个项目能帮助学习 go 如何进行如 io 输入输出、如何发起进程调用等操作。

核心流程

首先，我声明这是个简陋的 shell，但能帮助我们更好理解 shell。它支持如提示符打印、读取用户输入、解析输入内容、执行命令，另外还支持开发内建命令。

如下是演示效果：

接下来，我将从零开始一步步复现我的整个开发过程。

框架搭建

我从创建一个 shell 结构体开始，这是整个 shell 程序的核心，它其中包含一个 bufio.reader 从标准输入读取用户输入。

type shell struct {
  reader      *bufio.reader
}

func newshell() *shell {
  return &shell{
    reader: bufio.newreader(os.stdin),
  }
}

如上，通过 newshell 构造函数创建 shell 实例。这个函数返回一个新的 shell 实例，其中包含了初始化的 bufio.reader。

为了方便扩展，接下来添加了几个方法，分别是：

• printprompt用于打印提示符；

• readinput用于读取用户输入；

• parseinput用于解析输入并分割成命令名和参数；

• executecmd用于执行命令。

定义如下：

func (s *shell) printprompt()
func (s *shell) readinput() (string, error)
func (s *shell) parseinput(input string) (string, []string)
func (s *shell) executecmd(cmdname string, cmdargs []string) error

它们就是核心流程中最重要的四个方法，都是在 runandlisten 方法中被调用，如下所示：

func (s *shell) runandlisten() error {
  for {
    s.printprompt()

    input, err := s.readinput()
    if err != nil {
      fmt.fprintln(os.stderr, err)
      continue
    }

    cmdname, cmdargs := s.parseinput(input)

    if err := s.executecmd(cmdname, cmdargs); err != nil {
      fmt.fprintln(os.stderr, err)
      continue
    }
  }
}

主函数 main 的代码不复杂，如下所示：

func main() {
    s := newshell()
    _ = s.runandlisten()
}

通过 newshell 创建 shell 示例，调用 runandlisten 监听用户输入即可。

接下来，我开始介绍其中每一步的实现过程。

打印提示符

首先，打印提示符的代码，非常简单，如下所示：

func (s *shell) printprompt() {
  fmt.print("$ ")
}

单纯的打印 $ 作为提示符，更复杂的场景可以加上路径提示，如：

[~/demo/shell]$

修改后的代码如下所示：

func (s *shell) printprompt() {
  // 获取当前工作目录
  cwd, err := os.getwd()
  if err != nil {
    // 如果无法获取工作目录，打印错误并使用默认提示符
    fmt.println("error getting current directory:", err)
    fmt.print("$ ")
    return
  }

  // 获取当前用户的home目录
  homedir, err := os.userhomedir()
  if err != nil {
    fmt.println("error getting home directory:", err)
    fmt.print("$ ")
    return
  }

  // 如果当前工作目录以home目录开头，则用'~'替换掉home目录部分
  if strings.hasprefix(cwd, homedir) {
    cwd = strings.replace(cwd, homedir, "~", 1)
  }

  // 打印包含当前工作目录的提示符
  fmt.printf("[%s]$ ", cwd)
}

这是非常粗糙的拿到目录并打印出来。

通常 shell 的提示符是可以自定义，有兴趣可以在这里扩展个接口类型，用于不同提示符的格式化实现。

读取用户输入

最简单的读取用户输入的代码，代码如下：

func (s *shell) readinput() (string, error) {
  input, err := s.reader.readstring('\n')
  if err != nil {
    return "", err
  }

  return input, nil
}

按 \n 分割命令，分割出来的文本可以理解为一次执行请求。

但实际情况是在使用 shell 时，我们会发现一些特殊符号是要处理，如引号。

例如：

[~/demo/shell]$ echo '
hello world!
nice to see you!
'

下面是一个简化的实现：

func (s *shell) readinput() (string, error) {
  var input []rune
  var insinglequote, indoublequote bool

  for {
    r, _, err := s.reader.readrune()
    if err != nil {
      return "", err
    }

    // check for quote toggle
    switch r {
    case '\'':
      insinglequote = !insinglequote
    case '"':
      indoublequote = !indoublequote
  }

    // break on newline if not in quotes
    if r == '\n' && !insinglequote && !indoublequote {
      break
    }

    input = append(input, r)
  }

  return string(input), nil
}

如上的代码中，逐一读取输入内容。程序中，通过判断当前是处于引号中，保证正确识别用户输入。

如果你读过我之前一篇文章，熟练使用 bufio.scanner 类型，也可以用它提供的自定义分割规则的方式，在这个场景下也可以使用。我的完整源码 goshell 就是基于 scanner 实现的。

另外，这个输入不支持删除，如果我输出错了，只能退出重来，也是挺头疼的。如果要实现，要依赖于其他库实现。

解析输入

读取完成，通过 parseinput 方法解析成 cmdname 和 cmdargs，代码如下：

func (s *shell) parseinput(input string) (string, []string) {
  input = strings.trimsuffix(input, "\n")
  input = strings.trimsuffix(input, "\r")

  args := strings.split(input, " ")

  return args[0], args[1:]
}

真正的 shell 肯定比这个强大的多了。最容易想到的，一次 shell 执行请求可能包含多个命令，甚至是 shell 脚本。

太复杂的能力实现起来太麻烦，我们可以支持一个最简单的能力，分号分割运行多个命令。

$ cd /; ls

我们修改代码，支持这个能力。

type cmdrequest struct {
  name string
  args []string
}

func (s *shell) parseinput(input string) []*cmdrequest {
  subinputs := strings.split(input, ";")

  cmdrequests := make([]*cmdrequest, 0, len(subinputs))
  for _, subinput := range subinputs {
    subinput = strings.trim(subinput, " ")
    subinput = strings.trimsuffix(subinput, "\n")
    subinput = strings.trimsuffix(subinput, "\r")
    args := strings.split(subinput, " ")
    cmdrequests = append(cmdrequests, &cmdrequest{name: args[0], args: args[1:]})
  }

  return cmdrequests
}

上面代码里，定义了一个新类型 cmdrequest，它用于保存从用户输入解析而来的命令名和命令参数。

由于修改了 parseinput 的返回类型，runandlisten 中的逻辑就要改动了。

如下所示：

for {
  // ...

  cmdrequests := s.parseinput(input)
  for _, cmdrequest := range cmdrequests {
    cmdname := cmdrequest.name
    cmdargs := cmdrequest.args

    if err := s.executecmd(cmdname, cmdargs); err != nil {
      fmt.fprintln(os.stderr, err)
      continue
    }
  }
}

到此，通过分号分割多命令也是支持的了。

命令执行

最后一步就是执行命令了。代码如下所示：

func (s *shell) executecmd(cmdname string, cmdargs []string) error {
  cmd := exec.command(cmdname, cmdargs...)
  cmd.stderr = os.stderr
  cmd.stdout = os.stdout

  return cmd.run()
}

我使用的是标准库 exec 包中的 command 类型创建一个命令用于执行外部命令。

这个命令的标准输出和标准错误都被设置为当前进程的对应输出，这样命令的输出就可以直接显示给用户。

最后，通过调用 cmd.run() 执行该命令即可。

退出功能

在初步测试中，我发现 shell 还不支持退出。为了解决这个问题，我在 runandlisten 循环中加入了对 exit 命令的检查。

for {
  cmdname := cmdrequest.name
  cmdargs := cmdrequest.args

  if cmdname == "exit" {
    return nil
  }

  if err := s.executecmd(cmdname, cmdargs); err != nil {
  }
}

如果用户输入的是exit，循环将终止，直接退出 shell。

内建命令

现在，如果测试这个代码，看起来运转一切正常。但如果仔细测试，会发现它还不支持 cd 的能力。

为什么 cd 不能用？

因为改变当前目录要修改进程的工作目录，这种操作不能像其他外部命令那样通过创建新进程实现。因此，我引入了内建命令的实现，并实现第一个内建命令了changedircommand。

首先是搭建一个简单框架，定义一个接口：

type builtincmder interface {
    execute(args ...string) error
}

任何实现了这个接口的类型都可以作为内建的命令。

在 shell 类型新建了一个字段，名为 builtincmds ，修改定义如下：

type shell struct {
    reader      *bufio.reader
    builtincmds map[string]builtincmder
}

并添加了一个方法，名为 registerbuiltincmd：

func (s *shell) registerbuiltincmd(cmdname string, cmd builtincmder) {
    s.builtincmds[cmdname] = cmd
}

在 shell 的 executecmd 中新增了内建命令的执行：

func (s *shell) executecmd(cmdname string, cmdargs []string) error {
  if cmd, ok := s.builtincmds[cmdname]; ok {
    return cmd.execute(cmdargs...)
  }

  cmd := exec.command(cmdname, cmdargs...)
  // ...
}

现在，只要实现 changedircommand，并在 main 入口函数注册这个内建就行了。changedircommand 代码和入口注册代码，如下所示：

type changedircommand struct{}

func (c *changedircommand) execute(args ...string) error {
  if len(args) < 2 {
    return errors.new("expected path argument")
  }
  return os.chdir(args[1])
}

func main() {
    s := newshell()

    s.registerbuiltincmd("cd", &changedircommand{})

    _ = s.runandlisten()
}

到此大功搞成，源码地址：goshell