标签 Shell 下的文章

在 Linux 系统下,Shell 脚本可以在各种不同的情形下帮到我们,例如展示信息,甚至 自动执行特定的系统管理任务,创建简单的命令行工具等等。

在本指南中,我们将向 Linux 新手展示如何可靠地存储自定义的 shell 脚本,解释如何编写 shell 函数和函数库,以及如何在其它的脚本中使用函数库中的函数。

Shell 脚本要存储在何处

为了在执行你自己的脚本时不必输入脚本所在位置的完整或绝对路径,脚本必须被存储在 $PATH 环境变量所定义的路径里的其中一个。

使用下面的命令可以查看你系统中的 $PATH 环境变量:

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games

通常来说,如果在用户的家目录下存在名为 bin 的目录,你就可以将 shell 脚本存储在那个目录下,因为那个目录会自动地被包含在用户的 $PATH 环境变量中(LCTT 译注:在 Centos 6/7 下是这样的,在 Debian 8 下不是这样的,在 Ubuntu 16.04 下又是这样的)。

因此,在你的主目录下创建 bin 目录吧(当然这里也可以用来存储 Perl、Awk 或 Python 的脚本,或者其它程序):

$ mkdir ~/bin

接着,建立一个名为 lib(libraries 的简写)的目录来存放你自己的函数库。你也可以在其中存放其它编程语言的函数库,如 C ,Python 等语言。在 lib 目录下建立另一个名为 sh 的目录,这个目录将被用来存放你的 shell 函数库:

$ mkdir -p ~/lib/sh 

创建你自己的 Shell 函数和函数库

一个 shell 函数 就是在脚本中能够完成特定任务的一组命令。它们的工作原理与其他编程语言中的过程(LCTT 译注:可能指的是类似 SQL 中的存储过程之类的吧)、子例程、函数类似。

编写一个函数的语法如下:

函数名() { 一系列的命令 } 

( LCTT 校注:在函数名前可以加上 function 关键字,但也可省略不写)

例如,你可以像下面那样在一个脚本中写一个用来显示日期的函数:

showDATE() {date;}

每当你需要显示日期时,只需调用该函数的函数名即可:

$ showDATE

简单来说 shell 函数库也是一个 shell 脚本,不过你可以在一个函数库中仅存储其它 shell 脚本中需要调用的函数。

下面展示的是在我的 ~/lib/sh 目录下一个名为 libMYFUNCS.sh 的库函数:

#!/bin/bash 
### Function to clearly list directories in PATH 
showPATH() { 
  oldifs="$IFS"   ### store old internal field separator
  IFS=:              ### specify a new internal field separator
  for DIR in $PATH<br>  do<br>     echo $DIR<br>  done
  IFS="$oldifs"    ### restore old internal field separator
}
### Function to show logged user
showUSERS() {
  echo -e “Below are the user logged on the system:\n”
  w
}
### Print a user’s details 
printUSERDETS() {
  oldifs="$IFS"    ### store old internal field separator
  IFS=:                 ### specify a new internal field separator
  read -p "Enter user name to be searched:" uname   ### read username
  echo ""
  ### read and store from a here string values into variables
  ### using : as  a  field delimiter
  read -r username pass uid gid comments homedir shell <<< "$(cat /etc/passwd | grep   "^$uname")"
  ### print out captured values
  echo -e "Username is            : $username\n"
  echo -e "User's ID                 : $uid\n"
  echo -e "User's GID              : $gid\n"
  echo -e "User's Comments    : $comments\n"
  echo -e "User's Home Dir     : $homedir\n"
  echo -e "User's Shell             : $shell\n"
  IFS="$oldifs"         ### store old internal field separator
}

保存文件并且给脚本添加执行权限。

如何从函数库中调用函数

要使用某个 lib 目录下的函数,首先你需要按照下面的形式 将包含该函数的函数库导入到需要执行的 shell 脚本中:

$ . /path/to/lib 
或
$ source /path/to/lib

(LCTT 译注:第一行的 . 和路径间必须是有空格的)

这样你就可以像下面演示的那样,在其它的脚本中使用来自 ~/lib/sh/libMYFUNCS.shprintUSERDETS 函数了。

在下面的脚本中,如果要打印出某个特定用户的详细信息,你不必再一一编写代码,而只需要简单地调用已存在的函数即可。

创建一个名为 test.sh 的新文件:

#!/bin/bash 
### include lib
.  ~/lib/sh/libMYFUNCS.sh
### use function from lib
printUSERDETS
### exit script
exit 0

保存这个文件,并使得这个脚本可被执行,然后运行它:

$ chmod 755 test.sh
$ ./test.sh 

Write Shell Functions

编写 shell 函数

在本文中,我们介绍了在哪里可靠地存储 shell 脚本,如何编写自己的 shell 函数和函数库,以及如何在一个普通的 shell 脚本中从函数库中调用库中的某些函数。

在之后,我们还会介绍一种相当简单直接的方式来将 Vim 配置为一个编写 Bash 脚本的 IDE(集成开发环境)。在那之前,记得要经常关注我们 ,如果能和我们分享你对这份指南的想法就更好了。


