shell脚本编写笔记

mmdbcn

　　包含转载内容，转载自http://wenku.baidu.com/link?url=jtCHxEYzgGve6P64U3JRQRgU6nhpGvqFLLpWu9I2Htq6hi9TGLudRFkk7rJlzYt-3S-39oMAViQQ8oHDQMdBumP3MyIaxUFmo7ZH-6b0J37
　　一 .shell简介
　　Shell不仅是命令的收集，更是一门非常棒的编程语言。可以通过使用shell使大量的任务自动化，shell特别擅长系统管理任务，尤其适合那些易用性、可维护性和便携性比效率更重要的任务。 其实作为命令语言交互式地解释和执行用户输入的命令只是shell功能的一个方面，shell还可以用来进行程序设计，它提供了定义变量和参数的手段以及丰富的程序控制结构。使用shell编程类似于DOS中的批处理文件，称为shell script，又叫shell程序或shell命令文件。
　　二.几种流行的shell  
　　目前流行的shell有ash、bash、ksh、csh、zsh等，你可以用下面的命令来查看你自己的shell类型：  #echo $SHELL   $SHELL是一个环境变量，它记录用户所使用的shell类型。你可以用命令：  #shell-name   来转换到别的shell，这里shell-name是你想要尝试使用的shell的名称，如ash等。这个命令为用户又启动了一个shell，这个shell在最初登录的那个shell之后，称为下级的shell或子shell。使用命令：  $exit   可以退出这个子shell。
　　
　　三.shell基本语法  
　　shell的基本语法主要就是如何输入命令运行程序以及如何在程序之间通过shell的一些参数提供便利手段来进行通讯。
　　(1)输入输出重定向  
　　在Linux中，每一个进程都有三个特殊的文件描述指针：标准输入(standard input，文件描述指针为0)、标准输出(standard output，文件描述指针为1)、标准错误输出(standard error，文件描述指针为2)。这三个特殊的文件描述指针使进程在一般情况下接收标准输入终端的输入，同时由标准终端来显示输出，Linux同时也向使用者提供可以使用普通的文件或管道来取代这些标准输入输出设备。在shell中，使用者可以利用“>”和“<”来进行输入输出重定向。如：  
　　command>file：将命令的输出结果重定向到一个文件。  
　　command>&file：将命令的标准错误一起输出重定向到一个文件。  
　　command>>file：将标准输出的结果追加到文件中。   command>>&file：将标准输出和标准错误输出的结构都追加到文件中。  
　　(2)管道pipe  
　　pipe同样可以在标准输入输出和标准错误输出间做代替工作，这样一来，可以将某一个程序的输出送到另一个程序的输入，其语法如下：
　　command1| command2[| command3...]
　　也可以连同标准错误输出一起送入管道：  command1| &command2[|& command3...]  
　　(3)前台和后台  
　　在shell下面，一个新产生的进程可以通过用命令后面的符号“；”和“&”来分别以前台和后台的方式来执行，语法如下：  
　　command   产生一个前台的进程，下一个命令须等该命令运行结束后才能输入。
　　command &   产生一个后台的进程，此进程在后台运行的同时，可以输入其他的命令。  
　　四 .shell程序的变量和参数  
　　像高级程序设计语言一样，shell也提供说明和使用变量的功能。对shell来讲，所有变量的取值都是一个字符串，shell程序采用$var的形式来引用名为var的变量的值。
　　Shell有以下几种基本类型的变量：
　　(1)shell定义的环境变量
shell在开始执行时就已经定义了一些和系统的工作环境有关的变量，这些变量用户还可以重新定义，常用的shell环境变量有：
　　HOME：用于保存注册目录的完全路径名。
　　PATH：用于保存用冒号分隔的目录路径名，shell将按PATH变量中给出的顺序搜索这些目录，找到的第一个与命令名称一致的可执行文件将被执行。  
　　TERM：终端的类型。
　　UID：当前用户的标识符，取值是由数字构成的字符串。
　　PWD：当前工作目录的绝对路径名，该变量的取值随cd命令的使用而变化。
　　PS1：主提示符，在特权用户下，缺省的主提示符是“#”，在普通用户下，缺省的主提示符是“$”。
　　PS2：在shell接收用户输入命令的过程中，如果用户在输入行的末尾输入“\”然后回车，或者当用户按回车键时shell判断出用户输入的命令没有结束时，显示这个辅助提示符，提示用户继续输入命令的其余部分，缺省的辅助提示符是“>”。
　　(2)用户定义的变量
　　用户可以按照下面的语法规则定义自己的变量：  变量名=变量值
　　要注意的一点是，在定义变量时，变量名前不应加符号“$”，在引用变量的内容时则应在变量名前加“$”；
　　在给变量赋值时，等号两边一定不能留空格，若变量中本身就包含了空格，则整个字符串都要用双引号括起来。   在编写shell程序时，为了使变量名和命令名相区别，建议所有的变量名都用大写字母来表示。   有时我们想要在说明一个变量并对它设定为一个特定值后就不在改变它的值，这可以用下面的命令来保证一个变量的只读性：
　　readly 变量名  
　　在任何时候，建立的变量都只是当前shell的局部变量，所以不能被shell运行的其他命令或shell程序所利用，export命令可以将一局部变量提供给shell执行的其他命令使用，其格式为：
　　export 变量名
　　也可以在给变量赋值的同时使用export命令：  export 变量名=变量值
　　使用export说明的变量，在shell以后运行的所有命令或程序中都可以访问到。
　　(3)位置参数
　　位置参数是一种在调用shell程序的命令行中按照各自的位置决定的变量，是在程序名之后输入的参数。位置参数之间用空格分隔，shell取第一个位置参数替换程序文件中的$1，第二个替换$2，依次类推。
　　$0是一个特殊的变量，它的内容是当前这个shell程序的文件名，所以，$0不是一个位置参数，在显示当前所有的位置参数时是不包括$0的。
　　(4)预定义变量
　　预定义变量和环境变量相类似，也是在shell一开始时就定义了的变量，所不同的是，用户只能根据shell的定义来使用这些变量，而不能重定义它。所有预定义变量都是由$符和另一个符号组成的，常用的shell预定义变量有：
　　$#：位置参数的数量
　　$*：所有位置参数的内容
　　$?：命令执行后返回的状态
　　$$：当前进程的进程号  
$!：后台运行的最后一个进程号
　　$0：当前执行的进程名
　　其中，“$?”用于检查上一个命令执行是否正确(在Linux中，命令退出状态为0表示该命令正确执行，任何非0值表示命令出错)。
　　“$$”变量最常见的用途是用作临时文件的名字以保证临时文件不会重复。
　　(5)参数置换的变量
　　shell提供了参数置换能力以便用户可以根据不同的条件来给变量赋不同的值。参数置换的变量有四种，这些变量通常与某一个位置参数相联系，根据指定的位置参数是否已经设置类决定变量的取值，它们的语法和功能分别如下:
　　a. 变量=${参数-word}：如果设置了参数，则用参数的值置换变量的值，否则用word置换。即这种变量的值等于某一个参数的值，如果该参数没有设置，则变量就等于word的值。
　　b. 变量=${参数=word}：如果设置了参数，则用参数的值置换变量的值，否则把变量设置成word然后再用word替换参数的值。注意，位置参数不能用于这种方式，因为在shell程序中不能为位置参数赋值。
　　c. 变量=${参数？word}：如果设置了参数，则用参数的值置换变量的值，否则就显示word并从shell中退出，如果省略了word，则显示标准信息。这种变量要求一定等于某一个参数的值，如果该参数没有设置，就显示一个信息，然后退出，因此这种方式常用于出错指示。
　　d. 变量=${参数+word}：如果设置了参数，则用word置换变量，否则不进行置换。  所有这四种形式中的“参数”既可以是位置参数，也可以是另一个变量，只是用位置参数的情况比较多。
　　
　　
　　五.shell程序设计的流程控制
　　和其他高级程序设计语言一样，shell提供了用来控制程序执行流程的命令，包括条件分支和循环结构，用户可以用这些命令建立非常复杂的程序。   
　　与传统的语言不同的是，shell用于指定条件值的不是布尔表达式而是命令和字符串。  
　　1.test测试命令   
　　test命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试，其测试符和相应的功能分别如下：  
　　(1)数值测试：  
　　-eq：等于则为真  
　　-ne：不等于则为真  
　　-gt：大于则为真  
　　-ge：大于等于则为真  
　　-lt：小于则为真  
　　-le：小于等于则为真  
　　(2)字符串测试：  
　　=：等于则为真  
　　!=：不相等则为真   
　　-z 字符串：字符串长度伪则为真  
　　-n 字符串：字符串长度不伪则为真  
　　(3)文件测试：   
　　-e 文件名：如果文件存在则为真   
　　-r 文件名：如果文件存在且可读则为真  
　　-w 文件名：如果文件存在且可写则为真
　　-x 文件名：如果文件存在且可执行则为真   
　　-s 文件名：如果文件存在且至少有一个字符则为真  
　　-d 文件名：如果文件存在且为目录则为真   
　　-f 文件名：如果文件存在且为普通文件则为真   
　　-c 文件名：如果文件存在且为字符型特殊文件则为真   
　　-b 文件名：如果文件存在且为块特殊文件则为真   
　　另外，Linux还提供了与(“！”)、或(“-o)、非(“-a”)三个逻辑操作符用于将测试条件连接起来，其优先级为：“！”最高，“-a”次之，“-o”最低。  同时，bash也能完成简单的算术运算，格式如下：  
　　$[expression]  
　　例如：var1=2  var2=$[var1*10+1]  则：var2的值为21。  
　　2.if条件语句   
　　shell程序中的条件分支是通过if条件语句来实现的，其一般格式为：
　　if 条件命令串  then   
　　条件为真时的命令串  
　　else   
　　条件为假时的命令串  
　　fi   
　　3.for 循环   
　　for循环对一个变量的可能的值都执行一个命令序列。赋给变量的几个数值既可以在程序内以数值列表的形式提供，也可以在程序以外以位置参数的形式提供。for循环的一般格式为：   
　　for 变量名 [in 数值列表]
　　do  
　　若干个命令行  
　　done   
　　变量名可以是用户选择的任何字符串，如果变量名是var，则在in之后给出的数值将顺序替换循环命令列表中的$var。如果省略了in，则变量var的取值将是位置参数。对变量的每一个可能的赋值都将执行do和done之间的命令列表。   
　　4.while和until 循环   
　　while 和 until命令都是用命令的返回状态值来控制循环的。
　　While 循环的一般格式为：  
　　while  
　　若干个命令行1  
　　do   若干个命令行2  
　　done  
　　只要while的“若干个命令行1”中最后一个命令的返回状态为真，while循环就继续执行do...done之间的“若干个命令行2”。   
　　until命令是另一种循环结构，它和while命令相似，其格式如下：  
　　until   若干个命令行1
　　do   
　　若干个命令行2  
　　done  
　　until循环和while循环的区别在于：while循环在条件为真时继续执行循环，而until则是在条件为假时继续执行循环。   
　　Shell还提供了true和false两条命令用于建立无限循环结构的需要，它们的返回状态分别是总为0或总为非0   
　　5.case 条件选择   
　　if条件语句用于在两个选项中选定一项，而case条件选择为用户提供了根据字符串或变量的值从多个选项中选择一项的方法，其格式如下：
　　case string in  
　　exp-1)  若干个命令行1  ；；  
　　exp-2)   若干个命令行2  ；；
　　&bdquo;&bdquo;  *)   其他命令行
　　esac   
　　shell通过计算字符串string的值，将其结果依次和表达式exp-1、exp-2等进行比较，直到找到一个匹配的表达式为止，如果找到了匹配项则执行它下面的命令直到遇到一对分号(；；)为止。   在case表达式中也可以使用shell的通配符(“*”、“？”、“[ ]”)。通常用“*”作为case命令的最后表达式以便使在前面找不到任何相应的匹配项时执行“其他命令行”的命令。   
　　6.无条件控制语句break和continue   
　　break 用于立即终止当前循环的执行，而contiune用于不执行循环中后面的语句而立即开始下一个循环的执行。这两个语句只有放在do和done之间才有效。   
　　7.函数定义   
　　在shell中还可以定义函数。函数实际上也是由若干条shell命令组成的，因此它与shell程序形式上是相似的，不同的是它不是一个单独的进程，而是shell程序的一部分。函数定义的基本格式为：  
　　functionname  
　　{   
　　若干命令行  
　　}  
　　调用函数的格式为：   
　　functionname param1 param2 &bdquo;&bdquo;  
　　shell函数可以完成某些例行的工作，而且还可以有自己的退出状态，因此函数也可以作为if、while等控制结构的条件。  在函数定义时不用带参数说明，但在调用函数时可以带有参数，此时shell将把这些参数分别赋予相应的位置参数$1、$2、...及$*。
　　8.命令分组
　　在shell中有两种命令分组的方法：“()”和“{}”，前者当shell执行()中的命令时将再创建一个新的子进程，然后这个子进程去执行圆括弧中的命令。当用户在执行某个命令时不想让命令运行时对状态集合(如位置参数、环境变量、当前工作目录等)的改变影响到下面语句的执行时，就应该把这些命令放在圆括弧中，这样就能保证所有的改变只对子进程产生影响，而父进程不受任何干扰；
　　{}用于将顺序执行的命令的输出结果用于另一个命令的输入(管道方式)。当我们要真正使用圆括弧和花括弧时(如计算表达式的优先级)，则需要在其前面加上转义符(\)以便让shell知道它们不是用于命令执行的控制所用。
　　9.信号
　　trap命令用于在shell程序中捕捉到信号，之后可以有三种反应方式：
　　(1)执行一段程序来处理这一信号
　　(2)接受信号的默认操作
　　(3)忽视这一信号
　　trap对上面三种方式提供了三种基本形式：
　　第一种形式的trap命令在shell接收到signal list清单中数值相同的信号时，将执行双引号中的命令串。
　　trap 'commands' signal-list
　　trap "commands" signal-list
　　为了恢复信号的默认操作，使用第二种形式的trap命令：
　　trap signal-list
　　第三种形式的trap命令允许忽视信号： trap " " signal-list
　　注意：
　　(1)对信号11(段违例)不能捕捉，因为shell本身需要捕捉该信号去进行内存的转储。
　　(2)在trap中可以定义对信号0的处理(实际上没有这个信号)，shell程序在其终止(如执行exit语句)时发出该信号。
　　(3)在捕捉到signal-list中指定的信号并执行完相应的命令之后，如果这些命令没有将shell程序终止的话，shell程序将继续执行收到信号时所执行的命令后面的命令，这样将很容易导致shell程序无法终止。
　　另外，在trap语句中，单引号和双引号是不同的，当shell程序第一次碰到trap语句时，将把commands中的命令扫描一遍。此时若commands是用单引号括起来的话，那么shell不会对commands中的变量和命令进行替换，否则commands中的变量和命令将用当时具体的值来替换。
　　六、运行shell程序的方法
　　用户可以用任何编辑程序来编写shell程序。因为shell程序是解释执行的，所以不需要编译装配成目标程序，按照shell编程的惯例，以bash为例，程序的第一行一般为“#！/bin/bash”，其中#表示该行是注释，叹号“！”告诉shell运行叹号之后的命令并用文件的其余部分作为输入，也就是运行/bin/bash并让/bin/bash去执行shell程序的内容。
　　执行shell程序的方法有三种：
　　(1)sh shell程序文件名
　　这种方法的命令格式为： bash shell程序文件名
　　这实际上是调用一个新的bash命令解释程序，而把shell程序文件名作为参数传递给它。新启动的shell将去读指定的文件，执行文件中列出的命令，当所有的命令都执行完结束。该方法的优点是可以利用shell调试功能。
　　(2)sh格式为：   bash这种方式就是利用输入重定向，使shell命令解释程序的输入取自指定的程序文件。
　　(3)用chmod命令使shell程序成为可执行的
　　一个文件能否运行取决于该文件的内容本身可执行且该文件具有执行权。对于shell程序，当用编辑器生成一个文件时，系统赋予的许可权限都是644(rw-r-r--)，因此，当用户需要运行这个文件时，只需要直接键入文件名即可。
　　在这三种运行shell程序的方法中，最好按下面的方式选择：当刚建立一个shell程序，对它的正确性还没有把握时，应当使用第一种方式进行调试。当一个shell程序已经调试好时，应使用第三种方式把它固定下来，以后只要键入相应的文件名即可，并可被另一个程序所调用。
　　七、bash程序的调试
　　在编程过程中难免会出错，有的时候，调试程序比编写程序花费的时间还要多，shell程序同样如此。
　　shell程序的调试主要是利用bash命令解释程序的选择项。
　　调用bash的形式是：  bash -选择项 shell程序文件名
　　几个常用的选择项是：
　　-e：如果一个命令失败就立即退出
　　-n：读入命令但是不执行它们
　　-u：置换时把未设置的变量看作出错
　　-v：当读入shell输入行时把它们显示出来
　　-x：执行命令时把命令和它们的参数显示出来
　　上面的所有选项也可以在shell程序内部用“set -选择项”的形式引用，而“set +选择项”则将禁止该选择项起作用。如果只想对程序的某一部分使用某些选择项时，则可以将该部分用上面两个语句包围起来。
　　1.未置变量退出和立即退出   未置变量退出特性允许用户对所有变量进行检查，如果引用了一个未赋值的变量就终止shell程序的执行。shell通常允许未置变量的使用，在这种情况下，变量的值为空。如果设置了未置变量退出选择项，则一旦使用了未置变量就显示错误信息，并终止程序的运行。未置变量退出选择项为“-u”。   当shell运行时，若遇到不存在或不可执行的命令、重定向失败或命令非正常结束等情况时，如果未经重新定向，该出错信息会打印在终端屏幕上，而shell程序仍将继续执行。要想在错误发生时迫使shell程序立即结束，可以使用“-e”选项将shell程序的执行立即终止。
　　2.shell程序的跟踪   调试shell程序的主要方法是利用shell命令解释程序的“-v”或“-x”选项来跟踪程序的执行。“-v”选择项使shell在执行程序的过程中，把它读入的每一个命令行都显示出来，而“-x”选择项使shell在执行程序的过程中把它执行的每一个命令在行首用一个“+”加上命令名显示出来。并把每一个变量和该变量所取的值也显示出来，因此，它们的主要区别在于：在执行命令行之前无“-v”则打印出命令行的原始内容，而有“-v”则打印出经过替换后的命令行的内容。   除了使用shell的“-v”和“-x”选择项以外，还可以在shell程序内部采取一些辅助调试的措施。例如，可以在shell程序的一些关键地方使用echo命令把必要的信息显示出来，它的作用相当于C语言中的printf语句，这样就可以知道程序运行到什么地方及程序目前的状态。
　　八、bash的内部命令   
　　bash命令解释程序包含了一些内部命令。内部命令在目录列表时是看不见的，它们由shell本身提供。
　　常用的内部命令有：echo、eval、exec、export、readonly、read、shift、wait和点(.)。
　　下面简单介绍其命令格式和功能。  
　　1.echo   
　　命令格式：echo arg   
　　功能：在屏幕上打印出由arg指定的字符串。
　　2.eval   
　　命令格式：eval args   
　　功能：当shell程序执行到eval语句时，shell读入参数args，并将它们组合成一个新的命令，然后执行。
　　3.exec   
　　命令格式：exec 命令 命令参数   
　　功能：当shell执行到exec语句时，不会去创建新的子进程，而是转去执行指定的命令，当指定的命令执行完时，该进程，也就是最初的shell就终止了，所以shell程序中exec后面的语句将不再被执行。  
　　4.export   
　　命令格式：export 变量名 或：export 变量名=变量值   
　　功能：shell可以用export把它的变量向下带入子shell从而让子进程继承父进程中的环境变量。但子shell不能用export把它的变量向上带入父shell。   注意：不带任何变量名的export语句将显示出当前所有的export变量。  
　　5.readonly   
　　命令格式：readonly 变量名   
　　功能：将一个用户定义的shell变量标识为不可变的。不带任何参数的readonly命令将显示出所有只读的shell变量。
　　6.read   
　　命令格式：  read变量名表  
　　功能：从标准输入设备读入一行，分解成若干字，赋值给shell程序内部定义的变量。
　　7.shift语句   
　　功能：shift语句按如下方式重新命名所有的位置参数变量：$2成为$1，$3成为$2&bdquo;&bdquo;在程序中每使用一次shift语句，都使所有的位置参数依次向左移动一个位置，并使位置参数“$#”减一，直到减到0。  
　　8.wait   功能：是shell等待在后台启动的所有子进程结束。Wait的返回值总是真。  
　　9.exit   功能：退出shell程序。在exit之后可有选择地指定一个数字作为返回状态。  
　　10.“.”(点)   命令格式：. Shell程序文件名   功能：使shell读入指定的shell程序文件并依次执行文件中的所有语句。
　　
　　Linux 脚本编写基础
　　1.1.1 开头
　　程序必须以下面的行开始（必须方在文件的第一行）：
　　#!/bin/sh
　　符号#!用来告诉系统它后面的参数是用来执行该文件的程序。在这个例子中我们使用/bin/sh来执行程序。 当编辑好脚本时，如果要执行该脚本，还必须使其可执行。 要使脚本可执行：
　　编译 chmod +x filename
　　这样才能用./filename 来运行
　　1.1.2 注释 在进行shell编程时，以#开头的句子表示注释，直到这一行的结束。我们真诚地建议您在程序中使用注释。 如果您使用了注释，那么即使相当长的时间内没有使用该脚本，您也能在很短的时间内明白该脚本的作用及工作原理。
　　1.1.3 变量 在其他编程语言中您必须使用变量。在shell编程中，所有的变量都由字符串组成，并且您不需要对变量进行声明。要赋值给一个变量，您可以这样写： #!/bin/sh
　　#对变量赋值：
　　a="hello world"
　　# 现在打印变量a的内容：
　　echo "A is:" echo $a
　　有时候变量名很容易与其他文字混淆，比如：
　　num=2
　　echo "this is the $numnd" 这并不会打印出"this is the 2nd"，而仅仅打印"this is the "，因为shell会去搜索变量numnd的值，但是这个变量时没有值的。可以使用花括号来告诉shell我们要打印的是num变量：
　　num=2 echo "this is the ${num}nd"
　　这将打印： this is the 2nd
　　1.1.4 环境变量
　　由export关键字处理过的变量叫做环境变量。我们不对环境变量进行讨论，因为通常情况下仅仅在登录脚本中使用环境变量。
　　1.1.5 Shell命令和流程控制
　　在shell脚本中可以使用三类命令：
　　1)Unix 命令: 虽然在shell脚本中可以使用任意的unix命令，但是还是由一些相对更常用的命令。这些命令通常是用来进行文件和文字操作的。
　　常用命令语法及功能
　　echo "some text": 将文字内容打印在屏幕上
　　ls: 文件列表 wc –l filewc -w filewc -c file: 计算文件行数计算文件中的单词数计算文件中的字符数
　　cp sourcefile destfile: 文件拷贝
　　mv oldname newname : 重命名文件或移动文件
　　 rm file: 删除文件
　　grep 'pattern' file: 在文件内搜索字符串比如：grep 'searchstring' file.txt
　　cut -b colnum file: 指定欲显示的文件内容范围，并将它们输出到标准输出设备
　　比如：输出每行第5个到第9个字符cut -b5-9 file.txt
　　千万不要和cat命令混淆， 这是两个完全不同的命令 cat file.txt: 输出文件内容到标准输出设备（屏幕）上
　　file somefile: 得到文件类型
　　read var: 提示用户输入，并将输入赋值给变量
　　sort file.txt: 对file.txt文件中的行进行排序
　　uniq: 删除文本文件中出现的行列比如： sort file.txt | uniq
　　expr: 进行数学运算Example: add 2 and 3expr 2 "+" 3
　　find: 搜索文件比如：根据文件名搜索find . -name filename -print
　　tee: 将数据输出到标准输出设备(屏幕) 和文件比如：somecommand | tee outfile basename file: 返回不包含路径的文件名比如：
　　basename /bin/tux将返回 tux
　　dirname file: 返回文件所在路径比如：dirname /bin/tux将返回 /bin
　　head file: 打印文本文件开头几行
　　tail file : 打印文本文件末尾几行
　　sed: Sed是一个基本的查找替换程序。可以从标准输入（比如命令管道）读入文本，并将 结果输出到标准输出（屏幕）。该命令采用正则表达式（见参考）进行搜索。不要和shell中的通配符相混淆。比如：将linuxfocus 替换为LinuxFocus ：cat text.file | sed 's/linuxfocus/LinuxFocus/' > newtext.file awk: awk 用来从文本文件中提取字段。缺省地，字段分割符是空格，可以使用-F指定其他分割符。
　　cat file.txt | awk -F, '{print $1 "," $3 }'这里我们使用，作为字段分割符，同时打印第一个和第三个字段。如果该文件内容如下： Adam Bor, 34, IndiaKerry Miller, 22, USA命令输出结果为：Adam Bor, IndiaKerry Miller, USA 2) 概念: 管道, 重定向和 backtick 这些不是系统命令，但是他们真的很重要。
　　管道 (|)
　　将一个命令的输出作为另外一个命令的输入。 grep "hello" file.txt | wc -l 在file.txt中搜索包含有”hello”的行并计算其行数。 在这里grep命令的输出作为wc命令的输入。当然您可以使用多个命令。
　　重定向：将命令的结果输出到文件，而不是标准输出（屏幕）。
　　> 写入文件并覆盖旧文件
　　>> 加到文件的尾部，保留旧文件内容。
　　反短斜线 使用反短斜线可以将一个命令的输出作为另外一个命令的一个命令行参数。
　　命令： find . -mtime -1 -type f -print
　　用来查找过去24小时（-mtime –2则表示过去48小时）内修改过的文件。
　　如果您想将所有查找到的文件打一个包，则可以使用以下脚本：
　　#!/bin/sh # The ticks are backticks (`) not normal quotes ('): tar -zcvf lastmod.tar.gz `find . -mtime -1 -type f -print`
　　3) 流程控制
　　1.if
　　"if" 表达式 如果条件为真则执行then后面的部分：
　　if ....;then
　　....
　　elif
　　....;then
　　 ....
　　else
　　....
　　fi
　　大多数情况下，可以使用测试命令来对条件进行测试。比如可以比较字符串、判断文件是否存在及是否可读等等&bdquo; 通常用" [ ] "来表示条件测试。注意这里的空格很重要。要确保方括号的空格。
　　[ -f "somefile" ] ：判断是否是一个文件
　　[ -x "/bin/ls" ] ：判断/bin/ls是否存在并有可执行权限
　　[ -n "$var" ] ：判断$var变量是否有值
　　[ "$a" = "$b" ] ：判断$a和$b是否相等
　　执行man test可以查看所有测试表达式可以比较和判断的类型。
　　直接执行以下脚本：
　　#!/bin/sh
　　if [ "$SHELL" = "/bin/bash" ]; then
　　echo "your login shell is the bash (bourne again shell)"
　　else
　　echo "your login shell is not bash but $SHELL"
　　fi
　　变量$SHELL包含了登录shell的名称，我们和/bin/bash进行了比较。
　　快捷操作符 熟悉C语言的朋友可能会很喜欢下面的表达式：
　　[ -f "/etc/shadow" ] && echo "This computer uses shadow passwors"
　　这里 && 就是一个快捷操作符，如果左边的表达式为真则执行右边的语句。 您也可以认为是逻辑运算中的与操作。
　　上例中表示如果/etc/shadow文件存在则打印” This computer uses shadow passwors”。
　　同样或操作(||)在shell编程中也是可用的。这里有个例子：
　　#!/bin/sh
　　mailfolder=/var/spool/mail/james
　　[ -r "$mailfolder" ]' '{ echo "Can not read $mailfolder" exit 1; }
　　echo "$mailfolder has mail from:"
　　grep "^From " $mailfolder
　　该脚本首先判断mailfolder是否可读。如果可读则打印该文件中的"From" 一行。如果不可读则或操作生效，打印错误信息后脚本退出。
2.case
case :
表达式可以用来匹配一个给定的字符串，而不是数字。
case ... in
...) do something here ;
esac
让我们看一个例子。
file命令可以辨别出一个给定文件的文件类型，比如：
file lf.gz
这将返回：
lf.gz: gzip compressed data, deflated, original filename,
last modified: Mon Aug 27 23:09:18 2001, os: Unix
我们利用这一点写了一个叫做smartzip的脚本，该脚本可以自动解压bzip2, gzip 和zip 类型的压缩文件：
#!/bin/sh
ftype=`file "$1"`
case "$ftype" in
"$1: Zip archive"*)
unzip "$1" ;
"$1: gzip compressed"*)
gunzip "$1" ;
"$1: bzip2
bunzip2 "$1" ;
*) echo "File $1 can not be uncompressed with smartzip";;
您可能注意到我们在这里使用了一个特殊的变量$1。
该变量包含了传递给该程序的第一个参数值。
也就是说，当我们运行：
smartzip articles.zip
$1 就是字符串 articles.zip
3. selsect
select 表达式是一种bash的扩展应用，尤其擅长于交互式使用。用户可以从一组不同的值中进行选择。
select var in ...  do
break
done
.... now $var can be used ....
下面是一个例子：
#!/bin/sh
echo "What is your favourite OS?"
select var in "Linux" "Gnu Hurd" "Free BSD" "Other"; do
　　break
done
echo "You have selected $var"
下面是该脚本运行的结果：
What is your favourite OS?
1) Linux
2) Gnu Hurd
3) Free BSD
4) Other
#? 1
You have selected Linux
4.loop
loop表达式：
while ...; do
....
done
while-loop 将运行直到表达式测试为真。
关键字"break" 用来跳出循环。
而关键字”continue”用来不执行余下的部分而直接跳到下一个循环。
for-loop
表达式查看一个字符串列表(字符串用空格分隔) 然后将其赋给一个变量：
for var in ....; do
....
done
在下面的例子中，将分别打印
ABC到屏幕上：

