shell基础之03(初阶实战)

• read

每次调用读取文件中的“一行”，当文件没有可读时，read命令将以非零状态退出。
 读取文件的关键是如何将文本的数据传送给read命令。
最常用的方法是对文件使用cat命令并通过管道将结果直接传送给包含read命令的while命令。
#!/bin/bash
count=1 
cat text.sh| while read line  --------cat命令的输出作为read命令的输入，read读到的值放在line中

do
 echo "Line $count:$line"
 count=$[ $count+1 ] 
done
echo "finish"
exit 0
      

echo 显示信息
 echo 回车后会空一行
 echo -n
[root@localhost ~]# echo

[root@localhost ~]# echo -n--------- -n 不输出行尾的换行符，不会出现空行
[root@localhost ~]#

 #！/bin/bash
for i in 1 2 a b c  -----  【i在这里是个变量】【变量的值可以被覆盖】
do
  echo $i  ----------   【读取结果】
done

for i in a tt yy uu 22 33    -----------【这里的i只是表示反复读取的次数】
do
  echo abc
done

[root@localhost ~]# echo {1..20}   【产生8个数字】
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

[root@room9pc01 ~]# echo [a,b,c]-------------注意不要用成方括号
[a,b,c]

[root@localhost ~]#

[root@localhost ~]# seq 5  -----------生成1---5
1
2
3
4
5
[root@localhost ~]# seq 2 5----生成2---5
2
3
4
5
[root@localhost ~]# seq 2 5 20------生成以2开始递增值为5，直到20的所有值
2
7
12
17
[root@localhost ~]#

#！/bin/bash
for i in {1..1000}  --------【注意：{}没有空格】
do
    touch /tmp/$i.txt &  ----------【&速度会提高】
done

#!/bin/bash
for i in `seq 1000`
do     
  rm -rf /tmp/$i.txt &
done

写脚本，将/var/log/目录下，每个文件或目录，单独打包
ls /var/log

/var/log/a---->/var/log/a.tar.gz
/var/log/b---->/var/log/b.tar.gz
/var/log/c---->/var/log/c.tar.gz

tar -czf 打包后的文件名  打包对象
-c (create)
-z （gzip）
-f （file）

./test11.sh
#!/bin/bash
for i in `ls /var/log/`   【ls取出的东西是没有路径的】
do
  tar -czf /var/log/$i.tar.gz /var/log/$i &> /dev/null 【压缩是要给路径的！！从哪来，到哪去！】 重点：&> /dev/null
done
+++++一定要给绝对路径，否则会读取当前路径++++++

for 变量 in 值1 值2 值3 ...
do
    命令
done

for ((i=1;i<=5；i++))
do
  echo abc
done

练习：（打印9*9乘法表） 需要两个for
1*1=1
2*1=2  2*2=4
3*1=3  2*3=6  3*3=9

 for i in 1..x
   for j in 1..x
  echo "$i*$j=$[i*j]"
echo -n   【not】
有的地方需要换行，有些地方不需要

for i in `seq9`
do
  for j in j=1;j<10;j++
  do
        echo "$i*$j=$[i*j]" && j<10 || echo -n
  done
done

#!/bin/bash
for  i in `seq 9`
do
  for j in `seq $i` 【j的值不能大于i的值】
  do
        echo -n "$i*$j=$[i*j]  "
  done
  echo
done
     

需要两个for  8行8列

echo -e "\033[31mOK\033[Om"
echo -e【扩展】 "\033【 颜色】[31【shai】mOK【内容】\033【颜色】[Om【色到哪里】"
 extend   所有内容是红色\这个之间是红色

while 测试
do
  命令
done
当测试为真时，执行命令,直到测试为错时，循环结束

i=1
while [ $i -le 5 ]                    
do
  echo abc
  let i++   //循环5次
done
 

for 循环次数固定的时候

while [] 循环次数，不固定的时候使用

#!/bin/bash  //死循环
i=1
while [ $i -le 5 ]
do
      echo $i
done

定义死循环
while :   【不固定次数】
do

done
或
while true
do

done

##sed -n "11p"  user.txt  文件的第11行

head tail 11

wc -l user.txt