作者简介:Aaron Kili 是一名 Linux 和 F.O.S.S 爱好者、一名未来的 Linux 系统管理员、web 开发者,目前是一名 TecMint 上的内容创造者,他喜欢计算机相关的工作,并且坚信知识的分享。


via: http://www.tecmint.com/write-custom-shell-functions-and-libraries-in-linux/

作者:Aaron Kili 译者:wcnnbdk1 校对:FSSlc

本文由 LCTT 原创编译,Linux中国 荣誉推出

 title=

世界上对 shell 脚本最好的概念性介绍来自一个老的 AT&T 培训视频 。在视频中,Brian W. Kernighan(awk 中的“k”),Lorinda L. Cherry(bc 作者之一)论证了 UNIX 的基础原则之一是让用户利用现有的实用程序来定制和创建复杂的工具。

Kernighan 的话来说:“UNIX 系统程序基本上是 …… 你可以用来创造东西的构件。…… 管道的概念是 [UNIX] 系统的基础;你可以拿一堆程序 …… 并将它们端到端连接到一起,使数据从左边的一个流到右边的一个,由系统本身管着所有的连接。程序本身不知道任何关于连接的事情;对它们而言,它们只是在与终端对话。”

他说的是给普通用户以编程的能力。

POSIX 操作系统本身就像是一个 API。如果你能弄清楚如何在 POSIX 的 shell 中完成一个任务,那么你可以自动化这个任务。这就是编程,这种日常 POSIX 编程方法的主要方式就是 shell 脚本。

像它的名字那样,shell 脚本就是一行一行你想让你的计算机执行的语句,就像你手动的一样。

因为 shell 脚本包含常见的日常命令,所以熟悉 UNIX 或 Linux(通常称为 POSIX 系统)对 shell 是有帮助的。你使用 shell 的经验越多,就越容易编写新的脚本。这就像学习外语:你心里的词汇越多,组织复杂的句子就越容易。

当您打开终端窗口时,就是打开了 shell 。shell 有好几种,本教程适用于 bashtcshkshzsh 和其它几个。在下面几个部分,我提供一些 bash 特定的例子,但最终的脚本不会用那些,所以你可以切换到 bash 中学习设置变量的课程,或做一些简单的语法调整

如果你是新手,只需使用 bash 。它是一个很好的 shell,有许多友好的功能,它是 Linux、Cygwin、WSL、Mac 默认的 shell,并且在 BSD 上也支持。

Hello world

您可以从终端窗口生成您自己的 hello world 脚本 。注意你的引号;单和双都会有不同的效果(LCTT 译注:想必你不会在这里使用中文引号吧)。

$ echo "#\!/bin/sh" > hello.sh
$ echo "echo 'hello world' " >> hello.sh

正如你所看到的,编写 shell 脚本就是这样,除了第一行之外,就是把命令“回显”或粘贴到文本文件中而已。

像应用程序一样运行脚本:

$ chmod +x hello.sh
$ ./hello.sh
hello world

不管多少,这就是一个 shell 脚本了。

现在让我们处理一些有用的东西。

去除空格

如果有一件事情会干扰计算机和人类的交互,那就是文件名中的空格。您在互联网上看到过:http://example.com/omg%2ccutest%20cat%20photophoto%21%211.jpg 等网址。或者,当你不管不顾地运行一个简单的命令时,文件名中的空格会让你掉到坑里:

$ cp llama pic.jpg ~/photos
cp: cannot stat 'llama': No such file or directory
cp: cannot stat 'pic.jpg': No such file or directory

解决方案是用反斜杠来“转义”空格,或使用引号:

$ touch foo\ bar.txt
$ ls "foo bar.txt"
foo bar.txt

这些都是要知道的重要的技巧,但是它并不方便,为什么不写一个脚本从文件名中删除这些烦人的空格?

创建一个文件来保存脚本,以 释伴 shebang #!) 开头,让系统知道文件应该在 shell 中运行:

$ echo '#!/bin/sh' > despace

好的代码要从文档开始。定义好目的让我们知道要做什么。这里有一个很好的 README:

despace is a shell script for removing spaces from file names.

Usage:
$ despace "foo bar.txt"

现在让我们弄明白如何手动做,并且如何去构建脚本。

假设你有个只有一个 foo bar.txt 文件的目录,比如:

$ ls
hello.sh
foo bar.txt

计算机无非就是输入和输出而已。在这种情况下,输入是 ls 特定目录的请求。输出是您所期望的结果:该目录文件的名称。

在 UNIX 中,可以通过“管道”将输出作为另一个命令的输入,无论在管道的另一侧是什么过滤器。 tr 程序恰好设计为专门修改传输给它的字符串;对于这个例子,可以使用 --delete 选项删除引号中定义的字符。

$ ls "foo bar.txt" | tr --delete ' '
foobar.txt

现在你得到了所需的输出了。

在 Bash shell 中,您可以将输出存储为变量 。变量可以视为将信息存储到其中的空位:

