shell命令大全shell脚本编程100例,linux下shell脚本命令

shell命令大全shell脚本编程100例,linux下shell脚本命令详细介绍

本文目录一览： shell脚本基本命令

如何编写一个shell脚本首先打开编程界面，查看现在dog目录下的文件的权限信息。现在b.txt的用户权限是RW，组权限是RW，其他权限是R。现在我给用户权限加上X运行权限。
新建一个文件shell脚本一般用×.sh作为后缀当然勇气他的也可以。打开终端输入touchfirst.sh新建一个名为first的shell脚本。
在shell脚本中可以使用三类命令：1)Unix命令：虽然在shell脚本中可以使用任意的unix命令，但是还是由一些相对更常用的命令。这些命令通常是用来进行文件和文字操作的。
在UNIX/Linux下面编写一个SHELL脚本程序并不难，只要全屏幕编辑程序vi使用得熟练，即可以编写SHELL脚本程序。
如何在shell脚本中,判断一个基本命令执行是否成功符号显示上一条命令的返回值，如果为0则代表执行成功，其他表示失败。
用特殊变量：$？判断前一个命令的执行是否成功（或者说是返回码）执行成功变量的值是0，不是零表示没有执行成功例如：注意：一定要在命令执行后立即判断，否则后面的代码会冲掉$？变量的值。
shell脚本中判断上一个命令是否执行成功shell中使用符号“$？”来显示上一条命令执行的返回值，如果为0则代表执行成功，其他表示失败。结合if-else语句实现判断上一个命令是否执行成功。
第一步，将编写的bat批处理文件拖到cmd命令窗口中，以定期清除旧数据，见下图，转到下面的步骤。
、可以通过ps命令获取所有的进程，然后通过awk命令提取进程名，再用grep提取相应的进程名即可。
LINUX快速入门第八章:Shell基础1、第一种：BourneshellBourneshell又包括Bourneshell(sh)、Kornshell(ksh)、BourneAgainShell(bash)三种类型。Bourneshell(sh)由AT&T的SteveBourne开发，是标准的UNIXShell，很多UNIX系统都配有sh。
2、开头程序必须以下面的行开始（必须方在文件的第一行）：！/bin/sh符号#！用来告诉系统它后面的参数是用来执行该文件的程序。在这个例子中我们使用/bin/sh来执行程序。
3、沿着前面的轨迹，接下来是Linux中shell脚本的学习。这对于生信工程师后续处理大量(海量更合适些)数据是非常非常重要的，但是同样的，作为一个有点古板的人，对于脚本是什么意思我都死磕了好久。
4、先看《鸟哥的Linux私房菜-基础学习篇》，这个建议买本书，随时可翻。
shell脚本read命令的用法）while外层的read依次读取的是文件pbook中的每一行，而内层的read是从console读取的内容。2）要实现whileread的嵌套，可以使用exec命令，将I/O重定向。注意exec的用法，以及括号的使用。
在shell脚本中，用来读取文件内各个域的内容并将其赋值给Shell变量的命令是：read-pinputaval：valecho$val。read-从标准输入读取数值。这个read内部命令被用来从标准输入读取单行数据。
while条件do...done应该前面还有个do的。这是固定结构，满足条件就会一直循环下去。因为最后有输入重定向符号，将整个while循环条件的输入指定为config变量定义的文件。

linux下shell脚本命令

tar
Shell脚本基本知识
概述：shell其实是内核与用户之间的一个接口，
shell脚本
如果有一系列经常使用的linux命令，你可以把它们存储在一个文件肿。shenll可以读取这个文件，并执行其中的命令。这样的文件成为脚本文件。
执行shell脚本
要创建一个shell脚本，你要使用任何编辑器比如vi在文本文件中编写他。
为了使用bash shell赖执行脚本magic，其命令是：bash magic或者./magic
echo命令：
echo “this is an example of the echo command!”
屏幕上就会回显“this is an example of the echo command!”
＃符号
用于在shell脚本肿可以包含注解入口
echo “hello”
＃this is a comment line. this would not produce any output!
echo “world!”
第二行是一个注解的例子。它将被shell忽略，而且不产生任何消息
变量：
可以在任何时间通过简单的赋值来创建。
语法：

-

Linux 中的所有变量都被当作字符串

引用变量：

$符号用于引用一个变量的内容

variable1 = ${variable2}

读入值给变量

在执行shell脚本时，shell还允许用户直接从键盘读入一个值给变量，还可以使用read命令来作。

$read fname

本地和全局shell变量

局部变量

当引用shell时，只有创建它的shell能够知道变量的存在

全局变量

称为子shell

shell中创建的变量局部于创建它的shell，除非使用export命令特别指出是全局的。

环境变量：

通过改变这些变量的值，用户能够定制此环境

一些环境变量的例子是HOME,PATH,PS1,PS2,LOGNAME,SHLVL,及SHELL

HOME变量

Linux系统中的每个用户都有一个相关的称作HOME的目录

当一个用户登录后，进入相应的HOME的目录

$ echo $HOME

PATH变量

包含一列用冒号定界的目录的路径名字，便于可执行程序的搜索。

PS1变量

PS1（Prompt String 1）变量包含了shell提示符，$符号

$ PS1 = “HELLO>”

HELLO>

PS2变量

是为第二个提示符设置值的环境变量

LOGNAME变量

包含用户的注册名字

$echo “${LOGNAME}”

SHLVL 变量

该变量包含当前工作的shell level

SHELL变量

环境变量存储了用户缺省的shell

env命令

可用来查看所有的已移出的环境变量表和它们各自的值！

命令替换

在单个命令行中使用多个命令的另外一种方法（非Pipes）是通过命令替换

echo “the data is `date`”

expr命令

用于求之算术表达式。该命令的输出被送到标准输出

$ expr 4 + 5

将在屏幕上显示9

算术展开：

你可以在$((…)) 中括一个表达式，用下面的命令来计算它的值；

$((expression))

example1

编写一个shell脚本用于计算呼叫中心未应答的询问的数量。该脚本应该接受一天那所报告的询问的总数和应答的询问的数量，以便计算未应答的询问的数量。

所有未应答的询问总数＝所有询问的总数－应答的询问的数量

※
※※※※※※※※※※※※※※※※※※※※※※※

条件执行

test和[]

求值表达式，并返回true(0)或false()

数值测试：

-eq 等于则为真

-ne 不等于则为真

-gt 大于则为真

-ge 大于等于则为真

-lt 小于则为真