vim test.sh
while :
do
   n=$[RANDOM%45+1]
   sed -n "${i}p"  user.txt
    sleep 0.1
    clear
done

i=3
while [ $i < 4 ]   //伪代码
do
  命令
done

###九九乘法表####

[root@localhost ~]# vim test11.sh
#!/bin/bash
for  i in `seq 9`
do
  for j in `seq $i`
  do
        echo -n "$i*$j=$[i*j]  "
  done
  echo
done

[root@localhost ~]# ./test11.sh
1*1=1  
2*1=2  2*2=4  
3*1=3  3*2=6  3*3=9  
4*1=4  4*2=8  4*3=12  4*4=16  
5*1=5  5*2=10  5*3=15  5*4=20  5*5=25  
6*1=6  6*2=12  6*3=18  6*4=24  6*5=30  6*6=36  
7*1=7  7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49  
8*1=8  8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64  
9*1=9  9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81  

ping网段
for i in {1..254}
do
 ping -c 2 192.168.4.$i &> /dev/null
    if [ $? -eq 0 ];
     then
     echo "192.168.4.$i is up"
     else
      echo "192.168.4.$i is down"  
        let x++
    fi
done

+++++++++++++++++++++++++++++++++++++++++++++++++
国际象棋棋盘

#！/bin/bash
for i in {1..8}
do
        for j in {1..8}
        do
                if [ $[(i+j)%2] -eq 0 ] ; then
                        echo -en "\033[41m \033[0m"
                else
                        echo -en "\033[47m \033[0m"
                fi
        done
        echo
done

###批量创建用户###

版本1
for i in {1..100}
do
 useradd user$1
done

版本2
1）useradd $1
echo "$2" | passwd --stdin $1

2）read -p “请你输入用户名： ” num
useradd $num
read -p “请输入密码： ” pass
useradd $pass

版本3
vim user.txt
tom
jerry
......
++++++++++++++++++++++++++++++++++++++++++++
for i in `cat user.txt`
do
 useradd $i
 echo "123456" | passwd --stdin $i

done

+++++++++++++++++++++++++++++++++++++++++++++
[root@room4pc09 桌面]# ssh 192.168.4.1 touch /a.txt
[email protected]'s password:
[root@room4pc09 桌面]# ls /a.txt
ls: 无法访问/a.txt: 没有那个文件或目录
[root@room4pc09 桌面]#

[root@localhost test]# ls /a.txt
/a.txt
[root@localhost test]#

#！/bin/bash
for i in {1..254}
 do
        ping -c 3 172.40.3.$i $>/dev/null
   if [ $? -eq 0 ];
        then
         ssh 172.40.3.$i shutdown    //需要免密
        else
#         echo "172.40.3.$i is down"
   fi
 done           

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

当用户输入redhat，返回fedora
当用户输入fedora，返回redhat
其他，返回Usage：xxx

在 system1 上创建一个名为/root/foo.sh 的脚本,让其提供下列特性:
当运行/root/foo.sh redhat,输出为 fedora
当运行/root/foo.sh fedora,输出为 redhat
当没有任何参数或者参数不是 redhat 或者 fedora 时,其错误输出产生以下的信息:
/root/foo.sh redhat|fedora

[root@serverX ~]# vim /root/foo.sh
#!/bin/bash
if [ "$1" = "redhat" ]
then
echo "fedora"
elif [ "$1" = "fedora" ]
then
echo "redhat"
else
echo "/root/foo.sh redhat|fedora" >&2
fi
[root@serverX ~]# chmod +x /root/foo.sh
或者
[root@serverX ~]# vim /root/foo.sh
#!/bin/bash
case "$1" in
redhat)
echo "fedora"
10 / 14
http://bj.linux.tedu.cn/达内Linux 云计算学院
;;
fedora)
echo "redhat"
;;
*)
echo '/root/foo.sh redhat|fedora' >&2
esac
[root@serverX ~]# chmod +x /root/foo.sh

case 简化版的if（功能比if少）

语法格式

case 变量 in    //判断变量与值1是否相等
值1）
   命令
   命令;;
值2）          //判断变量与值2是否相等
   命令;;
*）            //相当于if语句中的else     
   命令;;
esac