#!/bin/sh
for var in A B C  do
echo "var is $var"
done
5. 引号
在向程序传递任何参数之前，程序会扩展通配符和变量。这里所谓扩展的意思是程序会把通配符（比如*）替换成合适的文件名，它变量替换成变量值。为了防止程序作这种替换，您可以使用引号
单引号和双引号的区别
[iyunv@linux ~]# name=TekTea
[iyunv@linux ~]# echo
$name
TekTea
[iyunv@linux ~]# sayhello=”Hello $name”
[iyunv@linux ~]#
echo $sayhello
Hello TekTea
[iyunv@linux ~]# sayhello='Hello
$name'
[iyunv@linux ~]# echo $sayhello
Hello $name
使用了单引号的时候，那 $name将失去原有的变量内容，仅为一般字符的显示型态而已！这里必需要特别小心在意！
　　所以，单引号与双引号的最大不同在于双引号仍然可以保有变量的内容，但单引号内仅能是一般字符，而不会有特殊符号，我们也可以这里理解：'$sayhello' 与 “\$sayhello”是相同的。
　　在Shell脚本开发过程中，针对变量的单引号(‘)和双引号(“)都是有应用场景的，根据我的经验总结起来就是：
　　1. 获取变量值的时候就使用双引号(“)，这是基本用法。
　　2. 如果是在脚本中要编写一个新的脚本，同时这个新的脚本中还需要包含变量，你就可以选择使用单引号(‘)了，特别是生成一个临时的expect脚本时，单引号(‘)就会经常使用到的。
6. Here documents
当要将几行文字传递给一个命令时，here documents（译者注：目前还没有见到过对该词适合的翻译）一种不错的方法。对每个脚本写一段帮助性的文字是很有用的，此时如果我们四有那个here documents就不必用echo函数一行行输出。一个"Here document" 以<< 开头，后面接上一个字符串，这个字符串还必须出现在here document的末尾。
下面是一个例子，在该例子中，我们对多个文件进行重命名，并且使用here documents打印帮助：
#!/bin/sh
# we have less than 3 arguments. Print the help text:
if [ $# -lt 3 ]  then
cat <
ren -- renames a number of files using sed regular expressions
USAGE: ren 'regexp' 'replacement' files...
EXAMPLE: rename all *.HTM files in *.html:
ren 'HTM$' 'html' *.HTM
HELP
  exit 0
fi

OLD="$1"
NEW="$2"
# The shift command removes one argument from the list of
# command line arguments.
shift
shift
# $* contains now all the files:
for file in $*; do
if [ -f "$file" ]  then
    newfile=`echo "$file" | sed "s/${OLD}/${NEW}/g"`
    if [ -f "$newfile" ]; then
        echo "ERROR: $newfile exists already"
    else
    echo "renaming $file to $newfile ..."  
    mv "$file" "$newfile"
    fi
fi
done
   这是一个复杂一些的例子。让我们详细讨论一下。第一个if表达式判断输入命令行参数是否小于3个 (特殊变量$# 表示包含参数的个数) 。如果输入参数小于3个，则将帮助文字传递给cat命令，然后由cat命令将其打印在屏幕上。打印帮助文字后程序退出。如果输入参数等于或大于3个，我们就将第一个参数赋值给变量OLD，第二个参数赋值给变量NEW。下一步，我们使用shift命令将第一个和第二个参数从参数列表中删除，这样原来的第三个参数就成为参数列表$*的第一个参数。然后我们开始循环，命令行参数列表被一个接一个地被赋值给变量$file。接着我们判断该文件是否存在，如果存在则通过sed命令搜索和替换来产生新的文件名。然后将反短斜线内命令结果赋值给newfile。这样我们就达到了我们的目的：得到了旧文件名和新文件名。然后使用mv命令进行重命名。
4）函数
如果您写了一些稍微复杂一些的程序，您就会发现在程序中可能在几个地方使用了相同的代
码，并且您也会发现，如果我们使用了函数，会方便很多。一个函数是这个样子的：
functionname()
{
# inside the body $1 is the first argument given to the function
# $2 the second ...
body
}
您需要在每个程序的开始对函数进行声明。
下面是一个叫做xtitlebar的脚本，使用这个脚本您可以改变终端窗口的名称。这里使用了一个叫做help的函数。正如您可以看到的那样，这个定义的函数被使用了两次
#!/bin/sh
# vim: set sw=4 ts=4 et:
help()
{
　　cat <
xtitlebar -- change the name of an xterm, gnome-terminal or kde konsole
USAGE: xtitlebar [-h] "string_for_titelbar"
OPTIONS: -h help text
EXAMPLE: xtitlebar "cvs"
HELP
exit 0
}
# in case of error or if -h is given we call the function help:
[ -z "$1" ] && help
[ "$1" = "-h" ] && help
# send the escape sequence to change the xterm titelbar:
echo -e "33]0;$107"
#
在脚本中提供帮助是一种很好的编程习惯，这样方便其他用户（和您）使用和理解脚本。 命令行参数    我们已经见过$* 和 $1, $2 ... $9 等特殊变量，这些特殊变量包含了用户从命令行输入的参数。迄今为止，我们仅仅了解了一些简单的命令行语法（比如一些强制性的参数和查看帮助的-h选项）。但是在编写更复杂的程序时，您可能会发现您需要更多的自定义的选项。通常的惯例是在所有可选的参数之前加一个减号，后面再加上参数值 (比如文件名)。 有好多方法可以实现对输入参数的分析，但是下面的使用case表达式的例子无遗是一个不错的方法。
#!/bin/sh
help()
{
　　cat <
This is a generic command line parser demo.
USAGE EXAMPLE: cmdparser -l hello -f -- -somefile1 somefile2
HELP
exit 0
}
while [ -n "$1" ]; do
case $1 in
　　-h) help;shift 1;; # function help is called
　　-f) opt_f=1;shift 1;; # variable opt_f is set
　　-l) opt_l=$2;shift 2;; # -l takes an argument -> shift by 2
　　--) shift;break;; # end of options
　　-*) echo "error: no such option $1. -h for help";exit 1;;
*) break;;
esac
　　one
echo "opt_f is $opt_f" echo "opt_l is $opt_l" echo "first arg is $1" echo "2nd arg is $2"
  您可以这样运行该脚本：