-le 小于等于则为真

if构造

Linux shell提供了循环和判定的构造，可以在shell脚本中使用

算术测试

结合if构造，它可以用于测试变量的数字值

串测试

test命令也可以用于字符串

= 等于则为真

!= 不相等则为真

-z 字符串 长度为零则为真

-n 字符串 长度不为零则为真

文件测试

test命令也可以用于检查文件的状态

-e 文件存在则为真

-r 文件存在并且可读则为真

-w 文件存在并且可写则为真

-x 文件存在并且可执行则为真

-s 文件存在并且至少有一个字符则为真

-d 文件存在并且为目录则为真

-f 文件存在并且为普通文件则为真

-c 文件存在并且为字符型文件则为真

-b 文件存在并且为块特殊文件则为真

-a并且 -o或者 !非

exit命令

用于终止shell脚本的执行并返回到$提示符下

case 。。。esac

shell脚本中使用的这个构造依据变量的值而执行一组特定指令

当变量的值和其中的一个值匹配的时候，就执行写在该值下的一组命令。

example3

迭代

while构造

while

do

done

只有条件为真的时候，才能执行do与done之间的命令

until构造

until循环构造的求值模式于while循环相反

until循环将继续执行直到求值的条件为真的时候

for构造

for variable_name in

do

…

done

for循环取一列值作为输入并对循环中每个值执行循环

break和contineu命令

同其他语言中的用法

example4

控制进程的执行

请求后台处理

用于请求后台进程的符号是 (&)

$ wc tempfile &

[1] 2082

$ vi newfile

检查后台进程

ps（进程状态）命令为每个当前的活动的每个进程产生一行入口。

终止后台进程

可用kill，如下所示

kill 278

查看完成一个命令所花的时间

你可以使用time命令来查看一个命令从开始到结束所花的时间

time fine /etc –name “passwd” 2> /dev/null /dev/null表明忽略错误信息。

管道的介绍

垂直条(|)是管道字符

它只是shell：“|”前面命令的输出作为“|”之后命令的输入发送

ls –l | more

用管道组合命令，功能强大

如何编写一个shell脚本

Her little hands are almost frozen stiff.
如何编写一个shell脚本
本文结合大量实例阐述如何编写一个shell脚本。
　　为什么要进行shell编程
　　在Linux系统中，虽然有各种各样的图形化接口工具，但是sell仍然是一个非常灵活的工具。Shell不仅仅是命令的收集，而且是一门非常棒的编程语言。您可以通过使用shell使大量的任务自动化，shell特别擅长系统管理任务，尤其适合那些易用性、可维护性和便携性比效率更重要的任务。
　　下面，让我们一起来看看shell是如何工作的：
　　建立一个脚本
　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在bash的大姐，bourne shell中运行）。
　　如同其他语言一样，通过我们使用任意一种文字编辑器，比如nedit、kedit、emacs、vi
　　等来编写我们的shell程序。
　　程序必须以下面的行开始（必须方在文件的第一行）：
　　#!/bin/sh
　　符号#!用来告诉系统它后面的参数是用来执行该文件的程序。在这个例子中我们使用/bin/sh来执行程序。
　　当编辑好脚本时，如果要执行该脚本，还必须使其可执行。
　　要使脚本可执行：
　　chmod +x filename
　　然后，您可以通过输入： ./filename 来执行您的脚本。
　　注释
　　在进行shell编程时，以#开头的句子表示注释，直到这一行的结束。我们真诚地建议您在程序中使用注释。如果您使用了注释，那么即使相当长的时间内没有使用该脚本，您也能在很短的时间内明白该脚本的作用及工作原理。
　　变量
　　在其他编程语言中您必须使用变量。在shell编程中，所有的变量都由字符串组成，并且您不需要对变量进行声明。要赋值给一个变量，您可以这样写：
　　变量名=值
　　取出变量值可以加一个美元符号（$）在变量前面：
　　#!/bin/sh
　　#对变量赋值：
　　a="hello world"
　　# 现在打印变量a的内容：
　　echo "A is:"
　　echo $a
　　在您的编辑器中输入以上内容，然后将其保存为一个文件first。之后执行chmod +x first
　　使其可执行，最后输入./first执行该脚本。
　　这个脚本将会输出：
　　A is:
　　hello world
　　有时候变量名很容易与其他文字混淆，比如：
　　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
　　有许多变量是系统自动设定的，这将在后面使用这些变量时进行讨论。
　　如果您需要处理数学表达式，那么您需要使用诸如expr等程序（见下面）。
　　除了一般的仅在程序内有效的shell变量以外，还有环境变量。由export关键字处理过的变量叫做环境变量。我们不对环境变量进行讨论，因为通常情况下仅仅在登录脚本中使用环境变量。
　　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) 流程控制
　　"if" 表达式 如果条件为真则执行then后面的部分：
　　if ....; then
　　　 ....
　　elif ....; then
　　　 ....
　　else
　　　 ....
　　fi
　　大多数情况下，可以使用测试命令来对条件进行测试。比如可以比较字符串、判断文件是否存在及是否可读等等…
　　通常用" [ ] "来表示条件测试。注意这里的空格很重要。要确保方括号的空格。
　　[ -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" 一行。如果不可读则或操作生效，打印错误信息后脚本退出。这里有个问题，那就是我们必须有两个命令：
-打印错误信息
-退出程序
　　我们使用花括号以匿名函数的形式将两个命令放到一起作为一个命令使用。一般函数将在下文提及。
　　不用与和或操作符，我们也可以用if表达式作任何事情，但是使用与或操作符会更便利很多。
　　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 compressed"*)
　　bunzip2 "$1" ;;
*) error "File $1 can not be uncompressed with smartzip";;
esac
　　您可能注意到我们在这里使用了一个特殊的变量$1。该变量包含了传递给该程序的第一个参数值。也就是说，当我们运行：
smartzip articles.zip
$1 就是字符串 articles.zip
　　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
您也可以在shell中使用如下的loop表达式：
while ...; do
....
done
while-loop 将运行直到表达式测试为真。will run while the expression that we test for is true. 关键字"break" 用来跳出循环。而关键字地continue地用来不执行余下的部分而直接跳到下一个循环。
for-loop表达式查看一个字符串列表 (字符串用空格分隔) 然后将其赋给一个变量：
for var in ....; do
　....
done
在下面的例子中，将分别打印ABC到屏幕上：
#!/bin/sh
for var in A B C ; do
　echo "var is $var"
done
下面是一个更为有用的脚本showrpm，其功能是打印一些RPM包的统计信息：
#!/bin/sh
# list a content summary of a number of RPM packages
# USAGE: showrpm rpmfile1 rpmfile2 ...
# EXAMPLE: showrpm /cdrom/RedHat/RPMS/*.rpm
for rpmpackage in $*; do
　if [ -r "$rpmpackage" ];then
　　echo "=============== $rpmpackage =============="
　　rpm -qi -p $rpmpackage
　else
　　echo "ERROR: cannot read file $rpmpackage"
　fi
done
这里出现了第二个特殊的变量$*，该变量包含了所有输入的命令行参数值。如果您运行showrpm openssh.rpm w3m.rpm webgrep.rpm
此时 $* 包含了 3 个字符串，即openssh.rpm, w3m.rpm and webgrep.rpm.
引号
在向程序传递任何参数之前，程序会扩展通配符和变量。这里所谓扩展的意思是程序会把通配符（比如*）替换成合适的文件名，它变量替换成变量值。为了防止程序作这种替换，您可以使用引号：让我们来看一个例子，假设在当前目录下有一些文件，两个jpg文件， mail.jpg 和tux.jpg。
#!/bin/sh
echo *.jpg
这将打印出"mail.jpg tux.jpg"的结果。
引号 (单引号和双引号) 将防止这种通配符扩展：
#!/bin/sh
echo "*.jpg"
echo '*.jpg'
这将打印"*.jpg" 两次。
单引号更严格一些。它可以防止任何变量扩展。双引号可以防止通配符扩展但允许变量扩展。
#!/bin/sh
echo $SHELL
echo "$SHELL"
echo '$SHELL'
运行结果为：
/bin/bash
/bin/bash
$SHELL
最后，还有一种防止这种扩展的方法，那就是使用转义字符——反斜杆：
echo *.jpg
echo $SHELL
这将输出：
*.jpg
$SHELL
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 <
<help
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命令进行重命名。