#!/bin/bash
case $1 in
 redhat)
        echo "fedora";;
 fedora)
        echo "redhat";;
*)
        echo "usage:xxx"
esac

vim编辑文件
cat 查看文件
rm 删除文件
touch 新建文件

./test.sh -v 文件 《编辑文件》
./test.sh -c 文件 《编辑文件》
./test.sh -r 文件 《编辑文件》
./test.sh -t 文件 《编辑文件》
./test.sh -h 文件 《显示帮助Usage》

case $1 in
-v)

#!/bin/bash
case $1 in
-v)
        vim $2;;
-c)
        cat $2;;
-r)
        rm $2;;
-t)
        touch $2;;
-*)
        echo "Usage:test.sh [-v|-c|-r|-t|-*]filename";;
esac

read -p "请输入点嘛：" key
case $key in
[a-Z]）      //Z  a-Z 的大小写都可以识别【逻辑上的或者】 还可以写成[a-z]|[A-Z])
    echo "字母";;
[0-9])
    echo "数字";;
*)
    echo "符号";;
esac
+++++++++++++++++++++++++++++++++++++++++++++++
快速将vim中的所有都注释掉：ECS,Ctrl+v,下键,I,#,ESC
u  在vim编辑器里，可以撤销上一条命令
++++++++++++++++++++++++++++++++++++++++++++++++==
[0-9][0-9]   表示两位数

++++++++++++++++++++++++++++++++++++++++++++++

函数（避免代码的重复）

yum install    httpd
systemctl start httpd
systemctl enable httpd

语法：
1.定义函数
    函数名（）{
       命令
       命令
       命令
    }
2.调用函数
    函数名

mkdir /test
 cd /test
 ls
[root@localhost test]# mymkdir (){
> mkdir /txt
> cd /txt
> ls -lh /txt
> }
[root@localhost test]# mymkdir
总用量 0
[root@localhost test]# mymkdir        //不能执行两遍，需要优化
mkdir: 无法创建目录"/test": 文件已存在
总用量 0
[root@localhost test]#

[root@localhost ~]# mymkdir () {
> mkdir $1
> cd $1
> ls -lh $1
> }
[root@localhost ~]# mymkdir /a
总用量 0
[root@localhost a]# mymkdir /b
总用量 0
[root@localhost b]# mymkdir /hehe
总用量 0
[root@localhost hehe]#

##写到profile里才是永久的。
install () {
yum -y install $1
systemctl start $1
systemctl enable $1
}

install httpd
install vsftpd
install mariadb-server

#!/bin/bash
cecho () {
echo -e "\033[$1m$2 \033[0m"
}
cecho 32 OK
cecho 32 OK
cecho 32 OK

+++++++++++++++++++++++++++++++++++++++++++

函数名称（）{
    命令
    命令
    命令
}

vim test.sh    //死机.shi得很彻底
#!/bin/bash
.(){   //定义函数名称为.
.|.&  //调用自己管道给自己，后台运行【核心问题在&上】
}
.   //自己执行7
---------------------------------------------------------------------------

vim test.sh
num=`who |wc -l`
[ $num -gt 3 ] && mail xxx

crontab -e
* * * * *  /root/test.sh

vim test.sh
while:
do
 echo a
 echo b
done

结果：while死循环，不会结束。每分钟都会执行

可以：
vim a.sh
while:
do
  text.sh
done
-------------------------------------------------------------------------------------

windox 上默认没有bash，但是可以安装

--------------------------------------------------------------------------------------

脚本的中断

假设i=x
for i in {1..254}
do
 ssh 192.168.4.$i shutdown++

done
结果：##自己是谁## 同一个网段的才可以ssh，如果自己是10，就把自己关掉了
       脚本的目的是什么

continue:结束本次循环，进入下一次循环。不关心时for还是while。
break：结束整个循环体
exit：结束脚本
eg:
for i in {1..5}
do
    echo $i
    continue   //1结束直接跳到2循环....
    echo a
done

for i in {1..5}
do
    echo $i
    break   //整个循环结束...
done
echo over
1 over

for i in {1..5}
do
    [ $i -eq 3 ] && [continiu|break|exit]
                            只有3不执行|只有1.2|1，2，然后直接退出脚本
    echo $i
done
echo over