cmdparser -l hello -f -- -somefile1 somefile2  
　　返回的结果是：
　　opt_f is 1
　　opt_l is hello
first arg is -somefile1
　　2nd arg is somefile2
　　这个脚本是如何工作的呢？脚本首先在所有输入命令行参数中进行循环，将输入参数与case表达式进行比较，如果匹配则设置一个变量并且移除该参数。根据unix系统的惯例，首先输入的应该是包含减号的参数.
　　
　　附录:
　　-e                          文件存在
-a                          文件存在（已被弃用）
-f                          被测文件是一个regular文件（正常文件，非目录或设备）
-s                          文件长度不为0
-d                          被测对象是目录
-b                          被测对象是块设备
-c                          被测对象是字符设备
-p                          被测对象是管道
-h                          被测文件是符号连接
-L                          被测文件是符号连接
-S(大写)                    被测文件是一个socket
-t                          关联到一个终端设备的文件描述符。用来检测脚本的stdin[-t0]或[-t1]是一个终端
-r                          文件具有读权限，针对运行脚本的用户
-w                          文件具有写权限，针对运行脚本的用户
-x                          文件具有执行权限，针对运行脚本的用户
-u                          set-user-id(suid)标志到文件，即普通用户可以使用的root权限文件，通过chmod +s file实现
-k                          设置粘贴位
-O                          运行脚本的用户是文件的所有者
-G                          文件的group-id和运行脚本的用户相同
-N                          从文件最后被阅读到现在，是否被修改
　　f1 -nt f2                   文件f1是否比f2新
f1 -ot f2                   文件f1是否比f2旧
f1 -ef f2                   文件f1和f2是否硬连接到同一个文件
　　二元比较操作符，比较变量或比较数字
　　整数比较：
-eq                      等于             if [ "$a" -eq "$b" ]
-ne                      不等于          if [ "$a" -ne "$b" ]
-gt                      大于             if [ "$a" -gt "$b" ]
-ge                      大于等于       if [ "$a" -ge "$b" ]
-lt                       小于             if [ "$a" -lt "$b" ]
-le                       小于等于       if [ "$a" -le "$b" ]
　　<                        小于（需要双括号）        (( "$a" < "$b" ))
<=                      小于等于(...)                (( "$a" <= "$b" ))
>                        大于(...)                      (( "$a" > "$b" ))
>=                      大于等于(...)                (( "$a" >= "$b" ))
　　
　　字符串比较：
=                         等于            if [ "$a" = "$b" ]
==                        与=等价
!=                        不等于         if [ "$a" = "$b" ]
<                         小于，在ASCII字母中的顺序：
                          if [[ "$a" < "$b" ]]
                          if [ "$a" \< "$b" ]         #需要对<进行转义