函数

如果您写了一些稍微复杂一些的程序，您就会发现在程序中可能在几个地方使用了相同的代码，并且您也会发现，如果我们使用了函数，会方便很多。一个函数是这个样子的：

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 <
<help
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 <
<help
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

done

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系统的惯例，首先输入的应该是包含减号的参数。

　　实例

　　一般编程步骤

　　现在我们来讨论编写一个脚本的一般步骤。任何优秀的脚本都应该具有帮助和输入参数。并且写一个伪脚本（framework.sh），该脚本包含了大多数脚本都需要的框架结构，是一个非常不错的主意。这时候，在写一个新的脚本时我们只需要执行一下copy命令：

cp framework.sh myscript

然后再插入自己的函数。

　　让我们再看两个例子：

　　二进制到十进制的转换

　　脚本 b2d 将二进制数 (比如 1101) 转换为相应的十进制数。这也是一个用expr命令进行数学运算的例子：

#!/bin/sh

# vim: set sw=4 ts=4 et:

help()

{

　cat <
<help
b2h -- convert binary to decimal

USAGE: b2h [-h] binarynum

OPTIONS: -h help text

EXAMPLE: b2h 111010

will return 58

HELP

　exit 0

}

error()

{

　　# print an error and exit

　　echo "$1"

　　exit 1

}

lastchar()

{

　　# return the last character of a string in $rval

　　if [ -z "$1" ]; then

　　　　# empty string

　　　　rval=""

　　　　return

　　fi

　　# wc puts some space behind the output this is why we need sed:

　　numofchar=`echo -n "$1" | wc -c | sed 's/ //g' `

　　# now cut out the last char

　　rval=`echo -n "$1" | cut -b $numofchar`

}

chop()

{

　　# remove the last character in string and return it in $rval

　　if [ -z "$1" ]; then

　　　　# empty string

　　　　rval=""

　　　　return

　　fi

　　# wc puts some space behind the output this is why we need sed:

　　numofchar=`echo -n "$1" | wc -c | sed 's/ //g' `

　　if [ "$numofchar" = "1" ]; then

　　　　# only one char in string

　　　　rval=""

　　　　return

　　fi

　　numofcharminus1=`expr $numofchar "-" 1`

　　# now cut all but the last char:

　　rval=`echo -n "$1" | cut -b 0-${numofcharminus1}`

}

while [ -n "$1" ]; do

case $1 in

　　-h) help;shift 1;; # function help is called

　　--) shift;break;; # end of options

　　-*) error "error: no such option $1. -h for help";;

　　*) break;;

esac

done

# The main program

sum=0

weight=1

# one arg must be given:

[ -z "$1" ] && help

binnum="$1"

binnumorig="$1"

while [ -n "$binnum" ]; do

　　lastchar "$binnum"

　　if [ "$rval" = "1" ]; then

　　　　sum=`expr "$weight" "+" "$sum"`

　　fi

　　# remove the last position in $binnum

　　chop "$binnum"

　　binnum="$rval"

　　weight=`expr "$weight" "*" 2`

done

echo "binary $binnumorig is decimal $sum"

#

　　该脚本使用的算法是利用十进制和二进制数权值 (1,2,4,8,16,..)，比如二进制"10"可以这样转换成十进制：

　　0 * 1 + 1 * 2 = 2

　　为了得到单个的二进制数我们是用了lastchar 函数。该函数使用wc –c计算字符个数，然后使用cut命令取出末尾一个字符。Chop函数的功能则是移除最后一个字符。

　　文件循环程序

　　或许您是想将所有发出的邮件保存到一个文件中的人们中的一员，但是在过了几个月以后，这个文件可能会变得很大以至于使对该文件的访问速度变慢。下面的脚本rotatefile 可以解决这个问题。这个脚本可以重命名邮件保存文件（假设为outmail）为outmail.1，而对于outmail.1就变成了outmail.2 等等等等...

#!/bin/sh

# vim: set sw=4 ts=4 et:

ver="0.1"

help()

{

　　cat <
<help
rotatefile -- rotate the file name

USAGE: rotatefile [-h] filename

OPTIONS: -h help text

EXAMPLE: rotatefile out

This will e.g rename out.2 to out.3, out.1 to out.2, out to out.1

and create an empty out-file

The max number is 10

version $ver

HELP

　　exit 0

}

error()

{

　　echo "$1"

　　exit 1

}

while [ -n "$1" ]; do

case $1 in

　　-h) help;shift 1;;

　　--) break;;

　　-*) echo "error: no such option $1. -h for help";exit 1;;

　　*) break;;