[root@localhost test]# vim duan.sh
[root@localhost test]# . duan.sh   //continue
1
2
4
5
[root@localhost test]# vim duan.sh
[root@localhost test]# . duan.sh   //break
1
2
[root@localhost test]# vim duan.sh
[root@localhost test]# . duan.sh    //exit
1
2
Connection to 192.168.4.1 closed.
您在 /var/spool/mail/root 中有新邮件
[root@room4pc09 桌面]#

==============================================
eg：从键盘循环取整数(0结束)并求和，输出最终结果
sum=0
while :
do
    read -p "请输入整数：" num
    求和 let num
    sum=sum+num
done

sum=0
5
sum=0+5=5
10
sum=5+10
15

vim qiuhe.sh
#!/bin/bash
sum=0
while :
do
    read -p "请输入整数：" num
    [ $num -eq 0 ] && break
    sum=$[sum+num]
done
echo $sum

-----------------------------------------------------------------------------------------------------------------

跳过1～20以内非6的倍数，输出其他数的平方值，设定退出代码为2

for i  in {1..20}
do
    x=$[i%6]
        [ $x -ne 0 ] && continue  or [ $x -eq 0 ] && continue
    pf=$[i*i]
done

echo "print 2**3" | python  //pri nt打印出结果。2的三次方

  exit 250              //250为退出码。不同的码代表不同的退出问题
---------------------------------------------------------------------------------------------------------------------------

1-10输出3，6，9 的平方数（3的倍数）

在红帽6中可以安装bash-completion====》》》》Tab

+++++++++++++++++++++++++++++++++++++++++++++++++++
字串截取
方法一
echo ${key:0:3}  //从
[root@localhost test1]# phone=18318616159
[root@localhost test1]# echo ${phone:0:3}
183
[root@localhost test1]# echo ${phone:3:6}
186161
[root@localhost test1]# echo ${phone:3:3}
186
[root@localhost test1]#

方法二
expr substr "$key" 起始位置 长度  //subway  下面的路==》地铁
[root@localhost test1]# phone=18318616159
[root@localhost test1]# expr substr "$phone" 1 3
183
[root@localhost test1]# expr substr "$phone" 6 2
61
[root@localhost test1]# expr substr "$phone" 3 3
318
[root@localhost test1]#

方法三
echo $key | cut -b 1-5
echo $key | cut -b 1,3,5
-b=--byte
[root@localhost test1]# phone=18318616159
[root@localhost test1]# echo $phone | cut -b 1-3  //第一位到第三位
183
[root@localhost test1]# echo $phone | cut -b 3-6
3186
[root@localhost test1]# echo $phone | cut -b 1,3,16  //没有第16位直接取空
13
[root@localhost test1]#
########
[root@localhost test1]# echo $phone | cut -b 1,3,5
138
######

-----------------------------------------------------------------------------------------------------------------------------
vim test.sh
key='abcdefghijklmnopqrstuvwxyz'
生成六位随机数

expr substr "$key" 随机数%26 1

#!/bin/bash
key='abcdefjhigklmnopqrstuvwxyz'
for i in {1..6}   // 6次
do
        echo -n ${key:$[RANDOM]%26:1}   //$[RANDOM]%26,每次循环都会取一个值。
done
echo

Top
NSD SHELL DAY03

    案例1：使用for循环结构
    案例2：使用while循环结构
    案例3：基于case分支编写服务脚本
    案例4：使用Shell函数
    案例5：中断及退出

1 案例1：使用for循环结构
1.1 问题

本案例要求编写一个Shell脚本chkhosts.sh，利用for循环来检测多个主机的存活状态，相关要求及说明如下：

    待检测的多个目标IP地址，存放在ipadds.txt文件内
    ping检测可参考前一天的pinghost.sh脚本
    脚本能遍历ping各主机，并反馈存活状态

执行检测脚本以后，反馈结果如图-1所示。

图-1
1.2 方案

在Shell脚本应用中，常见的for循环采用遍历式、列表式的执行流程，通过指定变量从值列表中循环赋值，每次复制后执行固定的一组操作。

for循环的语法结构如下所示：

    for  变量名  in  值列表
    do
        命令序列
    done

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：练习for循环基本用法