>                         大于
　　-z                        字符串为null，即长度为0
-n                        字符串不为null，即长度不为0
　　
　　sed常用方法：(注意：sed 要处理的内容里若有“*”或者换行等特殊字符，要在其前面加转义字符“\”,如\n是换行)
　　1.置换某一行
　　[weishusheng@localhost fl-easycwmp]$ cat test.txt
arm
fl2440
ios
java
swif
[weishusheng@localhost fl-easycwmp]$ sed -i 's/fl2440/linux/' test.txt
[weishusheng@localhost fl-easycwmp]$ cat test.txt                     
arm
linux
ios
java
swif
　　-i 表示insert
　　-s：
　　s/regexp/replacement/表示尝试匹配正则表达式模式空间。如果成功,regexp部分被替换为replacement。替换换可能包含特殊字符和引用。
　　2.在某行连续添加多行内容
　　比如test.txt
　　[weishusheng@localhost fl-easycwmp]$ cat test.txt
arm
linux
ios
java
swif
　　[weishusheng@localhost fl-easycwmp]$ sed -i "1 a\hello world\nI am here\nI am going" test.txt
[weishusheng@localhost fl-easycwmp]$ cat test.txt
arm
hello world
I am here
I am going
linux
ios
java
swif
　　“”里的1表示在行号为1（从零开始）的地方插入。
　　a表示以烦斜杠为开始符（插入内容不包括反斜杠）插入新行。
　　我的一个shell脚本的例程（功能：下载编译VisualBoyAdvance）