esac

done

# input check:

if [ -z "$1" ] ; then

error "ERROR: you must specify a file, use -h for help"

fi

filen="$1"

# rename any .1 , .2 etc file:

for n in 9 8 7 6 5 4 3 2 1; do

　　if [ -f "$filen.$n" ]; then

　　　　p=`expr $n + 1`

　　　　echo "mv $filen.$n $filen.$p"

　　　　mv $filen.$n $filen.$p

　　fi

done

# rename the original file:

if [ -f "$filen" ]; then

　　echo "mv $filen $filen.1"

　　mv $filen $filen.1

fi

echo touch $filen

touch $filen

　　这个脚本是如何工作的呢看在检测用户提供了一个文件名以后，我们进行一个9到1的循环。文件9被命名为10，文件8重命名为9等等。循环完成之后，我们将原始文件命名为文件1同时建立一个与原始文件同名的空文件。

　　调试

　　最简单的调试命令当然是使用echo命令。您可以使用echo在任何怀疑出错的地方打印任何变量值。这也是绝大多数的shell程序员要花费80%的时间来调试程序的原因。Shell程序的好处在于不需要重新编译，插入一个echo命令也不需要多少时间。

　　shell也有一个真实的调试模式。如果在脚本"strangescript" 中有错误，您可以这样来进行调试：

　　sh -x strangescript

　　这将执行该脚本并显示所有变量的值。

　　shell还有一个不需要执行脚本只是检查语法的模式。可以这样使用：

　　sh -n your_script

　　这将返回所有语法错误。
</help
</help
</help
</help
</help

如何编写简单的Shell脚本文件之Linux的基本操作

编写shell脚本 首先你要有Linux命令的基础，怎么进入文件，怎么执行文件，有什么命令等等。
我们的shell 类型有很多，常见的shell环境有sh，bash，csh，zsh等等。在Linux的脚本中可以最常见的就是 sh或者shell。在shell脚本中最开始 要指定shell环境。于是乎我们有了shell的沙邦：
/bin/sh 或者/bin/bash
shell脚本的格式：shell脚本一般是以*.sh 为名字，在权限上面是有可执行权限x的也就是chmod u+x *.sh
命令的执行：3种:
sh 脚本路径/脚本名
cd 脚本路径 && ./脚本名
soure 脚本路径/脚本
写一个最简单的脚本吧：
[root@linuxprobe ~]#vim 1.sh
/bin/sh
echo "this is my frist scripts,more and more linux ,you can read 《Linux就该这样学》"
[root@linuxprobe ~]#chmod u+x 1.sh
[root@linuxprobe ~]#./1.sh
this is my frist scripts,more and more linux ,you can read 《Linux就该这样学》
学习Linux需要多学多练

简单的shell编程

#include

#include

#include

#include

#include

#include

#define BUFFERSIZE 80

extern char *get_current_dir_name(void);

extern char *getenv(const char *name);

extern pid_t waitpid(pid_t pid, int *status, int options);

char buffer[BUFFERSIZE+1];

main()

{

char *path, *arg[10], *input;

int li_inputlen, is_bj, is_back, i, j, k, pid, status;

char lc_char;

while (1){

/* initiations */

is_bj = 0; /*redirection flag*/

is_back = 0; /*background*/

/* shell prompt */

path = get_current_dir_name();

printf("%s>$",path);

/*开始获取输入*/

li_inputlen = 0;

lc_char = getchar();

while (lc_char !='\n'){

if(li_inputlen < BUFFERSIZE)

buffer[li_inputlen++] = lc_char;

lc_char = getchar();

}

/*命令超长处理*/

if (li_inputlen >= BUFFERSIZE){

printf("Your command is too long! Please re-enter your command!\n");

li_inputlen = 0; /*reset */

continue;

}

else

buffer[li_inputlen] = '\0';/*加上串结束符号，形成字串*/

/*将命令从缓存拷贝到input中*/

input = (char *) malloc(sizeof(char) * (li_inputlen+1));

strcpy(input,buffer);

/* 获取命令和参数并保存在arg中*/

for (i = 0,j = 0,k = 0;i <= li_inputlen;i++){

/*管道和重定向单独处理*/

if (input[i] == '<' || input[i] == '>' || input[i] =='|'){

if (input[i] == '|')

pipel(input,li_inputlen);

else

redirect(input,li_inputlen);

is_bj = 1;

break;

}

/*处理空格、TAB和结束符。不用处理‘\n'，大家如果仔细分析前面的获取输入的程序的话，

*不难发现回车符并没有写入buffer*/

if (input[i] == ' ' || input[i] =='\t' || input[i] == '\0'){

if (j == 0) /*这个条件可以略去连在一起的多个空格或者tab*/

continue;

else{

buffer[j++] = '\0';

arg[k] = (char *) malloc(sizeof(char)*j);

/*将指令或参数从缓存拷贝到arg中*/

strcpy(arg[k],buffer);

j = 0; /*准备取下一个参数*/

k++;

}

}

else{

/*如果字串最后是‘&'，则置后台运行标记为1*/

if (input[i] == '&' && input[i+1] == '\0'){

is_back = 1;

continue;

}

buffer[j++] = input[i];

}

}

free(input);/*释放空间*/

/*如果输入的指令是leave则退出while，即退出程序*/

if (strcmp(arg[0],"leave") == 0 ){

printf("bye-bye\n");

break;

}

/*如果输入的指令是about则显示作者信息，同时结束本条命令的解析过程*/

if (strcmp(arg[0]," about") == 0 ){

printf("copyright by shike，shike13@163.com\n");

continue;

}

if (is_bj == 0){ /*非管道、重定向指令*/

/*在使用xxec执行命令的时候，最后的参数必须是NULL指针，

*所以将最后一个参数置成空值*/

arg[k] = (char *) 0;

/*判断指令arg[0]是否存在*/

if (is_fileexist(arg[0]) == -1 ){

printf("This command is not found?!\n");

for(i=0;i
<k;i++)
free(arg[i]);

continue;

}

/* fork a sub-process to run the execution file */

if ((pid = fork()) ==0) /*子进程*/

execv(buffer,arg);

else /*父进程*/

if (is_back == 0) /*并非后台执行指令*/

waitpid(pid,&status,0);

/*释放申请的空间*/

for (i=0;i
<k;i++)
free(arg[i]);

}

}

}

int is_fileexist(char *comm)