脚本1，通过循环读取账户文件user.txt，批量创建账户：

    [root@svr5 ~]# vim for01.sh
    #!/bin/bash
    for i in $(cat root/user.txt)
    do
            useradd $i
            echo "123456" | passwd --stdin $i
    done
    [root@svr5 ~]# chmod +x for01.sh

步骤二：批量检测多个主机的存活状态

1）准备工作

先确认（或建立）目标IP地址列表文件，能ping通、不能ping通的地址各添加几个，以方便测试：

    [root@svr5 ~]# vim /root/ipadds.txt
    192.168.4.5
    192.168.4.205
    172.16.16.78
    202.106.178.234

2）编写脚本如下：
ping -c【count】 -i【interval间隔】 -W【 timeout】
    [root@svr5 ~]# vim chkhosts.sh
    #!/bin/bash
    HLIST=$(cat /root/ipadds.txt)
    for IP in $HLIST
    do
        ping -c 3 -i 0.2 -W 3 $IP &> /dev/null
        if [ $? -eq 0 ] ; then
            echo "Host $IP is up."
        else
            echo "Host $IP is down."
        fi
    done
    [root@svr5 ~]# chmod +x chkhosts.sh

3）测试、验证脚本

    [root@svr5 ~]# ./chkhosts.sh
    Host 192.168.4.5 is up.
    Host 192.168.4.205 is up.
    Host 172.16.16.78 is down.
    Host 202.106.178.234 is down.

2 案例2：使用while循环结构
2.1 问题

本案例要求编写三个使用while循环的脚本程序，分别实现以下目标：

    批量添加用户账号：stu1-stu20
    批量删除用户账号：stu1-stu20
    检测192.168.4.0/24网段，列出不在线的主机地址

2.2 方案

while循环属于条件式的执行流程，会反复判断指定的测试条件，只要条件成立即执行固定的一组操作，直到条件变化为不成立为止。所以while循环的条件一般通过变量来进行控制，在循环体内对变量值做相应改变，以便在适当的时候退出，避免陷入死循环。

while循环的语法结构如下所示：

    while  条件测试
    do
        命令序列
    done

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：批量添加用户账号stu1-stu20

添加的账号有固定的前缀stu（练习中可自行设置），多个账号从1开始编号，比如stu1、stu2、stu3、……、stu20。—— 编写脚本uaddwhile.sh，实现批量添加这20个用户账号的功能，密码均设为123456。

脚本编写参考如下：

    [root@svr5 ~]# vim uaddwhile.sh
    #!/bin/bash
    PREFIX="stu"                                      //定义用户名前缀
    i=1
    while [ $i -le 20 ]
    do
        useradd ${PREFIX}$i                              //添加的用户名为：前缀+编号
        echo "123456" | passwd --stdin ${PREFIX}$i &> /dev/null
        let i++
    done
    [root@svr5 ~]# chmod +x uaddwhile.sh

执行脚本并验证结果：

    [root@svr5 ~]# ./uaddwhile.sh
    [root@svr5 ~]# grep ^stu /etc/passwd              //检查添加的用户
    stu1:x:531:531::/home/stu1:/bin/bash
    stu2:x:532:532::/home/stu2:/bin/bash
    stu3:x:533:533::/home/stu3:/bin/bash
    stu4:x:534:534::/home/stu4:/bin/bash
    stu5:x:535:535::/home/stu5:/bin/bash
    … …

步骤二：批量删除用户账号stu1-stu20

针对前面执行uaddwhile.sh脚本批量添加的用户账号，再建立一个批量删除这些账号的脚本udelwhile.sh。结构类似，只要替换为删除相关的操作即可。

脚本编写参考如下：

    [root@svr5 ~]# vim udelwhile.sh
    #!/bin/bash
    PREFIX="stu"
    i=1
    while [ $i -le 20 ]
    do
        userdel -r ${PREFIX}$i &> /dev/null
        let i++
    done
    [root@svr5 ~]# chmod +x udelwhile.sh

执行脚本并验证结果：

    [root@svr5 ~]# ./udelwhile.sh
    [root@svr5 ~]# grep ^stu /etc/passwd                  //再检查已无相应账号信息
    [root@svr5 ~]#

