Shell十三问
2009-05-26 21:13:22 Administrator
SHELL十三问之一:什么是shell?
在介绍 shell 是甚么东西之前,不妨让我们重新检视使用者与计算机系统的关系,我们知道计算机的运作不能离开硬件,但使用者却无法直接对硬件作驱动,硬件的驱动只能透过一个称为"操作系统(Operating System)"的软件来控管,事实上,我们每天所谈的 freebsd、netbsd、openbsd、linux 等等,严格来说只是一个操作系统,我们称之为"核心(kernel)"。然而,从使用者的角度来说,使用者也没办法直接操作 kernel ,而是透过 kernel 的"外壳"程序,也就是所谓的shell ,来与 kernel 沟通。从技术角度来说,shell是一个使用者与系统的互动界面(interface),主要是让使用者透过命令行(command line)来使用系统以完成工作。因此,shell 的最简单的定义就是---命令解译器(Command Interpreter):
* 将使用者的命令翻译给核心处理,
* 同时,将核心处理结果翻译给使用者。
Shell 有很多种,只要能给用户提供命令行环境的程序,都可以看作是 Shell 。历史上,主要的 Shell 有下面这些:
Bourne Shell(sh)
Bourne Again shell(bash)
C Shell(csh)
TENEX C Shell(tcsh)
Korn shell(ksh)
Z Shell(zsh)
Friendly Interactive Shell(fish)
其中 Bash 是目前最常用的 Shell。通过执行 echo $SHELL 命令可以查看到当前正在使用的 Shell;还可以通过 cat /etc/shells 查看当前系统安装的所有 Shell 种类。
每次当我们完成系统登入(login),我们就取得一个互动模式的shell ,也称为 login shell 或 primary shell。若从进程(process)角度来说,我们在 shell 所下达的命令,均是 shell 所产生的子进程。这现象,我们暂可称之为fork。如果是执行脚本(shell script)的话,脚本中的命令则是由另外一个非互动模式的子 shell (sub shell)来执行的。也就是primary shell 产生 sub shell 的进程,sub shell 再产生 script 中所有命令的进程。
FreeBSD的基本系统中可以使用的shell有两个:sh和csh。这两个基本shell的风格不太相同,不同的使用者常常会根据喜好来在两者之间进行选择。当然当前有更好的shell程序可供使用者选择,这些后续的 shell均是根据sh或csh的风格进一步发展出的,因此可以说在shell中,也有两种风格,需要使用者根据自己的使用习惯进行选择。在默认安装下,FreeBSD支持sh、csh、tsch,从/etc/shells中可以看出。
命令提示符补充一下:
如果shell是sh,则提示符为“$”,如果shell是csh,则为“%”,需要注意的是如果是root用户,则提示符为“#”。
sh和csh又有以下不同的分支:
Bourne shell :
burne shell (sh)
burne again shell (bash)
korn shell (ksh)
POSIX shell ( sh) C shell :
c shell (csh)
TENEX/TOPS C shell ( tcsh)
Bourne Shell 最初的UNIX shell是由Stephen R. Bourne于20世纪70年代中期在新泽西的AT&T贝尔实验室编写的,这就是Bourne shell。Bourne shell 是一个交换式的命令解释器和命令编程语言。Bourne shell 可以运行为login shell或者login shell的子shell(subshell)。只有login命令可以调用Bourne shell作为一个login shell。此时,shell先读取/etc/profile文件和$HOME/.profile文件。/etc/profile文件为所有的用户定制环境,$HOME/.profile文件为本用户定制环境。最后,shell会等待读取你的输入。
C Shell Bill Joy于20世纪80年代早期,在Berkeley的加利福尼亚大学开发了C shell。它主要是为了让用户更容易的使用交互式功能,并把ALGOL风格的语法结构变成了C语言风格。它新增了命令历史、别名、文件名替换、作业控制等功能。
有很长一段时间,只有两类shell供人们选择,Bourne shell用来编程,C shell用来交互。为了改变这种状况,AT&T的bell实验室David Korn开发了Korn shell。ksh结合了所有的C shell的交互式特性,并融入了Bourne shell的语法。因此,Korn shell广受用户的欢迎。它还新增了数学计算,进程协作(coprocess)、行内编辑(inline editing)等功能。Korn Shell 是一个交互式的命令解释器和命令编程语言.它符合POSIX——一个操作系统的国际标准.POSIX不是一个操作系统,而是一个目标在于应用程序的移植性的标准——在源程序一级跨越多种平台。
bash是GNU计划的一部分,用来替代Bourne shell。它用于基于GNU的系统如Linux.大多数的Linux(Red Hat, Slackware, Caldera)都以bash作为缺省的shell,并且运行sh时,其实调用的是bash。
POSIX shell 是Korn shell的一个变种. 当前提供POSIX shell的最大卖主是Hewlett-Packard。在HP-UX 11.0 , POSIX shell 就是/bin/sh,而bsh是/usr/old/bin/sh.
各主要操作系统下缺省的shell: AIX 下是Korn Shell. Solaris和FreeBSD缺省的是Bourne shell. HP-UX缺省的是POSIX shell. Linux是Bourne Again shell,输入命令echo $SHELL可查看你用的是什么shell,也可以根据提示符来看,如果shell是sh,则提示符为“$”,如果shell是csh,则为“%”,需要注意的是如果是root用户,则提示符为“#”。
对于管理员来将,要为使用不同shell的用户都设置好基本的环境,就必须了解这两种风格的 shell设置方式。系统登录时,sh将首先执行/etc/profile文件,为每个用户设置最基本的环境,而csh将使用/etc /csh.cshrc,csh.login和csh.logout作为系统csh资源文件。执行了系统级别的登录文件之后,每个用户的shell就在该用户的主目录下寻找该用户个人的资源文件:sh使用.profile文件,csh使用.login和.cshrc文件。这些资源文件均使用相应的shell 语言,/etc/profile和个人目录下的.profile使用sh风格的控制语言,/etc/cshrc和个人目录下的.login、.cshrc 使用csh 风格的控制语言。
系统管理员可以改动这些资源文件,为用户提供一个最方便的使用环境。当然,系统管理员没有必要直接去修改个人主目录下的资源文件,这些文件应该由用户自己管理,但是系统管理员可以在生成帐号时为用户产生缺省的资源文件,以减轻用户设置资源文件的麻烦。adduser命令缺省使用/usr/share/skel下的文件为用户提供各种资源文件的缺省设置,这个目录下除了可以放入shell的资源文件之外,还可以放入其他应用程序的资源文件。由于这些资源文件都是以点开头的隐藏文件,为了表示清楚,在skel目录下使用了一种转换方式,如使用dot.profile 作为.profile的模板。
# ls /usr/share/skel
dot.cshrc dot.login_conf dot.mailrc dot.rhosts
dot.login dot.mail_aliases dot.profile dot.shrc
在 /usr/share/skel中为用户设置的缺省配置文件,在用户生成之后,就不会对用户产生影响了。因此对系统登录文件进行修改更有效和直接。对于 sh风格的用户,可以更改/etc/profile文件,对csh应更改/etc/csh.cshrc文件。在这些文件中可以改动shell使用的环境变量,这样来改变shell的行为方式,或者执行一系列自动操作,完成一些用户登录时需要自动执行的任务。
常用的环境变量:
EDITOR 设置用户常用的编辑器,很多程序查看这个变量来启动具体的编辑器,可以 根据系统的情况更改
HOME 用户的主目录的名字,这个变量由login程序设置,一般不需要更改
DISPLAYX 使用这个环境变量来标识具体的显示位置,格式为“计算机名字:X服务 器序号.显示屏序号” ,例如:xt1:0.0,它不需要在资源文件中进行定义
LANG 系统使用的语言,用于系统的本地化,缺省为 “C” ,具体的设置可以查看 /usr/share/locale 目录,那里定义了不同的语言,可以将其设置为zh_CN.EUC来使得一些软件使用中文字符。
MAIL 用户mail文件的位置,也不需要改动
PATH 使用冒号分隔的一系列路径,系统用它来查找具体可执行程序,因此这个变量非常重要,可以根据具体的情况改动其值。为了安全的原因,不要将当前目录作为执行程序的搜寻路径,尤其对于root用户。这样在当前目录下启动程序,需要加上路径,例如启动当前目录下的a.out 程序,输入 “./a.out” 。
MANPATH 使用冒号分隔的一系列路径,系统用它来查找具体命令的在线手册,设置方法与PATH相同。
PS1sh 风格的shell使用这个变量的值作为提示符,缺省值为 “$”(root为 “#” )。更现代的sh就增强了提示符的灵活性,可以在提示符中加入当前目录、用户名、机器名,命令的序号等。
PS2sh 风格的shell使用这个变量的值作为后续提示符,提示命令还没有完全输入,缺省为 “>;“
TERM 终端的类型,对于需要全屏操作的程序,非常重要。有时要根据情况对设置进行调整。
TZ 时区设置,具体的时区信息位于/usr/share/zoneinfo目录下,需要设置为适合本地时区的标准值
可以将用户的shell设置为特殊的应用程序,来达到对特殊用户进行限制的目的。例如,仅仅给予用户一个电子邮件信箱,但不想给他终端使用权,可以将用户的 shell更改为/bin/true或者其他立即退出的程序。为了安全起见,用户shell应该是一个不存在漏洞的二进制程序,最好不要使用解释性语言脚本作为登录shell。由于系统认可的shell程序是在/etc/shells文件中列出的程序,将特殊用户的shell设置为特殊的应用程序,但这些应用程序没有列入shells文件,那么这个用户就会被一些应用程序区分出与普通用户的差异,从而拒绝提供服务。例如ftp服务器程序ftpd,通过检查用户的shell是不是标准shell,来区分这个用户是普通用户还是用于特定目的的用户。例如通过源代码编译安装mysql的时候,需要首先建立一个 mysql用户,该用户我们不希望他可以登录系统,因此把它的shell设置为/nonexistent:
pw groupadd mysql
pw useradd mysql -g mysql -s /nonexistent
在FreeBSD上,只需留意最接近游标的一个可见的提示符号,通常是如下两者之一:
$:给一般使用者帐号使用
#:给root (管理员)帐号使用
事实上,shell prompt的意思很简单:
* 是shell告诉使用者:您现在可以输入命令行了。我们可以说,使用者只有在得到shell prompt才能打命令行,而cursor是指示键盘在命令行所输入的位置,使用者每输入一个键,cursor就往后移动一格,直到碰到命令行读进 CR(Carriage Return,由Enter键产生)字符为止。
CR的意思也很简单:
*是使用者告诉shell:老兄你可以执行我的命令行了。严格来说:
*所谓的命令行,就是在shell prompt与CR字符之间所输入的文字。(思考:为何我们这里坚持使用CR字符而不说Enter键呢?答案在后面的学习中揭晓。)
不同的命令可接受的命令行格式或有不同,一般情况下,一个标准的命令行格式为如下所列:command-name options argument若从技术细节来看,shell会依据IFS(Internal Field Seperator)将command line所输入的文字给拆解为"字段"(word)。然后再针对特殊字符(meta)先作处理,最后再重组整行command line。
其中的IFS是shell预设使用的字段分隔符,可以由一个及多个如下按键组成:
*空格键(White Space)
*表格键(Tab)
*回车键(Enter)
系统可接受的命令名称(command-name)可以从如下途径获得:
*明确路径所指定的外部命令
*命令别名(alias)
*自定义功能(function)
* shell内建命令(built-in)
* $PATH之下的外部命令
每一个命令行均必须含有命令名称,这是不能缺少的。 原文地址 http://www.bsdlover.cn/html/80/n-180.html
* command_name option argument
echo是一个非常简单、直接的命令:
*将argument送出至标准输出(STDOUT),通常就是在监视器(monitor)上输出。为了更好理解,不如先让我们先跑一下echo命令好了:
$ echo
$
你会发现只有一个空白行,然后又回到shell prompt上了。这是因为echo在预设上,在显示完argument之后,还会送出一个换行符号(new-line charactor)。但是上面的command并没任何的argument,那结果就只剩一个换行符号了...若你要取消这个换行符号,可利用echo的-n option:
$ echo -n
$
不妨让我们回到command line的概念上来讨论上例的echo命令好了:
command line只有command_name(echo)及option(-n),并没有任何argument。要想看看echo的argument,那还不简单﹗接下来,你可试试如下的输入:
$ echo first line
first line
$ echo -n first line
first line $
从上两个echo命令中,你会发现argument的部份显示在你的荧幕,而换行符号则视-n option的有无而别。很明显的,第二个echo由于换行符号被取消了,接下来的shell prompt就接在输出结果同一行了...事实上,echo除了-n options之外,常用选项还有:
-e:启用反斜线控制字符的转换(参考下表)
-E:关闭反斜线控制字符的转换(预设如此)
-n:取消行末之换行符号(与-e选项下的c字符同意)
关于echo命令所支持的反斜线控制字符如下表:
\a:ALERT / BELL (从系统喇叭送出铃声)
\b:BACKSPACE,也就是向左删除键
\c:取消行末之换行符号
\E:ESCAPE,跳脱键
\f:FORMFEED,换页字符
\n:NEWLINE,换行字符
\r:RETURN,回车键
\t:TAB,表格跳位键
\v:VERTICAL TAB,垂直表格跳位键
\\n:ASCII八进位编码(以x开首为十六进制):反斜线本身
(表格资料来自O'Reilly出版社之Learning the Bash Shell, 2nd Ed.)或许,我们可以透过实例来了解echo的选项及控制字符:
例一:
$ echo -e "a\tb\tc\nd\te\tf"
a b c
d e f
上例运用\t来区隔abc还有def,及用\n将def换至下一行。
例二:
$ echo -e "\141\011\142\011\143\012\144\011\145\011\146"
a b c
d e f
与例一的结果一样,只是使用ASCII八进位编码。
例三:
$ echo -e "\x61\x09\x62\x09\x63\x0a\x64\x09\x65\x09\x66"
a b c
d e f
与例二差不多,只是这次换用ASCII十六进制编码。
例四:
$ echo -ne "a\tb\tc\nd\te\bf\a"
a b c
d f $
因为e字母后面是删除键(b),因此输出结果就没有e了。在结束时听到一声铃向,那是a的杰作﹗由于同时使用了-n选项,因此shell prompt紧接在第二行之后。若你不用-n的话,那你在a后再加个c,也是同样的效果。事实上,在日后的shell操作及shell script设计上,echo命令是最常被使用的命令之一。比方说,用echo来检查变量值:
$ A=B
$ echo $A
B
$ echo $
0
(注:关于变量概念,我们留到下两章才跟大家说明。)好了,更多的关于command line的格式,以及echo命令的选项,就请您自行多加练习、运用了...
简单而言(我不敢说这是精确的定议,注一),command line的每一个charactor,分为如下两种:
* literal:也就是普通纯文字,对shell来说没特殊功能。
* meta:对shell来说,具有特定功能的特殊保留字符。
(注一:关于bash shell在处理command line时的顺序说明,请参考O'Reilly出版社之Learning the Bash Shell, 2nd Edition,第177 - 180页的说明,尤其是178页的流程图Figure 7-1 ... )
Literal没甚么好谈的,凡举abcd、123456这些"文字"都是literal ... (easy?)
但meta却常使我们困惑..... (confused)事实上,前两章我们在command line中已碰到两个几乎每次都会碰到的meta:
* IFS:由<space>或<tab>或<enter>三者之一组成(我们常用space )。
* CR:由<enter>产生。
IFS 是用来拆解command line的每一个词(word)用的,因为shell command line是按词来处理的。而CR则是用来结束command line用的,这也是为何我们敲<enter>命令就会跑的原因。除了IFS与CR,常用的meta还有:
=:设定变量。
$:作变量或运算替换(请不要与shell prompt搞混了)。
>:重导向(重定向)stdout。
<:重导向(重定向)stdin。
|:命令管线(管道)。
&:重导向file desCRiptor,或将命令置于背境(后台)执行。
( ):将其内的命令置于nested subshell执行,或用于运算或命令替换。
{ }:将其内的命令置于non-named function中执行,或用在变量替换的界定范围。
;:在前一个命令结束时,而忽略其返回值,继续执行下一个命令。
&&:在前一个命令结束时,若返回值为true,继续执行下一个命令。
||:在前一个命令结束时,若返回值为false,继续执行下一个命令。
!:执行history列表中的命令
...
假如我们需要在command line中将这些保留字符的功能关闭的话,就需要quoting处理了。在bash中,常用的quoting有如下三种方法:
* hard quote:' ' (单引号),凡在hard quote中的所有meta均被关闭。
* soft quote:" " (双引号),在soft quoe中大部份meta都会被关闭,但某些则保留(如$,反引号,反斜杠)。
* escape:\(反斜线),只有紧接在escape (跳脱字符)之后的单一meta才被关闭。
下面的例子将有助于我们对quoting的了解:
$ A=B C#空格键未被关掉,作为IFS处理。
$ C: command not found.
$ echo $A
$ A="B C"#空格键已被关掉,仅作为空格键处理。
$ echo $A
B C
在第一次设定A变量时,由于空格键没被关闭,command line将被解读为:
* A=B然后碰到<IFS>,再执行C命令在第二次设定A变量时,由于空格键被置于soft quote中,因此被关闭,不再作为IFS:
* A=B<space>C事实上,空格键无论在soft quote还是在hard quote中,均会被关闭。Enter键亦然:
$ A='B
> C
> '
$ echo "$A"
B
C
在上例中,由于<enter>被置于hard quote当中,因此不再作为CR字符来处理。这里的<enter>单纯只是一个断行符号(new-line)而已,由于command line并没得到CR字符,因此进入第二个shell prompt (PS2,以>符号表示),command line并不会结束,直到第三行,我们输入的<enter>并不在hard quote里面,因此并没被关闭,此时,command line碰到CR字符,于是结束、交给shell来处理。上例的<enter>要是被置于soft quote中的话,CR也会同样被关闭:
$ A="B
> C
> "
$ echo $A
B C
然而,由于echo $A时的变量没置于soft quote中,因此当变量替换完成后并作命令行重组时,<enter>会被解释为IFS,而不是解释为New Line字符。同样的,用escape亦可关闭CR字符:
$ A=B\
> C\
>
$ echo $A
BC
上例中,第一个<enter>跟第二个<enter>均被escape字符关闭了,因此也不作为CR来处理,但第三个<enter>由于没被跳脱,因此作为CR结束command line。但由于<enter>键本身在shell meta中的特殊性,在跳脱后面,仅仅取消其CR功能,而不会保留其IFS功能。您或许发现光是一个<enter>键所产生的字符就有可能是如下这些可能:
CR
IFS
NL(New Line)
FF(Form Feed)
NULL
...至于甚么时候会解释为甚么字符,这个我就没去深挖了,或是留给读者诸君自行慢慢摸索了...至于soft quote跟hard quote的不同,主要是对于某些meta的关闭与否,以$来作说明:
$ A=B\C
$ echo "$A"
B C
$ echo '$A'
$A
在第一个echo命令行中,$被置于soft quote中,将不被关闭,因此继续处理变量替换,因此echo将A的变量值输出到荧幕,也就得到"B C"的结果。在第二个echo命令行中,$被置于hard quote中,则被关闭,因此$只是一个$符号,并不会用来作变量替换处理,因此结果是$符号后面接一个A字母:$A。
--------------------------------------
练习与思考:如下结果为何不同?
$ A=B\C
$ echo '"$A"'#最外面的是单引号
"$A"
我的理解:外面是单引号,因此里面所有东西都不变
$ echo "'$A'"#最外面的是双引号
'B C'
我的理解:最外面是双引号,因此除了$\`之外,其他的都meta都被关闭,所以$A要最终变量替换后变为B C,所以最终输出结果为'B C'
$ echo '"'$A'"'#先单引号再双引号再单引号
"B C"
我的理解:最外面是单引号,因此应该输出的是"'$A'",但由于"的存在,$A要进行变量替换,变成了'B C',而'内只有B C了,因此'不再起作用了,所以输出结果为"B C"
$ echo "'"$A"'"#先双引号再单引号再双引号
'B C'
我的理解:最外面是双引号,因此除了$\`之外,关闭所有的meta,即这个时候应该输出'"B C"',由于双引号里面已经是B C了,所以不再起作用了,输出B C即可。最终的结果是'B C'
--------------------------------------
在CU的shell版里,我发现有很多初学者的问题,都与quoting理解的有关。比方说,若我们在awk或sed的命令参数中调用之前设定的一些变量时,常会问及为何不能的问题。要解决这些问题,关键点就是:
*区分出shell meta与command meta
前面我们提到的那些meta,都是在command line中有特殊用途的,比方说{ }是将其内一系列command line置于不具名的函式中执行(可简单视为command block ),但是,awk却需要用{ }来区分出awk的命令区段(BEGIN, MAIN, END)。若你在command line中如此输入:
$ awk {print $0} 1.txt
awk: syntax error at source line 1
context is
>>><<<
awk: illegal statement at source line 1
missing }
由于{ } 在 shell 中并没关闭,那 shell 就将 {print $0} 视为 command block ,
但同时又没有" ; "符号作命令区隔,因此就出现 awk 的语法错误结果。
要解决之,可用 hard quote :
$ awk '{print $0}' 1.txt
上面的 hard quote 应好理解,就是将原本的 {、<space>、$(注三)、} 这几个 shell meta 关闭,避免掉在 shell 中遭到处理,而完整的成为 awk 参数中的 command meta 。( 注三:而其中的 $0 是 awk 内建的 field number ,而非awk 的变量,awk 自身的变量无需使用 $ 。),要是理解了 hard quote 的功能,再来理解 soft quote 与 escape 就不难:
$ awk "{print \$0}" 1.txt
$ awk \{print\ \$0\} 1.txt
然而,若你要改变 awk 的 $0 的 0 值是从另一个 shell 变量读进呢?
比方说:已有变量 $A 的值是 0 ,那如何在 command line 中解决 awk 的 $$A 呢?你可以很直接否定掉 hard quoe 的方案:
$ awk '{print $$A}' 1.txt
awk: illegal field $(), name "A"
input record number 1, file 1.txt
source line number 1
那是因为 $A 的 $ 在 hard quote 中是不能替换变量的。聪明的读者(如你!),经过本章学习,我想,应该可以解释为何我们可以使用如下操作了吧:
$ A=0
$ awk "{print \$$A}" 1.txt
$ awk \{print\ \$$A\} 1.txt
$ awk '{print $'$A'}' 1.txt
$ awk '{print $'"$A"'}' 1.txt # 注:"$A" 包在 soft quote 中
或许,你能举出更多的方案呢....^_^
*设定(set)*
在bash中,你可以用"="来设定或重新定义变量的内容:
name=value
在设定变量的时侯,得遵守如下规则:
*等号左右两边不能使用区隔符号(IFS),也应避免使用shell的保留字符(meta charactor)。
*变量名称不能使用$符号。
*变量名称的第一个字母不能是数字(number)。
*变量名称长度不可超过256个字母。
*变量名称及变量值之大小写是有区别的(case sensitive)。
如下是一些变量设定时常见的错误:
A= B:不能有IFS
1A=B:不能以数字开头
$A=B:名称不能有$
a=B:这跟a=b是不同的
如下则是可以接受的设定:
A=" B":IFS被关闭了(请参考前面的quoting章节)
A1=B:并非以数字开头
A=$B:$可用在变量值内
This_Is_A_Long_Name=b:可用_连接较长的名称或值,且大小写有别。
*变量替换(substitution)*
Shell之所以强大,其中的一个因素是它可以在命令行中对变量作替换(substitution)处理。在命令行中使用者可以使用$符号加上变量名称(除了在用=号定义变量名称之外),将变量值给替换出来,然后再重新组建命令行。
比方:
$ A=ls
$ B=la
$ C=/tmp
$ $A -$B $C
(注意:以上命令行的第一个$是shell prompt,并不在命令行之内。)
必需强调的是,我们所提的变量替换,只发生在command line上面。(是的,让我们再回到command line吧﹗)仔细分析最后那行command line,不难发现在被执行之前(在输入CR字符之前),$符号会对每一个变量作替换处理(将变量值替换出来再重组命令行),最后会得出如下命令行:ls -la /tmp
还记得第二章我请大家"务必理解"的那两句吗?若你忘了,那我这里再重贴一遍:
若从技术细节来看,shell会依据IFS(Internal Field Seperator)将command line所输入的文字给拆解为"字段"(word)。然后再针对特殊字符(meta)先作处理,最后再重组整行command line。这里的$就是command line中最经典的meta之一了,就是作变量替换的。在日常的shell操作中,我们常会使用echo命令来查看特定变量的值,例如:
$ echo $A -$B $C
我们已学过,echo命令只单纯将其argument送至"标准输出"(STDOUT,通常是我们的荧幕)。所以上面的命令会在荧幕上得到如下结果:ls -la /tmp
这是由于echo命令在执行时,会先将$A(ls)、$B(la)、跟$C(/tmp)给替换出来的结果。利用shell对变量的替换处理能力,我们在设定变量时就更为灵活了:
A=B
B=$A
这样,B的变量值就可继承A变量"当时"的变量值了。不过,不要以"数学罗辑"来套用变量的设定,比方说:
A=B
B=C
这样并不会让A的变量值变成C。上面是单纯定义了两个不同名称的变量:A与B,它们的值分别是B与C。再如:
A=B
B=$A
A=C
同样也不会让B的值换成C。
若变量被重复定义的话,则原有旧值将被新值所取代,(这不正是"可变的量"吗?^_^)。当我们在设定变量的时侯,请记着这点:
*用一个名称储存一个数值
仅此而已。
此外,我们也可利用命令行的变量替换能力来"扩充"(append)变量值:
A=B:C:D
A=$A:E
这样,第一行我们设定A的值为"B:C:D",然后,第二行再将值扩充为"A:B:C:E"。
上面的扩充范例,我们使用区隔符号( : )来达到扩充目的,要是没有区隔符号的话,如下是有问题的:
A=BCD
A=$AE
因为第二次是将A的值继承$AE的提换结果,而非$A再加E。要解决此问题,我们可用更严谨的替换处理:
A=BCD
A=${A}E
上例中,我们使用{}将变量名称的范围给明确定义出来,如此一来,我们就可以将A的变量值从BCD给扩充为BCDE。
(提示:关于${name}事实上还可做到更多的变量处理能力,这些均属于比较进阶的变量处理,现阶段暂时不介绍了,请大家自行参考数据。如CU的贴子:
http://www.chinaunix.net/forum/viewtopic.phpt=201843)
* export *
严格来说,我们在当前shell中所定义的变量,均属于"本地变量"(local variable),只有经过export命令的"输出"处理,才能成为环境变量(environment variable):
$ A=B
$ export A
或:
$ export A=B
经过export输出处理之后,变量A就能成为一个环境变量供其后的命令使用。在使用export的时侯,请别忘记shell在命令行对变量的"替换"(substitution)处理,
比方说:
$ A=B
$ B=C
$ export $A
上面的命令并未将A输出为环境变量,而是将B作输出,这是因为在这个命令行中,$A会首先被提换出B然后再"塞回"作export的参数。
要理解这个export,事实上需要从process的角度来理解才能透彻。
我将于下一章为大家说明process的观念,敬请留意。
*取消变量*
要取消一个变量,在bash中可使用unset命令来处理:
unset A
与export一样,unset命令行也同样会作变量替换(这其实就是shell的功能之一),
因此:
$ A=B
$ B=C
$ unset $A
事实上所取消的变量是B而不是A。
此外,变量一旦经过unset取消之后,其结果是将整个变量拿掉,而不仅是取消其变量值。如下两行其实是很不一样的:
$ A=
$ unset A
第一行只是将变量A设定为"空值"(nullvalue),但第二行则让变量A不在存在。虽然用眼睛来看,这两种变量状态在如下命令结果中都是一样的:
$ A=
$ echo $A
$ unset A
$ echo $A
请学员务必能识别null value与unset的本质区别,这在一些进阶的变量处理上是很严格的。比方说:
$ str= #设为null
$ var=${str=expr} #定义var
$ echo $var
$ echo $str
$ unset str #取消
$ var=${str=expr} #定义var
$ echo $var
expr
$ echo $str
expr
聪明的读者(yes, you!),稍加思考的话,应该不难发现为何同样的var=${str=expr}在null与unset之下的不同吧?若你看不出来,那可能是如下原因之一:
a.你太笨了
b.不了解var=${str=expr} 这个进阶处理
c.对本篇说明还没来得及消化吸收
e.我讲得不好
不知,你选哪个呢?....^_^
再来解释一下var=${str=expr}:
首先,var=$str这个大家都可理解吧。而接下来的思考方向是,究竟$str这个变量是如下哪一种情况呢:
1) unset
2) null
3) not null
1)假如是unset,那么var=${str=expr}的结果将是:
var=expr
str=expr
2)假如是null,那var=${str=expr}的结果是:
var=
str=
3)假如是not null (比方为xyz ),那var=${str=expr}之结果是:
var=xyz
str=xyz
测试如下:
$ showvar() {
>var=${str=expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
$var is expr
$str is expr
$ str=
$ showvar
$var is
$str is
$ str=xyz
$ showvar
$var is xyz
$str is xyz
接下来,再来看看var=${str:=expr}好了:
1) $str为not set:
var=expr
str=expr
2) $str为null:
var=expr
str=expr
3) $str为not null (str=xyz):
var=xyz
str=xyz
测试如下:
$ showvar() {
> var=${str:=expr}
> echo \$var is $var
> echo \$str is $str
> }
$ unset str
$ showvar
$var is expr
$str is expr
$ str=
$ showvar
$var is expr
$str is expr
$ str=xyz
$ showvar
$var is xyz
$str is xyz
最后比教一下${str=expr}与${str:=expr}:
*两者在not set与not null都一致
*但当null值时,${str=expr}会将$var与$str都设为null,但${str:=expr}则设为expr
从这个再延伸出其它模拟,不防请大家"实作"观查一下有何不同?
var=${str-expr} vs var=${str:-expr}
var=${str+expr} vs var=${str:+expr}
var=${strexpr} vs var=${str:expr}
$ showvar() {
>var=${str-expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
$var is expr
$str is
$ str=
$ showvar
$var is
$str is
$ str=xyz
$ showvar
$var is xyz
$str is xyz
$ showvar() {
>var=${str:-expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
$var is expr
$str is
$ str=
$ showvar
$var is expr
$str is
$ str=xyz
$ showvar
$var is xyz
$str is xyz
可以看出来${str-expr}与${str:-expr}
*两者在$str为not set与not null都一致
*但当null值时,${str-expr}会将$var与$str都设为null,但${str:-expr}则将$var设为expr
$ showvar() {
>var=${str+expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
$var is
$str is
$ str=
$ showvar
$var is expr
$str is
$ str=xyz
$ showvar
$var is expr
$str is xyz
$ showvar() {
>var=${str:+expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
$var is
$str is
$ str=
$ showvar
$var is
$str is
$ str=xyz
$ showvar
$var is expr
$str is xyz
可以看出来${str+expr}与${str:+expr}
*两者在$str为not set与not null都一致
*但当null值时,${str+expr}会将$var与$str都设为expr,但${str:+expr}则将$var设为null
$ showvar() {
>var=${strexpr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
expr
$ str=
$ showvar
$var is
$str is
$ str=xyz
$ showvar
$var is xyz
$str is xyz
$ showvar() {
>var=${str:expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
expr
$ str=
$ showvar
expr
$ str=xyz
$ showvar
$var is xyz
$str is xyz
可以看出来${strexpr}与${str:expr}
*两者在$str为not set与not null都一致
*但当null值时,${strexpr}会将$var与$str都设为null,但${str:expr}则将$var设为expr
综上所述:
$var=${str=expr}与$var=${str:=expr}
$var=${str-expr}与$var=${str:-expr}
$var=${str+expr}与$var=${str:+expr}
$var=${strexpr}与$var=${str:expr}
* 两者在 $str 为not set 与 not null 都一致
* 但当 null 值时不一致
分别描述如下:
$var=${str:-expr}的功能:
当str非空的时候var赋值为str,否则(包括not set和null)将var赋值为expr
$var=${str-expr}的功能:
当str非空的时候var赋值为str,为空的时候var设置为null,not set的时候将var赋值为expr
$var=${str:=expr}的功能:
当str非空的时候var赋值为str,否则(包括not set和null)将var和str均赋值为expr
$var=${str=expr}的功能:
当str非空的时候var赋值为str,为空的时候var设置为null,not set的时候将var和str均赋值为expr
$var=${str:expr}的功能:
当str非空的时候var赋值为expr,否则将expr写入标准错误后退出
$var=${strexpr}的功能:
当str非空的时候var赋值为expr,为空的时候var设置为null,not set的时候将expr写入标准错误后退出
$var=${str:+expr}的功能:
当str非空的时候var赋值为expr,否则将不做任何操作
$var=${str+expr}的功能:
当str非空的时候var赋值为expr,为空的时候var设置为expr,not set的时候不做任何操作
看来还是带有冒号的简单,只有两种情况:非空和其他,呵呵
原文地址 http://www.bsdlover.cn/html/83/n-183.html
SHELL十三问之六:exec 跟 source 差在哪?
这次先让我们从CU Shell版的一个实例贴子来谈起吧,例中的提问是:
cd /etc/aa/bb/cc可以执行,但是把这条命令写入shell时shell不执行!这是什么原因呀!
我当时如何回答暂时别去深究,先让我们了解一下进程(process)的观念好了。首先,我们所执行的任何程序,都是由父进程(parent process)所产生出来的一个子进程(child process),子进程在结束后,将返回到父进程去。此一现像在Linux系统中被称为 fork。当子进程被产生的时候,将会从父进程那里获得一定的资源分配、及(更重要的是)继承父进程的环境﹗
让我们回到上一章所谈到的"环境变量"吧:
*所谓环境变量其实就是那些会传给子进程的变量。简单而言,"遗传性"就是区分本地变量与环境变量的决定性指标。然而,从遗传的角度来看,我们也不难发现环境变量的另一个重要特征:
*环境变量只能从父进程到子进程单向继承。换句话说:在子进程中的环境如何变更,均不会影响父进程的环境。
接下来,再让我们了解一下命令脚本(shell script)的概念。所谓的shell script讲起来很简单,就是将你平时在shell prompt后所输入的多行command line依序写入一个文件去而已。其中再加上一些条件判断、互动界面、参数运用、函数调用、等等技巧,得以让script更加"聪明"的执行,但若撇开这些技巧不谈,我们真的可以简单的看成script只不过依次执行预先写好的命令行而已。
再结合以上两个概念(process + script),那应该就不难理解如下这句话的意思了:
*正常来说,当我们执行一个shell script时,其实是先产生一个sub-shell的子进程,然后sub-shell再去产生命令行的子进程。然则,那让我们回到本章开始时所提到的例子再从新思考:
cd /etc/aa/bb/cc可以执行,但是把这条命令写入shell时shell不执行!
这是什么原因呀!
我当时的答案是这样的:
因为,一般我们跑的shell script是用subshell去执行的。从process的观念来看,是parent process产生一个child process去执行,当child结束后,会返回parent,但parent的环境是不会因child的改变而改变的。所谓的环境元数很多,凡举 effective id, variable, workding dir等等...其中的workding dir ($PWD)正是楼主的疑问所在:当用subshell来跑script的话,sub shell的$PWD会因为cd而变更,但当返回primary shell时,$PWD是不会变更的。
能够了解问题的原因及其原理是很好的,但是?如何解决问题恐怕是我们更感兴趣的﹗是吧?^_^
那好,接下来,再让我们了解一下source命令好了。
当你有了fork的概念之后,要理解source就不难:
*所谓source就是让script在当前shell内执行、而不是产生一个sub-shell来执行。
由于所有执行结果均于当前shell内完成,若script的环境有所改变,当然也会改变当前环境了﹗因此,只要我们要将原本单独输入的script命令行变成source命令的参数,就可轻易解决前例提到的问题了。比方说,原本我们是如此执行 script的:
./my.script
现在改成这样即可:
source ./my.script
或:
. ./my.script
说到这里,我想,各位有兴趣看看/etc底下的众多设定文件,应该不难理解它们被定义后,如何让其它script读取并继承了吧?若然,日后你有机会写自己的script,应也不难专门指定一个设定文件以供不同的script一起"共享"了... ^_^
okay,到这里,若你搞得懂fork与source的不同,那接下来再接受一个挑战:
----那exec又与source/fork有何不同呢?
哦...要了解exec或许较为复杂,尤其扯上File Descriptor的话...
不过,简单来说:
* exec也是让script在同一个进程上执行,但是原有进程则被结束了。也就是简而言之:原有进程会否终止,就是exec与source/fork的最大差异了。嗯,光是从理论去理解,或许没那么好消化,不如动手"实作+思考"来的印像深刻哦。下面让我们写两个简单的script,分别命令为1.sh及 2.sh:
1.sh
#!/bin/sh
A=B
echo "PID for 1.sh before exec/source/fork:$$"
export A
echo "1.sh: \$A is $A"
case $1 in
exec)
echo "using exec..."
exec ./2.sh ;;
source)
echo "using source..."
. ./2.sh ;;
*)
echo "using fork by default..."
./2.sh ;;
esac
echo "PID for 1.sh after exec/source/fork:$$"
echo "1.sh: \$A is $A"
2.sh
#!/bin/sh
echo "PID for 2.sh: $$"
echo "2.sh get \$A=$A from 1.sh"
A=C
export A
echo "2.sh: \$A is $A"
然后,分别跑如下参数来观察结果:
$ ./1.sh fork
PID for 1.sh before exec/source/fork:531
1.sh: $A is B
using fork by default...
PID for 2.sh:532
2.sh get $A=B from 1.sh
2.sh: $A is C
PID for 1.sh after exec/source/fork:531
1.sh: $A is B
$ ./1.sh source
PID for 1.sh before exec/source/fork:533
1.sh: $A is B
using source...
PID for 2.sh:533
2.sh get $A=B from 1.sh
2.sh: $A is C
PID for 1.sh after exec/source/fork:533
1.sh: $A is C
$ ./1.sh exec
PID for 1.sh before exec/source/fork:537
1.sh: $A is B
using exec...
PID for 2.sh:537
2.sh get $A=B from 1.sh
2.sh: $A is C
############
echo "PID for 1.sh after exec/source/fork:$$"
echo "1.sh: \$A is $A"
已经不会执行了,1.sh的进程已经没了。
##############
SHELL十三问之七:( ) 与 { } 差在哪?
先说一下,为何要用( )或{ }好了。许多时候,我们在shell操作上,需要在一定条件下一次执行多个命令,也就是说,要么不执行,要么就全执行,而不是每次依序的判断是否要执行下一个命令。或是,需要从一些命令执行优先次顺中得到豁免,如算术的2*(3+4)那样...
这时候,我们就可引入"命令群组"(command group)的概念:将多个命令集中处理。在shell command line中,一般人或许不太计较( )与{ }这两对符号的差异,虽然两者都可将多个命令作群组化处理,但若从技术细节上,却是很不一样的:
( )将command group置于sub-shell去执行,也称nested sub-shell。
{ }则是在同一个shell内完成,也称为non-named command group。
如果你对上一章的fork与source的概念还记得的话,那就不难理解两者的差异了。
要是在command group中扯上变量及其它环境的修改,我们可以根据不同的需求来使用( )或{ }。通常而言,若所作的修改是临时的,且不想影响原有或以后的设定,那我们就nested sub-shell,反之,则用non-named command group。是的,光从command line来看,( )与{ }的差别就讲完了,够轻松吧~~~ ^_^
然而,若这两个meta用在其它command meta或领域中(如Regular Expression),还是有很多差别的。只是,我不打算再去说明了,留给读者自己慢慢发掘好了...
我这里只想补充一个概念,就是function。
所谓的function,就是用一个名字去命名一个 command group,然后再调用这个名字去执行command group。从non-named command group来推断,大概你也可以猜到我要说的是{ }了吧?
在bash中,function的定义方式有两种:
方式一:
function function_name {
command1
command2
command3
....
}
方式二:
fuction_name () {
command1
command2
command3
....
}
用哪一种方式无所谓,只是若碰到所定义的名称与现有的命令或别名(Alias)冲突的话,方式二或许会失败。但方式二起码可以少打function这一串英文字母,对懒人来说(如我),又何乐不为呢?... ^_^
function在某一程度来说,也可称为"函式",但请不要与传统编程所使用的函式(library)搞混了,毕竟两者差异很大。惟一相同的是,我们都可以随时用"已定义的名称"来调用它们...
若我们在shell操作中,需要不断的重复执行某些命令,我们首先想到的,或许是将命令写成命令稿(shell script)。不过,我们也可以写成function,然后在command line中打上function_name就可当一舨的script来使用了。只是若你在shell中定义的function,除了可用unset function_name取消外,一旦退出shell,function也跟着取消。然而,在script中使用function却有许多好处,除了可以提高整体script的执行效能外(因为已被加载),还可以节省许多重复的代码...
简单而言,若你会将多个命令写成script以供调用的话,那,你可以将function看成是script中的script ... ^_^而且,透过上一章介绍的source命令,我们可以自行定义许许多多好用的function,再集中写在特定文件中,然后,在其它的script中用source将它们加载并反复执行。若你是RedHat Linux的使用者,或许,已经猜得出/etc/rc.d/init.d/functions这个文件是作啥用的了~~~ ^_^
SHELL十三问之八:$(( )) 与 $( ) 还有${ } 差在哪?
我们上一章介绍了( )与{ }的不同,这次让我们扩展一下,看看更多的变化:$( )与${ }又是啥玩意儿呢?
在bash shell中,$( )与` ` (反引号)都是用来做命令替换用(command substitution)的。所谓的命令替换与我们第五章学过的变量替换差不多,都是用来重组命令行:
*完成引号里的命令行,然后将其结果替换出来,再重组命令行。
例如:
$ echo the last sunday is $(date -d "last sunday" +%Y-%m-%d)
如此便可方便得到上一星期天的日期了...
上例是在linux下,在FreeBSD下应该用下面的:
echo the last Sunday is `date –v Sunday +%Y%m%d`
在操作上,用$( )或` `都无所谓,只是我"个人"比较喜欢用$( ),理由是:
1, ` `很容易与' ' (单引号)搞混乱,尤其对初学者来说。
有时在一些奇怪的字形显示中,两种符号是一模一样的(直竖两点)。当然了,有经验的朋友还是一眼就能分辩两者。只是,若能更好的避免混乱,又何乐不为呢?
2,在多层次的复合替换中,` `须要额外的跳脱( \` )处理,而$( )则比较直观。例如:
这是错的:
command1 `command2 `command3` `
原本的意图是要在command2 `command3`先将command3提换出来给command 2处理,然后再将结果传给command1 `command2 ...`来处理。然而,真正的结果在命令行中却是分成了`command2 `与``两段。正确的输入应该如下:
command1 `command2 \`command3\` `
要不然,换成$( )就没问题了:
command1 $(command2 $(command3))
只要你喜欢,做多少层的替换都没问题啦~~~ ^_^
不过,$( )并不是没有弊端的...
首先,` `基本上可用在全部的unix shell中使用,若写成shell script,其移植性比较高。而$( )并不见的每一种shell都能使用,我只能跟你说,若你用bash2的话,肯定没问题... 接下来,再让我们看${ }吧...它其实就是用来作变量替换用的啦。一般情况下,$var与${var}并没有啥不一样。但是用${ }会比较精确的界定变量名称的范围,比方说:
$ A=B
$ echo $AB
原本是打算先将$A的结果替换出来,然后再补一个B字母于其后,但在命令行上,真正的结果却是只会替换变量名称为AB的值出来...若使用${ }就没问题了:
$ echo ${A}B
BB
不过,假如你只看到${ }只能用来界定变量名称的话,那你就实在太小看bash了﹗有兴趣的话,你可先参考一下cu本版的精华文章:
http://www.chinaunix.net/forum/viewtopic.phpt=201843
为了完整起见,我这里再用一些例子加以说明${ }的一些特异功能:
假设我们定义了一个变量为:file=/dir1/dir2/dir3/my.file.txt
我们可以用${ }分别替换获得不同的值:
${file#*/}:拿掉第一条/及其左边的字符串:dir1/dir2/dir3/my.file.txt
${file##*/}:拿掉最后一条/及其左边的字符串:my.file.txt
${file#*.}:拿掉第一个. 及其左边的字符串:file.txt
${file##*.}:拿掉最后一个. 及其左边的字符串:txt
${file%/*}:拿掉最后条/及其右边的字符串:/dir1/dir2/dir3
${file%%/*}:拿掉第一条/及其右边的字符串:(空值)
${file%.*}:拿掉最后一个. 及其右边的字符串:/dir1/dir2/dir3/my.file
${file%%.*}:拿掉第一个. 及其右边的字符串:/dir1/dir2/dir3/my
记忆的方法为:
#是去掉左边(在鉴盘上#在$之左边)
%是去掉右边(在鉴盘上%在$之右边)
单一符号是最小匹配﹔两个符号是最大匹配。
${file:0:5}:提取最左边的5个字节:/dir1
${file:5:5}:提取第5个字节右边的连续5个字节:/dir2
我们也可以对变量值里的字符串作替换:
${file/dir/path}:将第一个dir替换为path:/path1/dir2/dir3/my.file.txt
${file//dir/path}:将全部dir替换为path:/path1/path2/path3/my.file.txt
利用${ }还可针对不同的变量状态赋值(没设定、空值、非空值):
${file-my.file.txt}:假如$file没有设定,则使用my.file.txt作传回值。(空值及非空值时不作处理)
${file:-my.file.txt}:假如$file没有设定或为空值,则使用my.file.txt作传回值。(非空值时不作处理)
${file+my.file.txt}:假如$file设为空值或非空值,均使用my.file.txt作传回值。(没设定时不作处理)
${file:+my.file.txt}:若$file为非空值,则使用my.file.txt作传回值。(没设定及空值时不作处理)
${file=my.file.txt}:若$file没设定,则使用my.file.txt作传回值,同时将$file赋值为my.file.txt。(空值及非空值时不作处理)
${file:=my.file.txt}:若$file没设定或为空值,则使用my.file.txt作传回值,同时将$file赋值为my.file.txt。(非空值时不作处理)
${filemy.file.txt}:若$file没设定,则将my.file.txt输出至STDERR。(空值及非空值时不作处理)
${file:my.file.txt}:若$file没设定或为空值,则将my.file.txt输出至STDERR。(非空值时不作处理)
tips:
以上的理解在于,你一定要分清楚unset与null及non-null这三种赋值状态。一般而言, :与null有关,若不带:的话, null不受影响,若带:则连null也受影响.
还有哦,${#var}可计算出变量值的长度:
${#file}可得到27,因为/dir1/dir2/dir3/my.file.txt刚好是27个字节...
接下来,再为大家介稍一下bash的组数(array)处理方法。一般而言,A="a b c def"这样的变量只是将$A替换为一个单一的字符串,但是改为A=(a b c def),则是将$A定义为组数...bash的组数替换方法可参考如下方法:
${A[@]}或${A
}可得到a b c def (全部组数)
${A[0]}可得到a (第一个组数),${A[1]}则为第二个组数...
${#A[@]}或${#A
}可得到4 (全部组数数量)
${#A[0]}可得到1 (即第一个组数(a)的长度),${#A[3]}可得到3 (第四个组数(def)的长度)
A[3]=xyz则是将第四个组数重新定义为xyz ...
诸如此类的....
能够善用bash的$( )与${ }可大大提高及简化shell在变量上的处理能力哦,好了,最后为大家介绍$(( ))的用途吧:它是用来作整数运算的。在bash中,$(( ))的整数运算符号大致有这些:
+ - * /:分别为"加、减、乘、除"。
%:余数运算
& | ^ !:分别为"AND、OR、XOR、NOT"运算。
例:
$ a=5; b=7; c=2
$ echo $(( a+b*c ))
19
$ echo $(( (a+b)/c ))
6
$ echo $(( (a*b)%c))
1
在$(( ))中的变量名称,可于其前面加$符号来替换,也可以不用,如:
$(( $a + $b * $c))也可得到19的结果
此外,$(( ))还可作不同进位(如二进制、八进位、十六进制)作运算呢,只是,输出结果皆为十进制而已:echo $((16#2a))结果为42 (16进位转十进制),以一个实用的例子来看看吧:假如当前的 umask是022,那么新建文件的权限即为:
$ umask 022
$ echo "obase=8;$(( 8#666 & (8#777 ^ 8#$(umask)) ))" | bc
644
事实上,单纯用(( ))也可重定义变量值,或作testing:
a=5; ((a++))可将$a重定义为6
a=5; ((a--))则为a=4
a=5; b=7; ((a < b))会得到 0 (true)的返回值。
常见的用于(( ))的测试符号有如下这些:
<:小于
>:大于
<=:小于或等于
>=:大于或等于
==:等于
!=:不等于
不过,使用(( ))作整数测试时,请不要跟[ ]的整数测试搞混乱了。(更多的测试我将于第十章为大家介绍),上面的介绍,并没有详列每一种可用的状态,更多的,就请读者参考手册文件啰...
在shell script中,我们可用$0, $1, $2, $3 ...这样的变量分别提取命令行中的如下部份:
script_name parameter1 parameter2 parameter3 ...
我们很容易就能猜出$0就是代表shell script名称(路径)本身,而$1就是其后的第一个参数,如此类推....须得留意的是IFS的作用,也就是,若IFS被quoting处理后,那么positional parameter也会改变。
如下例:
my.sh p1 "p2 p3" p4
由于在p2与p3之间的空格键被soft quote所关闭了,因此my.sh中的$2是"p2 p3"而$3则是p4 ...
还记得前两章我们提到fucntion时,我不是说过它是script中的script吗? ^_^是的,function一样可以读取自己的(有别于script的) postitional parameter,惟一例外的是$0而已。举例而言:假设my.sh里有一个fucntion叫my_fun ,若在script中跑my_fun fp1 fp2 fp3,那么,function内的$0是my.sh,而$1则是fp1而非p1了...
不如写个简单的my.sh script 看看吧:
#!/bin/bash
my_fun() {
echo '$0 inside function is '$0
echo '$1 inside function is '$1
echo '$2 inside function is '$2
}
echo '$0 outside function is '$0
echo '$1 outside function is '$1
echo '$2 outside function is '$2
my_fun fp1 "fp2 fp3"
然后在command line中跑一下script就知道了:
chmod +x my.sh
./my.sh p1 "p2 p3"
$0 outside function is ./my.sh
$1 outside function is p1
$2 outside function is p2 p3
$0 inside function is ./my.sh
$1 inside function is fp1
$2 inside function is fp2 fp3
然而,在使用positional parameter的时候,我们要注意一些陷阱哦:
* $10不是替换第10个参数,而是替换第一个参数($1)然后再补一个0于其后!也就是,my.sh one two three four five six seven eigth nine ten这样的command line,my.sh里的$10不是ten而是one0哦...小心小心!要抓到ten的话,有两种方法:
方法一是使用我们上一章介绍的${ },也就是用${10}即可。
方法二,就是shift了。
用通俗的说法来说,所谓的shift就是取消positional parameter中最左边的参数( $0不受影响)。其默认值为1,也就是shift或shift 1 都是取消$1,而原本的$2则变成$1、$3变成$2 ...若shift 3则是取消前面三个参数,也就是原本的$4将变成$1 ...那,亲爱的读者,你说要shift掉多少个参数,才可用$1取得${10}呢?^_^
okay,当我们对positional parameter有了基本概念之后,那再让我们看看其它相关变量吧。首先是$#:它可抓出positional parameter的数量。以前面的my.sh p1 "p2 p3"为例:
由于p2与p3之间的IFS是在soft quote中,因此$#可得到2的值。但如果p2与p3没有置于quoting中话,那$#就可得到3的值了。同样的道理在function中也是一样的...因此,我们常在shell script里用如下方法测试script是否有读进参数:
[ $# = 0 ]
假如为0,那就表示script没有参数,否则就是有带参数...
接下来就是$@与$*:
精确来讲,两者只有在soft quote中才有差异,否则,都表示"全部参数"( $0除外)。举例来说好了:
若在command line上跑my.sh p1 "p2 p3" p4的话,
不管是$@还是$*,都可得到p1 p2 p3 p4就是了。
但是,如果置于soft quote中的话:
"$@"则可得到"p1" "p2 p3" "p4"这三个不同的词段(word)﹔
"$*"则可得到"p1 p2 p3 p4"这一整串单一的词段。
我们可修改一下前面的my.sh,使之内容如下:
#!/bin/bash
my_fun() {
echo "$#"
}
echo 'the number of parameter in "$@" is '$(my_fun "$@")
echo 'the number of parameter in "$*" is '$(my_fun "$*")
然后再执行./my.sh p1 "p2 p3" p4就知道$@与$*差在哪了...
the number of parameter in "$@" is3
the number of parameter in "$*" is1
SHELL十三问之十:&& 与 || 差在哪?
在解答本章题目之前,先让我们了解一个概念:return value !
我们在 shell 下跑的每一个 command 或 function ,在结束的时候都会传回父进程一个值,称为 return value 。在 shell command line 中可用 $ 这个变量得到最"新"的一个 return value ,也就是刚结束的那个进程传回的值。Return Value(RV) 的取值为 0-255 之间,由程序(或 script)的作者自行决定:
* 若在 script 里,用 exit RV 来指定其值,若没指定,在结束时以最后一道命令之 RV 为值。
* 若在 function 里,则用 return RV 来代替 exit RV 即可。
Return Value 的作用,是用来判断进程的退出状态(exit status),只有两种:
* 0 的话为"真"( true )
* 非 0 的话为"假"( false )
举个例子来说明好了:
假设当前目录内有一份 my.file 的文件,而 no.file 是不存在的:
$ touch my.file
$ ls my.file
$ echo $ # first echo
0
$ ls no.file
ls: no.file: No such file or directory
$ echo $ # second echo
1
$ echo $ # third echo
0
上例的第一个echo 是关于 ls my.file 的 RV ,可得到 0 的值,因此为 true ;
第二个 echo 是关于 ls no.file 的 RV ,则得到非 0 的值,因此为 false ;
第三个 echo 是关于第二个 echo $ 的 RV ,为 0 的值,因此也为 true 。
请记住:每一个 command 在结束时都会送回 return value 的﹗不管你跑甚么样的命令...然而,有一个命令却是"专门"用来测试某一条件而送出 return value 以供 true 或 false 的判断,它就是 test 命令了!
若你用的是 bash ,请在 command line 下打 man test 或 man bash 来了解这个 test 的用法。这是你可用作参考的最精确的文件了,要是听别人说的,仅作参考就好...下面我只简单作一些辅助说明,其余的一律以 man 为准:
首先,test 的表示式我们称为 expression ,其命令格式有两种:
test expression
or:
[ expression ]
(请务必注意[ ] 之间的空格键﹗)
用哪一种格式没所谓,都是一样的效果。(我个人比较喜欢后者...)
其次,bash 的 test 目前支持的测试对像只有三种:
* string:字符串,也就是纯文字。
* integer:整数( 0 或正整数,不含负数或小数点)。
* file:文件。
请初学者一定要搞清楚这三者的差异,因为 test 所用的 expression 是不一样的。以 A=123 这个变量为例:
* [ "$A" = 123 ]:是字符串的测试,以测试 $A 是否为 1、2、3 这三个连续的"文字"。
* [ "$A" -eq 123 ]:是整数的测试,以测试 $A 是否等于"一百二十三"。
* [ -e "$A" ]:是关于文件的测试,以测试 123 这份"文件"是否存在。
第三,当 expression 测试为"真"时,test 就送回 0 (true) 的 return value ,否则送出非 0 (false)。若在 expression 之前加上一个 " ! "(感叹号),则是当 expression 为"假时" 才送出 0 ,否则送出非 0 。
同时,test 也允许多重的覆合测试:
* expression1 -a expression2 :当两个 exrepssion 都为 true ,才送出 0 ,否则送出非 0 。
* expression1 -o expression2 :只需其中一个 exrepssion 为 true ,就送出 0 ,只有两者都为 false 才送出非 0 。
例如:
[ -d "$file" -a -x "$file" ]
是表示当$file 是一个目录、且同时具有 x 权限时,test 才会为 true 。
第四,在 command line 中使用 test 时,请别忘记命令行的"重组"特性,也就是在碰到 meta 时会先处理 meta 再重新组建命令行。(这个特性我在第二及第四章都曾反复强调过)比方说,若 test 碰到变量或命令替换时,若不能满足 expression 格式时,将会得到语法错误的结果。举例来说好了:
关于 [ string1 = string2 ] 这个 test 格式,在 = 号两边必须要有字符串,其中包括空(null)字符串(可用 soft quote 或 hard quote 取得)。假如 $A 目前没有定义,或被定义为空字符串的话,那如下的写法将会失败:
$ unset A
$ [ $A = abc ]
[: =: unary operator expected
这是因为命令行碰到 $ 这个 meta 时,会替换 $A 的值,然后再重组命令行,那就变成了:
[ = abc ]
如此一来 = 号左边就没有字符串存在了,因此造成 test 的语法错误﹗但是,下面这个写法则是成立的:
$ [ "$A" = abc ]
$ echo $
1
这是因为在命令行重组后的结果为:
[ "" = abc ]
由于 = 左边我们用 soft quote 得到一个空字符串,而让 test 语法得以通过...
读者诸君请务必留意这些细节哦,因为稍一不慎,将会导至 test 的结果变了个样﹗若您对 test 还不是很有经验的话,那在使用 test 时不妨先采用如下这一个"法则":
* 假如在 test 中碰到变量替换,用 soft quote 是最保险的﹗
若你对quoting 不熟的话,请重新温习第四章的内容吧... ^_^
okay,关于更多的 test 用法,老话一句:请看 man page 吧﹗ ^_^
虽然洋洋洒洒讲了一大堆,或许你还在嘀咕.... 那... 那个 return value 有啥用啊?﹗
问得好﹗告诉你:return value 的作用可大了﹗若你想让你的 shell 变"聪明"的话,就全靠它了:
* 有了 return value,我们可以让 shell 根据不同的状态做不同的时情...
这时候,才让我来揭晓本章的答案吧~~~ ^_^
&& 与 || 都是用来"组建"多个 command line 用的:
* command1 && command2 :其意思是 command2 只有在 RV 为 0 (true) 的条件下执行。
* command1 || command2 :其意思是 command2 只有在 RV 为非 0 (false) 的条件下执行。
来,以例子来说好了:
$ A=123
$ [ -n "$A" ] && echo "yes! it's ture."
yes! it's ture.
$ unset A
$ [ -n "$A" ] && echo "yes! it's ture."
$ [ -n "$A" ] || echo "no, it's NOT ture."
no, it's NOT ture.
(注:[ -n string ] 是测试 string 长度大于 0 则为 true 。)
上例的第一个 && 命令行之所以会执行其右边的 echo 命令,是因为上一个 test 送回了 0 的 RV 值;但第二次就不会执行,因为为 test 送回非 0 的结果...
同理,|| 右边的 echo 会被执行,却正是因为左边的 test 送回非 0 所引起的。
事实上,我们在同一命令行中,可用多个 && 或 || 来组建呢:
$ A=123
$ [ -n "$A" ] && echo "yes! it's ture." || echo "no, it's NOT ture."
yes! it's ture.
$ unset A
$ [ -n "$A" ] && echo "yes! it's ture." || echo "no, it's NOT ture."
no, it's NOT ture.
怎样,从这一刻开始,你是否觉得我们的shell 是"很聪明"的呢?好了,最后,布置一道习题给大家做做看、下面的判断是:当 $A 被赋与值时,再看是否小于 100 ,否则送出 too big! :
$ A=123
$ [ -n "$A" ] && [ "$A" -lt 100 ] || echo 'too big!'
too big!
若我将A 取消,照理说,应该不会送文字才对啊(因为第一个条件就不成立了)...
$ unset A
$ [ -n "$A" ] && [ "$A" -lt 100 ] || echo 'too big!'
too big!
为何上面的结果也可得到呢?又如何解决之呢?(提示:修改方法很多,其中一种方法可利用第七章介绍过的 command group ...)
$ unset A
$ [ -n "$A" ] && ([ "$A" -lt 100 ] || echo 'too big!')
$ A=123
$ [ -n "$A" ] && ([ "$A" -lt 100 ] || echo 'too big!')
too big!
$ A=90
$ [ -n "$A" ] && ([ "$A" -lt 100 ] || echo 'too big!')
原文地址 http://www.bsdlover.cn/html/88/n-188.html
SHELL十三问之十一:> 与 < 差在哪?
11.1
谈到 I/O redirection ,不妨先让我们认识一下 File Descriptor (FD) 。程序的运算,在大部份情况下都是进行数据(data)的处理, 这些数据从哪读进?又送出到哪里呢?这就是 file descriptor (FD) 的功用了。
在 shell 程序中,最常使用的 FD 大概有三个,分别为:
0: Standard Input (STDIN)
1: Standard Output (STDOUT)
2: Standard Error Output (STDERR)
在标准情况下,这些 FD 分别跟如下设备(device)关联:
stdin(0): keyboard
stdout(1): monitor
stderr(2): monitor
我们可以用如下下命令测试一下:
$ mail -s test root
this is a test mail.
please skip.
^d (同时按 crtl 跟 d 键)
很明显,mail 程序所读进的数据,就是从 stdin 也就是 keyboard 读进的。不过,不见得每个程序的 stdin 都跟 mail 一样从 keyboard 读进,因为程序作者可以从档案参数读进 stdin ,如:
$ cat /etc/passwd
但,要是cat 之后没有档案参数则又如何呢?哦,请您自己玩玩看啰....
$ cat
(请留意数据输出到哪里去了,最后别忘了按 ^d 离开...)至于 stdout 与 stderr ,嗯... 等我有空再续吧...还是,有哪位前辈要来玩接龙呢?
11.2
沿文再续,书接上一回... ^_^
相信,经过上一个练习后,你对 stdin 与 stdout 应该不难理解吧? 然后,让我们继续看 stderr 好了。事实上,stderr 没甚么难理解的:说穿了就是"错误信息"要往哪边送而已...
比方说,若读进的档案参数是不存在的,那我们在 monitor 上就看到了:
$ ls no.such.file
ls: no.such.file: No such file or directory
若,一个命令同时产生stdout 与 stderr 呢?那还不简单,都送到 monitor 来就好了:
$ touch my.file
$ ls my.file no.such.file
ls: no.such.file: No such file or directory
my.file
okay,至此,关于 FD 及其名称、还有相关联的设备,相信你已经没问题了吧?那好,接下来让我们看看如何改变这些 FD 的预设数据信道,我们可用 < 来改变读进的数据信道(stdin),使之从指定的档案读进。我们可用 > 来改变送出的数据信道(stdout, stderr),使之输出到指定的档案。
比方说:
$ cat < my.file
就是从my.file 读进数据
$ mail -s test root < /etc/passwd
则是从/etc/passwd 读进...这样一来,stdin 将不再是从 keyboard 读进,而是从档案读进了...严格来说,< 符号之前需要指定一个 FD 的(之间不能有空白), 但因为 0 是 < 的默认值,因此 < 与 0< 是一样的﹗
okay,这个好理解吧?
那,要是用两个 << 又是啥呢?这是所谓的 HERE Document ,它可以让我们输入一段文本,直到读到 << 后指定的字符串。比方说:
$ cat <<FINISH
first line here
second line there
third line nowhere
FINISH
这样的话,cat 会读进 3 行句子,而无需从 keyboard 读进数据且要等 ^d 结束输入。
至于 > 又如何呢?
且听下回分解....
--------------
11.3
当你搞懂了 0< 原来就是改变 stdin 的数据输入信道之后,相信要理解如下两个 redirection 就不难了:
* 1>
* 2>
前者是改变 stdout 的数据输出信道,后者是改变 stderr 的数据输出信道。两者都是将原本要送出到 monitor 的数据转向输出到指定档案去。由于 1 是 > 的默认值,因此,1> 与 > 是相同的,都是改 stdout 。
用上次的 ls 例子来说明一下好了:
$ ls my.file no.such.file 1>file.out
ls: no.such.file: No such file or directory
这样monitor 就只剩下 stderr 而已。因为 stdout 给写进 file.out 去了。
$ ls my.file no.such.file 2>file.err
my.file
这样monitor 就只剩下 stdout ,因为 stderr 写进了 file.err 。
$ ls my.file no.such.file 1>file.out 2>file.err
这样monitor 就啥也没有,因为 stdout 与 stderr 都给转到档案去了...呵~~~ 看来要理解 > 一点也不难啦﹗是不?没骗你吧? ^_^不过,有些地方还是要注意一下的。
首先,是同时写入的问题。比方如下这个例子:
$ ls my.file no.such.file 1>file.both 2>file.both
假如stdout(1) 与 stderr(2) 都同时在写入 file.both 的话, 则是采取“覆盖”方式:后来写入的覆盖前面的。让我们假设一个 stdout 与 stderr 同时写入 file.out 的情形好了:
* 首先 stdout 写入10个字符
* 然后 stderr 写入 6 个字符
那么,这时候原本 stdout 的前面 6 个字符就被 stderr 覆盖掉了。那,如何解决呢?所谓山不转路转、路不转人转嘛,我们可以换一个思维:将 stderr 导进 stdout 或将 stdout 导进 sterr ,而不是大家在抢同一份档案,不就行了﹗bingo﹗就是这样啦:
* 2>&1 就是将 stderr 并进 stdout 作输出
* 1>&2 或 >&2 就是将 stdout 并进 stderr 作输出
于是,前面的错误操作可以改为:
$ ls my.file no.such.file 1>file.both 2>&1
或
$ ls my.file no.such.file 2>file.both >&2
这样,不就皆大欢喜了吗? 呵~~~ ^_^
不过,光解决了同时写入的问题还不够,我们还有其它技巧需要了解的。故事还没结束,别走开﹗广告后,我们再回来...﹗
--------------
11.4
okay,这次不讲 I/O Redirction ,讲佛吧...
(有没搞错?﹗网中人是否头壳烧坏了?...) 嘻~~~ ^_^
学佛的最高境界,就是"四大皆空"。至于是空哪四大块?我也不知,因为我还没到那境界...
但这个"空"字,却非常值得我们返复把玩的:
--- 色即是空、空即是色﹗
好了,施主要是能够领会"空"的禅意,那离修成正果不远矣~~~
在 Linux 档案系统里,有个设备档位于 /dev/null 。
许多人都问过我那是甚么玩意儿?我跟你说好了:那就是"空"啦﹗没错﹗空空如也的空就是 null 了.... 请问施主是否忽然有所顿误了呢?然则恭喜了~~~ ^_^
这个 null 在 I/O Redirection 中可有用得很呢:
* 若将 FD1 跟 FD2 转到 /dev/null 去,就可将 stdout 与 stderr 弄不见掉。
* 若将 FD0 接到 /dev/null 来,那就是读进 nothing 。
比方说,当我们在执行一个程序时,画面会同时送出 stdout 跟 stderr , 假如你不想看到 stderr (也不想存到档案去),那可以:
$ ls my.file no.such.file 2>/dev/null
my.file
若要相反:只想看到stderr 呢?还不简单﹗将 stdout 弄到 null 就行:
$ ls my.file no.such.file >/dev/null
ls: no.such.file: No such file or directory
那接下来,假如单纯只跑程序,不想看到任何输出结果呢?
哦,这里留了一手上次节目没讲的法子,专门赠予有缘人﹗... ^_^
除了用 >/dev/null 2>&1 之外,你还可以如此:
$ ls my.file no.such.file &>/dev/null
(提示:将 &> 换成 >& 也行啦~~! )
okay?讲完佛,接下来,再让我们看看如下情况:
$ echo "1" > file.out
$ cat file.out
1
$ echo "2" > file.out
$ cat file.out
2
看来,我们在重导stdout 或 stderr 进一份档案时,似乎永远只获得最后一次导入的结果。那,之前的内容呢?呵~~~ 要解决这个问提很简单啦,将 > 换成 >> 就好:
$ echo "3" >> file.out
$ cat file.out
2
3
如此一来,被重导的目标档案之内容并不会失去,而新的内容则一直增加在最后面去。easy ? 呵 ... ^_^但,只要你再一次用回单一的 > 来重导的话,那么,旧的内容还是会被"洗"掉的﹗这时,你要如何避免呢?----备份﹗ yes ,我听到了﹗不过.... 还有更好的吗?既然与施主这么有缘份,老纳就送你一个锦囊妙法吧:
$ set -o noclobber
$ echo "4" > file.out
-bash: file: cannot overwrite existing file
那,要如何取消这个"限制"呢?哦,将 set -o 换成 set +o 就行:
$ set +o noclobber
$ echo "5" > file.out
$ cat file.out
5
再问:那... 有办法不取消而又"临时"盖写目标档案吗?
哦,佛曰:不可告也﹗啊~~~ 开玩笑的、开玩笑的啦~~~ ^_^ 唉,早就料到人心是不足的了
$ set -o noclobber
$ echo "6" >| file.out
$ cat file.out
6
留意到没有:在> 后面再加个" | "就好(注意: > 与 | 之间不能有空白哦)....
呼.... (深呼吸吐纳一下吧)~~~ ^_^
再来还有一个难题要你去参透的呢:
$ echo "some text here" > file
$ cat < file
some text here
$ cat < file > file.bak
$ cat < file.bak
some text here
$ cat < file > file
$ cat < file
嗯?﹗注意到没有?﹗﹗
---- 怎么最后那个 cat 命令看到的 file 竟是空的?﹗
同学们:下节课不要迟到啰~~~!
--------------
11.5
当当当~~~ 上课啰~~~ ^_^
前面提到:$ cat < file > file 之后原本有内容的档案结果却被洗掉了﹗
要理解这一现像其实不难,这只是 priority 的问题而已:
* 在 IO Redirection 中,stdout 与 stderr 的管道会先准备好,才会从 stdin 读进资料。
也就是说,在上例中,> file 会先将 file 清空,然后才读进 < file , 但这时候档案已经被清空了,因此就变成读不进任何数据了...
哦~~~ 原来如此~~~~ ^_^那... 如下两例又如何呢?
$ cat <> file
$ cat < file >> file
嗯... 同学们,这两个答案就当练习题啰,下节课之前请交作业﹗
好了,I/O Redirection 也快讲完了,sorry,因为我也只知道这么多而已啦~~~ 嘻~~ ^_^
不过,还有一样东东是一定要讲的,各位观众(请自行配乐~!#@!$%) :
---- 就是 pipe line 也﹗
谈到 pipe line ,我相信不少人都不会陌生:
我们在很多 command line 上常看到的" | "符号就是 pipe line 了。
不过,究竟 pipe line 是甚么东东呢?
别急别急... 先查一下英汉字典,看看 pipe 是甚么意思?
没错﹗它就是"水管"的意思...
那么,你能想象一下水管是怎么一根接着一根的吗?又,每根水管之间的 input 跟 output 又如何呢?
灵光一闪:原来 pipe line 的 I/O 跟水管的 I/O 是一模一样的:
* 上一个命令的 stdout 接到下一个命令的 stdin 去了﹗
的确如此... 不管在 command line 上你使用了多少个 pipe line ,
前后两个 command 的 I/O 都是彼此连接的﹗(恭喜:你终于开窍了﹗ ^_^ )
不过... 然而... 但是... ... stderr 呢?
好问题﹗不过也容易理解:
* 若水管漏水怎么办?
也就是说:在 pipe line 之间,前一个命令的 stderr 是不会接进下一命令的 stdin 的, 其输出,若不用 2> 导到 file 去的话,它还是送到监视器上面来﹗这点请你在 pipe line 运用上务必要注意的。
那,或许你又会问:
* 有办法将 stderr 也喂进下一个命令的 stdin 去吗?
(贪得无厌的家伙﹗)
方法当然是有,而且你早已学过了﹗ ^_^
我提示一下就好:
* 请问你如何将 stderr 合并进 stdout 一同输出呢?
若你答不出来,下课之后再来问我吧... (如果你脸皮真够厚的话...)或许,你仍意尤未尽﹗或许,你曾经碰到过下面的问题:
* 在 cm1 | cm2 | cm3 ... 这段 pipe line 中,若要将 cm2 的结果存到某一档案呢?
若你写成 cm1 | cm2 > file | cm3 的话,
那你肯定会发现 cm3 的 stdin 是空的﹗(当然啦,你都将水管接到别的水池了﹗)
聪明的你或许会如此解决:
cm1 | cm2 > file ; cm3 < file
是的,你的确可以这样做,但最大的坏处是:这样一来,file I/O 会变双倍﹗在 command 执行的整个过程中,file I/O 是最常见的最大效能杀手。凡是有经验的 shell 操作者,都会尽量避免或降低 file I/O 的频率。
那,上面问题还有更好方法吗?
有的,那就是 tee 命令了。
*所谓 tee 命令是在不影响原本 I/O 的情况下,将 stdout复制一份到档案去。
因此,上面的命令行可以如此打:
cm1 | cm2 | tee file | cm3
在预设上,tee 会改写目标档案,若你要改为增加内容的话,那可用 -a 参数达成。基本上,pipe line 的应用在 shell 操作上是非常广泛的,尤其是在 text filtering 方面, 凡举 cat, more, head, tail, wc, expand, tr, grep, sed, awk, ... 等等文字处理工具, 搭配起 pipe line 来使用,你会惊觉 command line 原来是活得如此精彩的﹗
常让人有"众里寻他千百度,蓦然回首,那人却在灯火阑珊处﹗"之感... ^_^
....
好了,关于 I/O Redirection 的介绍就到此告一段落。若日后有空的话,再为大家介绍其它在 shell 上好玩的东西﹗bye... ^_^
SHELL十三问之十二:你要 if 还是 case 呢?
还记得我们在第10 章所介绍的 return value 吗?若你记得 return value ,我想你也应该记得了 && 与 || 是甚么意思吧?用这两个符号再配搭 command group 的话,我们可让 shell script 变得更加聪明哦。
比方说:
comd1 && {
comd2
comd3
} || {
comd4
comd5
}
意思是说:
假如comd1 的 return value 为 true 的话,
然则执行 comd2 与 comd3 ,
否则执行 comd4 与 comd5 。
事实上,我们在写 shell script 的时候,经常需要用到这样那样的条件以作出不同的处理动作。用 && 与 || 的确可以达成条件执行的效果,然而,从"人类语言"上来理解,却不是那么直观。更多时候,我们还是喜欢用 if .... then ... else ... 这样的 keyword 来表达条件执行。在 bash shell 中,我们可以如此修改上一段代码:
if comd1
then
comd2
comd3
else
comd4
comd5
fi
这也是我们在shell script 中最常用到的 if 判断式:
只要if 后面的 command line 返回 true 的 return value (我们最常用 test 命令来送出 return value),然则就执行 then 后面的命令,否则执行 else 后的命令﹔fi 则是用来结束判断式的 keyword 。
在 if 判断式中,else 部份可以不用,但 then 是必需的。
(若 then 后不想跑任何 command ,可用" : " 这个 null command 代替)。
当然,then 或 else 后面,也可以再使用更进一层的条件判断式,这在 shell script 设计上很常见。若有多项条件需要"依序"进行判断的话,那我们则可使用 elif 这样的 keyword :
if comd1; then
comd2
elif comd3; then
comd4
else
comd5
fi
意思是说:
若comd1 为 true ,然则执行 comd2 ﹔
否则再测试 comd3 ,然则执行 comd4 ﹔
倘若 comd1 与 comd3 均不成立,那就执行 comd5 。
if 判断式的例子很常见,你可从很多 shell script 中看得到,我这里就不再举例子了...
接下来要为大家介绍的是 case 判断式。
虽然 if 判断式已可应付大部份的条件执行了,然而,在某些场合中,却不够灵活,尤其是在 string 式样的判断上,比方如下:
QQ () {
echo -n "Do you want to continue (Yes/No): "
read YN
if [ "$YN" = Y -o "$YN" = y -o "$YN" = "Yes" -o "$YN" = "yes" -o "$YN" = "YES" ]
then
QQ
else
exit 0
fi
}
QQ
从例中,我们看得出来,最麻烦的部份是在于判断YN 的值可能有好几种式样。聪明的你或许会如此修改:
if echo "$YN" | grep -q '^[Yy]\([Ee][Ss]\)*$'
...
也就是用Regular Expression 来简化代码。(我们有机会再来介绍 RE)只是... 是否有其它更方便的方法呢?有的,就是用 case 判断式即可:
QQ () {
echo -n "Do you want to continue (Yes/No): "
read YN
case "$YN" in
[Yy]|[Yy][Ee][Ss])
QQ
;;
*)
exit 0
;;
esac
}
QQ
我们常case 的判断式来判断某一变量在同的值(通常是 string)时作出不同的处理,比方说,判断 script 参数以执行不同的命令。若你有兴趣、且用 Linux 系统的话,不妨挖一挖 /etc/init.d/* 里那堆 script 中的 case 用法。如下就是一例:
case "$1" in
start)
start
;;
stop)
stop
;;
status)
rhstatus
;;
restart|reload)
restart
;;
condrestart)
[ -f /var/lock/subsys/syslog ] && restart || :
;;
*)
echo $"Usage: $0 {start|stop|status|restart|condrestart}"
exit 1
esac
(若你对 positional parameter 的印像已经模糊了,请重看第 9 章吧。)
SHELL十三问之十三:for、while 与 until 差在哪?
终于,来到shell 十三问的最后一问了... 长长吐一口气~~~~最后要介绍的是 shell script 设计中常见的"循环"(loop)。所谓的 loop 就是 script 中的一段在一定条件下反复执行的代码。
bash shell 中常用的 loop 有如下三种:
* for
* while
* until
for loop 是从一个清单列表中读进变量值,并"依次"的循环执行 do 到 done 之间的命令行。例:
for var in one two three four five
do
echo -----------
echo '$var is '$var
echo
done
上例的执行结果将会是:
1) for 会定义一个叫 var 的变量,其值依次是 one two three four five 。
2) 因为有 5 个变量值,因此 do 与 done 之间的命令行会被循环执行 5 次。
3) 每次循环均用 echo 产生三行句子。
而第二行中不在 hard quote 之内的 $var 会依次被替换为 one two three four five 。
4) 当最后一个变量值处理完毕,循环结束。
我们不难看出,在 for loop 中,变量值的多寡,决定循环的次数。然而,变量在循环中是否使用则不一定,得视设计需求而定。倘若 for loop 没有使用 in 这个 keyword 来指定变量值清单的话,其值将从 $@ (或 $* )中继承:
for var; do
....
done
(若你忘记了 positional parameter ,请温习第 9 章...)
for loop 用于处理"清单"(list)项目非常方便,其清单除了可明确指定或从 positional parameter 取得之外,也可从变量替换或命令替换取得... (再一次提醒:别忘了命令行的"重组"特性﹗)然而,对于一些"累计变化"的项目(如整数加减),for 亦能处理:
for ((i=1;i<=10;i++))
do
echo "num is $i"
done
除了for loop ,上面的例子我们也可改用 while loop 来做到:
num=1
while [ "$num" -le 10 ]; do
echo "num is $num"
num=$(($num + 1))
done
while loop 的原理与 for loop 稍有不同:
它不是逐次处理清单中的变量值,而是取决于 while 后面的命令行之 return value :
* 若为 ture ,则执行 do 与 done 之间的命令,然后重新判断 while 后的 return value 。
* 若为 false ,则不再执行 do 与 done 之间的命令而结束循环。
分析上例:
1) 在 while 之前,定义变量 num=1 。
2) 然后测试(test) $num 是否小于或等于 10 。
3) 结果为 true ,于是执行 echo 并将 num 的值加一。
4) 再作第二轮测试,其时 num 的值为 1+1=2 ,依然小于或等于 10,因此为 true ,继续循环。
5) 直到 num 为 10+1=11 时,测试才会失败... 于是结束循环。
我们不难发现:
* 若 while 的测试结果永远为 true 的话,那循环将一直永久执行下去:
while :; do
echo looping...
done
上例的" : "是 bash 的 null command ,不做任何动作,除了送回 true 的 return value 。因此这个循环不会结束,称作死循环。死循环的产生有可能是故意设计的(如跑 daemon),也可能是设计错误。若要结束死寻环,可透过 signal 来终止(如按下 ctrl-c )。(关于 process 与 signal ,等日后有机会再补充,十三问暂时略过。)
一旦你能够理解 while loop 的话,那,就能理解 until loop :
* 与 while 相反,until 是在 return value 为 false 时进入循环,否则结束。
因此,前面的例子我们也可以轻松的用 until 来写:
num=1
until [ ! "$num" -le 10 ]; do
echo "num is $num"
num=$(($num + 1))
done
或是:
num=1
until [ "$num" -gt 10 ]; do
echo "num is $num"
num=$(($num + 1))
done
关于 bash 的三个常用的 loop 暂时介绍到这里。在结束本章之前,再跟大家补充两个与 loop 有关的命令:
* break
* continue
这两个命令常用在复合式循环里,也就是在 do ... done 之间又有更进一层的 loop ,当然,用在单一循环中也未尝不可啦... ^_^
break 是用来打断循环,也就是"强迫结束" 循环。
若 break 后面指定一个数值 n 的话,则"从里向外"打断第 n 个循环,默认值为 break 1 ,也就是打断当前的循环。在使用 break 时需要注意的是, 它与 return 及 exit 是不同的:
* break 是结束 loop
* return 是结束 function
* exit 是结束 script/shell
而 continue 则与 break 相反:强迫进入下一次循环动作。
若你理解不来的话,那你可简单的看成:在 continue 到 done 之间的句子略过而返回循环顶端...与 break 相同的是:continue 后面也可指定一个数值 n ,以决定继续哪一层(从里向外计算)的循环,默认值为 continue 1 ,也就是继续当前的循环。
在 shell script 设计中,若能善用 loop ,将能大幅度提高 script 在复杂条件下的处理能力。请多加练习吧....
-----------
好了,该是到了结束的时候了。
婆婆妈妈的跟大家啰唆了一堆关于 shell 的基础概念,目的不是要告诉大家"答案",而是要带给大家"启发"...在日后关于 shell 的讨论中,我或许会经常用"链接"方式指引回来十三问中的内容,以便我们在进行技术探讨时彼此能有一些讨论基础,而不至于各说各话、徒费时力。但,更希望十三问能带给你更多的思考与乐趣,至为重要的是透过实作来加深理解。是的,我很重视"实作"与"独立思考"这两项学习要素,若你能够掌握其中真义,那请容我说声:
--- 恭喜﹗十三问你没白看了﹗ ^_^
p.s.
至于补充问题部份,我暂时不写了。而是希望:
1) 大家扩充题目。
2) 一起来写心得。
在介绍 shell 是甚么东西之前,不妨让我们重新检视使用者与计算机系统的关系,我们知道计算机的运作不能离开硬件,但使用者却无法直接对硬件作驱动,硬件的驱动只能透过一个称为"操作系统(Operating System)"的软件来控管,事实上,我们每天所谈的 freebsd、netbsd、openbsd、linux 等等,严格来说只是一个操作系统,我们称之为"核心(kernel)"。然而,从使用者的角度来说,使用者也没办法直接操作 kernel ,而是透过 kernel 的"外壳"程序,也就是所谓的shell ,来与 kernel 沟通。从技术角度来说,shell是一个使用者与系统的互动界面(interface),主要是让使用者透过命令行(command line)来使用系统以完成工作。因此,shell 的最简单的定义就是---命令解译器(Command Interpreter):
* 将使用者的命令翻译给核心处理,
* 同时,将核心处理结果翻译给使用者。
Shell 有很多种,只要能给用户提供命令行环境的程序,都可以看作是 Shell 。历史上,主要的 Shell 有下面这些:
Bourne Shell(sh)
Bourne Again shell(bash)
C Shell(csh)
TENEX C Shell(tcsh)
Korn shell(ksh)
Z Shell(zsh)
Friendly Interactive Shell(fish)
其中 Bash 是目前最常用的 Shell。通过执行 echo $SHELL 命令可以查看到当前正在使用的 Shell;还可以通过 cat /etc/shells 查看当前系统安装的所有 Shell 种类。
每次当我们完成系统登入(login),我们就取得一个互动模式的shell ,也称为 login shell 或 primary shell。若从进程(process)角度来说,我们在 shell 所下达的命令,均是 shell 所产生的子进程。这现象,我们暂可称之为fork。如果是执行脚本(shell script)的话,脚本中的命令则是由另外一个非互动模式的子 shell (sub shell)来执行的。也就是primary shell 产生 sub shell 的进程,sub shell 再产生 script 中所有命令的进程。
FreeBSD的基本系统中可以使用的shell有两个:sh和csh。这两个基本shell的风格不太相同,不同的使用者常常会根据喜好来在两者之间进行选择。当然当前有更好的shell程序可供使用者选择,这些后续的 shell均是根据sh或csh的风格进一步发展出的,因此可以说在shell中,也有两种风格,需要使用者根据自己的使用习惯进行选择。在默认安装下,FreeBSD支持sh、csh、tsch,从/etc/shells中可以看出。
命令提示符补充一下:
如果shell是sh,则提示符为“$”,如果shell是csh,则为“%”,需要注意的是如果是root用户,则提示符为“#”。
sh和csh又有以下不同的分支:
Bourne shell :
burne shell (sh)
burne again shell (bash)
korn shell (ksh)
POSIX shell ( sh) C shell :
c shell (csh)
TENEX/TOPS C shell ( tcsh)
Bourne Shell 最初的UNIX shell是由Stephen R. Bourne于20世纪70年代中期在新泽西的AT&T贝尔实验室编写的,这就是Bourne shell。Bourne shell 是一个交换式的命令解释器和命令编程语言。Bourne shell 可以运行为login shell或者login shell的子shell(subshell)。只有login命令可以调用Bourne shell作为一个login shell。此时,shell先读取/etc/profile文件和$HOME/.profile文件。/etc/profile文件为所有的用户定制环境,$HOME/.profile文件为本用户定制环境。最后,shell会等待读取你的输入。
C Shell Bill Joy于20世纪80年代早期,在Berkeley的加利福尼亚大学开发了C shell。它主要是为了让用户更容易的使用交互式功能,并把ALGOL风格的语法结构变成了C语言风格。它新增了命令历史、别名、文件名替换、作业控制等功能。
有很长一段时间,只有两类shell供人们选择,Bourne shell用来编程,C shell用来交互。为了改变这种状况,AT&T的bell实验室David Korn开发了Korn shell。ksh结合了所有的C shell的交互式特性,并融入了Bourne shell的语法。因此,Korn shell广受用户的欢迎。它还新增了数学计算,进程协作(coprocess)、行内编辑(inline editing)等功能。Korn Shell 是一个交互式的命令解释器和命令编程语言.它符合POSIX——一个操作系统的国际标准.POSIX不是一个操作系统,而是一个目标在于应用程序的移植性的标准——在源程序一级跨越多种平台。
bash是GNU计划的一部分,用来替代Bourne shell。它用于基于GNU的系统如Linux.大多数的Linux(Red Hat, Slackware, Caldera)都以bash作为缺省的shell,并且运行sh时,其实调用的是bash。
POSIX shell 是Korn shell的一个变种. 当前提供POSIX shell的最大卖主是Hewlett-Packard。在HP-UX 11.0 , POSIX shell 就是/bin/sh,而bsh是/usr/old/bin/sh.
各主要操作系统下缺省的shell: AIX 下是Korn Shell. Solaris和FreeBSD缺省的是Bourne shell. HP-UX缺省的是POSIX shell. Linux是Bourne Again shell,输入命令echo $SHELL可查看你用的是什么shell,也可以根据提示符来看,如果shell是sh,则提示符为“$”,如果shell是csh,则为“%”,需要注意的是如果是root用户,则提示符为“#”。
对于管理员来将,要为使用不同shell的用户都设置好基本的环境,就必须了解这两种风格的 shell设置方式。系统登录时,sh将首先执行/etc/profile文件,为每个用户设置最基本的环境,而csh将使用/etc /csh.cshrc,csh.login和csh.logout作为系统csh资源文件。执行了系统级别的登录文件之后,每个用户的shell就在该用户的主目录下寻找该用户个人的资源文件:sh使用.profile文件,csh使用.login和.cshrc文件。这些资源文件均使用相应的shell 语言,/etc/profile和个人目录下的.profile使用sh风格的控制语言,/etc/cshrc和个人目录下的.login、.cshrc 使用csh 风格的控制语言。
系统管理员可以改动这些资源文件,为用户提供一个最方便的使用环境。当然,系统管理员没有必要直接去修改个人主目录下的资源文件,这些文件应该由用户自己管理,但是系统管理员可以在生成帐号时为用户产生缺省的资源文件,以减轻用户设置资源文件的麻烦。adduser命令缺省使用/usr/share/skel下的文件为用户提供各种资源文件的缺省设置,这个目录下除了可以放入shell的资源文件之外,还可以放入其他应用程序的资源文件。由于这些资源文件都是以点开头的隐藏文件,为了表示清楚,在skel目录下使用了一种转换方式,如使用dot.profile 作为.profile的模板。
# ls /usr/share/skel
dot.cshrc dot.login_conf dot.mailrc dot.rhosts
dot.login dot.mail_aliases dot.profile dot.shrc
在 /usr/share/skel中为用户设置的缺省配置文件,在用户生成之后,就不会对用户产生影响了。因此对系统登录文件进行修改更有效和直接。对于 sh风格的用户,可以更改/etc/profile文件,对csh应更改/etc/csh.cshrc文件。在这些文件中可以改动shell使用的环境变量,这样来改变shell的行为方式,或者执行一系列自动操作,完成一些用户登录时需要自动执行的任务。
常用的环境变量:
EDITOR 设置用户常用的编辑器,很多程序查看这个变量来启动具体的编辑器,可以 根据系统的情况更改
HOME 用户的主目录的名字,这个变量由login程序设置,一般不需要更改
DISPLAYX 使用这个环境变量来标识具体的显示位置,格式为“计算机名字:X服务 器序号.显示屏序号” ,例如:xt1:0.0,它不需要在资源文件中进行定义
LANG 系统使用的语言,用于系统的本地化,缺省为 “C” ,具体的设置可以查看 /usr/share/locale 目录,那里定义了不同的语言,可以将其设置为zh_CN.EUC来使得一些软件使用中文字符。
MAIL 用户mail文件的位置,也不需要改动
PATH 使用冒号分隔的一系列路径,系统用它来查找具体可执行程序,因此这个变量非常重要,可以根据具体的情况改动其值。为了安全的原因,不要将当前目录作为执行程序的搜寻路径,尤其对于root用户。这样在当前目录下启动程序,需要加上路径,例如启动当前目录下的a.out 程序,输入 “./a.out” 。
MANPATH 使用冒号分隔的一系列路径,系统用它来查找具体命令的在线手册,设置方法与PATH相同。
PS1sh 风格的shell使用这个变量的值作为提示符,缺省值为 “$”(root为 “#” )。更现代的sh就增强了提示符的灵活性,可以在提示符中加入当前目录、用户名、机器名,命令的序号等。
PS2sh 风格的shell使用这个变量的值作为后续提示符,提示命令还没有完全输入,缺省为 “>;“
TERM 终端的类型,对于需要全屏操作的程序,非常重要。有时要根据情况对设置进行调整。
TZ 时区设置,具体的时区信息位于/usr/share/zoneinfo目录下,需要设置为适合本地时区的标准值
可以将用户的shell设置为特殊的应用程序,来达到对特殊用户进行限制的目的。例如,仅仅给予用户一个电子邮件信箱,但不想给他终端使用权,可以将用户的 shell更改为/bin/true或者其他立即退出的程序。为了安全起见,用户shell应该是一个不存在漏洞的二进制程序,最好不要使用解释性语言脚本作为登录shell。由于系统认可的shell程序是在/etc/shells文件中列出的程序,将特殊用户的shell设置为特殊的应用程序,但这些应用程序没有列入shells文件,那么这个用户就会被一些应用程序区分出与普通用户的差异,从而拒绝提供服务。例如ftp服务器程序ftpd,通过检查用户的shell是不是标准shell,来区分这个用户是普通用户还是用于特定目的的用户。例如通过源代码编译安装mysql的时候,需要首先建立一个 mysql用户,该用户我们不希望他可以登录系统,因此把它的shell设置为/nonexistent:
pw groupadd mysql
pw useradd mysql -g mysql -s /nonexistent
SHELL十三问之二:shell prompt(PS1) 与 Carriage Return(CR)
当你成功登录进一个文字界面之后,大部份情形下,你会在荧幕上看到一个不断闪烁的方块或底线(视不同版本而别),我们称之为*游标*(coursor)。游标的作用就是告诉你接下来你从键盘输入的按键所插入的位置,且每输入一键游标便向右边移动一个格子,若连续输入太多的话,则自动接在下一行输入。假如你刚完成登录还没输入任何按键之前,你所看到的游标所在位置的同一行的左边部份,我们称之为*提示符号*(prompt)。提示符号的格式或因不同系统版本而各有不同,在FreeBSD上,只需留意最接近游标的一个可见的提示符号,通常是如下两者之一:
$:给一般使用者帐号使用
#:给root (管理员)帐号使用
事实上,shell prompt的意思很简单:
* 是shell告诉使用者:您现在可以输入命令行了。我们可以说,使用者只有在得到shell prompt才能打命令行,而cursor是指示键盘在命令行所输入的位置,使用者每输入一个键,cursor就往后移动一格,直到碰到命令行读进 CR(Carriage Return,由Enter键产生)字符为止。
CR的意思也很简单:
*是使用者告诉shell:老兄你可以执行我的命令行了。严格来说:
*所谓的命令行,就是在shell prompt与CR字符之间所输入的文字。(思考:为何我们这里坚持使用CR字符而不说Enter键呢?答案在后面的学习中揭晓。)
不同的命令可接受的命令行格式或有不同,一般情况下,一个标准的命令行格式为如下所列:command-name options argument若从技术细节来看,shell会依据IFS(Internal Field Seperator)将command line所输入的文字给拆解为"字段"(word)。然后再针对特殊字符(meta)先作处理,最后再重组整行command line。
其中的IFS是shell预设使用的字段分隔符,可以由一个及多个如下按键组成:
*空格键(White Space)
*表格键(Tab)
*回车键(Enter)
系统可接受的命令名称(command-name)可以从如下途径获得:
*明确路径所指定的外部命令
*命令别名(alias)
*自定义功能(function)
* shell内建命令(built-in)
* $PATH之下的外部命令
每一个命令行均必须含有命令名称,这是不能缺少的。 原文地址 http://www.bsdlover.cn/html/80/n-180.html
SHELL十三问之三:别人 echo、你也 echo ,是问 echo 知多少?
承接上一章所介绍的command line,这里我们用echo这个命令加以进一步说明。温习---标准的command line包含三个部件:* command_name option argument
echo是一个非常简单、直接的命令:
*将argument送出至标准输出(STDOUT),通常就是在监视器(monitor)上输出。为了更好理解,不如先让我们先跑一下echo命令好了:
$ echo
$
你会发现只有一个空白行,然后又回到shell prompt上了。这是因为echo在预设上,在显示完argument之后,还会送出一个换行符号(new-line charactor)。但是上面的command并没任何的argument,那结果就只剩一个换行符号了...若你要取消这个换行符号,可利用echo的-n option:
$ echo -n
$
不妨让我们回到command line的概念上来讨论上例的echo命令好了:
command line只有command_name(echo)及option(-n),并没有任何argument。要想看看echo的argument,那还不简单﹗接下来,你可试试如下的输入:
$ echo first line
first line
$ echo -n first line
first line $
从上两个echo命令中,你会发现argument的部份显示在你的荧幕,而换行符号则视-n option的有无而别。很明显的,第二个echo由于换行符号被取消了,接下来的shell prompt就接在输出结果同一行了...事实上,echo除了-n options之外,常用选项还有:
-e:启用反斜线控制字符的转换(参考下表)
-E:关闭反斜线控制字符的转换(预设如此)
-n:取消行末之换行符号(与-e选项下的c字符同意)
关于echo命令所支持的反斜线控制字符如下表:
\a:ALERT / BELL (从系统喇叭送出铃声)
\b:BACKSPACE,也就是向左删除键
\c:取消行末之换行符号
\E:ESCAPE,跳脱键
\f:FORMFEED,换页字符
\n:NEWLINE,换行字符
\r:RETURN,回车键
\t:TAB,表格跳位键
\v:VERTICAL TAB,垂直表格跳位键
\\n:ASCII八进位编码(以x开首为十六进制):反斜线本身
(表格资料来自O'Reilly出版社之Learning the Bash Shell, 2nd Ed.)或许,我们可以透过实例来了解echo的选项及控制字符:
例一:
$ echo -e "a\tb\tc\nd\te\tf"
a b c
d e f
上例运用\t来区隔abc还有def,及用\n将def换至下一行。
例二:
$ echo -e "\141\011\142\011\143\012\144\011\145\011\146"
a b c
d e f
与例一的结果一样,只是使用ASCII八进位编码。
例三:
$ echo -e "\x61\x09\x62\x09\x63\x0a\x64\x09\x65\x09\x66"
a b c
d e f
与例二差不多,只是这次换用ASCII十六进制编码。
例四:
$ echo -ne "a\tb\tc\nd\te\bf\a"
a b c
d f $
因为e字母后面是删除键(b),因此输出结果就没有e了。在结束时听到一声铃向,那是a的杰作﹗由于同时使用了-n选项,因此shell prompt紧接在第二行之后。若你不用-n的话,那你在a后再加个c,也是同样的效果。事实上,在日后的shell操作及shell script设计上,echo命令是最常被使用的命令之一。比方说,用echo来检查变量值:
$ A=B
$ echo $A
B
$ echo $
0
(注:关于变量概念,我们留到下两章才跟大家说明。)好了,更多的关于command line的格式,以及echo命令的选项,就请您自行多加练习、运用了...
SHELL十三问之四:双引号与单引号差别在哪?
还是回到我们的command line来吧...经过前面两章的学习,应该很清楚当你在shell prompt后面敲打键盘、直到按下Enter的时候,你输入的文字就是command line了,然后shell才会以行程的方式执行你所交给它的命令。但是,你又可知道:你在command line输入的每一个文字,对shell来说,是有类别之分的呢?简单而言(我不敢说这是精确的定议,注一),command line的每一个charactor,分为如下两种:
* literal:也就是普通纯文字,对shell来说没特殊功能。
* meta:对shell来说,具有特定功能的特殊保留字符。
(注一:关于bash shell在处理command line时的顺序说明,请参考O'Reilly出版社之Learning the Bash Shell, 2nd Edition,第177 - 180页的说明,尤其是178页的流程图Figure 7-1 ... )
Literal没甚么好谈的,凡举abcd、123456这些"文字"都是literal ... (easy?)
但meta却常使我们困惑..... (confused)事实上,前两章我们在command line中已碰到两个几乎每次都会碰到的meta:
* IFS:由<space>或<tab>或<enter>三者之一组成(我们常用space )。
* CR:由<enter>产生。
IFS 是用来拆解command line的每一个词(word)用的,因为shell command line是按词来处理的。而CR则是用来结束command line用的,这也是为何我们敲<enter>命令就会跑的原因。除了IFS与CR,常用的meta还有:
=:设定变量。
$:作变量或运算替换(请不要与shell prompt搞混了)。
>:重导向(重定向)stdout。
<:重导向(重定向)stdin。
|:命令管线(管道)。
&:重导向file desCRiptor,或将命令置于背境(后台)执行。
( ):将其内的命令置于nested subshell执行,或用于运算或命令替换。
{ }:将其内的命令置于non-named function中执行,或用在变量替换的界定范围。
;:在前一个命令结束时,而忽略其返回值,继续执行下一个命令。
&&:在前一个命令结束时,若返回值为true,继续执行下一个命令。
||:在前一个命令结束时,若返回值为false,继续执行下一个命令。
!:执行history列表中的命令
...
假如我们需要在command line中将这些保留字符的功能关闭的话,就需要quoting处理了。在bash中,常用的quoting有如下三种方法:
* hard quote:' ' (单引号),凡在hard quote中的所有meta均被关闭。
* soft quote:" " (双引号),在soft quoe中大部份meta都会被关闭,但某些则保留(如$,反引号,反斜杠)。
* escape:\(反斜线),只有紧接在escape (跳脱字符)之后的单一meta才被关闭。
下面的例子将有助于我们对quoting的了解:
$ A=B C#空格键未被关掉,作为IFS处理。
$ C: command not found.
$ echo $A
$ A="B C"#空格键已被关掉,仅作为空格键处理。
$ echo $A
B C
在第一次设定A变量时,由于空格键没被关闭,command line将被解读为:
* A=B然后碰到<IFS>,再执行C命令在第二次设定A变量时,由于空格键被置于soft quote中,因此被关闭,不再作为IFS:
* A=B<space>C事实上,空格键无论在soft quote还是在hard quote中,均会被关闭。Enter键亦然:
$ A='B
> C
> '
$ echo "$A"
B
C
在上例中,由于<enter>被置于hard quote当中,因此不再作为CR字符来处理。这里的<enter>单纯只是一个断行符号(new-line)而已,由于command line并没得到CR字符,因此进入第二个shell prompt (PS2,以>符号表示),command line并不会结束,直到第三行,我们输入的<enter>并不在hard quote里面,因此并没被关闭,此时,command line碰到CR字符,于是结束、交给shell来处理。上例的<enter>要是被置于soft quote中的话,CR也会同样被关闭:
$ A="B
> C
> "
$ echo $A
B C
然而,由于echo $A时的变量没置于soft quote中,因此当变量替换完成后并作命令行重组时,<enter>会被解释为IFS,而不是解释为New Line字符。同样的,用escape亦可关闭CR字符:
$ A=B\
> C\
>
$ echo $A
BC
上例中,第一个<enter>跟第二个<enter>均被escape字符关闭了,因此也不作为CR来处理,但第三个<enter>由于没被跳脱,因此作为CR结束command line。但由于<enter>键本身在shell meta中的特殊性,在跳脱后面,仅仅取消其CR功能,而不会保留其IFS功能。您或许发现光是一个<enter>键所产生的字符就有可能是如下这些可能:
CR
IFS
NL(New Line)
FF(Form Feed)
NULL
...至于甚么时候会解释为甚么字符,这个我就没去深挖了,或是留给读者诸君自行慢慢摸索了...至于soft quote跟hard quote的不同,主要是对于某些meta的关闭与否,以$来作说明:
$ A=B\C
$ echo "$A"
B C
$ echo '$A'
$A
在第一个echo命令行中,$被置于soft quote中,将不被关闭,因此继续处理变量替换,因此echo将A的变量值输出到荧幕,也就得到"B C"的结果。在第二个echo命令行中,$被置于hard quote中,则被关闭,因此$只是一个$符号,并不会用来作变量替换处理,因此结果是$符号后面接一个A字母:$A。
--------------------------------------
练习与思考:如下结果为何不同?
$ A=B\C
$ echo '"$A"'#最外面的是单引号
"$A"
我的理解:外面是单引号,因此里面所有东西都不变
$ echo "'$A'"#最外面的是双引号
'B C'
我的理解:最外面是双引号,因此除了$\`之外,其他的都meta都被关闭,所以$A要最终变量替换后变为B C,所以最终输出结果为'B C'
$ echo '"'$A'"'#先单引号再双引号再单引号
"B C"
我的理解:最外面是单引号,因此应该输出的是"'$A'",但由于"的存在,$A要进行变量替换,变成了'B C',而'内只有B C了,因此'不再起作用了,所以输出结果为"B C"
$ echo "'"$A"'"#先双引号再单引号再双引号
'B C'
我的理解:最外面是双引号,因此除了$\`之外,关闭所有的meta,即这个时候应该输出'"B C"',由于双引号里面已经是B C了,所以不再起作用了,输出B C即可。最终的结果是'B C'
--------------------------------------
在CU的shell版里,我发现有很多初学者的问题,都与quoting理解的有关。比方说,若我们在awk或sed的命令参数中调用之前设定的一些变量时,常会问及为何不能的问题。要解决这些问题,关键点就是:
*区分出shell meta与command meta
前面我们提到的那些meta,都是在command line中有特殊用途的,比方说{ }是将其内一系列command line置于不具名的函式中执行(可简单视为command block ),但是,awk却需要用{ }来区分出awk的命令区段(BEGIN, MAIN, END)。若你在command line中如此输入:
$ awk {print $0} 1.txt
awk: syntax error at source line 1
context is
>>><<<
awk: illegal statement at source line 1
missing }
由于{ } 在 shell 中并没关闭,那 shell 就将 {print $0} 视为 command block ,
但同时又没有" ; "符号作命令区隔,因此就出现 awk 的语法错误结果。
要解决之,可用 hard quote :
$ awk '{print $0}' 1.txt
上面的 hard quote 应好理解,就是将原本的 {、<space>、$(注三)、} 这几个 shell meta 关闭,避免掉在 shell 中遭到处理,而完整的成为 awk 参数中的 command meta 。( 注三:而其中的 $0 是 awk 内建的 field number ,而非awk 的变量,awk 自身的变量无需使用 $ 。),要是理解了 hard quote 的功能,再来理解 soft quote 与 escape 就不难:
$ awk "{print \$0}" 1.txt
$ awk \{print\ \$0\} 1.txt
然而,若你要改变 awk 的 $0 的 0 值是从另一个 shell 变量读进呢?
比方说:已有变量 $A 的值是 0 ,那如何在 command line 中解决 awk 的 $$A 呢?你可以很直接否定掉 hard quoe 的方案:
$ awk '{print $$A}' 1.txt
awk: illegal field $(), name "A"
input record number 1, file 1.txt
source line number 1
那是因为 $A 的 $ 在 hard quote 中是不能替换变量的。聪明的读者(如你!),经过本章学习,我想,应该可以解释为何我们可以使用如下操作了吧:
$ A=0
$ awk "{print \$$A}" 1.txt
$ awk \{print\ \$$A\} 1.txt
$ awk '{print $'$A'}' 1.txt
$ awk '{print $'"$A"'}' 1.txt # 注:"$A" 包在 soft quote 中
或许,你能举出更多的方案呢....^_^
SHELL十三问之五
var=value export 前后差在哪?这次让我们暂时丢开command line,先来了解一下bash变量(variable)吧...所谓的变量,就是就是利用一个特定的"名称"(name)来存取一段可以变化的"值"(value)。
*设定(set)*
在bash中,你可以用"="来设定或重新定义变量的内容:
name=value
在设定变量的时侯,得遵守如下规则:
*等号左右两边不能使用区隔符号(IFS),也应避免使用shell的保留字符(meta charactor)。
*变量名称不能使用$符号。
*变量名称的第一个字母不能是数字(number)。
*变量名称长度不可超过256个字母。
*变量名称及变量值之大小写是有区别的(case sensitive)。
如下是一些变量设定时常见的错误:
A= B:不能有IFS
1A=B:不能以数字开头
$A=B:名称不能有$
a=B:这跟a=b是不同的
如下则是可以接受的设定:
A=" B":IFS被关闭了(请参考前面的quoting章节)
A1=B:并非以数字开头
A=$B:$可用在变量值内
This_Is_A_Long_Name=b:可用_连接较长的名称或值,且大小写有别。
*变量替换(substitution)*
Shell之所以强大,其中的一个因素是它可以在命令行中对变量作替换(substitution)处理。在命令行中使用者可以使用$符号加上变量名称(除了在用=号定义变量名称之外),将变量值给替换出来,然后再重新组建命令行。
比方:
$ A=ls
$ B=la
$ C=/tmp
$ $A -$B $C
(注意:以上命令行的第一个$是shell prompt,并不在命令行之内。)
必需强调的是,我们所提的变量替换,只发生在command line上面。(是的,让我们再回到command line吧﹗)仔细分析最后那行command line,不难发现在被执行之前(在输入CR字符之前),$符号会对每一个变量作替换处理(将变量值替换出来再重组命令行),最后会得出如下命令行:ls -la /tmp
还记得第二章我请大家"务必理解"的那两句吗?若你忘了,那我这里再重贴一遍:
若从技术细节来看,shell会依据IFS(Internal Field Seperator)将command line所输入的文字给拆解为"字段"(word)。然后再针对特殊字符(meta)先作处理,最后再重组整行command line。这里的$就是command line中最经典的meta之一了,就是作变量替换的。在日常的shell操作中,我们常会使用echo命令来查看特定变量的值,例如:
$ echo $A -$B $C
我们已学过,echo命令只单纯将其argument送至"标准输出"(STDOUT,通常是我们的荧幕)。所以上面的命令会在荧幕上得到如下结果:ls -la /tmp
这是由于echo命令在执行时,会先将$A(ls)、$B(la)、跟$C(/tmp)给替换出来的结果。利用shell对变量的替换处理能力,我们在设定变量时就更为灵活了:
A=B
B=$A
这样,B的变量值就可继承A变量"当时"的变量值了。不过,不要以"数学罗辑"来套用变量的设定,比方说:
A=B
B=C
这样并不会让A的变量值变成C。上面是单纯定义了两个不同名称的变量:A与B,它们的值分别是B与C。再如:
A=B
B=$A
A=C
同样也不会让B的值换成C。
若变量被重复定义的话,则原有旧值将被新值所取代,(这不正是"可变的量"吗?^_^)。当我们在设定变量的时侯,请记着这点:
*用一个名称储存一个数值
仅此而已。
此外,我们也可利用命令行的变量替换能力来"扩充"(append)变量值:
A=B:C:D
A=$A:E
这样,第一行我们设定A的值为"B:C:D",然后,第二行再将值扩充为"A:B:C:E"。
上面的扩充范例,我们使用区隔符号( : )来达到扩充目的,要是没有区隔符号的话,如下是有问题的:
A=BCD
A=$AE
因为第二次是将A的值继承$AE的提换结果,而非$A再加E。要解决此问题,我们可用更严谨的替换处理:
A=BCD
A=${A}E
上例中,我们使用{}将变量名称的范围给明确定义出来,如此一来,我们就可以将A的变量值从BCD给扩充为BCDE。
(提示:关于${name}事实上还可做到更多的变量处理能力,这些均属于比较进阶的变量处理,现阶段暂时不介绍了,请大家自行参考数据。如CU的贴子:
http://www.chinaunix.net/forum/viewtopic.phpt=201843)
* export *
严格来说,我们在当前shell中所定义的变量,均属于"本地变量"(local variable),只有经过export命令的"输出"处理,才能成为环境变量(environment variable):
$ A=B
$ export A
或:
$ export A=B
经过export输出处理之后,变量A就能成为一个环境变量供其后的命令使用。在使用export的时侯,请别忘记shell在命令行对变量的"替换"(substitution)处理,
比方说:
$ A=B
$ B=C
$ export $A
上面的命令并未将A输出为环境变量,而是将B作输出,这是因为在这个命令行中,$A会首先被提换出B然后再"塞回"作export的参数。
要理解这个export,事实上需要从process的角度来理解才能透彻。
我将于下一章为大家说明process的观念,敬请留意。
*取消变量*
要取消一个变量,在bash中可使用unset命令来处理:
unset A
与export一样,unset命令行也同样会作变量替换(这其实就是shell的功能之一),
因此:
$ A=B
$ B=C
$ unset $A
事实上所取消的变量是B而不是A。
此外,变量一旦经过unset取消之后,其结果是将整个变量拿掉,而不仅是取消其变量值。如下两行其实是很不一样的:
$ A=
$ unset A
第一行只是将变量A设定为"空值"(nullvalue),但第二行则让变量A不在存在。虽然用眼睛来看,这两种变量状态在如下命令结果中都是一样的:
$ A=
$ echo $A
$ unset A
$ echo $A
请学员务必能识别null value与unset的本质区别,这在一些进阶的变量处理上是很严格的。比方说:
$ str= #设为null
$ var=${str=expr} #定义var
$ echo $var
$ echo $str
$ unset str #取消
$ var=${str=expr} #定义var
$ echo $var
expr
$ echo $str
expr
聪明的读者(yes, you!),稍加思考的话,应该不难发现为何同样的var=${str=expr}在null与unset之下的不同吧?若你看不出来,那可能是如下原因之一:
a.你太笨了
b.不了解var=${str=expr} 这个进阶处理
c.对本篇说明还没来得及消化吸收
e.我讲得不好
不知,你选哪个呢?....^_^
再来解释一下var=${str=expr}:
首先,var=$str这个大家都可理解吧。而接下来的思考方向是,究竟$str这个变量是如下哪一种情况呢:
1) unset
2) null
3) not null
1)假如是unset,那么var=${str=expr}的结果将是:
var=expr
str=expr
2)假如是null,那var=${str=expr}的结果是:
var=
str=
3)假如是not null (比方为xyz ),那var=${str=expr}之结果是:
var=xyz
str=xyz
测试如下:
$ showvar() {
>var=${str=expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
$var is expr
$str is expr
$ str=
$ showvar
$var is
$str is
$ str=xyz
$ showvar
$var is xyz
$str is xyz
接下来,再来看看var=${str:=expr}好了:
1) $str为not set:
var=expr
str=expr
2) $str为null:
var=expr
str=expr
3) $str为not null (str=xyz):
var=xyz
str=xyz
测试如下:
$ showvar() {
> var=${str:=expr}
> echo \$var is $var
> echo \$str is $str
> }
$ unset str
$ showvar
$var is expr
$str is expr
$ str=
$ showvar
$var is expr
$str is expr
$ str=xyz
$ showvar
$var is xyz
$str is xyz
最后比教一下${str=expr}与${str:=expr}:
*两者在not set与not null都一致
*但当null值时,${str=expr}会将$var与$str都设为null,但${str:=expr}则设为expr
从这个再延伸出其它模拟,不防请大家"实作"观查一下有何不同?
var=${str-expr} vs var=${str:-expr}
var=${str+expr} vs var=${str:+expr}
var=${strexpr} vs var=${str:expr}
$ showvar() {
>var=${str-expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
$var is expr
$str is
$ str=
$ showvar
$var is
$str is
$ str=xyz
$ showvar
$var is xyz
$str is xyz
$ showvar() {
>var=${str:-expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
$var is expr
$str is
$ str=
$ showvar
$var is expr
$str is
$ str=xyz
$ showvar
$var is xyz
$str is xyz
可以看出来${str-expr}与${str:-expr}
*两者在$str为not set与not null都一致
*但当null值时,${str-expr}会将$var与$str都设为null,但${str:-expr}则将$var设为expr
$ showvar() {
>var=${str+expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
$var is
$str is
$ str=
$ showvar
$var is expr
$str is
$ str=xyz
$ showvar
$var is expr
$str is xyz
$ showvar() {
>var=${str:+expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
$var is
$str is
$ str=
$ showvar
$var is
$str is
$ str=xyz
$ showvar
$var is expr
$str is xyz
可以看出来${str+expr}与${str:+expr}
*两者在$str为not set与not null都一致
*但当null值时,${str+expr}会将$var与$str都设为expr,但${str:+expr}则将$var设为null
$ showvar() {
>var=${strexpr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
expr
$ str=
$ showvar
$var is
$str is
$ str=xyz
$ showvar
$var is xyz
$str is xyz
$ showvar() {
>var=${str:expr}
>echo \$var is $var
>echo \$str is $str
> }
$ unset str
$ showvar
expr
$ str=
$ showvar
expr
$ str=xyz
$ showvar
$var is xyz
$str is xyz
可以看出来${strexpr}与${str:expr}
*两者在$str为not set与not null都一致
*但当null值时,${strexpr}会将$var与$str都设为null,但${str:expr}则将$var设为expr
综上所述:
$var=${str=expr}与$var=${str:=expr}
$var=${str-expr}与$var=${str:-expr}
$var=${str+expr}与$var=${str:+expr}
$var=${strexpr}与$var=${str:expr}
* 两者在 $str 为not set 与 not null 都一致
* 但当 null 值时不一致
分别描述如下:
$var=${str:-expr}的功能:
当str非空的时候var赋值为str,否则(包括not set和null)将var赋值为expr
$var=${str-expr}的功能:
当str非空的时候var赋值为str,为空的时候var设置为null,not set的时候将var赋值为expr
$var=${str:=expr}的功能:
当str非空的时候var赋值为str,否则(包括not set和null)将var和str均赋值为expr
$var=${str=expr}的功能:
当str非空的时候var赋值为str,为空的时候var设置为null,not set的时候将var和str均赋值为expr
$var=${str:expr}的功能:
当str非空的时候var赋值为expr,否则将expr写入标准错误后退出
$var=${strexpr}的功能:
当str非空的时候var赋值为expr,为空的时候var设置为null,not set的时候将expr写入标准错误后退出
$var=${str:+expr}的功能:
当str非空的时候var赋值为expr,否则将不做任何操作
$var=${str+expr}的功能:
当str非空的时候var赋值为expr,为空的时候var设置为expr,not set的时候不做任何操作
看来还是带有冒号的简单,只有两种情况:非空和其他,呵呵
原文地址 http://www.bsdlover.cn/html/83/n-183.html
SHELL十三问之六:exec 跟 source 差在哪?
这次先让我们从CU Shell版的一个实例贴子来谈起吧,例中的提问是:
cd /etc/aa/bb/cc可以执行,但是把这条命令写入shell时shell不执行!这是什么原因呀!
我当时如何回答暂时别去深究,先让我们了解一下进程(process)的观念好了。首先,我们所执行的任何程序,都是由父进程(parent process)所产生出来的一个子进程(child process),子进程在结束后,将返回到父进程去。此一现像在Linux系统中被称为 fork。当子进程被产生的时候,将会从父进程那里获得一定的资源分配、及(更重要的是)继承父进程的环境﹗
让我们回到上一章所谈到的"环境变量"吧:
*所谓环境变量其实就是那些会传给子进程的变量。简单而言,"遗传性"就是区分本地变量与环境变量的决定性指标。然而,从遗传的角度来看,我们也不难发现环境变量的另一个重要特征:
*环境变量只能从父进程到子进程单向继承。换句话说:在子进程中的环境如何变更,均不会影响父进程的环境。
接下来,再让我们了解一下命令脚本(shell script)的概念。所谓的shell script讲起来很简单,就是将你平时在shell prompt后所输入的多行command line依序写入一个文件去而已。其中再加上一些条件判断、互动界面、参数运用、函数调用、等等技巧,得以让script更加"聪明"的执行,但若撇开这些技巧不谈,我们真的可以简单的看成script只不过依次执行预先写好的命令行而已。
再结合以上两个概念(process + script),那应该就不难理解如下这句话的意思了:
*正常来说,当我们执行一个shell script时,其实是先产生一个sub-shell的子进程,然后sub-shell再去产生命令行的子进程。然则,那让我们回到本章开始时所提到的例子再从新思考:
cd /etc/aa/bb/cc可以执行,但是把这条命令写入shell时shell不执行!
这是什么原因呀!
我当时的答案是这样的:
因为,一般我们跑的shell script是用subshell去执行的。从process的观念来看,是parent process产生一个child process去执行,当child结束后,会返回parent,但parent的环境是不会因child的改变而改变的。所谓的环境元数很多,凡举 effective id, variable, workding dir等等...其中的workding dir ($PWD)正是楼主的疑问所在:当用subshell来跑script的话,sub shell的$PWD会因为cd而变更,但当返回primary shell时,$PWD是不会变更的。
能够了解问题的原因及其原理是很好的,但是?如何解决问题恐怕是我们更感兴趣的﹗是吧?^_^
那好,接下来,再让我们了解一下source命令好了。
当你有了fork的概念之后,要理解source就不难:
*所谓source就是让script在当前shell内执行、而不是产生一个sub-shell来执行。
由于所有执行结果均于当前shell内完成,若script的环境有所改变,当然也会改变当前环境了﹗因此,只要我们要将原本单独输入的script命令行变成source命令的参数,就可轻易解决前例提到的问题了。比方说,原本我们是如此执行 script的:
./my.script
现在改成这样即可:
source ./my.script
或:
. ./my.script
说到这里,我想,各位有兴趣看看/etc底下的众多设定文件,应该不难理解它们被定义后,如何让其它script读取并继承了吧?若然,日后你有机会写自己的script,应也不难专门指定一个设定文件以供不同的script一起"共享"了... ^_^
okay,到这里,若你搞得懂fork与source的不同,那接下来再接受一个挑战:
----那exec又与source/fork有何不同呢?
哦...要了解exec或许较为复杂,尤其扯上File Descriptor的话...
不过,简单来说:
* exec也是让script在同一个进程上执行,但是原有进程则被结束了。也就是简而言之:原有进程会否终止,就是exec与source/fork的最大差异了。嗯,光是从理论去理解,或许没那么好消化,不如动手"实作+思考"来的印像深刻哦。下面让我们写两个简单的script,分别命令为1.sh及 2.sh:
1.sh
#!/bin/sh
A=B
echo "PID for 1.sh before exec/source/fork:$$"
export A
echo "1.sh: \$A is $A"
case $1 in
exec)
echo "using exec..."
exec ./2.sh ;;
source)
echo "using source..."
. ./2.sh ;;
*)
echo "using fork by default..."
./2.sh ;;
esac
echo "PID for 1.sh after exec/source/fork:$$"
echo "1.sh: \$A is $A"
2.sh
#!/bin/sh
echo "PID for 2.sh: $$"
echo "2.sh get \$A=$A from 1.sh"
A=C
export A
echo "2.sh: \$A is $A"
然后,分别跑如下参数来观察结果:
$ ./1.sh fork
PID for 1.sh before exec/source/fork:531
1.sh: $A is B
using fork by default...
PID for 2.sh:532
2.sh get $A=B from 1.sh
2.sh: $A is C
PID for 1.sh after exec/source/fork:531
1.sh: $A is B
$ ./1.sh source
PID for 1.sh before exec/source/fork:533
1.sh: $A is B
using source...
PID for 2.sh:533
2.sh get $A=B from 1.sh
2.sh: $A is C
PID for 1.sh after exec/source/fork:533
1.sh: $A is C
$ ./1.sh exec
PID for 1.sh before exec/source/fork:537
1.sh: $A is B
using exec...
PID for 2.sh:537
2.sh get $A=B from 1.sh
2.sh: $A is C
############
echo "PID for 1.sh after exec/source/fork:$$"
echo "1.sh: \$A is $A"
已经不会执行了,1.sh的进程已经没了。
##############
SHELL十三问之七:( ) 与 { } 差在哪?
先说一下,为何要用( )或{ }好了。许多时候,我们在shell操作上,需要在一定条件下一次执行多个命令,也就是说,要么不执行,要么就全执行,而不是每次依序的判断是否要执行下一个命令。或是,需要从一些命令执行优先次顺中得到豁免,如算术的2*(3+4)那样...
这时候,我们就可引入"命令群组"(command group)的概念:将多个命令集中处理。在shell command line中,一般人或许不太计较( )与{ }这两对符号的差异,虽然两者都可将多个命令作群组化处理,但若从技术细节上,却是很不一样的:
( )将command group置于sub-shell去执行,也称nested sub-shell。
{ }则是在同一个shell内完成,也称为non-named command group。
如果你对上一章的fork与source的概念还记得的话,那就不难理解两者的差异了。
要是在command group中扯上变量及其它环境的修改,我们可以根据不同的需求来使用( )或{ }。通常而言,若所作的修改是临时的,且不想影响原有或以后的设定,那我们就nested sub-shell,反之,则用non-named command group。是的,光从command line来看,( )与{ }的差别就讲完了,够轻松吧~~~ ^_^
然而,若这两个meta用在其它command meta或领域中(如Regular Expression),还是有很多差别的。只是,我不打算再去说明了,留给读者自己慢慢发掘好了...
我这里只想补充一个概念,就是function。
所谓的function,就是用一个名字去命名一个 command group,然后再调用这个名字去执行command group。从non-named command group来推断,大概你也可以猜到我要说的是{ }了吧?
在bash中,function的定义方式有两种:
方式一:
function function_name {
command1
command2
command3
....
}
方式二:
fuction_name () {
command1
command2
command3
....
}
用哪一种方式无所谓,只是若碰到所定义的名称与现有的命令或别名(Alias)冲突的话,方式二或许会失败。但方式二起码可以少打function这一串英文字母,对懒人来说(如我),又何乐不为呢?... ^_^
function在某一程度来说,也可称为"函式",但请不要与传统编程所使用的函式(library)搞混了,毕竟两者差异很大。惟一相同的是,我们都可以随时用"已定义的名称"来调用它们...
若我们在shell操作中,需要不断的重复执行某些命令,我们首先想到的,或许是将命令写成命令稿(shell script)。不过,我们也可以写成function,然后在command line中打上function_name就可当一舨的script来使用了。只是若你在shell中定义的function,除了可用unset function_name取消外,一旦退出shell,function也跟着取消。然而,在script中使用function却有许多好处,除了可以提高整体script的执行效能外(因为已被加载),还可以节省许多重复的代码...
简单而言,若你会将多个命令写成script以供调用的话,那,你可以将function看成是script中的script ... ^_^而且,透过上一章介绍的source命令,我们可以自行定义许许多多好用的function,再集中写在特定文件中,然后,在其它的script中用source将它们加载并反复执行。若你是RedHat Linux的使用者,或许,已经猜得出/etc/rc.d/init.d/functions这个文件是作啥用的了~~~ ^_^
SHELL十三问之八:$(( )) 与 $( ) 还有${ } 差在哪?
我们上一章介绍了( )与{ }的不同,这次让我们扩展一下,看看更多的变化:$( )与${ }又是啥玩意儿呢?
在bash shell中,$( )与` ` (反引号)都是用来做命令替换用(command substitution)的。所谓的命令替换与我们第五章学过的变量替换差不多,都是用来重组命令行:
*完成引号里的命令行,然后将其结果替换出来,再重组命令行。
例如:
$ echo the last sunday is $(date -d "last sunday" +%Y-%m-%d)
如此便可方便得到上一星期天的日期了...
上例是在linux下,在FreeBSD下应该用下面的:
echo the last Sunday is `date –v Sunday +%Y%m%d`
在操作上,用$( )或` `都无所谓,只是我"个人"比较喜欢用$( ),理由是:
1, ` `很容易与' ' (单引号)搞混乱,尤其对初学者来说。
有时在一些奇怪的字形显示中,两种符号是一模一样的(直竖两点)。当然了,有经验的朋友还是一眼就能分辩两者。只是,若能更好的避免混乱,又何乐不为呢?
2,在多层次的复合替换中,` `须要额外的跳脱( \` )处理,而$( )则比较直观。例如:
这是错的:
command1 `command2 `command3` `
原本的意图是要在command2 `command3`先将command3提换出来给command 2处理,然后再将结果传给command1 `command2 ...`来处理。然而,真正的结果在命令行中却是分成了`command2 `与``两段。正确的输入应该如下:
command1 `command2 \`command3\` `
要不然,换成$( )就没问题了:
command1 $(command2 $(command3))
只要你喜欢,做多少层的替换都没问题啦~~~ ^_^
不过,$( )并不是没有弊端的...
首先,` `基本上可用在全部的unix shell中使用,若写成shell script,其移植性比较高。而$( )并不见的每一种shell都能使用,我只能跟你说,若你用bash2的话,肯定没问题... 接下来,再让我们看${ }吧...它其实就是用来作变量替换用的啦。一般情况下,$var与${var}并没有啥不一样。但是用${ }会比较精确的界定变量名称的范围,比方说:
$ A=B
$ echo $AB
原本是打算先将$A的结果替换出来,然后再补一个B字母于其后,但在命令行上,真正的结果却是只会替换变量名称为AB的值出来...若使用${ }就没问题了:
$ echo ${A}B
BB
不过,假如你只看到${ }只能用来界定变量名称的话,那你就实在太小看bash了﹗有兴趣的话,你可先参考一下cu本版的精华文章:
http://www.chinaunix.net/forum/viewtopic.phpt=201843
为了完整起见,我这里再用一些例子加以说明${ }的一些特异功能:
假设我们定义了一个变量为:file=/dir1/dir2/dir3/my.file.txt
我们可以用${ }分别替换获得不同的值:
${file#*/}:拿掉第一条/及其左边的字符串:dir1/dir2/dir3/my.file.txt
${file##*/}:拿掉最后一条/及其左边的字符串:my.file.txt
${file#*.}:拿掉第一个. 及其左边的字符串:file.txt
${file##*.}:拿掉最后一个. 及其左边的字符串:txt
${file%/*}:拿掉最后条/及其右边的字符串:/dir1/dir2/dir3
${file%%/*}:拿掉第一条/及其右边的字符串:(空值)
${file%.*}:拿掉最后一个. 及其右边的字符串:/dir1/dir2/dir3/my.file
${file%%.*}:拿掉第一个. 及其右边的字符串:/dir1/dir2/dir3/my
记忆的方法为:
#是去掉左边(在鉴盘上#在$之左边)
%是去掉右边(在鉴盘上%在$之右边)
单一符号是最小匹配﹔两个符号是最大匹配。
${file:0:5}:提取最左边的5个字节:/dir1
${file:5:5}:提取第5个字节右边的连续5个字节:/dir2
我们也可以对变量值里的字符串作替换:
${file/dir/path}:将第一个dir替换为path:/path1/dir2/dir3/my.file.txt
${file//dir/path}:将全部dir替换为path:/path1/path2/path3/my.file.txt
利用${ }还可针对不同的变量状态赋值(没设定、空值、非空值):
${file-my.file.txt}:假如$file没有设定,则使用my.file.txt作传回值。(空值及非空值时不作处理)
${file:-my.file.txt}:假如$file没有设定或为空值,则使用my.file.txt作传回值。(非空值时不作处理)
${file+my.file.txt}:假如$file设为空值或非空值,均使用my.file.txt作传回值。(没设定时不作处理)
${file:+my.file.txt}:若$file为非空值,则使用my.file.txt作传回值。(没设定及空值时不作处理)
${file=my.file.txt}:若$file没设定,则使用my.file.txt作传回值,同时将$file赋值为my.file.txt。(空值及非空值时不作处理)
${file:=my.file.txt}:若$file没设定或为空值,则使用my.file.txt作传回值,同时将$file赋值为my.file.txt。(非空值时不作处理)
${filemy.file.txt}:若$file没设定,则将my.file.txt输出至STDERR。(空值及非空值时不作处理)
${file:my.file.txt}:若$file没设定或为空值,则将my.file.txt输出至STDERR。(非空值时不作处理)
tips:
以上的理解在于,你一定要分清楚unset与null及non-null这三种赋值状态。一般而言, :与null有关,若不带:的话, null不受影响,若带:则连null也受影响.
还有哦,${#var}可计算出变量值的长度:
${#file}可得到27,因为/dir1/dir2/dir3/my.file.txt刚好是27个字节...
接下来,再为大家介稍一下bash的组数(array)处理方法。一般而言,A="a b c def"这样的变量只是将$A替换为一个单一的字符串,但是改为A=(a b c def),则是将$A定义为组数...bash的组数替换方法可参考如下方法:
${A[@]}或${A
}可得到a b c def (全部组数)
${A[0]}可得到a (第一个组数),${A[1]}则为第二个组数...
${#A[@]}或${#A
}可得到4 (全部组数数量)
${#A[0]}可得到1 (即第一个组数(a)的长度),${#A[3]}可得到3 (第四个组数(def)的长度)
A[3]=xyz则是将第四个组数重新定义为xyz ...
诸如此类的....
能够善用bash的$( )与${ }可大大提高及简化shell在变量上的处理能力哦,好了,最后为大家介绍$(( ))的用途吧:它是用来作整数运算的。在bash中,$(( ))的整数运算符号大致有这些:
+ - * /:分别为"加、减、乘、除"。
%:余数运算
& | ^ !:分别为"AND、OR、XOR、NOT"运算。
例:
$ a=5; b=7; c=2
$ echo $(( a+b*c ))
19
$ echo $(( (a+b)/c ))
6
$ echo $(( (a*b)%c))
1
在$(( ))中的变量名称,可于其前面加$符号来替换,也可以不用,如:
$(( $a + $b * $c))也可得到19的结果
此外,$(( ))还可作不同进位(如二进制、八进位、十六进制)作运算呢,只是,输出结果皆为十进制而已:echo $((16#2a))结果为42 (16进位转十进制),以一个实用的例子来看看吧:假如当前的 umask是022,那么新建文件的权限即为:
$ umask 022
$ echo "obase=8;$(( 8#666 & (8#777 ^ 8#$(umask)) ))" | bc
644
事实上,单纯用(( ))也可重定义变量值,或作testing:
a=5; ((a++))可将$a重定义为6
a=5; ((a--))则为a=4
a=5; b=7; ((a < b))会得到 0 (true)的返回值。
常见的用于(( ))的测试符号有如下这些:
<:小于
>:大于
<=:小于或等于
>=:大于或等于
==:等于
!=:不等于
不过,使用(( ))作整数测试时,请不要跟[ ]的整数测试搞混乱了。(更多的测试我将于第十章为大家介绍),上面的介绍,并没有详列每一种可用的状态,更多的,就请读者参考手册文件啰...
SHELL十三问之九:$@ 与 $* 差在哪?
要说$@与$*之前,需得先从shell script的positional parameter谈起...我们都已经知道变量(variable)是如何定义及替换的,这个不用再多讲了。但是,我们还需要知道有些变量是shell 内定的,且其名称是我们不能随意修改的,其中就有positional parameter在内。在shell script中,我们可用$0, $1, $2, $3 ...这样的变量分别提取命令行中的如下部份:
script_name parameter1 parameter2 parameter3 ...
我们很容易就能猜出$0就是代表shell script名称(路径)本身,而$1就是其后的第一个参数,如此类推....须得留意的是IFS的作用,也就是,若IFS被quoting处理后,那么positional parameter也会改变。
如下例:
my.sh p1 "p2 p3" p4
由于在p2与p3之间的空格键被soft quote所关闭了,因此my.sh中的$2是"p2 p3"而$3则是p4 ...
还记得前两章我们提到fucntion时,我不是说过它是script中的script吗? ^_^是的,function一样可以读取自己的(有别于script的) postitional parameter,惟一例外的是$0而已。举例而言:假设my.sh里有一个fucntion叫my_fun ,若在script中跑my_fun fp1 fp2 fp3,那么,function内的$0是my.sh,而$1则是fp1而非p1了...
不如写个简单的my.sh script 看看吧:
#!/bin/bash
my_fun() {
echo '$0 inside function is '$0
echo '$1 inside function is '$1
echo '$2 inside function is '$2
}
echo '$0 outside function is '$0
echo '$1 outside function is '$1
echo '$2 outside function is '$2
my_fun fp1 "fp2 fp3"
然后在command line中跑一下script就知道了:
chmod +x my.sh
./my.sh p1 "p2 p3"
$0 outside function is ./my.sh
$1 outside function is p1
$2 outside function is p2 p3
$0 inside function is ./my.sh
$1 inside function is fp1
$2 inside function is fp2 fp3
然而,在使用positional parameter的时候,我们要注意一些陷阱哦:
* $10不是替换第10个参数,而是替换第一个参数($1)然后再补一个0于其后!也就是,my.sh one two three four five six seven eigth nine ten这样的command line,my.sh里的$10不是ten而是one0哦...小心小心!要抓到ten的话,有两种方法:
方法一是使用我们上一章介绍的${ },也就是用${10}即可。
方法二,就是shift了。
用通俗的说法来说,所谓的shift就是取消positional parameter中最左边的参数( $0不受影响)。其默认值为1,也就是shift或shift 1 都是取消$1,而原本的$2则变成$1、$3变成$2 ...若shift 3则是取消前面三个参数,也就是原本的$4将变成$1 ...那,亲爱的读者,你说要shift掉多少个参数,才可用$1取得${10}呢?^_^
okay,当我们对positional parameter有了基本概念之后,那再让我们看看其它相关变量吧。首先是$#:它可抓出positional parameter的数量。以前面的my.sh p1 "p2 p3"为例:
由于p2与p3之间的IFS是在soft quote中,因此$#可得到2的值。但如果p2与p3没有置于quoting中话,那$#就可得到3的值了。同样的道理在function中也是一样的...因此,我们常在shell script里用如下方法测试script是否有读进参数:
[ $# = 0 ]
假如为0,那就表示script没有参数,否则就是有带参数...
接下来就是$@与$*:
精确来讲,两者只有在soft quote中才有差异,否则,都表示"全部参数"( $0除外)。举例来说好了:
若在command line上跑my.sh p1 "p2 p3" p4的话,
不管是$@还是$*,都可得到p1 p2 p3 p4就是了。
但是,如果置于soft quote中的话:
"$@"则可得到"p1" "p2 p3" "p4"这三个不同的词段(word)﹔
"$*"则可得到"p1 p2 p3 p4"这一整串单一的词段。
我们可修改一下前面的my.sh,使之内容如下:
#!/bin/bash
my_fun() {
echo "$#"
}
echo 'the number of parameter in "$@" is '$(my_fun "$@")
echo 'the number of parameter in "$*" is '$(my_fun "$*")
然后再执行./my.sh p1 "p2 p3" p4就知道$@与$*差在哪了...
the number of parameter in "$@" is3
the number of parameter in "$*" is1
SHELL十三问之十:&& 与 || 差在哪?
在解答本章题目之前,先让我们了解一个概念:return value !
我们在 shell 下跑的每一个 command 或 function ,在结束的时候都会传回父进程一个值,称为 return value 。在 shell command line 中可用 $ 这个变量得到最"新"的一个 return value ,也就是刚结束的那个进程传回的值。Return Value(RV) 的取值为 0-255 之间,由程序(或 script)的作者自行决定:
* 若在 script 里,用 exit RV 来指定其值,若没指定,在结束时以最后一道命令之 RV 为值。
* 若在 function 里,则用 return RV 来代替 exit RV 即可。
Return Value 的作用,是用来判断进程的退出状态(exit status),只有两种:
* 0 的话为"真"( true )
* 非 0 的话为"假"( false )
举个例子来说明好了:
假设当前目录内有一份 my.file 的文件,而 no.file 是不存在的:
$ touch my.file
$ ls my.file
$ echo $ # first echo
0
$ ls no.file
ls: no.file: No such file or directory
$ echo $ # second echo
1
$ echo $ # third echo
0
上例的第一个echo 是关于 ls my.file 的 RV ,可得到 0 的值,因此为 true ;
第二个 echo 是关于 ls no.file 的 RV ,则得到非 0 的值,因此为 false ;
第三个 echo 是关于第二个 echo $ 的 RV ,为 0 的值,因此也为 true 。
请记住:每一个 command 在结束时都会送回 return value 的﹗不管你跑甚么样的命令...然而,有一个命令却是"专门"用来测试某一条件而送出 return value 以供 true 或 false 的判断,它就是 test 命令了!
若你用的是 bash ,请在 command line 下打 man test 或 man bash 来了解这个 test 的用法。这是你可用作参考的最精确的文件了,要是听别人说的,仅作参考就好...下面我只简单作一些辅助说明,其余的一律以 man 为准:
首先,test 的表示式我们称为 expression ,其命令格式有两种:
test expression
or:
[ expression ]
(请务必注意[ ] 之间的空格键﹗)
用哪一种格式没所谓,都是一样的效果。(我个人比较喜欢后者...)
其次,bash 的 test 目前支持的测试对像只有三种:
* string:字符串,也就是纯文字。
* integer:整数( 0 或正整数,不含负数或小数点)。
* file:文件。
请初学者一定要搞清楚这三者的差异,因为 test 所用的 expression 是不一样的。以 A=123 这个变量为例:
* [ "$A" = 123 ]:是字符串的测试,以测试 $A 是否为 1、2、3 这三个连续的"文字"。
* [ "$A" -eq 123 ]:是整数的测试,以测试 $A 是否等于"一百二十三"。
* [ -e "$A" ]:是关于文件的测试,以测试 123 这份"文件"是否存在。
第三,当 expression 测试为"真"时,test 就送回 0 (true) 的 return value ,否则送出非 0 (false)。若在 expression 之前加上一个 " ! "(感叹号),则是当 expression 为"假时" 才送出 0 ,否则送出非 0 。
同时,test 也允许多重的覆合测试:
* expression1 -a expression2 :当两个 exrepssion 都为 true ,才送出 0 ,否则送出非 0 。
* expression1 -o expression2 :只需其中一个 exrepssion 为 true ,就送出 0 ,只有两者都为 false 才送出非 0 。
例如:
[ -d "$file" -a -x "$file" ]
是表示当$file 是一个目录、且同时具有 x 权限时,test 才会为 true 。
第四,在 command line 中使用 test 时,请别忘记命令行的"重组"特性,也就是在碰到 meta 时会先处理 meta 再重新组建命令行。(这个特性我在第二及第四章都曾反复强调过)比方说,若 test 碰到变量或命令替换时,若不能满足 expression 格式时,将会得到语法错误的结果。举例来说好了:
关于 [ string1 = string2 ] 这个 test 格式,在 = 号两边必须要有字符串,其中包括空(null)字符串(可用 soft quote 或 hard quote 取得)。假如 $A 目前没有定义,或被定义为空字符串的话,那如下的写法将会失败:
$ unset A
$ [ $A = abc ]
[: =: unary operator expected
这是因为命令行碰到 $ 这个 meta 时,会替换 $A 的值,然后再重组命令行,那就变成了:
[ = abc ]
如此一来 = 号左边就没有字符串存在了,因此造成 test 的语法错误﹗但是,下面这个写法则是成立的:
$ [ "$A" = abc ]
$ echo $
1
这是因为在命令行重组后的结果为:
[ "" = abc ]
由于 = 左边我们用 soft quote 得到一个空字符串,而让 test 语法得以通过...
读者诸君请务必留意这些细节哦,因为稍一不慎,将会导至 test 的结果变了个样﹗若您对 test 还不是很有经验的话,那在使用 test 时不妨先采用如下这一个"法则":
* 假如在 test 中碰到变量替换,用 soft quote 是最保险的﹗
若你对quoting 不熟的话,请重新温习第四章的内容吧... ^_^
okay,关于更多的 test 用法,老话一句:请看 man page 吧﹗ ^_^
虽然洋洋洒洒讲了一大堆,或许你还在嘀咕.... 那... 那个 return value 有啥用啊?﹗
问得好﹗告诉你:return value 的作用可大了﹗若你想让你的 shell 变"聪明"的话,就全靠它了:
* 有了 return value,我们可以让 shell 根据不同的状态做不同的时情...
这时候,才让我来揭晓本章的答案吧~~~ ^_^
&& 与 || 都是用来"组建"多个 command line 用的:
* command1 && command2 :其意思是 command2 只有在 RV 为 0 (true) 的条件下执行。
* command1 || command2 :其意思是 command2 只有在 RV 为非 0 (false) 的条件下执行。
来,以例子来说好了:
$ A=123
$ [ -n "$A" ] && echo "yes! it's ture."
yes! it's ture.
$ unset A
$ [ -n "$A" ] && echo "yes! it's ture."
$ [ -n "$A" ] || echo "no, it's NOT ture."
no, it's NOT ture.
(注:[ -n string ] 是测试 string 长度大于 0 则为 true 。)
上例的第一个 && 命令行之所以会执行其右边的 echo 命令,是因为上一个 test 送回了 0 的 RV 值;但第二次就不会执行,因为为 test 送回非 0 的结果...
同理,|| 右边的 echo 会被执行,却正是因为左边的 test 送回非 0 所引起的。
事实上,我们在同一命令行中,可用多个 && 或 || 来组建呢:
$ A=123
$ [ -n "$A" ] && echo "yes! it's ture." || echo "no, it's NOT ture."
yes! it's ture.
$ unset A
$ [ -n "$A" ] && echo "yes! it's ture." || echo "no, it's NOT ture."
no, it's NOT ture.
怎样,从这一刻开始,你是否觉得我们的shell 是"很聪明"的呢?好了,最后,布置一道习题给大家做做看、下面的判断是:当 $A 被赋与值时,再看是否小于 100 ,否则送出 too big! :
$ A=123
$ [ -n "$A" ] && [ "$A" -lt 100 ] || echo 'too big!'
too big!
若我将A 取消,照理说,应该不会送文字才对啊(因为第一个条件就不成立了)...
$ unset A
$ [ -n "$A" ] && [ "$A" -lt 100 ] || echo 'too big!'
too big!
为何上面的结果也可得到呢?又如何解决之呢?(提示:修改方法很多,其中一种方法可利用第七章介绍过的 command group ...)
$ unset A
$ [ -n "$A" ] && ([ "$A" -lt 100 ] || echo 'too big!')
$ A=123
$ [ -n "$A" ] && ([ "$A" -lt 100 ] || echo 'too big!')
too big!
$ A=90
$ [ -n "$A" ] && ([ "$A" -lt 100 ] || echo 'too big!')
原文地址 http://www.bsdlover.cn/html/88/n-188.html
SHELL十三问之十一:> 与 < 差在哪?
11.1
谈到 I/O redirection ,不妨先让我们认识一下 File Descriptor (FD) 。程序的运算,在大部份情况下都是进行数据(data)的处理, 这些数据从哪读进?又送出到哪里呢?这就是 file descriptor (FD) 的功用了。
在 shell 程序中,最常使用的 FD 大概有三个,分别为:
0: Standard Input (STDIN)
1: Standard Output (STDOUT)
2: Standard Error Output (STDERR)
在标准情况下,这些 FD 分别跟如下设备(device)关联:
stdin(0): keyboard
stdout(1): monitor
stderr(2): monitor
我们可以用如下下命令测试一下:
$ mail -s test root
this is a test mail.
please skip.
^d (同时按 crtl 跟 d 键)
很明显,mail 程序所读进的数据,就是从 stdin 也就是 keyboard 读进的。不过,不见得每个程序的 stdin 都跟 mail 一样从 keyboard 读进,因为程序作者可以从档案参数读进 stdin ,如:
$ cat /etc/passwd
但,要是cat 之后没有档案参数则又如何呢?哦,请您自己玩玩看啰....
$ cat
(请留意数据输出到哪里去了,最后别忘了按 ^d 离开...)至于 stdout 与 stderr ,嗯... 等我有空再续吧...还是,有哪位前辈要来玩接龙呢?
11.2
沿文再续,书接上一回... ^_^
相信,经过上一个练习后,你对 stdin 与 stdout 应该不难理解吧? 然后,让我们继续看 stderr 好了。事实上,stderr 没甚么难理解的:说穿了就是"错误信息"要往哪边送而已...
比方说,若读进的档案参数是不存在的,那我们在 monitor 上就看到了:
$ ls no.such.file
ls: no.such.file: No such file or directory
若,一个命令同时产生stdout 与 stderr 呢?那还不简单,都送到 monitor 来就好了:
$ touch my.file
$ ls my.file no.such.file
ls: no.such.file: No such file or directory
my.file
okay,至此,关于 FD 及其名称、还有相关联的设备,相信你已经没问题了吧?那好,接下来让我们看看如何改变这些 FD 的预设数据信道,我们可用 < 来改变读进的数据信道(stdin),使之从指定的档案读进。我们可用 > 来改变送出的数据信道(stdout, stderr),使之输出到指定的档案。
比方说:
$ cat < my.file
就是从my.file 读进数据
$ mail -s test root < /etc/passwd
则是从/etc/passwd 读进...这样一来,stdin 将不再是从 keyboard 读进,而是从档案读进了...严格来说,< 符号之前需要指定一个 FD 的(之间不能有空白), 但因为 0 是 < 的默认值,因此 < 与 0< 是一样的﹗
okay,这个好理解吧?
那,要是用两个 << 又是啥呢?这是所谓的 HERE Document ,它可以让我们输入一段文本,直到读到 << 后指定的字符串。比方说:
$ cat <<FINISH
first line here
second line there
third line nowhere
FINISH
这样的话,cat 会读进 3 行句子,而无需从 keyboard 读进数据且要等 ^d 结束输入。
至于 > 又如何呢?
且听下回分解....
--------------
11.3
当你搞懂了 0< 原来就是改变 stdin 的数据输入信道之后,相信要理解如下两个 redirection 就不难了:
* 1>
* 2>
前者是改变 stdout 的数据输出信道,后者是改变 stderr 的数据输出信道。两者都是将原本要送出到 monitor 的数据转向输出到指定档案去。由于 1 是 > 的默认值,因此,1> 与 > 是相同的,都是改 stdout 。
用上次的 ls 例子来说明一下好了:
$ ls my.file no.such.file 1>file.out
ls: no.such.file: No such file or directory
这样monitor 就只剩下 stderr 而已。因为 stdout 给写进 file.out 去了。
$ ls my.file no.such.file 2>file.err
my.file
这样monitor 就只剩下 stdout ,因为 stderr 写进了 file.err 。
$ ls my.file no.such.file 1>file.out 2>file.err
这样monitor 就啥也没有,因为 stdout 与 stderr 都给转到档案去了...呵~~~ 看来要理解 > 一点也不难啦﹗是不?没骗你吧? ^_^不过,有些地方还是要注意一下的。
首先,是同时写入的问题。比方如下这个例子:
$ ls my.file no.such.file 1>file.both 2>file.both
假如stdout(1) 与 stderr(2) 都同时在写入 file.both 的话, 则是采取“覆盖”方式:后来写入的覆盖前面的。让我们假设一个 stdout 与 stderr 同时写入 file.out 的情形好了:
* 首先 stdout 写入10个字符
* 然后 stderr 写入 6 个字符
那么,这时候原本 stdout 的前面 6 个字符就被 stderr 覆盖掉了。那,如何解决呢?所谓山不转路转、路不转人转嘛,我们可以换一个思维:将 stderr 导进 stdout 或将 stdout 导进 sterr ,而不是大家在抢同一份档案,不就行了﹗bingo﹗就是这样啦:
* 2>&1 就是将 stderr 并进 stdout 作输出
* 1>&2 或 >&2 就是将 stdout 并进 stderr 作输出
于是,前面的错误操作可以改为:
$ ls my.file no.such.file 1>file.both 2>&1
或
$ ls my.file no.such.file 2>file.both >&2
这样,不就皆大欢喜了吗? 呵~~~ ^_^
不过,光解决了同时写入的问题还不够,我们还有其它技巧需要了解的。故事还没结束,别走开﹗广告后,我们再回来...﹗
--------------
11.4
okay,这次不讲 I/O Redirction ,讲佛吧...
(有没搞错?﹗网中人是否头壳烧坏了?...) 嘻~~~ ^_^
学佛的最高境界,就是"四大皆空"。至于是空哪四大块?我也不知,因为我还没到那境界...
但这个"空"字,却非常值得我们返复把玩的:
--- 色即是空、空即是色﹗
好了,施主要是能够领会"空"的禅意,那离修成正果不远矣~~~
在 Linux 档案系统里,有个设备档位于 /dev/null 。
许多人都问过我那是甚么玩意儿?我跟你说好了:那就是"空"啦﹗没错﹗空空如也的空就是 null 了.... 请问施主是否忽然有所顿误了呢?然则恭喜了~~~ ^_^
这个 null 在 I/O Redirection 中可有用得很呢:
* 若将 FD1 跟 FD2 转到 /dev/null 去,就可将 stdout 与 stderr 弄不见掉。
* 若将 FD0 接到 /dev/null 来,那就是读进 nothing 。
比方说,当我们在执行一个程序时,画面会同时送出 stdout 跟 stderr , 假如你不想看到 stderr (也不想存到档案去),那可以:
$ ls my.file no.such.file 2>/dev/null
my.file
若要相反:只想看到stderr 呢?还不简单﹗将 stdout 弄到 null 就行:
$ ls my.file no.such.file >/dev/null
ls: no.such.file: No such file or directory
那接下来,假如单纯只跑程序,不想看到任何输出结果呢?
哦,这里留了一手上次节目没讲的法子,专门赠予有缘人﹗... ^_^
除了用 >/dev/null 2>&1 之外,你还可以如此:
$ ls my.file no.such.file &>/dev/null
(提示:将 &> 换成 >& 也行啦~~! )
okay?讲完佛,接下来,再让我们看看如下情况:
$ echo "1" > file.out
$ cat file.out
1
$ echo "2" > file.out
$ cat file.out
2
看来,我们在重导stdout 或 stderr 进一份档案时,似乎永远只获得最后一次导入的结果。那,之前的内容呢?呵~~~ 要解决这个问提很简单啦,将 > 换成 >> 就好:
$ echo "3" >> file.out
$ cat file.out
2
3
如此一来,被重导的目标档案之内容并不会失去,而新的内容则一直增加在最后面去。easy ? 呵 ... ^_^但,只要你再一次用回单一的 > 来重导的话,那么,旧的内容还是会被"洗"掉的﹗这时,你要如何避免呢?----备份﹗ yes ,我听到了﹗不过.... 还有更好的吗?既然与施主这么有缘份,老纳就送你一个锦囊妙法吧:
$ set -o noclobber
$ echo "4" > file.out
-bash: file: cannot overwrite existing file
那,要如何取消这个"限制"呢?哦,将 set -o 换成 set +o 就行:
$ set +o noclobber
$ echo "5" > file.out
$ cat file.out
5
再问:那... 有办法不取消而又"临时"盖写目标档案吗?
哦,佛曰:不可告也﹗啊~~~ 开玩笑的、开玩笑的啦~~~ ^_^ 唉,早就料到人心是不足的了
$ set -o noclobber
$ echo "6" >| file.out
$ cat file.out
6
留意到没有:在> 后面再加个" | "就好(注意: > 与 | 之间不能有空白哦)....
呼.... (深呼吸吐纳一下吧)~~~ ^_^
再来还有一个难题要你去参透的呢:
$ echo "some text here" > file
$ cat < file
some text here
$ cat < file > file.bak
$ cat < file.bak
some text here
$ cat < file > file
$ cat < file
嗯?﹗注意到没有?﹗﹗
---- 怎么最后那个 cat 命令看到的 file 竟是空的?﹗
同学们:下节课不要迟到啰~~~!
--------------
11.5
当当当~~~ 上课啰~~~ ^_^
前面提到:$ cat < file > file 之后原本有内容的档案结果却被洗掉了﹗
要理解这一现像其实不难,这只是 priority 的问题而已:
* 在 IO Redirection 中,stdout 与 stderr 的管道会先准备好,才会从 stdin 读进资料。
也就是说,在上例中,> file 会先将 file 清空,然后才读进 < file , 但这时候档案已经被清空了,因此就变成读不进任何数据了...
哦~~~ 原来如此~~~~ ^_^那... 如下两例又如何呢?
$ cat <> file
$ cat < file >> file
嗯... 同学们,这两个答案就当练习题啰,下节课之前请交作业﹗
好了,I/O Redirection 也快讲完了,sorry,因为我也只知道这么多而已啦~~~ 嘻~~ ^_^
不过,还有一样东东是一定要讲的,各位观众(请自行配乐~!#@!$%) :
---- 就是 pipe line 也﹗
谈到 pipe line ,我相信不少人都不会陌生:
我们在很多 command line 上常看到的" | "符号就是 pipe line 了。
不过,究竟 pipe line 是甚么东东呢?
别急别急... 先查一下英汉字典,看看 pipe 是甚么意思?
没错﹗它就是"水管"的意思...
那么,你能想象一下水管是怎么一根接着一根的吗?又,每根水管之间的 input 跟 output 又如何呢?
灵光一闪:原来 pipe line 的 I/O 跟水管的 I/O 是一模一样的:
* 上一个命令的 stdout 接到下一个命令的 stdin 去了﹗
的确如此... 不管在 command line 上你使用了多少个 pipe line ,
前后两个 command 的 I/O 都是彼此连接的﹗(恭喜:你终于开窍了﹗ ^_^ )
不过... 然而... 但是... ... stderr 呢?
好问题﹗不过也容易理解:
* 若水管漏水怎么办?
也就是说:在 pipe line 之间,前一个命令的 stderr 是不会接进下一命令的 stdin 的, 其输出,若不用 2> 导到 file 去的话,它还是送到监视器上面来﹗这点请你在 pipe line 运用上务必要注意的。
那,或许你又会问:
* 有办法将 stderr 也喂进下一个命令的 stdin 去吗?
(贪得无厌的家伙﹗)
方法当然是有,而且你早已学过了﹗ ^_^
我提示一下就好:
* 请问你如何将 stderr 合并进 stdout 一同输出呢?
若你答不出来,下课之后再来问我吧... (如果你脸皮真够厚的话...)或许,你仍意尤未尽﹗或许,你曾经碰到过下面的问题:
* 在 cm1 | cm2 | cm3 ... 这段 pipe line 中,若要将 cm2 的结果存到某一档案呢?
若你写成 cm1 | cm2 > file | cm3 的话,
那你肯定会发现 cm3 的 stdin 是空的﹗(当然啦,你都将水管接到别的水池了﹗)
聪明的你或许会如此解决:
cm1 | cm2 > file ; cm3 < file
是的,你的确可以这样做,但最大的坏处是:这样一来,file I/O 会变双倍﹗在 command 执行的整个过程中,file I/O 是最常见的最大效能杀手。凡是有经验的 shell 操作者,都会尽量避免或降低 file I/O 的频率。
那,上面问题还有更好方法吗?
有的,那就是 tee 命令了。
*所谓 tee 命令是在不影响原本 I/O 的情况下,将 stdout复制一份到档案去。
因此,上面的命令行可以如此打:
cm1 | cm2 | tee file | cm3
在预设上,tee 会改写目标档案,若你要改为增加内容的话,那可用 -a 参数达成。基本上,pipe line 的应用在 shell 操作上是非常广泛的,尤其是在 text filtering 方面, 凡举 cat, more, head, tail, wc, expand, tr, grep, sed, awk, ... 等等文字处理工具, 搭配起 pipe line 来使用,你会惊觉 command line 原来是活得如此精彩的﹗
常让人有"众里寻他千百度,蓦然回首,那人却在灯火阑珊处﹗"之感... ^_^
....
好了,关于 I/O Redirection 的介绍就到此告一段落。若日后有空的话,再为大家介绍其它在 shell 上好玩的东西﹗bye... ^_^
SHELL十三问之十二:你要 if 还是 case 呢?
还记得我们在第10 章所介绍的 return value 吗?若你记得 return value ,我想你也应该记得了 && 与 || 是甚么意思吧?用这两个符号再配搭 command group 的话,我们可让 shell script 变得更加聪明哦。
比方说:
comd1 && {
comd2
comd3
} || {
comd4
comd5
}
意思是说:
假如comd1 的 return value 为 true 的话,
然则执行 comd2 与 comd3 ,
否则执行 comd4 与 comd5 。
事实上,我们在写 shell script 的时候,经常需要用到这样那样的条件以作出不同的处理动作。用 && 与 || 的确可以达成条件执行的效果,然而,从"人类语言"上来理解,却不是那么直观。更多时候,我们还是喜欢用 if .... then ... else ... 这样的 keyword 来表达条件执行。在 bash shell 中,我们可以如此修改上一段代码:
if comd1
then
comd2
comd3
else
comd4
comd5
fi
这也是我们在shell script 中最常用到的 if 判断式:
只要if 后面的 command line 返回 true 的 return value (我们最常用 test 命令来送出 return value),然则就执行 then 后面的命令,否则执行 else 后的命令﹔fi 则是用来结束判断式的 keyword 。
在 if 判断式中,else 部份可以不用,但 then 是必需的。
(若 then 后不想跑任何 command ,可用" : " 这个 null command 代替)。
当然,then 或 else 后面,也可以再使用更进一层的条件判断式,这在 shell script 设计上很常见。若有多项条件需要"依序"进行判断的话,那我们则可使用 elif 这样的 keyword :
if comd1; then
comd2
elif comd3; then
comd4
else
comd5
fi
意思是说:
若comd1 为 true ,然则执行 comd2 ﹔
否则再测试 comd3 ,然则执行 comd4 ﹔
倘若 comd1 与 comd3 均不成立,那就执行 comd5 。
if 判断式的例子很常见,你可从很多 shell script 中看得到,我这里就不再举例子了...
接下来要为大家介绍的是 case 判断式。
虽然 if 判断式已可应付大部份的条件执行了,然而,在某些场合中,却不够灵活,尤其是在 string 式样的判断上,比方如下:
QQ () {
echo -n "Do you want to continue (Yes/No): "
read YN
if [ "$YN" = Y -o "$YN" = y -o "$YN" = "Yes" -o "$YN" = "yes" -o "$YN" = "YES" ]
then
else
exit 0
fi
}
从例中,我们看得出来,最麻烦的部份是在于判断YN 的值可能有好几种式样。聪明的你或许会如此修改:
if echo "$YN" | grep -q '^[Yy]\([Ee][Ss]\)*$'
...
也就是用Regular Expression 来简化代码。(我们有机会再来介绍 RE)只是... 是否有其它更方便的方法呢?有的,就是用 case 判断式即可:
QQ () {
echo -n "Do you want to continue (Yes/No): "
read YN
case "$YN" in
[Yy]|[Yy][Ee][Ss])
;;
*)
exit 0
;;
esac
}
我们常case 的判断式来判断某一变量在同的值(通常是 string)时作出不同的处理,比方说,判断 script 参数以执行不同的命令。若你有兴趣、且用 Linux 系统的话,不妨挖一挖 /etc/init.d/* 里那堆 script 中的 case 用法。如下就是一例:
case "$1" in
start)
start
;;
stop)
stop
;;
status)
rhstatus
;;
restart|reload)
restart
;;
condrestart)
[ -f /var/lock/subsys/syslog ] && restart || :
;;
*)
echo $"Usage: $0 {start|stop|status|restart|condrestart}"
exit 1
esac
(若你对 positional parameter 的印像已经模糊了,请重看第 9 章吧。)
SHELL十三问之十三:for、while 与 until 差在哪?
终于,来到shell 十三问的最后一问了... 长长吐一口气~~~~最后要介绍的是 shell script 设计中常见的"循环"(loop)。所谓的 loop 就是 script 中的一段在一定条件下反复执行的代码。
bash shell 中常用的 loop 有如下三种:
* for
* while
* until
for loop 是从一个清单列表中读进变量值,并"依次"的循环执行 do 到 done 之间的命令行。例:
for var in one two three four five
do
echo -----------
echo '$var is '$var
echo
done
上例的执行结果将会是:
1) for 会定义一个叫 var 的变量,其值依次是 one two three four five 。
2) 因为有 5 个变量值,因此 do 与 done 之间的命令行会被循环执行 5 次。
3) 每次循环均用 echo 产生三行句子。
而第二行中不在 hard quote 之内的 $var 会依次被替换为 one two three four five 。
4) 当最后一个变量值处理完毕,循环结束。
我们不难看出,在 for loop 中,变量值的多寡,决定循环的次数。然而,变量在循环中是否使用则不一定,得视设计需求而定。倘若 for loop 没有使用 in 这个 keyword 来指定变量值清单的话,其值将从 $@ (或 $* )中继承:
for var; do
....
done
(若你忘记了 positional parameter ,请温习第 9 章...)
for loop 用于处理"清单"(list)项目非常方便,其清单除了可明确指定或从 positional parameter 取得之外,也可从变量替换或命令替换取得... (再一次提醒:别忘了命令行的"重组"特性﹗)然而,对于一些"累计变化"的项目(如整数加减),for 亦能处理:
for ((i=1;i<=10;i++))
do
echo "num is $i"
done
除了for loop ,上面的例子我们也可改用 while loop 来做到:
num=1
while [ "$num" -le 10 ]; do
echo "num is $num"
num=$(($num + 1))
done
while loop 的原理与 for loop 稍有不同:
它不是逐次处理清单中的变量值,而是取决于 while 后面的命令行之 return value :
* 若为 ture ,则执行 do 与 done 之间的命令,然后重新判断 while 后的 return value 。
* 若为 false ,则不再执行 do 与 done 之间的命令而结束循环。
分析上例:
1) 在 while 之前,定义变量 num=1 。
2) 然后测试(test) $num 是否小于或等于 10 。
3) 结果为 true ,于是执行 echo 并将 num 的值加一。
4) 再作第二轮测试,其时 num 的值为 1+1=2 ,依然小于或等于 10,因此为 true ,继续循环。
5) 直到 num 为 10+1=11 时,测试才会失败... 于是结束循环。
我们不难发现:
* 若 while 的测试结果永远为 true 的话,那循环将一直永久执行下去:
while :; do
echo looping...
done
上例的" : "是 bash 的 null command ,不做任何动作,除了送回 true 的 return value 。因此这个循环不会结束,称作死循环。死循环的产生有可能是故意设计的(如跑 daemon),也可能是设计错误。若要结束死寻环,可透过 signal 来终止(如按下 ctrl-c )。(关于 process 与 signal ,等日后有机会再补充,十三问暂时略过。)
一旦你能够理解 while loop 的话,那,就能理解 until loop :
* 与 while 相反,until 是在 return value 为 false 时进入循环,否则结束。
因此,前面的例子我们也可以轻松的用 until 来写:
num=1
until [ ! "$num" -le 10 ]; do
echo "num is $num"
num=$(($num + 1))
done
或是:
num=1
until [ "$num" -gt 10 ]; do
echo "num is $num"
num=$(($num + 1))
done
关于 bash 的三个常用的 loop 暂时介绍到这里。在结束本章之前,再跟大家补充两个与 loop 有关的命令:
* break
* continue
这两个命令常用在复合式循环里,也就是在 do ... done 之间又有更进一层的 loop ,当然,用在单一循环中也未尝不可啦... ^_^
break 是用来打断循环,也就是"强迫结束" 循环。
若 break 后面指定一个数值 n 的话,则"从里向外"打断第 n 个循环,默认值为 break 1 ,也就是打断当前的循环。在使用 break 时需要注意的是, 它与 return 及 exit 是不同的:
* break 是结束 loop
* return 是结束 function
* exit 是结束 script/shell
而 continue 则与 break 相反:强迫进入下一次循环动作。
若你理解不来的话,那你可简单的看成:在 continue 到 done 之间的句子略过而返回循环顶端...与 break 相同的是:continue 后面也可指定一个数值 n ,以决定继续哪一层(从里向外计算)的循环,默认值为 continue 1 ,也就是继续当前的循环。
在 shell script 设计中,若能善用 loop ,将能大幅度提高 script 在复杂条件下的处理能力。请多加练习吧....
-----------
好了,该是到了结束的时候了。
婆婆妈妈的跟大家啰唆了一堆关于 shell 的基础概念,目的不是要告诉大家"答案",而是要带给大家"启发"...在日后关于 shell 的讨论中,我或许会经常用"链接"方式指引回来十三问中的内容,以便我们在进行技术探讨时彼此能有一些讨论基础,而不至于各说各话、徒费时力。但,更希望十三问能带给你更多的思考与乐趣,至为重要的是透过实作来加深理解。是的,我很重视"实作"与"独立思考"这两项学习要素,若你能够掌握其中真义,那请容我说声:
--- 恭喜﹗十三问你没白看了﹗ ^_^
p.s.
至于补充问题部份,我暂时不写了。而是希望:
1) 大家扩充题目。
2) 一起来写心得。
该文章最后由 阿炯 于 2024-05-11 16:51:55 更新,目前是第 2 版。