{

char *path,*p;

int i;

i = 0;

/*使用getenv函数来获取系统环境变量，用参数PATH表示获取路径*/

path = getenv("PATH");

p = path;

while (*p != '\0'){

/*路径列表使用‘:’来分隔路径*/

if (*p != ':')

buffer[i++] = *p;

else{

buffer[i++] = '/';

buffer[i] = '\0';

/*将指令和路径合成，形成pathname，并使用access函数来判断该文件是否存在*/

strcat(buffer,comm);

if (access(buffer,F_OK) == 0) /*文件被找到*/

return 0;

else

/*继续寻找其它路径*/

i = 0;

}

p++;

}

/*搜索完所有路径，依然没有找到则返回-1*/

return -1;

}

int redirect(char *in,int len)

{

char *argv[30],*filename[2];

pid_t pid;

int i,j,k,fd_in,fd_out,is_in = -1,is_out = -1,num = 0;

int is_back = 0,status=0;

/*这里是重定向的命令解析过程，其中filename用于存放重定向文件，

*is_in, is_out分别是输入重定向标记和输出重定向标记*/

for (i = 0,j = 0,k = 0;i <= len;i++){

if (in[i]==' '||in[i]=='\t'||in[i]=='\0'||in[i] =='<'||in[i]=='>'){

if (in[i] == '>' || in[i] == '<'){

/*重定向指令最多'<'，'>'各出现一次，因此num最大为2，

*否则认为命令输入错误*/

if (num < 3){

num ++;

if (in[i] == '<')

is_in = num - 1;

else

is_out = num - 1;

/*处理命令和重定向符号相连的情况，比如ls>a*/

if (j > 0 && num == 1) {

buffer[j++] = '\0';

argv[k] = (char *) malloc(sizeof(char)*j);

strcpy(argv[k],buffer);

k++;

j = 0;

}

}

else{

printf("The format is error!\n");

return -1;

}

}

if (j == 0)

continue;

else{

buffer[j++] = '\0';

/*尚未遇到重定向符号，字符串是命令或参数*/

if (num == 0){

argv[k] = (char *) malloc(sizeof(char)*j);

strcpy(argv[k],buffer);

k++;

}

/*是重定向后符号的字符串，是文件名*/

else{

filename[status] = (char *) malloc(sizeof(char)*j);

strcpy(filename[status++],buffer);

}

j = 0; /*initate*/

}

}

else{

if (in[i] == '&' && in[i+1] == '\0'){

is_back = 1;

continue;

}

buffer[j++] = in[i];

}

}

argv[k] = (char *) 0;

if (is_fileexist(argv[0]) == -1 ){

printf("This command is not founded!\n");

for(i=0;i
<k;i++)
free(argv[i]);

return 0;

}

if ((pid = fork()) ==0){

/*存在输出重定向*/

if (is_out != -1)

if((fd_out=open(filename[is_out],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1){

printf("Open out %s Error\n",filename[is_out]);

return -1;

}

/*存在输入重定向*/

if (is_in != -1)

if((fd_in=open(filename[is_in],O_RDONLY,S_IRUSR|S_IWUSR))==-1){

printf("Open in %s Error\n",filename[is_out]);

return -1;

}

if (is_out != -1)

/*使用dup2函数将标准输出重定向到fd_out上，dup2(int oldfd,int newfd)实现的

*是把oldfd所指的文件描述符复制到newfd。若newfd为一已打开的文件描述词，

*则newfd所指的文件会先被关闭，dup2复制的文件描述词与原来的文件描述词

*共享各种文件状态*/

if(dup2(fd_out,STDOUT_FILENO)==-1){

printf("Redirect Standard Out Error\n");

exit(1);

}

if (is_in != -1)

if(dup2(fd_in,STDIN_FILENO)==-1){

printf("Redirect Standard Out Error\n");

exit(1);

}

execv(buffer,argv);

}

else

if (is_back == 0) /*run on the TOP*/

waitpid(pid,&status,0);

for (i=0;i
<k;i++)
free(argv[i]);

if (is_in != -1){

free(filename[is_in]);

close(fd_in);

}

if (is_out != -1){

free(filename[is_out]);

close(fd_out);

}

return 0;

}

int pipel(char *input,int len)

{

char *argv[2][30];

int i,j,k,count,is_back = 0;

int li_comm = 0,fd[2],fpip[2];

char lc_char,lc_end[1];

pid_t child1,child2;

/*管道的命令解析过程*/

for (i = 0,j = 0,k = 0;i <= len;i++){

if (input[i]== ' ' || input[i] == '\t' || input[i] == '\0' || input[i] == '|'){

if (input[i] == '|' ) /*管道符号*/

{

if (j > 0)

{

buffer[j++] = '\0';

/*因为管道连接的是两个指令，所以用二维数组指针来存放命令和参数，

*li_comm是表示第几个指令*/

argv[li_comm][k] = (char *) malloc(sizeof(char)*j);

strcpy(argv[li_comm][k++],buffer);

}

argv[li_comm][k++] = (char *) 0;

/*遇到管道符，第一个指令完毕，开始准备接受第二个指令*/

li_comm++;

count = k;

k=0;j=0;

}

if (j == 0)

continue;

else

{

buffer[j++] = '\0';

argv[li_comm][k] = (char *) malloc(sizeof(char)*j);

strcpy(argv[li_comm][k],buffer);

k++;

}

j = 0; /*initate*/

}

else{

if (input[i] == '&' && input[i+1] == '\0'){

is_back = 1;

continue;

}

buffer[j++] = input[i];

}

}

argv[li_comm][k++] = (char *) 0;

if (is_fileexist(argv[0][0]) == -1 ){

printf("This first command is not found!\n");

for(i=0;i
<count;i++)
free(argv[0][i]);

return 0;

}

/*指令解析结束*/

/*建立管道*/

if (pipe(fd) == -1 ){

printf("open pipe error!\n");

return -1;

}

/*创建第一个子进程执行管道符前的指令，并将输出写到管道*/

if ((child1 = fork()) ==0){

/*关闭读端*/

close(fd[0]);

if (fd[1] != STDOUT_FILENO){

/*将标准输出重定向到管道的写入端，这样该子进程的输出就写入了管道*/

if (dup2(fd[1],STDOUT_FILENO) == -1){

printf("Redirect Standard Out Error\n");

return -1;

}

/*关闭写入端*/

close(fd[1]);

}

execv(buffer,argv[0]);

}

else{ /*父进程*/

/*先要等待写入管道的进程结束*/

waitpid(child1,&li_comm,0);

/*然后我们必须写入一个结束标记，告诉读管道进程数据到这里就完了*/

lc_end[0] = 0x1a;

write(fd[1],lc_end,1);

close(fd[1]);

if (is_fileexist(argv[1][0]) == -1 ){

printf("This command is not founded!\n");

for(i=0;i
<k;i++)
free(argv[1][i]);

return 0;

}

/*创建第二个进程执行管道符后的指令，并从管道读输入流 */

if ((child2 = fork()) == 0){

if (fd[0] != STDIN_FILENO){

/*将标准输入重定向到管道读入端*/

if(dup2(fd[0],STDIN_FILENO) == -1){

printf("Redirect Standard In Error!\n");

return -1;

}

close(fd[0]);

}

execv(buffer,argv[1]);

}

else /*父进程*/

if (is_back == 0)

waitpid(child2,NULL,0);

}

for (i=0;i
<count;i++)
free(argv[0][i]);

for (i=0;i
<k;i++)
free(argv[1][i]);

return 0;

}

以前写的，好像一些细节不一样，不明白的地方，发邮件给我，shike13@163.com
</k;i++)
</count;i++)
</k;i++)
</count;i++)
</k;i++)
</k;i++)
</k;i++)
</k;i++)