步骤三：检测192.168.4.0/24网段，列出不在线的主机地址

1）任务需求及思路分析

要求的是“检测192.168.4.0/24网段，列出不在线的主机地址”。

检测目标是一个网段，其网络部分“192.168.4.”可以作为固定的前缀；而主机部分包括从1~254连续的地址，所以可结合while循环和自增变量进行控制。

2）根据实现思路编写脚本

    [root@svr5 ~]# vim chknet.sh
    #!/bin/bash
    NET="192.168.4."
    i=1
    while [ $i -le 254 ]
    do
        IP="${NET}$i"
        ping -c 3 -i 0.2 -W 1 $IP &> /dev/null
        if [ $? -eq 0 ] ; then
            echo "Host $IP is up."
        else
            echo "Host $IP is down."
        fi
        let i++
    done
    [root@svr5 ~]# chmod +x chknet.sh

3）测试、验证脚本

    [root@svr5 ~]# ./chknet.sh
    Host 192.168.4.1 is down.
    Host 192.168.4.2 is down.
    Host 192.168.4.3 is down.
    Host 192.168.4.4 is down.
    Host 192.168.4.5 is up.
    .. ..
    Host 192.168.4.250 is down.
    Host 192.168.4.251 is down.
    Host 192.168.4.252 is down.
    Host 192.168.4.253 is down.
    Host 192.168.4.254 is down.

3 案例3：基于case分支编写服务脚本
3.1 问题

本案例要求编写myhttpd服务脚本，相关要求如下：

    能支持start、stop、restart等控制参数
    控制参数通过位置变量$1传入
    能通过chkconfig命令来管理此服务
    Apache主程序/usr/sbin/httpd

3.2 方案

case分支属于匹配执行的方式，它针对指定的变量预先设置一个可能的取值，判断该变量的实际取值是否与预设的某一个值相匹配，如果匹配上了，就执行相应的一组操作，如果没有任何值能够匹配，就执行预先设置的默认操作。

case分支的语法结构如下所示：

    case  变量值  in
    模式1)
        命令序列1 ;;
    模式2)
        命令序列2 ;;
        .. ..
    *)
        默认命令序列
    Esac

Linux系统的服务脚本默认均位于/etc/init.d/目录下，基本上都采用了case分支结构来识别控制参数。能够执行“/etc/init.d/服务名 start”或“service 服务名 start”来启动对应的服务，是因为对应的脚本文件能够处理“start”这个位置参数。
3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写脚本文件

脚本编写参考如下：

    [root@svr5 ~]# vim /etc/init.d/myhttpd
    #!/bin/bash
    # chkconfig: 2345 90 10
    # description: Startup script for http Server. (for Test only)
    #!/bin/bash
    case $1 in
    start)
            /usr/sbin/httpd
            echo "我已经启动了";;
    stop)
            kill `cat /var/run/httpd/httpd.pid`;;   #反引号
    restart)
            kill `cat /var/run/httpd/httpd.pid`
            sleep 1
            /usr/sbin/httpd;;
    status)
            if [ -f /var/run/httpd/httpd.pid ];then
                echo "服务正在运行..."
            else
                echo "服务已经关闭"
            fi;;
    esac
    *)                                              //默认输出脚本用法
        echo "用法: $0 {start|stop|status|restart}"
        exit 1
    esac
    [root@svr5 ~]# chmod +x /etc/init.d/myhttpd

步骤二：验证、测试脚本

未提供参数，或提供的参数无法识别时，提示正确用法：

    [root@svr5 ~]# /etc/init.d/myhttpd
    用法: /etc/init.d/myhttpd {start|stop|status|restart}
    [root@svr5 ~]# /etc/init.d/myhttpd check
    用法: /etc/init.d/myhttpd {start|stop|status|restart}

确认可响应status控制参数：

    [root@svr5 ~]# service myhttpd status
    服务已经停止。

确认可响应start控制参数，再次检查服务状态：

    [root@svr5 ~]# service myhttpd start
    [root@svr5 ~]# service myhttpd status
    服务正在运行...

确认可响应stop控制参数，再次检查服务状态：

    [root@svr5 ~]# service myhttpd stop
    [root@svr5 ~]# service myhttpd status
    服务已经停止。