#!/bin/bash  
#+--------------------------------------------------------------------------------------------
#|Description:  This shell script used to download VisualBoyAdvance and compile it, which is
#|              a game box can runs on FL2440.
#|     Author:  GuoWenxue <guowenxue@gmail.com>
#|  ChangeLog:
#|           1, Initialize 1.0.0 on 2015.04.23 by WeiShusheng
#|           2, Modify to static compile by guowenxue
#+--------------------------------------------------------------------------------------------
PRJ_PATH=`pwd`
PREFIX_PATH=$PRJ_PATH/install
PNG_NAME="libpng-1.4.3"
PNG_SUFIX="tar.bz2"
PNG_ADDR="http://down1.iyunv.com/distfiles/libpng-1.4.3.tar.bz2"
SDL_NAME="SDL-1.2.13"
SDL_SUFIX="tar.gz"
SDL_ADDR="http://down1.iyunv.com/distfiles/SDL-1.2.13.tar.gz"
VBOY_NAME="VisualBoyAdvance"
VBOY_SRC="-src-1.7.2"
VBOY_NOSRC="-1.7.2"
VBOY_SUFIX="tar.gz"
VBOY_ADDR="http://downloads.sourceforge.net/project/vba/VisualBoyAdvance/1.7.2/VisualBoyAdvance-src-1.7.2.tar.gz?r=http%3A%2F%2Fsourceforge.net%2Fprojects%2Fvba%2Ffiles%2FVisualBoyAdvance%2F1.7.2%2F&ts=1429342329&use_mirror=ncu
"
if [ ! -d $PREFIX_PATH ] ; then
mkdir -p $PREFIX_PATH
fi
CROSS=/opt/buildroot-2012.08/arm920t/usr/bin/arm-linux-
export CC=${CROSS}gcc
export CXX=${CROSS}g++
export CPP=${CROSS}cpp
export AS=${CROSS}as
export LD=${CROSS}ld
export AR=${CROSS}ar
export RANLIB=${CROSS}ranlib
export STRIP=${CROSS}strip
cd ${PRJ_PATH}/
if [ ! -f $PREFIX_PATH/lib/libpng.a ] ; then
# Download libpng source code packet
if [ ! -s $PNG_NAME.$PNG_SUFIX ] ; then
echo "+------------------------------------------------------------------+"
echo "|  Download $PNG_NAME.$PNG_SUFIX now "  
echo "+------------------------------------------------------------------+"
wget $PNG_ADDR
fi
#unzip libpng
if [ ! -d $PNG_NAME ];then
tar -xjf $PNG_NAME.$PNG_SUFIX
if [ $? != 0 ] ; then
echo "Decompress $PNG_NAME.$PNG_SUFIX failure and exit now..."
exit 1;
else
echo "Decompress $PNG_NAME.$PNG_SUFIX and compile it..."
fi
fi
cd ${PRJ_PATH}/$PNG_NAME
./configure  --host=arm-linux --prefix=$PREFIX_PATH --enable-static --disable-shared
make && make install
if [ $? != 0 ] ; then
echo "Compress $PNG_NAME failure, exit now..."
exit 1;
fi
fi
cd ${PRJ_PATH}/
if [ ! -f $PREFIX_PATH/lib/libSDL.a ] ; then
# Download SDL source code packet
if [ ! -s $SDL_NAME.$SDL_SUFIX ] ; then
cd ${PRJ_PATH}/
echo "+------------------------------------------------------------------+"
echo "|  Download $SDL_NAME.$SDL_SUFIX now "  
echo "+------------------------------------------------------------------+"
wget $SDL_ADDR
fi