linux（shell）脚本编程题目求教（200分请教）

1. 用vi打开一个空文件，文件名随意，然后在第一行写：
#!/bin/bash
另起一行跟上要使用的命令，比如ls date之类的，一条命令一行。
退出vi后，在命令行下输入 chmod +x 文件名 给文件增加运行权限
最后用 ./文件名 执行这个文件就可以了。
2. 环境变量用 env 和 set 2个命令可以看到，在命令行下直接输入就可以了，至于具体内容，太多，你得自己去查
3.
for 循环：
i=1
for i in 1..100; do
i=$(($i + 1))
done
while循环
i=1
while [ $i -le 100 ]; do
i=$(($i + 1))
done
父进程安装一个SIGCHLD处理程序，在子进程终止时执行
1. 用vi打开一个空文件，文件名随意，然后在第一行写：
#!/bin/bash
另起一行跟上要使用的命令，比如ls date之类的，一条命令一行。
退出vi后，在命令行下输入 chmod +x 文件名 给文件增加运行权限
最后用 ./文件名 执行这个文件就可以了。
2. 环境变量用 env 和 set 2个命令可以看到，在命令行下直接输入就可以了，至于具体内容，太多，你得自己去查
3.
for 循环：
i=1
for i in 1..100; do
i=$(($i + 1))
done
while循环
i=1
while [ $i -le 100 ]; do
i=$(($i + 1))
done
算了，这些都能做，但做起来太麻烦，放弃了

编写Shell脚本文件，在当前目录下建立100个目录，并给出执行该文件的步骤

用bash不用写脚本，一行命令就成
printf 'user%01d\n' {1..100} | xargs mkdir
nc10@your-5554c55be4 ~
$ cd tmp
nc10@your-5554c55be4 ~/tmp
$ ls
nc10@your-5554c55be4 ~/tmp
$ pwd
/home/nc10/tmp
nc10@your-5554c55be4 ~/tmp
$ ls
nc10@your-5554c55be4 ~/tmp
$ printf 'user%01d\n' {1..100} | xargs mkdir
nc10@your-5554c55be4 ~/tmp
$ ls
user1/ user20/ user32/ user44/ user56/ user68/ user8/ user91/
user10/ user21/ user33/ user45/ user57/ user69/ user80/ user92/
user100/ user22/ user34/ user46/ user58/ user7/ user81/ user93/
user11/ user23/ user35/ user47/ user59/ user70/ user82/ user94/
user12/ user24/ user36/ user48/ user6/ user71/ user83/ user95/
user13/ user25/ user37/ user49/ user60/ user72/ user84/ user96/
user14/ user26/ user38/ user5/ user61/ user73/ user85/ user97/
user15/ user27/ user39/ user50/ user62/ user74/ user86/ user98/
user16/ user28/ user4/ user51/ user63/ user75/ user87/ user99/
user17/ user29/ user40/ user52/ user64/ user76/ user88/
user18/ user3/ user41/ user53/ user65/ user77/ user89/
user19/ user30/ user42/ user54/ user66/ user78/ user9/
user2/ user31/ user43/ user55/ user67/ user79/ user90/
nc10@your-5554c55be4 ~/tmp
$
或者用seq
mkdir $(seq -f 'user%01g' 1 100)
nc10@your-5554c55be4 ~/tmp
$ ls
nc10@your-5554c55be4 ~/tmp
$ mkdir $(seq -f 'user%01g' 1 100)
nc10@your-5554c55be4 ~/tmp
$ ls
user1/ user20/ user32/ user44/ user56/ user68/ user8/ user91/
user10/ user21/ user33/ user45/ user57/ user69/ user80/ user92/
user100/ user22/ user34/ user46/ user58/ user7/ user81/ user93/
user11/ user23/ user35/ user47/ user59/ user70/ user82/ user94/
user12/ user24/ user36/ user48/ user6/ user71/ user83/ user95/
user13/ user25/ user37/ user49/ user60/ user72/ user84/ user96/
user14/ user26/ user38/ user5/ user61/ user73/ user85/ user97/
user15/ user27/ user39/ user50/ user62/ user74/ user86/ user98/
user16/ user28/ user4/ user51/ user63/ user75/ user87/ user99/
user17/ user29/ user40/ user52/ user64/ user76/ user88/
user18/ user3/ user41/ user53/ user65/ user77/ user89/
user19/ user30/ user42/ user54/ user66/ user78/ user9/
user2/ user31/ user43/ user55/ user67/ user79/ user90/
nc10@your-5554c55be4 ~/tmp
$

linux的shell脚本编程，求两数字间所有偶数的和，我是小白，不太懂。