上述操作完成后，说明此服务脚本基本上可以使用了。

步骤三：添加myhttpd服务

通过将服务提交给chkconfig管理，方便配置在不同运行级别是否自动运行。

执行以下操作将myhttpd添加为系统服务，并再次检查自启状态：

    [root@svr5 ~]# chkconfig --add httpd                  //添加myprog服务
    [root@svr5 ~]# chkconfig --list httpd              //确认添加结果
    myprog          0:关闭  1:关闭  2:启用  3:启用  4:启用  5:启用  6:关闭

此后，就可以使用chkconfig工具来调整myhttpd服务的自启状态了。比如，以下操作可以将所有自启关闭：

    [root@svr5 ~]# chkconfig myprog off                  //将自启设为关闭
    [root@svr5 ~]# chkconfig --list httpd              //确认设置结果
    myprog          0:关闭  1:关闭  2:关闭  3:关闭  4:关闭  5:关闭  6:关闭

4 案例4：使用Shell函数
4.1 问题

本案例要求编写两个Shell脚本，相关要求如下：

    一个funexpr.sh脚本：由用户在执行时提供2个整数值参数，计算这2个整数的加、减、乘、除结果

4.2 方案

在Shell脚本中，将一些需重复使用的操作，定义为公共的语句块，即可称为函数。通过使用函数，可以使脚本代码更加简洁，增强易读性，提高Shell脚本的执行效率

1）函数的定义方法

格式1：

    function  函数名 {
        命令序列
        .. ..
    }

格式2：

    函数名() {
        命令序列
        .. ..
    }

2）函数的调用

直接使用“函数名”的形式调用，如果该函数能够处理位置参数，则可以使用“函数名 参数1 参数2 .. ..”的形式调用。

注意：函数的定义语句必须出现在调用之前，否则无法执行。
4.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写funexpr.sh脚本

1）任务需求及思路分析

用户在执行时提供2个整数参数，这个可以通过位置变量$1、$2读入。

针对给定的两个整数，四则运算可以视为一组操作，可以定义为一个函数，依次负责加减乘除运算并输出结果。

调用函数时，将用户提供的两个参数传递给函数处理。

2）根据实现思路编写脚本文件

    [root@svr5 ~]# vim funexpr.sh
    #!/bin/bash
    myexpr() {
        echo "$1 + $2 = $[$1+$2]"
        echo "$1 - $2 = $[$1-$2]"
        echo "$1 * $2 = $[$1*$2]"
        echo "$1 / $2 = $[$1/$2]"
    }
    myexpr $1 $2
    [root@svr5 ~]# chmod +x funexpr.sh

3）测试脚本执行效果

    [root@svr5 ~]# ./funexpr.sh  43  21
    43 + 21 = 64
    43 - 21 = 22
    43 * 21 = 903
    43 / 21 = 2
    [root@svr5 ~]# ./funexpr.sh 1234 567
    1234 + 567 = 1801
    1234 - 567 = 667
    1234 * 567 = 699678
    1234 / 567 = 2

5 案例5：中断及退出
5.1 问题

本案例要求编写两个Shell脚本，相关要求如下：

    从键盘循环取整数（0结束）并求和，输出最终结果
    跳过1~20以内非6的倍数，输出其他数的平方值，设定退出代码为2

5.2 方案

通过break、continue、exit在Shell脚本中实现中断与退出的功能。
5.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写脚本sum.sh

1）编写脚本文件

    [root@svr5 ~]# vim sum.sh
    #!/bin/bash
    while  read  -p  "请输入待累加的整数（0表示结束）："     x
    do
        [ $x -eq 0 ]  &&  break
        SUM=$[SUM+x]
    done
    echo "总和是：$SUM"
    [root@svr5 ~]# chmod +x chkint.sh

步骤二：编写sum.sh脚本文件

1）编写脚本文件

    [root@svr5 ~]# vim mysum.sh
    #!/bin/bash
    i=0
    while  [ $i -le 20 ]
    do
        let i++
        [ $[i%6] -ne 0 ]  &&  continue
        echo $[i*i]
    done
    exit 2
    [root@svr5 ~]# chmod +x sum.sh

##需要复习##
tar
crontab