#unzip SDL
if [ ! -d $SDL_NAME ];then
tar -xzf $SDL_NAME.$SDL_SUFIX
if [ $? != 0 ] ; then
echo "Decompress $SDL_NAME.$SDL_SUFIX failure and exit now..."
exit 1;
else
echo "Decompress $SDL_NAME.$SDL_SUFIX and compile it..."
fi
fi
cd ${PRJ_PATH}/$SDL_NAME
./configure  --host=arm-linux --prefix=$PREFIX_PATH --enable-static --disable-shared
make && make install
if [ $? != 0 ] ; then
echo "Compress $SDL_NAME failure, exit now..."
exit 1;
fi
fi

cd ${PRJ_PATH}/
if [ ! -f VisualBoyAdvance ] ; then
# Download VBOY source code packet
if [ ! -s $VBOY_NAME$VBOY_SRC.$VBOY_SUFIX ] ; then
echo "+------------------------------------------------------------------+"
echo "|  Download $VBOY_NAME$VBOY_SRC.$VBOY_SUFIX now "
echo "+------------------------------------------------------------------+"
wget $VBOY_ADDR
fi
#unzip VBOY
if [ ! -d $VBOY_NAME$VBOY_NOSRC ];then
tar -xzf $VBOY_NAME$VBOY_SRC.$VBOY_SUFIX
if [ $? != 0 ] ; then
echo "Decompress $VBOY_NAME$VBOY_SRC.$VBOY_SUFIX failure and exit now..."
exit 1;
else
echo "Decompress $VBOY_NAME$VBOY_SRC.$VBOY_SUFIX and compile it..."
fi
fi
cd ${PRJ_PATH}/$VBOY_NAME$VBOY_NOSRC
sed -i 's/utilGzWriteFunc = (int (\*)(void \*,void \* const, unsigned int))gzwrite;/utilGzWriteFunc = (int (\*)(gzFile_s\*,void \* const, unsigned int))gzwrite;/' src/Util.cpp
export CFLAGS+="-I$PREFIX_PATH/include -I$PREFIX_PATH/include/SDL"
export CXXFLAGS+="-I$PREFIX_PATH/include -I$PREFIX_PATH/include/SDL"
export LDFLAGS="-L$PREFIX_PATH/lib"
export SDL_CONFIG=$PREFIX_PATH/bin
export LIBS+=-lSDL
if [ -f Makefile ] ; then
make distclean
fi
./configure --host=arm-linux --prefix=$PREFIX_PATH --with-sdl-exec-prefix=$PREFIX_PATH --with-sdl-exec-prefix=$PREFIX_PATH
make && make install
${STRIP} $PREFIX_PATH/bin/VisualBoyAdvance
fi