错的地方太多了
每个运算符和数字/变量之间应该有空格，如“ 1 > 2 ”
小于等于不能用“<=”表示，应该用 -le
使用“>”“<”等运算符时，必须用“[[ ]]”符号扩起来以进行转义（while那里就应该改成 while ( [[ $c -le $b ]] )
我把改好后的贴出来给你看看吧（虽然按照你输入的，一直没运算出结果）
#@/bin/basha=$1b=$2c=$1d=0while ( [[ $c -le $b ]] )doif [[ $c%2 == 0 ]]thend=$c+$dc=$c+1fidoneecho $d
这部分主要讨论数学相关的shell脚本编程。
加法运算
新建一个文件“Addition.sh”，输入下面的内容并赋予其可执行的权限。
复制代码代码如下:
#!/bin/bash
echo “Enter the First Number: ”
read a
echo “Enter the Second Number: ”
read b
x=$(expr "$a" + "$b")
echo $a + $b = $x
输出结果：
复制代码代码如下:
[root@tecmint ~]# vi Additions.sh
[root@tecmint ~]# chmod 755 Additions.sh
[root@tecmint ~]# ./Additions.sh
“Enter the First Number: ”
12
“Enter the Second Number: ”
13
12 + 13 = 25
减法运算
复制代码代码如下:
#!/bin/bash
echo “Enter the First Number: ”
read a
echo “Enter the Second Number: ”
read b
x=$(($a - $b))
echo $a - $b = $x
注意：这里我们没有像上面的例子中使用“expr”来执行数学运算。
输出结果：
复制代码代码如下:
[root@tecmint ~]# vi Substraction.sh
[root@tecmint ~]# chmod 755 Substraction.sh
[root@tecmint ~]# ./Substraction.sh
“Enter the First Number: ”
13
“Enter the Second Number: ”
20
13 - 20 = -7
乘法运算
复制代码代码如下:
#!/bin/bash
echo “Enter the First Number: ”
read a
echo “Enter the Second Number: ”
read b
echo "$a * $b = $(expr $a \* $b)"
输出结果：
复制代码代码如下:
[root@tecmint ~]# vi Multiplication.sh
[root@tecmint ~]# chmod 755 Multiplication.sh
[root@tecmint ~]# ./Multiplication.sh
“Enter the First Number: ”
11
“Enter the Second Number: ”
11
11 * 11 = 12
除法运算
复制代码代码如下:
#!/bin/bash
echo “Enter the First Number: ”
read a
echo “Enter the Second Number: ”
read b
echo "$a / $b = $(expr $a / $b)"
输出结果：
复制代码代码如下:
[root@tecmint ~]# vi Division.sh
[root@tecmint ~]# chmod 755 Division.sh
[root@tecmint ~]# ./Division.sh
“Enter the First Number: ”
12
“Enter the Second Number: ”
3
12 / 3 = 4
数组
下面的这个脚本可以打印一组数字。
复制代码代码如下:
#!/bin/bash
echo “Enter The Number upto which you want to Print Table: ”
read n
i=1
while [ $i -ne 10 ]
do
i=$(expr $i + 1)
table=$(expr $i \* $n)
echo $table
done
输出结果：
复制代码代码如下:
[root@tecmint ~]# vi Table.sh
[root@tecmint ~]# chmod 755 Table.sh
[root@tecmint ~]# ./Table.sh
“Enter The Number upto which you want to Print Table: ”
29
58
87
116
145
174
203
232
261
290
你可以从这里下载这个例子的代码
判断奇偶数
复制代码代码如下:
#!/bin/bash
echo "Enter The Number"
read n
num=$(expr $n % 2)
if [ $num -eq 0 ]
then
echo "is a Even Number"
else
echo "is a Odd Number"
fi
输出结果：
复制代码代码如下:
[root@tecmint ~]# vi EvenOdd.sh
[root@tecmint ~]# chmod 755 EvenOdd.sh
[root@tecmint ~]# ./EvenOdd.sh
Enter The Number
12
is a Even Number
1
2
3
4
5
[root@tecmint ~]# ./EvenOdd.sh
Enter The Number
11
is a Odd Number
Factorial数
复制代码代码如下:
#!/bin/bash
echo "Enter The Number"
read a
fact=1
while [ $a -ne 0 ]
do
fact=$(expr $fact \* $a)
a=$(expr $a - 1)
done
echo $fact
输出结果：
复制代码代码如下:
[root@tecmint ~]# vi Factorial.sh
[root@tecmint ~]# chmod 755 Factorial.sh
[root@tecmint ~]# ./Factorial.sh
Enter The Number
12
479001600
你可以从这里下载这个例子的代码
判断Armstrong数
Armstrong数：在三位的正整数中，例如abc，有一些可能满足(a^3)+(b^3)+(c^3)=abc，即各个位数的立方和正好是该数的本身。这些数即称为Armstrong数。
复制代码代码如下:
#!/bin/bash
echo "Enter A Number"
read n
arm=0
temp=$n
while [ $n -ne 0 ]
do
r=$(expr $n % 10)
arm=$(expr $arm + $r \* $r \* $r)
n=$(expr $n / 10)
done
echo $arm
if [ $arm -eq $temp ]
then
echo "Armstrong"
else
echo "Not Armstrong"
fi
输出结果：
复制代码代码如下:
[root@tecmint ~]# vi Armstrong.sh
[root@tecmint ~]# chmod 755 Armstrong.sh
[root@tecmint ~]# ./Armstrong.sh
Enter A Number
371
371
Armstrong
1
2
3
4
5
6
[root@tecmint ~]# ./Armstrong.sh
Enter A Number
123
36
Not Armstrong
判断质数
复制代码代码如下:
#!/bin/bash
echo “Enter Any Number”
read n
i=1
c=1
while [ $i -le $n ]
do
i=$(expr $i + 1)
r=$(expr $n % $i)
if [ $r -eq 0 ]
then
c=$(expr $c + 1)
fi
done
if [ $c -eq 2 ]
then
echo “Prime”
else
echo “Not Prime”
fi
输出结果：
复制代码代码如下:
[root@tecmint ~]# vi Prime.sh
[root@tecmint ~]# chmod 755 Prime.sh
[root@tecmint ~]# ./Prime.sh
“Enter Any Number”
12
“Not Prime”

在Linux下利用Shell脚本编写一程序,实现1到100之和。

#!/usr/bin/ksh
cal_id=1
num_count=100
sum_num=0
while [ $cal_id -le $num_count ]
do
sum_num=`expr $cal_id + $sum_num`
cal_id=`expr $cal_id + 1`
done
echo $sum_num
#!/bin/bash
for num in {1..100}
do
sum=$(($sum + $num))
done
echo $sum
#注：bash中产生序列的方法用 seq 1 100 或者 {1..100} 注意其中不能有空格！
#后面的语法比较简单，求值用 $(( ... )) 中间的省略号表示表达式；
#shell语法 赋值的时候变量直接写名字，取值的时候要在变量名前面加上 $ .
#附带，命令行一句话的版本：
for num in {1..100};do sum=$(($sum + $num));done;echo $sum

Shell脚本编程实战