$ NAME=foo

当您需要返回信息时,可以通过在变量名称前面缀上美元符号($ )来引用该位置。

$ echo $NAME
foo

要获得您的这个去除空格后的输出并将其放在一边供以后使用,请使用一个变量。将命令的结果放入变量,使用反引号(`)来完成:

$ NAME=`ls "foo bar.txt" | tr -d ' '`
$ echo $NAME
foobar.txt

我们完成了一半的目标,现在可以从源文件名确定目标文件名了。

到目前为止,脚本看起来像这样:

#!/bin/sh

NAME=`ls "foo bar.txt" | tr -d ' '`
echo $NAME

第二部分必须执行重命名操作。现在你可能已经知道这个命令:

$ mv "foo bar.txt" foobar.txt

但是,请记住在脚本中,您正在使用一个变量来保存目标名称。你已经知道如何引用变量:

#!/bin/sh

NAME=`ls "foo bar.txt" | tr -d ' '`
echo $NAME
mv "foo bar.txt" $NAME

您可以将其标记为可执行文件并在测试目录中运行它。确保您有一个名为 foo bar.txt(或您在脚本中使用的其它名字)的测试文件。

$ touch "foo bar.txt"
$ chmod +x despace
$ ./despace
foobar.txt
$ ls
foobar.txt

去除空格 v2.0

脚本可以正常工作,但不完全如您的文档所述。它目前非常具体,只适用于一个名为 foo\ bar.txt 的文件,其它都不适用。

POSIX 命令会将其命令自身称为 $0,并将其后键入的任何内容依次命名为 $1$2$3 等。您的 shell 脚本作为 POSIX 命令也可以这样计数,因此请尝试用 $1 来替换 foo\ bar.txt

#!/bin/sh

NAME=`ls $1 | tr -d ' '`
echo $NAME
mv $1 $NAME

创建几个新的测试文件,在名称中包含空格:

$ touch "one two.txt"
$ touch "cat dog.txt"

然后测试你的新脚本:

$ ./despace "one two.txt"
ls: cannot access 'one': No such file or directory
ls: cannot access 'two.txt': No such file or directory

看起来您发现了一个 bug!

这实际上不是一个 bug,一切都按设计工作,但不是你想要的。你的脚本将 $1 变量真真切切地 “扩展” 成了:“one two.txt”,捣乱的就是你试图消除的那个麻烦的空格。

解决办法是将变量用以引号封装文件名的方式封装变量:

#!/bin/sh

NAME=`ls "$1" | tr -d ' '`
echo $NAME
mv "$1" $NAME

再做个测试:

$ ./despace "one two.txt"
onetwo.txt
$ ./despace c*g.txt
catdog.txt

此脚本的行为与任何其它 POSIX 命令相同。您可以将其与其他命令结合使用,就像您希望的使用的任何 POSIX 程序一样。您可以将其与命令结合使用:

$ find ~/test0 -type f -exec /path/to/despace {} \;

或者你可以使用它作为循环的一部分:

$ for FILE in ~/test1/* ; do /path/to/despace $FILE ; done

等等。

去除空格 v2.5

这个去除脚本已经可以发挥功用了,但在技术上它可以优化,它可以做一些可用性改进。

首先,变量实际上并不需要。 shell 可以一次计算所需的信息。

POSIX shell 有一个操作顺序。在数学中使用同样的方式来首先处理括号中的语句,shell 在执行命令之前会先解析反引号 ` 或 Bash 中的 $() 。因此,下列语句:

$ mv foo\ bar.txt `ls foo\ bar.txt | tr -d ' '`

会变换成:

$ mv foo\ bar.txt foobar.txt

然后实际的 mv 命令执行,就得到了 foobar.txt 文件。

知道这一点,你可以将该 shell 脚本压缩成:

#!/bin/sh

mv "$1" `ls "$1" | tr -d ' '`

这看起来简单的令人失望。你可能认为它使脚本减少为一个单行并没有必要,但没有几行的 shell 脚本是有意义的。即使一个用简单的命令写的紧缩的脚本仍然可以防止你发生致命的打字错误,这在涉及移动文件时尤其重要。

此外,你的脚本仍然可以改进。更多的测试发现了一些弱点。例如,运行没有参数的 despace 会产生一个没有意义的错误:

$ ./despace
ls: cannot access '': No such file or directory

mv: missing destination file operand after ''
Try 'mv --help' for more information.

这些错误是让人迷惑的,因为它们是针对 lsmv 发出的,但就用户所知,它运行的不是 lsmv,而是 despace

如果你想一想,如果它没有得到一个文件作为命令的一部分,这个小脚本甚至不应该尝试去重命名文件,请尝试使用你知道的变量以及 test 功能来解决。

if 和 test

if 语句将把你的小 despace 实用程序从脚本蜕变成程序。这里面涉及到代码领域,但不要担心,它也很容易理解和使用。

if 语句是一种开关;如果某件事情是真的,那么你会做一件事,如果它是假的,你会做不同的事情。这个 if-then 指令的二分决策正好是计算机是擅长的;你需要做的就是为计算机定义什么是真或假以及并最终执行什么。

测试真或假的最简单的方法是 test 实用程序。你不用直接调用它,使用它的语法即可。在终端试试:

$ if [ 1 == 1 ]; then echo "yes, true, affirmative"; fi
yes, true, affirmative
$ if [ 1 == 123 ]; then echo "yes, true, affirmative"; fi
$

这就是 test 的工作方式。你有各种方式的简写可供选择,这里使用的是 -z 选项,它检测字符串的长度是否为零(0)。将这个想法翻译到你的 despace 脚本中就是:

#!/bin/sh

if [ -z "$1" ]; then
   echo "Provide a \"file name\", using quotes to nullify the space."
   exit 1
fi

mv "$1" `ls "$1" | tr -d ' '`

为了提高可读性,if 语句被放到单独的行,但是其概念仍然是:如果 $1 变量中的数据为空(零个字符存在),则打印一个错误语句。

尝试一下:

$ ./despace
Provide a "file name", using quotes to nullify the space.
$

成功!

好吧,其实这是一个失败,但它是一个漂亮的失败,更重要的是,一个有意义的失败。

注意语句 exit 1 。这是 POSIX 应用程序遇到错误时向系统发送警报的一种方法。这个功能对于需要在脚本中使用 despace ,并依赖于它成功执行才能顺利运行的你或其它人来说很重要。

最后的改进是添加一些东西,以保护用户不会意外覆盖文件。理想情况下,您可以将此选项传递给脚本,所以它是可选的;但为了简单起见,这里对其进行了硬编码。 -i 选项告诉 mv 在覆盖已存在的文件之前请求许可:

#!/bin/sh

if [ -z "$1" ]; then
   echo "Provide a \"file name\", using quotes to nullify the space."
   exit 1
fi

mv -i "$1" `ls "$1" | tr -d ' '`

现在你的 shell 脚本是有意义的、有用的、友好的 - 你是一个程序员了,所以不要停。学习新命令,在终端中使用它们,记下您的操作,然后编写脚本。最终,你会把自己从工作中解脱出来,当你的机器仆人运行 shell 脚本,接下来的生活将会轻松。

Happy hacking!


作者简介:

Seth Kenlon 是一位独立的多媒体艺术家,自由文化倡导者和 UNIX 极客。他是基于 Slackware 的多媒体制作项目(http://slackermedia.ml)的维护者之一


via: https://opensource.com/article/17/1/getting-started-shell-scripting

作者:Seth Kenlon 译者:hkurj 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

运行一条命令时,它都会产生某种输出:要么是该命令的期望结果,或者是该命令执行细节的状态/错误消息。有些时候,你可能想要将某个命令的输出内容存储在一个变量中,以待在后续操作中取出来使用。

本文将介绍将 shell 命令赋值给变量的不同方法,这对于 shell 脚本编程是特别有用的。

可以使用如下形式的 shell 命令置换特性,将命令的输出存储到变量中:

变量名=$(命令)
变量名=$(命令 [命令选项 ...] 参数1 参数2 ...)
或者:
变量名=`命令`
变量名=`命令 [命令选项 ...] 参数1 参数2 ...`

以下是使用命令置换特性的示例:

本例,我们将 who (显示当前登录系统的用户) 的输出值存储到 CURRENT_USERS 变量中:

$ CURRENT_USERS=$(who)

然后,我们可以使用 echo 命令 显示一个句子并使用上述变量,如下:

$ echo -e "以下为登录到系统中的用户:\n\n $CURRENT_USERS"

上面的命令中:-e 标记表示解释所有的转义序列 (如 \n 为换行)。为节约时间和内存,通常在 echo 命令 中直接使用命令置换特性,如下:

$ echo -e "以下为登录到系统中的用户:\n\n $(who)"

显示当前登录系统的用户

在 Linux 中显示当前登录系统的用户

接下来,为了演示上面提到的第二种形式,我们以把当前工作目录下文件数存储到变量 FILES ,然后使用 echo 来输出,如下:

$ FILES=`sudo find . -type f -print | wc -l`
$ echo "当前目录有 $FILES 个文件。"

显示目中包含文件的数量

显示目中包含文件的数量

就是这些了。我们展示了将 shell 命令的输出赋值给变量的方法。你可以在下边的评论反馈区留下你的想法。


作者简介:

Aaron Kili 是一名 Linux 和 F.O.S.S 忠实拥护者、未来的 Linux 系统管理员、Web 开发者,目前是 TecMint 的原创作者,热衷于计算机并乐于知识分享。

译者简介:

GHLandy —— 欲得之,则为之奋斗。 If you want it, work for it.


作者:Aaron Kili 译者:GHLandy 校对:jasminepeng

本文由 LCTT 原创编译,Linux中国 荣誉推出

上篇中,我们已经创建了一个 shell 主循环、切分了命令输入,以及通过 forkexec 执行命令。在这部分,我们将会解决剩下的问题。首先,cd test_dir2 命令无法修改我们的当前目录。其次,我们仍无法优雅地从 shell 中退出。

步骤 4:内置命令

cd test_dir2 无法修改我们的当前目录” 这句话是对的,但在某种意义上也是错的。在执行完该命令之后,我们仍然处在同一目录,从这个意义上讲,它是对的。然而,目录实际上已经被修改,只不过它是在子进程中被修改。

还记得我们分叉(fork)了一个子进程,然后执行命令,执行命令的过程没有发生在父进程上。结果是我们只是改变了子进程的当前目录,而不是父进程的目录。

然后子进程退出,而父进程在原封不动的目录下继续运行。

因此,这类与 shell 自己相关的命令必须是内置命令。它必须在 shell 进程中执行而不是在分叉中(forking)。

cd

让我们从 cd 命令开始。

我们首先创建一个 builtins 目录。每一个内置命令都会被放进这个目录中。

yosh_project
|-- yosh
   |-- builtins
   |   |-- __init__.py
   |   |-- cd.py
   |-- __init__.py
   |-- shell.py

cd.py 中,我们通过使用系统调用 os.chdir 实现自己的 cd 命令。

import os
from yosh.constants import *

def cd(args):
    os.chdir(args[0])

    return SHELL_STATUS_RUN

注意,我们会从内置函数返回 shell 的运行状态。所以,为了能够在项目中继续使用常量,我们将它们移至 yosh/constants.py

yosh_project
|-- yosh
   |-- builtins
   |   |-- __init__.py
   |   |-- cd.py
   |-- __init__.py
   |-- constants.py
   |-- shell.py

constants.py 中,我们将状态常量都放在这里。

SHELL_STATUS_STOP = 0
SHELL_STATUS_RUN = 1

现在,我们的内置 cd 已经准备好了。让我们修改 shell.py 来处理这些内置函数。

...
### 导入常量
from yosh.constants import *

### 使用哈希映射来存储内建的函数名及其引用
built_in_cmds = {}

def tokenize(string):
    return shlex.split(string)

def execute(cmd_tokens):
    ### 从元组中分拆命令名称与参数
    cmd_name = cmd_tokens[0]
    cmd_args = cmd_tokens[1:]

    ### 如果该命令是一个内建命令,使用参数调用该函数
    if cmd_name in built_in_cmds:
        return built_in_cmds[cmd_name](cmd_args)

    ...

我们使用一个 python 字典变量 built_in_cmds 作为 哈希映射 hash map ,以存储我们的内置函数。我们在 execute 函数中提取命令的名字和参数。如果该命令在我们的哈希映射中,则调用对应的内置函数。

(提示:built_in_cmds[cmd_name] 返回能直接使用参数调用的函数引用。)

我们差不多准备好使用内置的 cd 函数了。最后一步是将 cd 函数添加到 built_in_cmds 映射中。

...
### 导入所有内建函数引用
from yosh.builtins import *

...

### 注册内建函数到内建命令的哈希映射中
def register_command(name, func):
    built_in_cmds[name] = func


### 在此注册所有的内建命令
def init():
    register_command("cd", cd)


def main():
    ###在开始主循环之前初始化 shell
    init()
    shell_loop()

我们定义了 register_command 函数,以添加一个内置函数到我们内置的命令哈希映射。接着,我们定义 init 函数并且在这里注册内置的 cd 函数。

注意这行 register_command("cd", cd) 。第一个参数为命令的名字。第二个参数为一个函数引用。为了能够让第二个参数 cd 引用到 yosh/builtins/cd.py 中的 cd 函数引用,我们必须将以下这行代码放在 yosh/builtins/__init__.py 文件中。

from yosh.builtins.cd import *

因此,在 yosh/shell.py 中,当我们从 yosh.builtins 导入 * 时,我们可以得到已经通过 yosh.builtins 导入的 cd 函数引用。

我们已经准备好了代码。让我们尝试在 yosh 同级目录下以模块形式运行我们的 shell,python -m yosh.shell

现在,cd 命令可以正确修改我们的 shell 目录了,同时非内置命令仍然可以工作。非常好!

exit

最后一块终于来了:优雅地退出。

我们需要一个可以修改 shell 状态为 SHELL_STATUS_STOP 的函数。这样,shell 循环可以自然地结束,shell 将到达终点而退出。

cd 一样,如果我们在子进程中分叉并执行 exit 函数,其对父进程是不起作用的。因此,exit 函数需要成为一个 shell 内置函数。

让我们从这开始:在 builtins 目录下创建一个名为 exit.py 的新文件。

yosh_project
|-- yosh
   |-- builtins
   |   |-- __init__.py
   |   |-- cd.py
   |   |-- exit.py
   |-- __init__.py
   |-- constants.py
   |-- shell.py

exit.py 定义了一个 exit 函数,该函数仅仅返回一个可以退出主循环的状态。

from yosh.constants import *

def exit(args):
    return SHELL_STATUS_STOP

然后,我们导入位于 yosh/builtins/__init__.py 文件的 exit 函数引用。

from yosh.builtins.cd import *
from yosh.builtins.exit import *

最后,我们在 shell.py 中的 init() 函数注册 exit 命令。

...

### 在此注册所有的内建命令
def init():
    register_command("cd", cd)
    register_command("exit", exit)

...

到此为止!

尝试执行 python -m yosh.shell。现在你可以输入 exit 优雅地退出程序了。

最后的想法

我希望你能像我一样享受创建 yoshyour own shell)的过程。但我的 yosh 版本仍处于早期阶段。我没有处理一些会使 shell 崩溃的极端状况。还有很多我没有覆盖的内置命令。为了提高性能,一些非内置命令也可以实现为内置命令(避免新进程创建时间)。同时,大量的功能还没有实现(请看 公共特性不同特性)。

我已经在 https://github.com/supasate/yosh 中提供了源代码。请随意 fork 和尝试。

现在该是创建你真正自己拥有的 Shell 的时候了。

Happy Coding!


via: https://hackercollider.com/articles/2016/07/06/create-your-own-shell-in-python-part-2/

作者:Supasate Choochaisri 译者:cposture 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

我很想知道一个 shell (像 bash,csh 等)内部是如何工作的。于是为了满足自己的好奇心,我使用 Python 实现了一个名为 yosh (Your Own Shell)的 Shell。本文章所介绍的概念也可以应用于其他编程语言。

(提示:你可以在这里查找本博文使用的源代码,代码以 MIT 许可证发布。在 Mac OS X 10.11.5 上,我使用 Python 2.7.10 和 3.4.3 进行了测试。它应该可以运行在其他类 Unix 环境,比如 Linux 和 Windows 上的 Cygwin。)

让我们开始吧。

步骤 0:项目结构

对于此项目,我使用了以下的项目结构。

yosh_project
|-- yosh
   |-- __init__.py
   |-- shell.py

yosh_project 为项目根目录(你也可以把它简单命名为 yosh)。

yosh 为包目录,且 __init__.py 可以使它成为与包的目录名字相同的包(如果你不用 Python 编写的话,可以忽略它。)

shell.py 是我们主要的脚本文件。

步骤 1:Shell 循环

当启动一个 shell,它会显示一个命令提示符并等待你的命令输入。在接收了输入的命令并执行它之后(稍后文章会进行详细解释),你的 shell 会重新回到这里,并循环等待下一条指令。

shell.py 中,我们会以一个简单的 main 函数开始,该函数调用了 shell\_loop() 函数,如下:

def shell_loop():
    # Start the loop here

def main():
    shell_loop()

if __name__ == "__main__":
    main()

接着,在 shell_loop() 中,为了指示循环是否继续或停止,我们使用了一个状态标志。在循环的开始,我们的 shell 将显示一个命令提示符,并等待读取命令输入。

import sys

SHELL_STATUS_RUN = 1
SHELL_STATUS_STOP = 0

def shell_loop():
    status = SHELL_STATUS_RUN

    while status == SHELL_STATUS_RUN:
        ### 显示命令提示符
        sys.stdout.write('> ')
        sys.stdout.flush()

        ### 读取命令输入
        cmd = sys.stdin.readline()

之后,我们 切分命令 tokenize 输入并进行 执行 execute (我们即将实现 tokenizeexecute 函数)。

因此,我们的 shell\_loop() 会是如下这样:

import sys

SHELL_STATUS_RUN = 1
SHELL_STATUS_STOP = 0

def shell_loop():
    status = SHELL_STATUS_RUN

    while status == SHELL_STATUS_RUN:
        ### 显示命令提示符
        sys.stdout.write('> ')
        sys.stdout.flush()

        ### 读取命令输入
        cmd = sys.stdin.readline()

        ### 切分命令输入
        cmd_tokens = tokenize(cmd)

        ### 执行该命令并获取新的状态
        status = execute(cmd_tokens)

这就是我们整个 shell 循环。如果我们使用 python shell.py 启动我们的 shell,它会显示命令提示符。然而如果我们输入命令并按回车,它会抛出错误,因为我们还没定义 tokenize 函数。

为了退出 shell,可以尝试输入 ctrl-c。稍后我将解释如何以优雅的形式退出 shell。

步骤 2: 命令切分 tokenize

当用户在我们的 shell 中输入命令并按下回车键,该命令将会是一个包含命令名称及其参数的长字符串。因此,我们必须切分该字符串(分割一个字符串为多个元组)。

咋一看似乎很简单。我们或许可以使用 cmd.split(),以空格分割输入。它对类似 ls -a my_folder 的命令起作用,因为它能够将命令分割为一个列表 ['ls', '-a', 'my_folder'],这样我们便能轻易处理它们了。

然而,也有一些类似 echo "Hello World"echo 'Hello World' 以单引号或双引号引用参数的情况。如果我们使用 cmd.spilt,我们将会得到一个存有 3 个标记的列表 ['echo', '"Hello', 'World"'] 而不是 2 个标记的列表 ['echo', 'Hello World']

幸运的是,Python 提供了一个名为 shlex 的库,它能够帮助我们如魔法般地分割命令。(提示:我们也可以使用正则表达式,但它不是本文的重点。)

import sys
import shlex

...

def tokenize(string):
    return shlex.split(string)

...

然后我们将这些元组发送到执行进程。

步骤 3:执行

这是 shell 中核心而有趣的一部分。当 shell 执行 mkdir test_dir 时,到底发生了什么?(提示: mkdir 是一个带有 test_dir 参数的执行程序,用于创建一个名为 test_dir 的目录。)

execvp 是这一步的首先需要的函数。在我们解释 execvp 所做的事之前,让我们看看它的实际效果。

import os
...

def execute(cmd_tokens):
    ### 执行命令
    os.execvp(cmd_tokens[0], cmd_tokens)

    ### 返回状态以告知在 shell_loop 中等待下一个命令
    return SHELL_STATUS_RUN

...

再次尝试运行我们的 shell,并输入 mkdir test_dir 命令,接着按下回车键。

在我们敲下回车键之后,问题是我们的 shell 会直接退出而不是等待下一个命令。然而,目录正确地创建了。

因此,execvp 实际上做了什么?

execvp 是系统调用 exec 的一个变体。第一个参数是程序名字。v 表示第二个参数是一个程序参数列表(参数数量可变)。p 表示将会使用环境变量 PATH 搜索给定的程序名字。在我们上一次的尝试中,它将会基于我们的 PATH 环境变量查找mkdir 程序。

(还有其他 exec 变体,比如 execv、execvpe、execl、execlp、execlpe;你可以 google 它们获取更多的信息。)

exec 会用即将运行的新进程替换调用进程的当前内存。在我们的例子中,我们的 shell 进程内存会被替换为 mkdir 程序。接着,mkdir 成为主进程并创建 test_dir 目录。最后该进程退出。

这里的重点在于我们的 shell 进程已经被 mkdir 进程所替换。这就是我们的 shell 消失且不会等待下一条命令的原因。

因此,我们需要其他的系统调用来解决问题:fork

fork 会分配新的内存并拷贝当前进程到一个新的进程。我们称这个新的进程为子进程,调用者进程为父进程。然后,子进程内存会被替换为被执行的程序。因此,我们的 shell,也就是父进程,可以免受内存替换的危险。

让我们看看修改的代码。

...

def execute(cmd_tokens):
    ### 分叉一个子 shell 进程
    ### 如果当前进程是子进程,其 `pid` 被设置为 `0`
    ### 否则当前进程是父进程的话,`pid` 的值
    ### 是其子进程的进程 ID。
    pid = os.fork()

    if pid == 0:
    ### 子进程
        ### 用被 exec 调用的程序替换该子进程
        os.execvp(cmd_tokens[0], cmd_tokens)
    elif pid > 0:
    ### 父进程
        while True:
            ### 等待其子进程的响应状态(以进程 ID 来查找)
            wpid, status = os.waitpid(pid, 0)

            ### 当其子进程正常退出时
            ### 或者其被信号中断时,结束等待状态
            if os.WIFEXITED(status) or os.WIFSIGNALED(status):
                break

    ### 返回状态以告知在 shell_loop 中等待下一个命令
    return SHELL_STATUS_RUN

...

当我们的父进程调用 os.fork() 时,你可以想象所有的源代码被拷贝到了新的子进程。此时此刻,父进程和子进程看到的是相同的代码,且并行运行着。

如果运行的代码属于子进程,pid 将为 0。否则,如果运行的代码属于父进程,pid 将会是子进程的进程 id。

os.execvp 在子进程中被调用时,你可以想象子进程的所有源代码被替换为正被调用程序的代码。然而父进程的代码不会被改变。

当父进程完成等待子进程退出或终止时,它会返回一个状态,指示继续 shell 循环。

运行

现在,你可以尝试运行我们的 shell 并输入 mkdir test_dir2。它应该可以正确执行。我们的主 shell 进程仍然存在并等待下一条命令。尝试执行 ls,你可以看到已创建的目录。

但是,这里仍有一些问题。

第一,尝试执行 cd test_dir2,接着执行 ls。它应该会进入到一个空的 test_dir2 目录。然而,你将会看到目录并没有变为 test_dir2

第二,我们仍然没有办法优雅地退出我们的 shell。

我们将会在下篇解决诸如此类的问题。


via: https://hackercollider.com/articles/2016/07/05/create-your-own-shell-in-python-part-1/

作者:Supasate Choochaisri 译者:cposture 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

这个世界上有两种 Linux 用户:敢于冒险的和态度谨慎的。

其中一类用户总是本能的去尝试任何能够戳中其痛点的新选择。他们尝试过不计其数的窗口管理器、系统发行版和几乎所有能找到的桌面插件。

另一类用户找到他们喜欢的东西后,会一直使用下去。他们往往喜欢所使用的系统发行版的默认配置。最先熟练掌握的文本编辑器会成为他们最钟爱的那一个。

作为一个使用桌面版和服务器版十五年之久的 Linux 用户,比起第一类来,我无疑属于第二类用户。我更倾向于使用现成的东西,如此一来,很多时候我就可以通过文档和示例方便地找到我所需要的使用案例。如果我决定选择使用非费标准的东西,这个切换过程一定会基于细致的研究,并且前提是来自好基友的大力推荐。

但这并不意味着我不喜欢尝试新事物并且查漏补失。所以最近一段时间,在我不假思索的使用了 bash shell 多年之后,决定尝试一下另外四个 shell 工具:ksh、tcsh、zsh 和 fish。这四个 shell 都可以通过我所用的 Fedora 系统的默认库轻松安装,并且他们可能已经内置在你所使用的系统发行版当中了。

这里对它们每个选择都稍作介绍,并且阐述下它适合做为你的下一个 Linux 命令行解释器的原因所在。

bash

首先,我们回顾一下最为熟悉的一个。 GNU Bash,又名 Bourne Again Shell,它是我这些年使用过的众多 Linux 发行版的默认选择。它最初发布于 1989 年,并且轻松成长为 Linux 世界中使用最广泛的 shell,甚至常见于其他一些类 Unix 系统当中。

Bash 是一个广受赞誉的 shell,当你通过互联网寻找各种事情解决方法所需的文档时,总能够无一例外的发现这些文档都默认你使用的是 bash shell。但 bash 也有一些缺点存在,如果你写过 Bash 脚本就会发现我们写的代码总是得比真正所需要的多那么几行。这并不是说有什么事情是它做不到的,而是说它读写起来并不总是那么直观,至少是不够优雅。

如上所述,基于其巨大的安装量,并且考虑到各类专业和非专业系统管理员已经适应了它的使用方式和独特之处,至少在将来一段时间内,bash 或许会一直存在。

ksh

KornShell,或许你对这个名字并不熟悉,但是你一定知道它的调用命令 ksh。这个替代性的 shell 于 80 年代起源于贝尔实验室,由 David Korn 所写。虽然最初是一个专有软件,但是后期版本是在 Eclipse Public 许可下发布的。

ksh 的拥趸们列出了他们觉得其优越的诸多理由,包括更好的循环语法,清晰的管道退出代码,处理重复命令和关联数组的更简单的方式。它能够模拟 vi 和 emacs 的许多行为,所以如果你是一个重度文本编辑器患者,它值得你一试。最后,我发现它虽然在高级脚本方面拥有不同的体验,但在基本输入方面与 bash 如出一辙。

tcsh

tcsh 衍生于 csh(Berkely Unix C shell),并且可以追溯到早期的 Unix 和计算机时代开始。

tcsh 最大的卖点在于它的脚本语言,对于熟悉 C 语言编程的人来说,看起来会非常亲切。tcsh 的脚本编写有人喜欢,有人憎恶。但是它也有其他的技术特色,包括可以为 aliases 添加参数,各种可能迎合你偏好的默认行为,包括 tab 自动完成和将 tab 完成的工作记录下来以备后查。

tcsh 以 BSD 许可发布。

zsh

zsh 是另外一个与 bash 和 ksh 有着相似之处的 shell。诞生于 90 年代初,zsh 支持众多有用的新技术,包括拼写纠正、主题化、可命名的目录快捷键,在多个终端中共享同一个命令历史信息和各种相对于原来的 bash 的轻微调整。

虽然部分需要遵照 GPL 许可,但 zsh 的代码和二进制文件可以在一个类似 MIT 许可证的许可下进行分发; 你可以在 actual license 中查看细节。

fish

之前我访问了 fish 的主页,当看到 “好了,这是一个为 90 后而生的命令行 shell” 这条略带调侃的介绍时(fish 完成于 2005 年),我就意识到我会爱上这个交互友好的 shell 的。

fish 的作者提供了若干切换过来的理由,这些理由有点小幽默并且能戳中笑点,不过还真是那么回事。这些特性包括自动建议(“注意, Netscape Navigator 4.0 来了”,LCTT 译注:NN4 是一个重要版本。),支持“惊人”的 256 色 VGA 调色,不过也有真正有用的特性,包括根据你机器上的 man 页面自动补全命令,清除脚本和基于 web 界面的配置方式。

fish 的许可主要基于 GPLv2,但有些部分是在其他许可下的。你可以查看资源库来了解完整信息

如果你想要寻找关于每个选择确切不同之处的详尽纲要,这个网站应该可以帮到你。

我的立场到底是怎样的呢?好吧,最终我应该还是会重新投入 bash 的怀抱,因为对于大多数时间都在使用命令行交互的人来说,切换过程对于编写高级的脚本能带来的好处微乎其微,并且我已经习惯于使用 bash 了。

但是我很庆幸做出了敞开大门并且尝试新选择的决定。我知道门外还有许许多多其他的东西。你尝试过哪些 shell,更中意哪一个?请在评论里告诉我们。


via: https://opensource.com/business/16/3/top-linux-shells

作者:Jason Baker 译者:mr-ping 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出