做 Java 的肯定都接触过 Linux 系统，那么很多时候我们在开发的过程中都是把我们项目打成一个jar包，或者是war包的形式，然后通过 XFTP 上传到我们服务器的指定目录，然后运行一端启动脚本，让我们的项目变得可以访问 就像 ./sh service.sh start 然后启动我们写好的 sh 的shell脚本。接下来我们就来学习一下关于 Shell 脚本是如何写出来的。

Shell 脚本是什么？Shell是一个命令解释器，它的作用是解释执行用户输入的命令及程序等，也就是说，我们用户每输入一条命令，Shell 就会相对应的执行一条命令。当命令或程序语句不在命令行下执行，而是通过一个程序文件来执行时，该程序文件就被称为Shell脚本。

在我们的 Shell 脚本中，会有各种各样的内容，赋值，计算，循环等一系列的操作，接下来我们就来看看这个 Shell 脚本怎么写吧

1.查看自己当前系统默认的 Shell

echo $SHELL

输出：/bin/bash

2.查看系统支持的Shell

cat /etc/shells

输出：

/bin/sh /bin/bash /usr/bin/sh /usr/bin/bash

也就是说，我们的云服务器是支持我们在这里给他安排 Shell 脚本的

我们这时候先来安排一下 sh 的文件,创建一个文件夹，然后在其中创建一个 sh 的文件。

mkdir /usr/local/shelltest

touch test.sh

创建完成我们编辑一下内容

vim test.sh

然后我们出来运行一下我们的 Shell 的第一个脚本

bash test.sh

出来的结果是 Hello World Shell

一个及其简单的脚本出现了，接下我们就分析一波我们写了点啥？

#!/bin/bash

#! 是一个约定的标记，它告诉系统这个脚本需要什么解释器来执行，即使用哪一种 Shell

我们在之前也使用了 echo $SHELL 来查看了自己系统默认的是哪一种 sh 解析器，之前看到的是/bin/bash，所以我们在写 Shell 脚本的时候，我们在开头默认的约定中，我们写了这个是用 /bin/bash 来进行解释的，

那么我们如何像之前调用我们的当前目录中的 Shell 脚本一样去调用他呢？就像这个样子的 ./sh service.sh start

1.授权，

我们先不授权试一下看看能通过 ./test.sh 进行调用么

bash: ./test.sh: Permission denied 会提示这个，也就是没有授权定义，

授权命令：chmod +x test.sh

2.执行 ./test.sh

然后调用就能正常输出了,就是说，在当前的目录下执行这个脚本命令。

变量命名实际上很简单，我们先来试一下

name=zhiyikeji

这时候我们怎么使用变量呢？实际上只要在前面加上一个符号就可以 $

echo $name

上面的两种写法都是可以的，外面的大括号加和不加区别不大，可以省略，直接就 $name 就可以使用你定义的变量

使用括号的意义一般在于区别某些变量，比如你写了一串的内容，可能写的是 echo $nameismyfriend ,如果连在一起，是不是有点尴尬，这时候就可以使用括号区别一下， echo ${name}ismyfriend 不使用括号的时候，他就去找nameismyfriend这个变量了，就无法出来我们要的效果。

unset name

这时候我们就把我们刚才定义的 name=zhiyikeji 这个变量给去掉了，我们可以调用一下我们的变量看是什么？

echo $name

这是不是就证明我们自己定义的变量已经删除了

那么我们需要一个关键字，大家肯定能想到是什么关键字 readonly

我们先给name赋值，然后使用 readonly 设置只读，然后再改变一下试试，

竟然是真的，如果不设置只读，是不是会重新可以进行赋值，我们测试个年龄，

所以我们就可以肯定，readonly就是设置只读的关键词，记住了么？

那么设置只读的变量可以删除么？毕竟总有杠精的面试官会提问这个棘手的问题，但是，阿粉试过的所有方式好像都是不行的，阿粉就直接重启了自己的服务器，这样临时的变量就不存在了！

说真的，Shell脚本的流程控制数一般才是yyds，为什么这么说，因为你在写大部分的脚本的时候，流程控制的地方永远是最多的，判断，选择，等等一系列的函数，当时熟练使用的时候，就发现这东西确实很有意思。

我们先说最简单的 if else 这也是我们最经常使用的判断，在写 Shell 脚本的时候,就不像我们的 Java 中直接写

Xshell 中的语法就不是这个样子的， Xshell 语法：

末尾的 fi 就是 if 倒过来拼写,我们可以写一个 if 的脚本试一下这个流程能否理解。

这里申明一下，

我们在上面这段脚本中写就是内容就是，我们给脚本传入一个值，然后比对这个值和2的大小关系，然后输出我们指定的内容。

运行后就能看到

$1 表示我们给 Shell 脚本输入的第一个参数, $0 就是你写的shell脚本本身的名字,$2 是我们给 Shell 脚本传的第二个参数

大家在部署某些项目的时候，是不是启动命令就很简洁，就是 sh service.sh start 类似这种的，那我们来看看一般这种是怎么写的，这就用到了另外一块的内容，和 if 类似，在 Java 中也有，那就是 Case .

我们先来看看 Case 的语法，

case ... esac 实际上就和 Java 中的 Case 是非常相似的，case 语句匹配一个值与一个模式，如果匹配成功，执行相匹配的命令. esac 是一个结束的标志。

光说不练，假把式，我们来搞一下试试写一个脚本来搞一下。就用我们刚才说的 sh servic.sh start 来进行测试。

我们来看看运行结果

那么这段 Shell 脚本是什么意思呢？其实很简单，匹配我们传入的第一个字符，和 start 还有 stop 进行比较，如果匹配上之后，输出命令，最后退出即可。

是不是感觉没有那么复杂了呢？

说到流程控制,那么肯定不能不说 for , 毕竟 for 循环在 Java 中那可是重头戏。

我们先看他的格式

那么我们有没有说像是 Java 中那种 for 循环一样的方式呢？比如说这个 for ((i=1; i<=j; i++))

实际上也是支持这种的，我们来写一个试试。

执行一下看看

既然有 for 那是不是就有 while 呢？是的，没错，确实是有 while ，也是循环的意思，但是写法有略微不一样的地方

我们来举个尝试打印九九乘法表来看一下

是不是也挺简单的？

其实 Shell 脚本的编写一般都是在实际应用中提升，单纯的写测试脚本，也是可以让自己对知识的掌握比较充分，而我们一般都是写一些比较简单的脚本，复杂的不是还有运维么？