Shell 编程

最新推荐文章于 2024-06-11 21:57:24 发布

奔跑的大西吉

最新推荐文章于 2024-06-11 21:57:24 发布

阅读量546

点赞数 1

分类专栏： linux 文章标签： Linux Shell

原文链接：https://www.cnblogs.com/clsn/p/8006210.html

版权

linux 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

1.1 前言

1.1.1 为什么学Shell

Shell脚本语言是实现Linux/UNIX系统管理及自动化运维所必备的重要工具， Linux/UNIX系统的底层及基础应用软件的核心大都涉及Shell脚本的内容。每一个合格的Linux系统管理员或运维工程师，都需要能够熟练地编写Shell脚本语言，并能够阅读系统及各类软件附带的Shell脚本内容。只有这样才能提升运维人员的工作效率，适应曰益复杂的工作环境，减少不必要的重复工作，从而为个人的职场发展奠定较好的基础

1.1.2 什么是shell

Shell是一个命令解释器，它在操作系统的最外层，负责直接与用户对话，把用户的输入解释给操作系统，并处理各种各样的操作系统的输出结果，输出屏幕返回给用户。

交互的方式：从键盘输入命令，通过/bin/bash的解析，可以立即得到Shell的回应

[root@clsn ~]# ls           
anaconda-ks.cfg 
[root@clsn ~]# echo ls |bash
anaconda-ks.cfg

非交互的方式: 脚本

1.1.3 什么是Shell脚本

命令、变量和流程控制语句等有机的结合起来

shell脚本擅长处理纯文本类型的数据，而linux中，几乎所有的配置文件，日志，都是纯文本类型文件

1.1.4 脚本语言的种类

一、编译型语言

定义：指用专用的编译器，针对特定的操作平台（操作系统）将某种高级语言源代码一次性翻译成可被硬件平台直接运行的二进制机器码（具有操作数，指令、及相应的格式），这个过程叫做编译（./configure make makeinstall ）；编译好的可执行性文件（.exe），可在相对应的平台上运行（移植性差，但运行效率高）。。

典型的编译型语言有， C语言、C++等。

另外，Java语言是一门很特殊的语言，Java程序需要进行编译步骤，但并不会生成特定平台的二进制机器码，它编译后生成的是一种与平台无关的字节码文件（*.class）（移植性好的原因），这种字节码自然不能被平台直接执行，运行时需要由解释器解释成相应平台的二进制机器码文件；大多数人认为Java是一种编译型语言，但我们说Java即是编译型语言，也是解释型语言也并没有错。

二、解释型语言

定义：指用专门解释器对源程序逐行解释成特定平台的机器码并立即执行的语言；相当于把编译型语言的编译链接过程混到一起同时完成的。

解释型语言执行效率较低，且不能脱离解释器运行，但它的跨平台型比较容易，只需提供特定解释器即可。

常见的解释型语言有， Python（同时是脚本语言）与Ruby等。

三、脚本语言

定义：为了缩短传统的编写-编译-链接-运行（edit-compile-link-run）过程而创建的计算机编程语言。

特点：程序代码即是最终的执行文件，只是这个过程需要解释器的参与，所以说脚本语言与解释型语言有很大的联系。脚本语言通常是被解释执行的，而且程序是文本文件。

典型的脚本语言有，JavaScript，Python，shell等。

其他常用的脚本语言种类

PHP是网页程序，也是脚本语言。是一款更专注于web页面开发（前端展示）的脚本语言，例如：Dedecms,discuz。PHP程序也可以处理系统日志，配置文件等，php也可以调用系统命令。

Perl脚本语言。比shell脚本强大很多，语法灵活、复杂，实现方式很多，不易读，团队协作困难，但仍不失为很好的脚本语言，存世大量的程序软件。MHA高可用 Perl 写的

Python，不但可以做脚本程序开发，也可以实现web程序以及软件的开发。近两年越来越多的公司都会要求会Python。

Shell脚本与php/perl/python语言的区别和优势？

shell脚本的优势在于处理操作系统底层的业务（linux系统内部的应用都是shell脚本完成）因为有大量的linux系统命令为它做支撑。2000多个命令都是shell脚本编程的有力支撑，特别是grep、awk、sed等。例如：一键软件安装、优化、监控报警脚本，常规的业务应用，shell开发更简单快速，符合运维的简单、易用、高效原则.

PHP、Python优势在于开发运维工具以及web界面的管理工具，web业务的开发等。处理一键软件安装、优化，报警脚本。常规业务的应用等php/python也是能够做到的。但是开发效率和复杂比用shell就差很多了。

1.1.5 系统中的shell

查看系统中的解释器

[root@clsn ~]# cat /etc/shells
/bin/sh
/bin/bash
/sbin/nologin
/usr/bin/sh
/usr/bin/bash
/usr/sbin/nologin

# 产看当前系统所用 bash 
[root@clsn ~]# echo $SHELL
/bin/bash

# 产看当前系统 bash 版本 
[root@clsn scripts]# bash -version
GNU bash， 版本 4.2.46(2)-release (x86_64-redhat-linux-gnu)
Copyright (C) 2011 Free Software Foundation, Inc.

# 许可证 GPLv3+: GNU GPL 许可证版本3或者更高 <http://gnu.org/licenses/gpl.html>
# 这是自由软件，您可以自由地更改和重新发布。
# 在法律允许的范围内没有担保.

常用操作系统的默认shell

Linux是Bourne Again shell（bash）
Solaris和FreeBSD缺省的是Bourne shell（sh）
AIX下是Korn Shell（ksh）
HP-UX缺省的是POSIX shell（sh）

bash 破壳漏洞

原理：Bash使用的环境变量是通过函数名称来调用的，导致漏洞出问题是以“(){”开头定义的环境变量在命令ENV中解析成函数后，Bash执行并未退出，而是继续解析并执行shell命令。而其核心的原因在于在输入的过滤中没有严格限制边界，也没有做出合法化的参数判断。

检测：使用命令 env x='() { :;}; echo be careful' bash -c "echo this is a test"。如果返回结果为一行，则为正常，

[root@clsn ~]# env x='() { :;}; echo be careful' bash -c "echo this is a test"
this is a test

#解决办法 升级当前的bash版本
yum install update bash

sh与bash 的关系

[root@clsn ~]#  ll /bin/sh
lrwxrwxrwx. 1 root root 4 11月 13 11:15 /bin/sh -> bash

/bin与 /user/bin 的关系

[root@clsn ~]# ll /bin -d
lrwxrwxrwx. 1 root root 7 11月 13 11:15 /bin -> usr/bin

1.2 脚本书写规范

1.2.1 脚本统一存放目录

[root@clsn ~]# mkdir -p /server/scripts/
[root@clsn ~]# cd /server/scripts/

1.2.2 选择解释器

注意格式

其中开头的"#!"字符又称为幻数，在执行bash脚本的时候，内核会根据"#!"后的解释器来确定该用那个程序解释这个脚本中的内容。例如

[root@clsn scripts]# head -1 /etc/init.d/*
==> /etc/init.d/functions <==
# -*-Shell-script-*-

==> /etc/init.d/netconsole <==
#!/bin/bash

==> /etc/init.d/network <==
#! /bin/bash

1.2.3 编辑脚本使用vim

使用 .vimrc 文件，能够快速的生成开头的注释信息

[root@clsn scripts]# cat  ~/.vimrc
autocmd BufNewFile *.py,*.cc,*.sh,*.java exec ":call SetTitle()"

func SetTitle()
if expand("%:e") == ‘sh’
call setline(1,"#!/bin/bash")
call setline(2, “##############################################################”)
call setline(3, “# File Name: “.expand(”%”))
call setline(4, “# Version: V1.0”)
call setline(5, “# Author: lp”)
call setline(6, “# Organization: ”)
call setline(7, “# Created Time : “.strftime(”%F %T”))
call setline(8, “# Description:”)
call setline(9, “##############################################################”)
call setline(10, “”)
endif
endfunc

使用后的效果

[root@clsn scripts]# cat  scripts_test.sh 
#!/bin/bash
##############################################################
# File Name: scripts_test.sh
# Version: V1.0
# Author: flp
# Organization: 
# Created Time : 2019-10-21 11:39:57
# Description:  First scripts file
##############################################################

在Shell脚本中，跟在#后面的内容表示注释。注释部分不会被执行，仅给人看。注释可以自成一行，也可以跟在命令后面，与命令同行。要养成写注释的习惯，方便自己与他人。

最好不用中文注释，因为在不同字符集的系统会出现乱码。(字符集为zh_CN.UTF-8,为中文)。

1.2.4 文件名规范

名字要有意义，并且结尾以 .sh 结束

1.2.5 开发的规范和习惯小结

1) 放在统一的目录
2) 脚本以.sh为扩展名
3) 开头指定脚本解释器。
4) 开头加版本版权等信息，可配置~/.vimrc文件自动添加。
5) 脚本不要用中文注释，尽量用英文注释。
6) 代码书写优秀习惯
  a、成对的内容一次性写出来，防止遗漏，如[  ]、' '、" "等
  b、[  ]两端要有空格，先输入[  ],退格，输入2个空格，再退格写。
  c、流程控制语句一次书写完，再添加内容。(if 条件 ; then  内容;fi)ddd
  d、通过缩进让代码易读。
  e、脚本中的引号都是英文状态下的引号，其他字符也是英文状态。

1.3 shell脚本的执行

1.3.1 执行脚本

# 方式一
sh/bash scripts.sh

# 方式二
chown +x   ./scripts.sh  && ./scripts.sh 

# 方式三 source  
# 格式：source 文件名 [参数]
# 作用：在当前 shell 中执行一个文件中的命令。
source scripts.sh

# 方式四 点  
# 格式：. 文件名 [参数] 
# 作用：在当前 shell 中执行一个文件中的命令。
. (空格) scripts.sh

# 方式五，效率较低
cat oldboyedu.sh |bash

1.3.2 sh 与 source的区别

sh 新建一个Shell窗口（新建一个进程）执行一个文件中的命令。source 在当前窗口执行。

[root@clsn scripts]# sh  clsn_test.sh
Hello World!

[root@clsn scripts]# echo $clsn
#  sh  新建一个Shell窗口（新建一个进程）执行一个文件中的命令。


[root@clsn scripts]# source clsn_test.sh
Hello World!

[root@clsn scripts]# echo $clsn
Hello World!

面试题：问sh test.sh后echo $user返回的结果。答案：空

1.4 Shell的变量

1.4.1 什么是变量

变量可以分为两类：环境变量（全局变量）和普通变量（局部变量）

环境变量也可称为全局变量，可以在创建他们的Shell及其派生出来的任意子进程shell中使用，环境变量又可分为自定义环境变量和Bash内置的环境变量

普通变量也可称为局部变量，只能在创建他们的Shell函数或Shell脚本中使用。普通变量一般是由开发者用户开发脚本程序时创建的。

1.4.2 环境变量

使用 env/declare/set/export -p 命令查看系统中的环境变量，这三个命令的的输出方式稍有不同。

[root@clsn scripts]# env
XDG_SESSION_ID=1
HOSTNAME=clsn
TERM=linux
SHELL=/bin/bash
HISTSIZE=1000
SSH_CLIENT=10.0.0.1 5537 22
SSH_TTY=/dev/pts/0
USER=root
~~~

输出一个系统中的环境变量

[root@clsn ~]# echo $LANG
zh_CN.UTF-8

1.4.3 普通变量

本地变量在用户当前的Shell生存期的脚本中使用。例如，本地变量OLDBOY取值为bingbing，这个值在用户当前Shell生存期中有意义。如果在Shell中启动另一个进程或退出，本地变量值将无效。例如：

[root@clsn ~]# a=1
[root@clsn ~]# b='2'
[root@clsn ~]# c="3"
[root@clsn ~]# echo "$a"
1
[root@clsn ~]# echo "$b"
2
[root@clsn ~]# echo "${c}"
3

# 提示：$变量名表示输出变量，可以用$c和${c}两种用法

小结：连续普通字符串内容赋值给变量，不管用什么引号或者不用引号，它的内容是什么，打印变量就输出什么

1.4.4 export命令

export [-fnp][变量名称]=[变量设置值]
参数说明：
  -f 　代表[变量名称]中为函数名称。
  -n 　删除指定的变量。变量实际上并未删除，只是不会输出到后续指令的执行环境中。
  -p 　列出所有的shell赋予程序的环境变量。

export命令在当前shell窗口及子shell窗口生效，在新开的shell窗口不会生效，生效需要写入配置文件。

# 定义变量
[root@clsn scripts]# CSLN=clsn
[root@clsn scripts]# export CSLN1=1

# 当前窗口查看
[root@clsn scripts]# echo $CSLN
clsn
[root@clsn scripts]# echo $CSLN1
1

# 编写测试脚本
[root@clsn scripts]# vim quanju.sh
#!/bin/bash
echo $CSLN
echo $CSLN1

# 使用sh执行,  子窗口export生效
[root@clsn scripts]# sh  quanju.sh

1


# 使用 source 执行
[root@clsn scripts]# source quanju.sh
clsn
1

1.4.5 环境变量相关配置文件

/etc/proflie
/etc/bashrc
~/.bashrc
~/.bash_profile
/etc/proflie.d/  # 目录

四文件读取顺序（CentOS6和7都一样）

/etc/profile
~/.bash_profile
~/.bashrc
/etc/bashrc

文件读取过程示意图

验证四文件读取顺序的方法

sed -i '1a echo "$(date +%T-%s) /etc/profile1" >>/tmp/clsn' /etc/profile
sed -i '$a echo "$(date +%T-%s) /etc/profile2" >>/tmp/clsn' /etc/profile
sed -i '1a echo "$(date +%T-%s) /etc/bashrc1" >>/tmp/clsn' /etc/bashrc
sed -i '$a echo "$(date +%T-%s) /etc/bashrc2" >>/tmp/clsn' /etc/bashrc
sed -i '1a echo "$(date +%T-%s) ~/.bashrc1" >>/tmp/clsn' ~/.bashrc
sed -i '$a echo "$(date +%T-%s) ~/.bashrc2" >>/tmp/clsn' ~/.bashrc
sed -i '1a echo "$(date +%T-%s) ~/.bash_profile1" >>/tmp/clsn' ~/.bash_profile
sed -i '$a echo "$(date +%T-%s) ~/.bash_profile2" >>/tmp/clsn' ~/.bash_profile

1.4.6 环境变量的知识小结

变量名通常要大写。
变量可以在自身的Shell及子Shell中使用。
常用export来定义环境变量。
执行env默认可以显示所有的环境变量名称及对应的值。
输出时用“$变量名”，取消时用“unset变量名”。
书写crond定时任务时要注意，脚本要用到的环境变量最好先在所执行的Shell脚本中重新定义。
如果希望环境变量永久生效，则可以将其放在用户环境变量文件或全局环境变量文件里。

1.4.7 变量中引号的使用

只有在变量的值中有空格的时候，会使用引号。单引号与双引号的区别在于，是否能够解析特殊符号。

以单引号' '包围变量的值时，单引号里面是什么就输出什么，即使内容中有变量和命令（命令需要反引起来）也会把它们原样输出。这种方式比较适合定义显示纯字符串的情况，即不希望解析变量、命令等的场景。

以双引号" "包围变量的值时，输出时会先解析里面的变量和命令，而不是把双引号中的变量名和命令原样输出。这种方式比较适合字符串中附带有变量和命令并且想将其解析后再输出的变量定义。

反引号``是命令替换，命令替换是指Shell可以先执行``中的命令，将输出结果保存到变量。

建议：如果变量的内容是数字，那么可以不加引号；如果真的需要原样输出就加单引号；其他没有特别要求的字符串等最好都加上双引号，定义变量时加双引号是最常见的使用场景

[root@clsn ~]# name=lp
[root@clsn ~]# name2='clsn'
[root@clsn ~]# name3="http://blog.lp"
[root@clsn ~]# echo $name
lp
[root@clsn ~]# echo $name2
clsn
[root@clsn ~]# echo $name3
http://blog.lp
[root@clsn ~]# name4='cl sn'
[root@clsn ~]# echo $name4
cl sn
[root@clsn ~]# name5="cl sn"
[root@clsn ~]# echo $name5
cl sn
[root@clsn ~]# name6='cl sn $PWD'
[root@clsn ~]# echo $name6
cl sn $PWD
[root@clsn ~]# name6="cl sn $PWD"
[root@clsn ~]# echo $name6
cl sn /root

1.4.8 普通变量的要求

1) 内容是纯数字、简单的连续字符（内容中不带任何空格）时，定义时可以不加任何引号，例如：

ClsnAge=22
NETWORKING=yes

2) 没有特殊情况时，字符串一律用双引号定义赋值，特别是多个字符串中间有空格时，例如：

NFSD_MODULE="no load"
MyName="Oldboy is a handsome boy."

3) 当变量里的内容需要原样输出时，要用单引号（M），这样的需求极少，例如：

aOLDBOY_NAME='OLDBOY'

变量使用反引号赋值

[root@clsn scripts]# time=`date`
[root@clsn scripts]# echo $time
2017年 12月 05日 星期二 09:02:06 CST
[root@clsn scripts]# file=ls
[root@clsn scripts]# echo $file
clsn_test.sh panduan.sh quanju.sh yhk.sh

使用${}

[root@clsn scripts]# time=`date`
[root@clsn scripts]# echo $time_day
[root@clsn scripts]# echo ${time}_day
2017年 12月 05日 星期二 09:02:06 CST_day

[root@clsn scripts]# echo $time-day
2017年 12月 05日 星期二 09:02:06 CST-day

1.4.9 定义变量名技巧

变量名只能为字母、数字或下划线，只能以字母或下划线开头。
变量名的定义要有一定的规范，并且要见名知意。
一般的变量定义、赋值常用双引号；简单连续的字符串可以不加引号；希望原样输出时使用单引号。
希望变量的内容是命令的解析结果时，要用反引号''，或者用$()把命令括起来再赋值。

示例：

ClsnAge=22       # 每个单词的首字母大写的写法
clsn_age=22      # 单词之间用"_"的写法
clsnAgeSex=man   # 驼峰语法：首个单词的首字母小写，其余单词首字母大写
CLSNAGE=22       # 单词全大写的写法

1.5 特殊变量

1.5.1 位置变量

常用的特殊位置参数说明

位置变量	作用说明
$0	获取当前执行的shell脚本的文件名，如果执行脚本带路径那么就包括脚本路径。
$n	获取当前执行的shell脚本的第n个参数值，n=1..9，当n为0时表示脚本的文件名，如果n大于9用大括号括起来{10}，参数以空格隔开。
$#	获取当前执行的shell脚本后面接的参数的总个数
$*	获取当前shell的所有传参的参数，不加引号同$@;如果给$加上双引号，例如:“$”,则表示将所有的参数视为单个字符串，相当于“112$3”。
$@	获取当前shell的所有传参的参数，不加引号同$*;如果给$@加上双引号，例如:“$@”,则表示将所有参数视为不同的独立字符串，相当于“$1” “$2” “$3”“……”，这是将参数传递给其他程序的最佳方式，因为他会保留所有内嵌在每个参数里的任何空白。
当“$*”和“$@”都加双引号时，两者有区别，都不加双引号时，两者无区别。

参数实践

[root@clsn scripts]# vim chanshu.sh
#!/bin/bash
#
echo $0
echo "第一个参数：" $1
echo "第二个参数：" $2
echo "第11个参数：" ${11}
[root@clsn scripts]# sh chanshu.sh
chanshu.sh
第一个参数：
第二个参数：
第11个参数：
[root@clsn scripts]# sh chanshu.sh 1 2 3 4 5 6 7 8 9 10 11 
chanshu.sh
第一个参数： 1
第二个参数： 2
第11个参数： 11

$# ，$* 参数实践

[root@clsn scripts]# vim chanshu.sh
#!/bin/bash
#
echo $0
echo "第一个参数：" $1
echo "第二个参数：" $2
echo "第10个参数：" ${10}
echo "第11个参数：" ${11}
echo "参数个数：" $#
echo "参数:" $*
"chanshu.sh" 18L, 456C 已写入                                  
[root@clsn scripts]# sh chanshu.sh 55 2 3 4 5 6 7 8 9 10 11 112
chanshu.sh
第一个参数： 55
第二个参数： 2
第10个参数： 10
第11个参数： 11
参数个数： 12
参数: 55 2 3 4 5 6 7 8 9 10 11 112

$* 与 $@ 对比实践

[root@clsn scripts]# set -- "I am" handsome boy..
[root@clsn scripts]# echo $1
I am
[root@clsn scripts]# echo $2
handsome
[root@clsn scripts]# echo $3
boy..
[root@clsn scripts]# echo $*
I am handsome boy..
[root@clsn scripts]# echo $@
I am handsome boy..

[root@clsn scripts]# for i in $*;do echo $i ;done
I
am
handsome
boy..
[root@clsn scripts]# for i in $@;do echo $i ;done
I
am
handsome
boy..
[root@clsn scripts]# for i in "$@";do echo $i ;done
I am
handsome
boy..
[root@clsn scripts]# for i in "$*";do echo $i ;done
I am handsome boy..

1.5.2 进程状态变量

Shell进程的特殊状态变量说明

位置变量	作用说明
$?	获取执行上一个指令的执行状态返回值（0为成功，非零为失败)，这个变量最常用
$$	获取当前执行的Shell脚本的进程号（PID)，这个变量不常用，了解即可
$!	获取上一个在后台工作的进程的进程号（PID)，这个变量不常用，了解即可
$_	获取在此之前执行的命令或脚本的最后一个参数，这个变量不常用，了解即可

进程参数实践

[root@clsn scripts]# echo $?
0
[root@clsn scripts]# echo $$
1368
[root@clsn scripts]# echo $!

[root@clsn scripts]# echo $_
echo

1.5.3 echo参数说明

参数	参数说明
-n	不要追加换行
-e	启用下列反斜杠转义的解释
-E	显式地抑制对于反斜杠转义的解释
`echo' 对下列反斜杠字符进行转义：
\n	换行
\r	回车
\t	横向制表符
\b	退格
\v	纵向制表符
\c	抑制更多的输出

1.6 定义变量的方式

1.6.1 三种定义变量的方式

直接赋值
传参 (传递参数)
交互式设置变量，使用read命令

1.6.2 read命令说明

read命令的帮助说明

Linux read命令用于从标准输入读取数值。

read 内部命令被用来从标准输入读取单行数据。这个命令可以用来读取键盘输入，当使用重定向的时候，可以读取文件中的一行数据。

语法
read [-ers] [-a aname] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]

参数说明:
-a 后跟一个变量，该变量会被认为是个数组，然后给其赋值，默认是以空格为分割符。
-d 后面跟一个标志符，其实只有其后的第一个字符有用，作为结束的标志。
-p 后面跟提示信息，即在输入前打印提示信息。
-e 在输入的时候可以使用命令补全功能。
-n 后跟一个数字，定义输入文本的长度，很实用。
-r 屏蔽\，如果没有该选项，则\作为一个转义字符，有的话 \就是个正常的字符了。
-s 安静模式，在输入字符时不再屏幕上显示，例如login时输入密码。
-t 后面跟秒数，定义输入字符的等待时间。
-u 后面跟fd，从文件描述符中读入，该文件描述符可以是exec新开启的。

在命令行中使用

[root@clsn scripts]# read
132
[root@clsn scripts]# echo $REPLY 
132
[root@clsn scripts]# read clsn 
456
[root@clsn scripts]# echo $clsn
456
[root@clsn scripts]# echo $REPLY 
132

在脚本中使用

[root@clsn scripts]# vim clsn_test.sh 
#!/bin/bash
read -p '请输入:'  cl
echo $cl

# 执行结果
[root@clsn scripts]# sh clsn_test.sh
请输入:aaa
aaa

1.6.3 定义方法实践

直接赋值方法

[root@clsn scripts]# vim bianliang.sh
#!/bin/bash
#
name=CLSN
age=22
sex=Man
hobby=`ls`
ethFile=/etc/sysconfig/network-scripts/ifcfg-eth0

echo $hobby
ls $ethFile
[root@clsn scripts]# sh  bianliang.sh
bianliang.sh chanshu.sh clsn.sh clsn_test.sh panduan.sh quanju.sh xiugaizhuji.sh yhk.sh
/etc/sysconfig/network-scripts/ifcfg-eth0

传参 (传递参数)

[root@clsn scripts]# vim bianliang.sh
#!/bin/bash
#
name=CLSN
age=22
sex=Man
hobby=$1
ethFile=$2

echo $hobby
ls $ethFile
[root@clsn scripts]# sh  bianliang.sh  clsn /etc/hostname 
clsn
/etc/hostname

交互式设置变量 read

[root@clsn scripts]# vim yhk.sh 
#!/bin/bash
#
read -p  "请输入你的银行卡号："  Yhk
read -s -p  "请输入密码:" miMa
echo
echo "你的银行卡号："  $Yhk
echo "你的密码为：" $miMa
# 测试结果
[root@clsn scripts]# sh  yhk.sh 
请输入你的银行卡号：123456
请输入密码:
你的银行卡号： 123456
你的密码为： 123456

1.6.4 写一个交互脚本，实现能够定义主机名及IP地址

[root@clsn scripts]# cat xiugaizhuji.sh 
#!/bin/bash
#

ethFile=/etc/sysconfig/network-scripts/ifcfg-eth[01]
Now_eth=`hostname -I|awk -F "[. ]+" '{print $4}'`

read -p "请输入主机名:" Hostname
read -p "请输入IP地址的主机位:" HostIP

hostnamectl set-hostname  $Hostname
 
sed  -i "s#${Now_eth}#${HostIP}#g" $ethFile 

read -p "是否重启服务器:{yes/no}"  REboot

if [ $REboot == yes ]
then 
   echo "系统将在10秒后重启！"
   shutdown -r  10 
else
   echo "请稍后手动重启系统！"
fi

脚本测试结果

[root@clsn scripts]# sh xiugaizhuji.sh
请输入主机名:clsn
请输入IP地址的主机位:180
是否重启服务器:{yes/no}yes
系统将在10秒后重启！
[root@clsn scripts]# sh xiugaizhuji.sh
请输入主机名:clsn
请输入IP地址的主机位:180
是否重启服务器:{yes/no}no
请稍后手动重启！

1.7 变量子串

1.7.1 变量子串说明

表达式	说明
${parameter}	返回变量$parameter的内容
${#parameter}	返回变内容的长度（按字符)，也适用于特殊变量
${parameter:offset}	在变量${parameter}中，从位置offset之后开始提取子串到结尾
${parameter:offset:length}	在变量${parameter}中，从位置offset之后开始提取长度为length的子串
${parameter#word}	从变量${parameter}开头开始删除最短匹配的word子串
${parameter##word}	从变量${parameter}开头开始删除最长匹配的word子串
${parameter%word}	从变量${parameter}结尾开始删除最短匹配的word子串
${parameter%%word}	从变量${parameter}结尾开始删除最长匹配的word子串
${parameter/pattem/string}	使用string代替第一个匹配的pattern
${parameter//pattem/string}	使用string代替所有匹配的pattern

计算变量的长度

[root@clsn scripts]# clsn=http://blog.znix.top
[root@clsn scripts]# echo ${clsn} |wc -L 
20
[root@clsn scripts]# echo ${#clsn} 
20
[root@clsn scripts]# time echo ${clsn} |wc -L 
20

real    0m0.002s
user    0m0.002s
sys    0m0.000s
[root@clsn scripts]# time echo ${#clsn} 
20

real    0m0.000s
user    0m0.000s
sys    0m0.000s

截取变量中的字符

[root@clsn scripts]# clsn=abcABC123ABCabc
[root@clsn scripts]# echo ${clsn#abc}
ABC123ABCabc
[root@clsn scripts]# echo ${clsn##abc}
ABC123ABCabc
[root@clsn scripts]# echo ${clsn%abc}
abcABC123ABC
[root@clsn scripts]# echo ${clsn%%abc}
abcABC123ABC
[root@clsn scripts]# echo ${clsn#a*c}
ABC123ABCabc
[root@clsn scripts]# echo ${clsn##a*c}

[root@clsn scripts]# echo ${clsn%a*c}
abcABC123ABC
[root@clsn scripts]# echo ${clsn%%a*c}

[root@clsn scripts]# echo ${clsn#a*C}
123ABCabc
[root@clsn scripts]# echo ${clsn#a*C}
123ABCabc
[root@clsn scripts]# echo ${clsn##a*C}
abc
[root@clsn scripts]# echo ${clsn%a*c}
abcABC123ABC
[root@clsn scripts]# echo ${clsn%A*c}
abcABC123
[root@clsn scripts]# echo ${clsn%%A*c}
abc

替换变量内容

[root@clsn scripts]# echo $clsn
abcABC123ABCabc
[root@clsn scripts]# echo ${clsn/abc/clsn}
clsnABC123ABCabc
[root@clsn scripts]# echo ${clsn//abc/clsn}
clsnABC123ABCclsn

有关上述匹配删除的小结

#表示从幵头删除匹配最短。
##表示从开头删除匹配最长。
%表示从结尾删除匹配最短。
%%表示从结尾删除匹配最长。
a*c表示匹配的突符串，*表示匹配所有，a*c匹配开头为a、中间为任意多个字符、结尾为c的字符串。
a*C表示匹配的字符串，*表示匹配所有，a*C匹配开头为a、中间为任意多个字符、结尾为C的字符串。

有关替换的小结

一个“/”表示替换匹配的第-个字符串。
两个“/”表示替换匹配的所有字符串。

1.7.2 Shell的特殊扩展变量说明

表达式	说明
${parameter:-word}	如果parameter的变量值为空或未赋值，则会返回word字符串并替代变量的值用途.如果变量未定义，则返回备用的值，防止变量为空值或因未定义而导致异常
${parameter:=word}	如果parameter的变量值为空或未赋值，则设置这个变量值为word,并返回其值。位置变量和特殊变量不适用用途：基本同上一个${parameter>word}，但该变量又额外给parameter变量赋值了
${parameter:?word}	如果parameter变量值为空或未赋值，那么word字符串将被作为标准错误输出，否则输出变量的值。用途：用于捕捉由于变量未定义而导致的错误，并退出程序
${parameter:+word}	如果parameter变量值为空或未赋值，则什么都不做，否则word字符串将替代变量的值

特殊变量实践

[root@clsn scripts]# cat  clsn.sh 
#!/bin/bash
#
dir=
echo ${dir:-/tmp}
echo ${dir}
echo ${dir:=/mnt}
echo ${dir}
dir2= (空格)
echo ${dir2-/tmp}
echo ${dir2}
echo ${dir2:-/tmp}
echo ${dir2}
echo ${dir2=/mnt}
echo ${dir2}

测试结果

[root@clsn scripts]# sh clsn.sh 
/tmp

/mnt
/mnt


/tmp

1.8 变量的数值计算

1.8.1 仅支持整数的运算

echo $((数学运算表达式))

# 形式一
[root@clsn scripts]# echo $((1 + 1))
2
[root@clsn scripts]# echo $((2*7-3/6+5))
19
# 形式二
[root@clsn scripts]# ((clsn=2*8))
[root@clsn scripts]# echo $clsn
16
# 形式三
[root@clsn scripts]# znix=$((2*7-3/6+5))
[root@clsn scripts]# echo $znix
19

延伸产物(重要)

i++ 自增1
i-- 自减1
++i
--i

示例：

[root@clsn scripts]# i=1
[root@clsn scripts]# echo $((i++))
1
[root@clsn scripts]# echo $((i++))
2
[root@clsn scripts]# echo $((i--))
3
[root@clsn scripts]# echo $((i--))
2
[root@clsn scripts]# echo $((i--))
1
[root@clsn scripts]# echo $((++i))
1
[root@clsn scripts]# echo $((++i))
2
[root@clsn scripts]# echo $((++i))
3
[root@clsn scripts]# echo $((--i))
2
[root@clsn scripts]# echo $((--i))
1
[root@clsn scripts]# echo $((--i))
0

记忆方法：++，--

变量a在前，表达式的值为a，然后a自增或自减，变量a在符号后，表达式值自增或自减，然后a值自增或自减。

let命令

[root@clsn scripts]# i=1
[root@clsn scripts]# i=i+1
[root@clsn scripts]# echo $i
i+1

[root@clsn scripts]# i=1
[root@clsn scripts]# let i=i+1
[root@clsn scripts]# echo $i
2

expr 命令

整数计算
判断扩展名
判断输入是否为整数，非整数返回值为2
计算变量的长度

[root@clsn scripts]# expr 1+1
1+1
[root@clsn scripts]# expr 1 + 1
2
[root@clsn scripts]# expr 1 * 1
expr: 语法错误
[root@clsn scripts]# expr 1 \* 1
1

# 非整数返回值为2 示例：

[root@clsn scripts]# expr 1 + 1 
2
[root@clsn scripts]# echo $?
0
[root@clsn scripts]# expr -1 + 1 
0
[root@clsn scripts]# echo $?
1
[root@clsn scripts]# expr a + 1 
expr: 非整数参数
[root@clsn scripts]# echo $?
2

$[]运算符

[root@clsn scripts]# echo $[1+2]
3
[root@clsn scripts]# echo $[1-2]
-1
[root@clsn scripts]# echo $[1*2]
2
[root@clsn scripts]# echo $[1/2]
0

typeset

[root@clsn scripts]# typeset -i A=2017 B=2018
[root@clsn scripts]# A=A+B
[root@clsn scripts]# echo $A
4035

1.8.2 可以进行小数运算的命令

bc 命令

# 安装 bc  依赖于base源
[root@clsn scripts]# yum -y install bc

交互模式测试bc命令

[root@clsn scripts]# bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc. 
1+1
2
[root@clsn scripts]# echo 1+1.1|bc
2.1

免交互模式测试bc命令

[root@clsn scripts]# echo 'scale=6;1/3'|bc
.333333

python 命令

[root@clsn scripts]# python 
>>> import os
>>> os.system('df -h')
>>> 1+1.1
2.1
>>>exit()

awk 命令

[root@clsn ~]# echo "7.7 3.8"|awk '{print ($1-$2)}'
3.9
[root@clsn ~]# echo "358 113"|awk '{print ($1-3)/$2}'
3.14159
[root@clsn ~]# echo "3 9"|awk '{print ($1+3)*$2}'
54
[root@backup scripts]# awk BEGIN'{print 1.2+3.3}'
4.5

1.8.3 运算相关练习题

【练习题】实现一个加减乘除等功能的计算器

[root@clsn scripts]# cat jishuanqi.sh 
#!/bin/bash
#

read -p "请输入第一个整数:" a
read -p "请输入第二个整数:" b


echo $a + $b =$(($a+$b))
echo $a - $b =$(($a-$b))
echo $a \* $b =$(($a*$b))
echo $a / $b =$(($a/$b))

脚本执行过程：

[root@clsn scripts]# sh jishuanqi.sh 
请输入第一个整数:12
请输入第二个整数:12
12 + 12 =24
12 - 12 =0
12 * 12 =144
12 / 12 =1

精简方法

[root@clsn scripts]# vim jishuanqi2.sh 
#!/bin/bash
#
echo $(($1))

脚本执行过程：

[root@clsn scripts]# sh jishuanqi2.sh  1+1
2
[root@clsn scripts]# sh jishuanqi2.sh  1*9
9

【练习题】打印结果1+2+3+4+5+6+7+8+9+10=55

[root@clsn scripts]# vim yunshuan.sh
#!/bin/bash
#

Num=`seq -s + 1 10`
echo  $Num=$(($Num))

脚本执行结果

[root@clsn scripts]# sh  yunshuan.sh
1+2+3+4+5+6+7+8+9+10=55

1.9 补充说明

shell脚本中批量注释的方法

<<'EOF'
文件内容
EOF

或
使用 exit可以注释其之后的所有内容(类似注释，实质为不执行后面的内容)

2.1 条件表达式

1.1.1 文件判断

常用文件测试操作符

常用文件测试操作符	说明
-d文件，d的全拼为directory	文件存在且为目录则为真，即测试表达式成立
-f文件，f的全拼为file	文件存在且为普通文件则为真，即测试表达式成立
-e文件，e的全拼为exist	文件存在则为真，即测试表达式成立。注意区别于“-f”，-e不辨别是目录还是文件
-r文件，r的全拼为read	文件存在且可读则为真，即测试表达式成立
-s文件，s的全拼为size	文件存在且文件大小不为0则为真，即测试表达式成立
-w文件，w的全拼为write	文件存在且可写则为真，即测试表达式成立
-x文件，x的全拼为executable	文件存在且可执行则为真，即测试表达式成立
-L文件，L的全拼为link	文件存在且为链接文件则为真，即测试表达式成立
fl -nt f2，nt 的全拼为 newer than	文件fl比文件f2新则为真，即测试表达式成立。根据文件的修改时间来计算
fl -ot f2，ot 的全拼为 older than	文件fl比文件f2旧则为真，即测试表达式成立。根据文件的修改时间来计算

判断文件是否存在

[root@clsn scripts]# [ -f /etc/hosts ]
[root@clsn scripts]# echo $?
0
[root@clsn scripts]# [ -f /etc/hosts1 ]
[root@clsn scripts]# echo $?
1

判断文件是否存在,返回方式

[root@clsn scripts]# [ -f /etc/hosts ] && echo "文件存在" || echo "文件不存在" 
文件存在
[root@clsn scripts]# [ -f /etc/hosts1 ] && echo "文件存在" || echo "文件不存在" 
文件不存在

判断目录是否存在

[root@clsn scripts]# [ -d /tmp ] && echo "目录存在" || echo "目录不存在" 
目录存在
[root@clsn scripts]# [ -d /tmp1 ] && echo "目录存在" || echo "目录不存在" 
目录不存在

使用变量的方法进行判断

dir=/etc1/;[ -d $dir ] && tar zcf etc.tar.gz $dir || echo "$dir目录不存在"

2.1.2 字符串判断

字符串测试操作符

常用字符串测试操作符	说明
-n "字符串"	若字符串的长度不为0,则为真，即测试表达式成立，n可以理解为no zero
-Z "字符串"	若字符串的长度为0,则为真，即测试表达式成立，z可以理解为zero的缩写
"串 1"== "串 2"	若字符串1等于字符串2,则为真，即测试表达式成立，可使用"=="代替"="
"串 1" ！= "串 2"	若字符串1不等于字符串2,则为真，即测试表达式成立，但不能用"!=="代替"!="
1.对于字符串的测试，一定要将字符串加双引号之后再进行比较。 2.空格非空

示例：

#-z 判断字符串长度
[root@clsn scripts]# x=  ; [ -z "$x" ] && echo "输入为空" || echo '输入有内容'
输入为空
[root@clsn scripts]# x=12 ; [ -z "$x" ] && echo "输入为空" || echo '输入有内容'
输入有内容


# -n 判断字符串长度
[root@clsn scripts]# x=12 ; [ -n "$x" ] && echo "输入有内容" || echo '输入为空'
输入有内容
[root@clsn scripts]# x= ; [ -n "$x" ] && echo "输入有内容" || echo '输入为空'
输入为空


# "串 1" == " 串 2 "       使用定义变量的方式进行判断
cmd=$1
[ "$cmd" == "start" ] && echo start
# 测试
[root@clsn scripts]# cmd=start;[ "$cmd" == "start" ] && echo start
start

2.1.3 整数判断

整数二元比较操作符参考

在[]以及test中使用的比较符号	在(())和[[]]中使用的比较符号	说明
-eq	==或=	相等，全拼为equal
-ne	！=	不相等，全拼为not equal
-gt	>	大于，全拼为greater than
-ge	>=	大于等于，全拼为greater equal
-lt	<	小于，全拼为less than
-le	<=	小于等于，全拼为less equal

示例：

# 判断两数是否相等
[root@clsn scripts]# [ 1 -eq 1 ]
[root@clsn scripts]# echo $?
0
[root@clsn scripts]# [ 1 -eq 2 ]
[root@clsn scripts]# echo $?
1


# 大于等于
[root@clsn ~]# [ 11 -ge 1 ] && echo "成立" || echo "不成立"
成立


# 小于
[root@clsn ~]# [ 11 -lt 1 ] && echo "成立" || echo "不成立"
不成立


# 大于
[root@clsn ~]# [ 11 -gt 1 ] && echo "成立" || echo "不成立"
成立


# 不等于
[root@clsn ~]# [ 11 -ne 1 ] && echo "成立" || echo "不成立"
成立

2.1.4 逻辑符号

常用逻辑操作符

在[]和test中使用的操作符	说明	在[[]]和中使用的操作符	说明
-a	[ 条件A -a 条件B ] A与B都要成立，整个表达式才成立	&&	and，与，两端都为真，则结果为真
-o	[ 条件A -o 条件B] A与B都不成立，整个表达式才不成立	\|\|	or，或，两端有一个为真，则结果为真
！		!	not，非，两端相反，则结果为真

# 逻辑操作符与整数判断配合
[root@clsn ~]# [ 11 -ne 1 ] && echo "成立" || echo "不成立"
成立


# 取反
[root@clsn ~]# [ ! 11 -ne 1 ] && echo "成立" || echo "不成立"
不成立


# 两边都为真
[root@clsn ~]# [  11 -ne 1 -a 1 -eq 1 ] && echo "成立" || echo "不成立"
成立


# 至少有一边为真
[root@clsn ~]# [  11 -ne 1 -o 1 -eq 1 ] && echo "成立" || echo "不成立"
成立

感叹号的特殊用法：使用历史命令,感叹号加上history中的序号,即可执行

[root@clsn ~]#  !516
 ls
anaconda-ks.cfg  bootime.avg  setup.sh  vim

2.1.5 【练习题】开发3个shell脚本比较2个整数大小

要求：

分别以定义变量，脚本传参以及read读入的方式写3个脚本。
用条件表达式（禁止if语句）进行判断。
将2个整数的比较结果输出到屏幕，出错需要提示。

使用定义变量方法

root@clsn panduan1]# cat panduan1.sh 
#!/bin/bash
#

NUM1=6
NUM2=2

expr 1 + $NUM1  &>/dev/null
[ $? -eq 2 ] && echo "$NUM1 不是整数 " &&  exit 2
expr 1 + $NUM2 &>/dev/null
[ $? -eq 2 ] && echo "$NUM2 不是整数 " &&  exit 2

[ "$NUM1" -eq "$NUM2" ] && echo $NUM1 = $NUM2  && exit
[ "$NUM1" -gt "$NUM2" ] && echo $NUM1 \> $NUM2 && exit
[ "$NUM1" -lt "$NUM2" ] && echo $NUM1 \< $NUM2

使用传参方法

[root@clsn panduan1]# cat panduan_chuanchan.sh 
#!/bin/bash
#
[ $# -ne 2 ] && echo "UASGE $0 num1 num2 " && exit

NUM1=$1
NUM2=$2

expr 1 + $NUM1  &>/dev/null
[ $? -eq 2 ] && echo "$NUM1 不是整数 " &&  exit 2
expr 1 + $NUM2  &>/dev/null
[ $? -eq 2 ] && echo "$NUM2 不是整数 " &&  exit 2

[ "$NUM1" -eq "$NUM2" ] && echo $NUM1 = $NUM2  && exit
[ "$NUM1" -gt "$NUM2" ] && echo $NUM1 \> $NUM2 && exit
[ "$NUM1" -lt "$NUM2" ] && echo $NUM1 \< $NUM2

使用read读入

[root@clsn panduan1]# cat panduan_read.sh 
#!/bin/bash
#
read -p "请输入第一个整数：" NUM1
read -p "请输入第二个整数：" NUM2

expr 1 + $NUM1  &>/dev/null
[ $? -eq 2 ] && echo "$NUM1 不是整数 " &&  exit 2
expr 1 + $NUM2  &>/dev/null 
[ $? -eq 2 ] && echo "$NUM2 不是整数 " &&  exit 2

[ "$NUM1" -eq "$NUM2" ] && echo "$NUM1 = $NUM2"  && exit
[ "$NUM1" -gt "$NUM2" ] && echo "$NUM1 > $NUM2" && exit
echo "$NUM1 < $NUM2"

2.2 if条件语句

　　# 条件表达式和if语句可以互相转换

2.2.1 三种语法

# 单分支语句
if [ -f /etc/hosts ]
then
    echo '文件存在'
fi


# 双分支语句
if [ -f /etc/hosts ]  
then
    echo "文件存在"
else
    echo "文件不存在"
    echo "..." >>/tmp/test.log
fi


# 多分支语句
if [ -f /etc/hosts ]  
then
    echo " hosts文件存在"
elif [ -f /etc/host ]
then
    echo " host文件存在"
fi

2.2.2 if条件语句小结

单分支：一个条件一个结果
双分支：一个条件两个结果
多分支：多个条件多个结果

2.2.3 【练习题1】输入2个数字，比较大小（使用if语句结合条件表达式实现）

说明:3个脚本：使用直接赋值，传参，read任一种方法写3种脚本（单分支，双分支，多分支）

示例脚本一：

[root@clsn panduan1]# cat if_panduan_1.sh 
#!/bin/bash
#

read -p "请输入第一个整数：" NUM1
expr 1 + $NUM1  &>/dev/null
    if [ $? -eq 2 ] 
    then
        echo "$NUM1 不是整数 "
        exit 2
    fi

read -p "请输入第二个整数：" NUM2
expr 1 + $NUM2  &>/dev/null 
    if [ $? -eq 2 ] 
      then 
         echo "$NUM2 不是整数 " 
         exit 2
    fi

# 判断输入数值大小 
    if [ $NUM1 -eq $NUM2 ]
      then
        echo "$NUM1 = $NUM2"
        exit
    fi
  
    if [ $NUM1 -gt $NUM2 ] 
      then 
        echo "$NUM1 > $NUM2" 
        exit
    fi
   
    if [ $NUM1 -lt $NUM2 ]
      then
        echo "$NUM1 < $NUM2"
    fi

示例脚本二：

[root@clsn panduan1]# cat if_panduan_2.sh 
#!/bin/bash
#

read -p "请输入第一个整数：" NUM1
expr 1 + $NUM1  &>/dev/null
if [ $? -eq 2 ] 
then
    echo "$NUM1 不是整数 "
    exit 2
fi

read -p "请输入第二个整数：" NUM2
expr 1 + $NUM2  &>/dev/null 
if [ $? -eq 2 ] 
then 
    echo "$NUM2 不是整数 " 
     exit 2
fi
 
# 判断输入数值大小 
if [ $NUM1 -eq $NUM2 ]
then
    echo "$NUM1 = $NUM2"
    exit
else
    if [ $NUM1 -gt $NUM2 ]
    then
        echo "$NUM1 > $NUM2" 
        exit
    else
        if [ $NUM1 -lt $NUM2 ]  
        then
             echo "$NUM1 < $NUM2"
        fi
    fi
fi

示例脚本三：

[root@clsn panduan1]# cat if_panduan_3.sh 
#!/bin/bash
#
read -p "请输入第一个整数：" NUM1
expr 1 + $NUM1  &>/dev/null
NUM1_FH=$?   
if [ $NUM1_FH -eq 2 ] 
then
     echo "$NUM1 不是整数 "
     exit 2
else  
     read -p "请输入第二个整数：" NUM2
     expr 1 + $NUM2  &>/dev/null 
     NUM2_FH=$?
     if [ $NUM2_FH -eq 2 ] 
     then 
         echo "$NUM2 不是整数 " 
         exit 2
     fi
fi

# 判断输入数值大小 
if [ $NUM1 -eq $NUM2 ]
then
    echo "$NUM1 = $NUM2"
    exit 
elif [ $NUM1 -gt $NUM2 ]
then
    echo "$NUM1 > $NUM2" 
         exit
elif [ $NUM1 -lt $NUM2 ]
then
        echo "$NUM1 < $NUM2"
fi

1.2.4 【练习题2】系统内存低于100M邮件报警,加入计划任务，3分钟检查一次。

对于开发程序而言，一般来说应该遵循下面的3步法则。

（1）分析需求
明白开发需求，是完成程序的大前提，因此，分析需求至关重要，一切不以需求为主的程序开发，都是耍流氓的！

（2）设计思路
设计思路就是根据需求，把需求进行拆解，分模块逐步实现，例如本题可以分为如下几步：
  1）获取当前系统剩余内存的值（先在命令行实现）。
  2）配置邮件报警（可采用第三方邮件服务器）。
  3）判断取到的值是否小于100MB，如果小于100MB，就报警（采用if语句）。
  4）编码实现Shell脚本。
  5）加入crond定时任务，每三分钟检查一次。

（3）编码实现
编码实现就是具体的编码及调试过程，工作中很可能需要先在测试环境下调试，调试好了，再发布到生产环境中。

第一步先配置邮件服务,保证能够发生邮件

echo 'set from=mail@znix.top smtp=smtp.znix.top smtp-auth-user=mail@znix.top  smtp-auth-password=****** smtp-auth=login' >> /etc/mail.rc

发送测试邮件发送

echo "`date +%F_%T`" |mail -s "这是测试邮件" admin@znix.top

第二步编写检查脚本

[root@clsn scripts]# cat mem_info.sh 
#!/bin/bash
#
Mem=`free -m |awk 'NR==2{print $NF}'`
host=`hostname`
Ip=`hostname -I`
Date=`date +%F_%T`
mail_file=/tmp/mail.s
dest_user=admin@znix.top

if [ $Mem -lt 100 ]
then
    echo "发生时间: $Date" >$mail_file
    echo "发生主机: $host  主机IP地址: $Ip " >> $mail_file
    echo "内存余量: $Mem M" >> $mail_file
    mail -s "【警告】内存不足了呀！"  $dest_user < $mail_file
fi

第三步测试脚本(可以修改判断的值)

[root@clsn scripts]# sh mem_info.sh

第四步脚本测试成功,写入定时任务

[root@clsn panduan1]# crontab -l 
# 检查内存剩余大小
*/3 * * * * /bin/sh /server/scripts/panduan/mem_info.sh  &>/dev/null

至此,一个监控脚本就写好了

2.2.5 【练习题3】模拟编写启动nginx脚本

脚本内容

[root@clsn scripts]# cat nginx.sh 
#!/bin/bash
#
. /etc/init.d/functions  

StartCheck=`netstat -lntup  |grep -c 80`
StartCMD='/application/nginx/sbin/nginx '
StopCMD='/application/nginx/sbin/nginx -s stop '
StatusCheck=`netstat -lntp|grep -c nginx`
ReloadCMD='/application/nginx/sbin/nginx -s reload'
CheckCMD='/application/nginx/sbin/nginx  -t'
UsaGe="Usage: $0 {start|stop|status|reload|check}"

COMMAND=$1

if [  $# -ne 1 ]
    then
    echo $UsaGe  && exit 2
fi 

if [ $COMMAND = start ]
    then
    if [ $StartCheck  == 1  ]
    then
        action  "启动Nginx失败,端口被占用"  /bin/false
    else
        $StartCMD
        action  "启动Nginx"  /bin/true
    fi
elif [ $COMMAND = stop ]
then
    $StopCMD  &>/dev/null
    if [ $? -eq 0 ] 
    then
        action   "停止Nginx"   /bin/true 
    else
        action   "停止Nginx"   /bin/false
    fi
elif [ $COMMAND = status ]
then
    if [ $StatusCheck -eq 1 ]
    then
        echo "nginx 正在运行..."
    else
        echo "Nginx 未运行."
    fi
elif [ $COMMAND = reload ]  
then
    $ReloadCMD
    action  "reload" /bin/true
elif [ $COMMAND = check ]
then 
    $CheckCMD
else 
    echo $UsaGe
exit 2
fi

脚本执行过程：

2.2.6 【练习题5】Web及MySQL服务异常监测案例

用if条件语句实现对Nginx Web服务以及MySQL数据库服务是否正常进行检测，如果服务未启动，则启动相应服务。

脚本编写思路：

判断web服务器正常

进程 ps -ef |grep [n]ginx
端口 netstat ss losf telnet nc nmap
curl 页面返回值
curl check.html 的内容

判断mysql服务器正常

端口 netstat ss losf telnet nc nmap
进程 ps -ef |grep [m]ysql
mysql 登录访问看一下
mysql insert一个数据 select一个数据

web服务监控脚本示例

[root@clsn scripts]# cat  web_check.sh 
#!/bin/bash
#
. /etc/init.d/functions

JinChen=`ps -ef |grep -c  [n]ginx`
QiDong='/server/scripts/nginx.sh start'
StatuS=`curl -I -w "%{http_code}\n" -o /dev/null -s   10.0.0.180`
StatuS2=`curl -s 10.0.0.180/check.html|grep -c ok`
StartNginx='/server/scripts/nginx.sh start'

if [ $JinChen -ge 2  ]
then 
    if [ "$StatuS" -eq 200 ]
    then
        if [ "$StatuS2" -eq 1 ]
        then
            action "Nginx 服务运行正常" /bin/true
        else
            action "请检查chenk.html文件！" /bin/false
        fi
    else
        action "请检查首页文件！" /bin/false
    fi
else
    action "Nginx 未正常运行！" /bin/false
    $StartNginx    
fi

脚本执行过程：

2.3 case条件结构语句

2.3.1 case语法结构

case "字符串变量" in 
  值1)
     指令1
     ;;
  值2)
     指令2
     ;;
  值*)
     指令
esac

2.3.2 case与if的对比

# case书写方式
case $name in
  值1) 
      指令1
      ;;
  值2) 
      指令2
      ;;
   *) 
      指令
esac


# if书写方式
if [ $name == "值1" ]
  then 
    指令1
elif [ $name == "值2" ]
  then 
    指令2
else
    指令    
fi

2.3.3 case值的书写方式

apple)
      echo -e "$RED_COLOR apple $RES"
      ;;


# 也可以这样写，输入2种格式找同一个选项
apple|APPLE)
      echo -e "$RED_COLOR apple $RES"
      ;;

2.3.4 case语句小结

case语句就相当于多分支的if语句。case语句的优势是更规范、易读。
case语句适合变量的值少，且为固定的数字或字符串集合。(1,2,3)或(start,stop,restart)。
系统服务启动脚本传参的判断多用case语句，多参考rpcbind/nfs/crond脚本；菜单脚本也可以使用case

2.3.5 【练习题1】使用case编写一个菜单脚本

脚本内容

[root@clsn case]# cat menu.sh 
#!/bin/bash
#

cat<<EOF
1. install rsync
2. install nfs
3. install mysql
4. install all
EOF

read -p '请输入你的选择：' chs

case $chs in
   1)
    echo install rsync success
    ;;
   2)
    echo install nfs success
    ;;
   3)
    echo install mysql success
    ;;
   4)
    echo install rsync/nfs/mysql success
    ;;
   *)
    echo "你输入有误"
esac

脚本执行过程：

2.3.6 写脚本规范及注意事项

变量名称不能和系统已经存在的命令等重复 free == > Free
判断单位要统一
脚本一行不超过一屏的一半。
能写成变量的内容尽量写成变量

2.4 练习题

2.4.1 【练习题1】监控Memcached缓存服务是否正常

　　监控Memcached缓存服务是否正常，模拟用户（web客户端）检测。

　　使用nc命令加上set/get来模拟检测。

脚本内容：

[root@clsn scripts]# vim  memcache_check.sh 
#!/bin/bash
#
. /etc/init.d/functions
. /etc/init.d/run  # 函数 jingdutiao 使用
MemPort=`netstat -lntp  |grep -c  0.0.0.0:11211`
Set_Key='printf "set clsn2017 0 10 8\r\nclsn2018\r\n"|nc 10.0.0.180 11211'
Get_Key='printf "get clsn2017\r\n" |nc 10.0.0.180 11211 |grep -c clsn2018'
ReStart='systemctl restart memcached.service'

if [ $MemPort -eq 1 ]
  then
    $Set_Key
    $Get_Key
    if [ $? -ne 1 ]
      then
      action "Memcached 运行正常！" /bin/true
    else
      action "Memcached 服务异常！"  /bin/false
    fi
else
    action "服务未启动！" /bin/false
    $ReStart
    jingdutiao
fi

脚本执行过程

2.4.2 【练习题2】使用（case）编写rsync管理脚本

写网络服务独立进程模式下Rsync的系统启动脚本，例如：/etc/init.d/rsyncd {start|stop|restart}要求：

要使用系统函数库技巧。

要用函数，不能一坨💩的方式。

在centos 6中可被chkconfig管理。

注意：服务的停止操作和启动操作之间要有间隔时间，使用sleep 1

pkill 进程
 sleep 1
start 服务

rsync服务启动脚本

[root@clsn scripts]# cat rsyncd 
#!/bin/bash
#

. /etc/init.d/functions
. /etc/init.d/run 

Rsync_Port=`netstat -lntup |grep -c  0.0.0.0:873`
Rsync_COM1='rsync --daemon'
Rsync_COM2='pkill rsync'

Rsync_Start() {
   Rsync_Port1=`netstat -lntup |grep -c  0.0.0.0:873`
   if [ $Rsync_Port1 -ne 0 ]
     then
      action  "服务已启动" /bin/false
      exit 3
   else
      $Rsync_COM1
      #action  "Rsync 启动" /bin/true
      QiDong
   fi
}

Rsync_Stop() {
   Rsync_Port2=`netstat -lntup |grep -c  0.0.0.0:873`
   if [ $Rsync_Port2 -eq 0 ]
     then
       action  "服务未启动" /bin/false
       exit 3
   else
       $Rsync_COM2 
       #action  "Rsync 停止" /bin/true
       TingZhi
   fi
}

Rsync_Status() {
   if [ $Rsync_Port -eq 1 ]
     then
       echo  "Rsync 服务运行中..." 
   else
       echo  "Rsync 服务未运行" 
   fi
}

Rsync_Restart() {
   Rsync_Stop 
   Rsync_Start
}
COMMAND=$1

case "$COMMAND" in
  start)
    Rsync_Start
    ;;
  stop)
    Rsync_Stop
    ;;
  status)
    Rsync_Status
    ;;
  restart|reload|force-reload)
    Rsync_Restart
    ;;
  *)
    echo $"Usage: $0 {start|stop|status|restart|reload|force-reload}"
    exit 2
esac

脚本执行过程

2.4.4 if 与 case 对比

　　if 语句类似黑名单，需要把这种错误场景封堵

　　case 语句类似白名单，只要把正确结果列完整即可

2.5 其他补充说明

2.5.1 linux中产生随机数的方法

[root@clsn scripts]# echo $RANDOM
29291
[root@clsn scripts]# echo $RANDOM
5560
[root@clsn scripts]# echo $RANDOM
2904

2.5.2 echo 命令输出带颜色字符

# 彩色字体

echo -e "\033[40;37m 黑底白字 clsn \033[0m"
echo -e "\033[41;37m 红底白字 clsn \033[0m"
echo -e "\033[42;37m 绿底白字 clsn \033[0m"
echo -e "\033[43;37m 黄底白字 clsn \033[0m"
echo -e "\033[44;37m 蓝底白字 clsn \033[0m"
echo -e "\033[45;37m 紫底白字 clsn \033[0m"
echo -e "\033[46;37m 天蓝白字 clsn \033[0m

效果示意图

# 彩色底纹

echo -e "\033[40;37m 黑底白字 clsn \033[0m"
echo -e "\033[41;37m 红底白字 clsn \033[0m"
echo -e "\033[42;37m 绿底白字 clsn \033[0m"
echo -e "\033[43;37m 黄底白字 clsn \033[0m"
echo -e "\033[44;37m 蓝底白字 clsn \033[0m"
echo -e "\033[45;37m 紫底白字 clsn \033[0m"
echo -e "\033[46;37m 天蓝白字 clsn \033[0m

效果示意图

# 特效字体

\033[0m 关闭所有属性
\033[1m 设置高亮度
\033[4m 下划线
\033[5m 闪烁
\033[7m 反显
\033[8m 消隐
\033[30m — \033[37m 设置前景色
\033[40m — \033[47m 设置背景色
\033[nA 光标上移 n 行
\033[nB 光标下移 n 行
\033[nC 光标右移 n 行
\033[nD 光标左移 n 行
\033[y;xH 设置光标位置
\033[2J 清屏
\033[K 清除从光标到行尾的内容
\033[s 保存光标位置
\033[u 恢复光标位置
\033[?25l 隐藏光标
\033[?25h 显示光标

部分效果示意图

2.5.3 显示文本中的隐藏字符

使用cat命令查看文本中的隐藏字符

[root@clsn ~]# cat --help
用法：cat [选项]... [文件]...
将[文件]或标准输入组合输出到标准输出。

  -A, --show-all           等于-vET
  -b, --number-nonblank    对非空输出行编号
  -e                       等于-vE
  -E, --show-ends          在每行结束处显示"$"
  -n, --number             对输出的所有行编号
  -s, --squeeze-blank      不输出多行空行
  -t                       与-vT 等价
  -T, --show-tabs          将跳格字符显示为^I
  -u                       (被忽略)
  -v, --show-nonprinting   使用^ 和M- 引用，除了LFD和 TAB 之外

使用cat -A查看隐藏的字符

[root@clsn ~]# cat -A /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4$
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6$
10.0.0.1 mirrors.aliyuncs.com mirrors.aliyun.com$
10.0.0.180 clsn$

关于隐藏字符常见错误

在windows中编写的脚本换行使用的是 \r\n, 但是在linux中使用\n 进行换行

[root@clsn ~]# cat -A windowe.sh 
n1=2^M$
n2=1^M$
^M$
[ $n1 -gt $n2 ] && echo "$n1 > $n2" && exit^M$
[ $n1 -eq $n2 ] && echo "$n1 = $n2" && exit^M$
echo "$n1 < $n2"^M$

使用dos2unix 把windows上的脚本转化linux格式

[root@clsn ~]# dos2unix windowe.sh 
dos2unix: converting file windowe.sh to Unix format ...

转换后，脚本的内容隐藏内容改变。

[root@clsn ~]# cat -A windowe.sh 
n1=2$
n2=1$
$
[ $n1 -gt $n2 ] && echo "$n1 > $n2" && exit$
[ $n1 -eq $n2 ] && echo "$n1 = $n2" && exit$
echo "$n1 < $n2"$

排错技巧

sh -x  脚本.sh
 -x 开启脚本调试模式

cat -A  文件.txt
-A  查看文件的隐藏字符

:命令的说明

[root@clsn scripts]# help :
:: :
    空的命令。
    
    没有效果； 此命令不做任何操作。
    
    退出状态：
    总是成功。

：命令的应用场景

if 条件
  then 
    :
else
    命令
fi

2.5.6 其他补充

类进度条效果

yum install -y pv
echo {1..20}|pv -qL 15

1.1 for循环语句

在计算机科学中，for循环（英语：for loop）是一种编程语言的迭代陈述，能够让程式码反复的执行。

它跟其他的循环，如while循环，最大的不同，是它拥有一个循环计数器，或是循环变数。这使得for循环能够知道在迭代过程中的执行顺序。

1.1.1 shell中的for循环

shell中的for 循环与在c中不同，它包含三种形式：第一种结构是列表for 循环;第二种结构就是不带列表的for循环；第三种就类似于C语言。

# 列表for循环(常用)
#！/bin/bash
for i in 取值列表
do
    循环主体/命令
done
 

# 不带列表for循环(示例)
#!/bin/absh
for i 
     do   
     echo "$i" 
done 

# 脚本执行结果
[root@clsn for]# sh  for2.sh http://blog.znix.top
http://blog.znix.top
 

 
# 类似C语言的风格（这种用法常在C语语言中使用）
for((exp1;exp2;exp3))
    do
      指令...
done

# 编写类似C语言风格脚本
for((i=0;i<=3;i++))
    do
      echo $i
done

1.1.2 不同语言的For循环

# Shell中的两种样式
# 样式一：
for i in 1 2 3 
  do 
    echo $i
done
# 样式二：
for i in 1 2 3;do  echo $i;done
　　JAVA

for(int i = 0; i < 5; i++){
    //循环语句;
}


# PHP
for ($i = 0; $i < 5; $i++) {
  # statements;
}


# VB
For i = 1 To 5
===PASCAL===
for not i=1 do
begin
   i=0;
   writeln('Go on!');
end.
   
  '循环语句
Next i


# swift
var x = 0
for i in 1...100{
    x += i
}
print(x)

//5050
for _ in 1...100{
    x += 1
}
print(x)
// 100

var box = [1,2,3,4,5]
for i in box{
    print(i)
}
/*
1 
2 
3 
4 
5
*/
---

1.2 for循环相关练习题

1.2.1 【练习题1】批量生成随机字符文件名案例

使用for循环在/clsn目录下批量创建10个html文件，其中每个文件需要包含10个随机小写字母加固定字符串clsn，名称示例如下：

apquvdpqbk_clsn.html mpyogpsmwj_clsn.html txynzwofgg_clsn.html bmqiwhfpgv_clsn.html udrzobsprf_clsn.html vjxmlflawa_clsn.html jhjdcjnjxc_clsn.html qeztkkmewn_clsn.html jpvirsnjld_clsn.html ruscyxwxai_clsn.html

脚本内容

[root@clsn for]# cat make_file.sh 
#!/bin/bash
#

[ -d /clsn ] || mkdir -p /clsn
rpm -qa |grep pwgen &>/dev/null
if [ $? -eq  1 ] 
  then 
    yum install pwgen -y &>/dev/null
fi

cd /clsn &&\
for i in {1..10}
  do
   #File_Name=`uuidgen |tr "0-9-" "a-z"|cut -c 1-10`
   File_Name2=`pwgen -1A0 10`
   touch ${File_Name2}_clsn.html
done

1.2.2 【练习题2】批量改名特殊案例

【练习题1】中结果文件名中的clsn字符串全部改成znix(最好用for循环实现),并且将扩展名html全部改成大写。

jpvirsnjld_clsn.html ===> jpvirsnjld_znix.HTML

脚本内容：

[root@clsn for2]# cat rename_file.sh 
#!/bin/bash
#

cd /clsn &&\
File_name=`ls |sed -r 's#(.*)_clsn.html#\1#g'`

for i in $File_name
do
  if [ -f ${i}_clsn.html ] 
     then
     mv ${i}_clsn.html ${i}_znix.HTML
   else
     echo "文件修改完成."
     exit
   fi
done

批量改名其他方式　　

# rename 方式(最方便，专业改名)
rename txt jpg *

# 非 for 循环方式批量改名(使用sed命令进行拼接，然后交给bash执行)
ls *jpg|sed -r 's#(.*).jpg#mv &  \1.mp4#'|bash

1.3 while循环语句

在编程语言中，while循环（英语：while loop）是一种控制流程的陈述。利用一个返回结果为布林值（Boolean）的表达式作为循环条件，当这个表达式的返回值为“真”（true）时，则反复执行循环体内的程式码；若表达式的返回值为“假”（false），则不再执行循环体内的代码，继续执行循环体下面的代码。

因为while循环在区块内代码被执行之前，先检查陈述是否成立，因此这种控制流程通常被称为是一种前测试循环（pre-test loop）。相对而言do while循环，是在循环区块执行结束之后，再去检查陈述是否成立，被称为是后测试循环。

1.3.1 shell中while语法

while 条件
  do
    命令
done

1.3.2 while 使用场景，多用于创建守护进程

【示例1】:while实现web服务器搭建

[root@clsn scripts]# vim web_view.sh 
#!/bin/bash
#
while true
  do
  echo "ok" | nc -l 81
done

# 客户端进行访问测试
[root@clsn html]# curl 10.0.0.180:81
ok

# 服务端显示结果：
[root@clsn scripts]# sh  web_view.sh
GET / HTTP/1.1
User-Agent: curl/7.29.0
Host: 10.0.0.180:81
Accept: */*

【示例2】:while创建定时任务

# 脚本内容:
#!/bin/bash
while  true
  do
    uptime
       sleep 0.6
done


# 脚本执行结果
[root@clsn while]# sh  while1.sh 
 15:01:52 up 2 days,  6:02,  3 users,  load average: 0.00, 0.01, 0.05
 15:01:53 up 2 days,  6:02,  3 users,  load average: 0.00, 0.01, 0.05
 15:01:53 up 2 days,  6:02,  3 users,  load average: 0.00, 0.01, 0.05
 15:01:54 up 2 days,  6:02,  3 users,  load average: 0.00, 0.01, 0.05
 15:01:55 up 2 days,  6:02,  3 users,  load average: 0.00, 0.01, 0.05
 15:01:55 up 2 days,  6:02,  3 users,  load average: 0.00, 0.01, 0.05

说明：

sleep 单位秒 sleep 1 休息1秒

usleep 单位微秒 usleep 1000000 休息1s

1微秒等于百万分之一秒（10的负6次方秒）

1.3.3 while 作用

补充定时任务功能，执行小于1秒的定时任务

循环执行某些操作，

示例2：计算1-100的和

方法一 (bc命令实现)

echo `seq -s + 1 100`|bc

方法二(while循环方法)

[root@clsn while]# cat jishan.sh 
#!/bin/bash
#

i=1

while [ "$i" -le 100 ]
  do
  ((b=b+i))
  ((i++))
done
echo $b

示例3：实现类似手机通讯计费功能

[root@clsn scripts]# cat while/shouji.sh 
#!/bin/bash
#
sum=1000
i=15


while [ $sum -ge 15 ]
  do
cat<<EOF
=================
1.发短信
2.查余额
3.账户充值
4.退出
=================
EOF
    read -p "你要做什么呢？" Some
    case "$Some" in
      1)
        sum=$((sum-i))
        read -p  "请输入发送短信的内容："
        read -p  "请输入收信人："
        sleep 0.3
        echo "发送成功."
        echo "您当前余额为$sum"
        ;;
      2)
        echo "您当前余额为$sum"
        ;;
      3)
        read -p "请输入你要充值的金额：" ChongZhi
        sum=$((sum+ChongZhi))
        echo "充值成功，当前余额为$sum"
        ;;
      4)
        exit
        ;;
      *)
        echo "输入有误！"
        exit 2
    esac
done

echo "余额不足，请及时充值！"

1.4 获取取文件中的行，单词和字符

1.4.1 迭代获取文件中的每一行

# 方法一
while read line;
  do 
    echo $line;
done < file.txt


# 方法二
cat file.txt|while read line
  do
echo $line
done


# 方法三
exec < file.txt
while read line;
  do
    echo line;
done

1.4.2 迭代获取每一个单词

for word in $line;
  do
    echo $word;
done

1.4.3 迭代获取每一个字符

word=participate
for ((i=0;i<${#word};i++))
  do
    echo  ${word:1:1};
done

1.4.4 同时获取取文件中的行，单词和字符脚本

#!/bin/bash
n=1
while read i
  do
   echo "第${n}行 $i"
   m=1
   for x in $i
     do
       echo "第${m}个单词 $x"
       echo $x|grep -o . 
       ((m++))
   done
   ((n++))
done < $1

1.4.5 eval 命令用法

[root@clsn ~]# clsn=6

[root@clsn ~]# echo {1..$clsn}

{1..6}

[root@clsn ~]# eval echo {1..$clsn}

1 2 3 4 5 6

eval 命令的说明

eval: eval [参数 ...]
    将参数作为 shell 命令执行。
    
    将 ARGs 合成一个字符串，用结果作为 shell 的输入，
    并且执行得到的命令。
    
    退出状态：
    以命令的状态退出，或者在命令为空的情况下返回成功。
1.5 break continue exit return

1.5 break continue exit return

条件与循环控制及程序返回值命令表

命令	说明
break n	如果省略n，则表示跳出整个循环，n表示跳出循环的层数
continue n	如果省略n，则表示跳过本次循环，忽略本次循环的剩余代码，进人循环的下一次循环。 n表示退到第n层继续循环
exit n	退出当前Shell程序，n为上一次程序执行的状态返回值。n也可以省略，在下一个Shell里可通过"$?"接收exit n的n值
return n	用于在函数里作为函数的返回值，以判断函数执行是否正确。在下一个Shell里可通过"$?"接收exit n的n值

简单来说即：

break 跳出循环
continue 跳出本次循环
exit 退出脚本
return 与 exit 相同，在函数中使用

1.5.1 break命令说明

break: break [n]
    退出 for、while、或 until 循环
    退出一个 FOR、WHILE 或 UNTIL 循环。如果指定了N，则打破N重
    循环
    退出状态：
    退出状态为0除非 N 不大于或等于 1。

1.5.2 continue命令说明

continue: continue [n]
    继续 for、while、或 until 循环。
    
    继续当前 FOR、WHILE 或 UNTIL 循环的下一步。
    如果指定了 N， 则继续当前的第 N 重循环。
    
    退出状态：
    退出状态为 0 除非 N 不大于或等于1。

1.5.3 exit命令说明

exit: exit [n]
    退出shell。
    
    以状态 N 退出 shell。  如果 N 被省略，则退出状态
    为最后一个执行的命令的退出状态。

1.5.4 return命令说明

return: return [n]
    从一个 shell 函数返回。
    
    使一个函数或者被引用的脚本以指定的返回值 N 退出。
    如果 N 被省略，则返回状态就是
    函数或脚本中的最后一个执行的命令的状态。
    
    退出状态：
    返回 N，或者如果 shell 不在执行一个函数或引用脚本时，失败。

1.6 shell中的数组

1.6.1 为什么会产生Shell数组

通常在开发Shell脚本时，定义变量采用的形式为“a=l;b=2;C=3”，可如果有多个变量呢？这时再逐个地定义就会很费劲，并且要是有多个不确定的变量内容，也会难以进行变量定义，此外，快速读取不同变量的值也是一件很痛苦的事情，于是数组就诞生了，它就是为了解决上述问题而出现的。

1.6.2 什么是Shell数组

Shell的数组就是一个元素集合，它把有限个元素（变量或字符内容）用一个名字来命名，然后用编号对它们进行区分。这个名字就称为数组名，用于区分不同内容的编号就称为数组下标。组成数组的各个元素（变量）称为数组的元素，有时也称为下标变量。

1.6.3 数组中的增删改查

数组的定义

# 定义数组
[root@clsn scripts]# stu=(001 002 003)
# 打印数组
[root@clsn scripts]# echo ${stu[@]}
001 002 003
# 显示数组长度
[root@clsn scripts]# echo ${#stu}
3

查: 遍历数组的内容

# 打印数组内容（通过数组下标或索引）
[root@clsn scripts]# echo ${stu[0]}
001
[root@clsn scripts]# echo ${stu[1]}
002
[root@clsn scripts]# echo ${stu[2]}
003
[root@clsn scripts]# echo ${stu[3]}

# 遍历数组
# 方法一
[root@clsn scripts]# for i in ${stu[@]};do echo $i ;done 
001
002
003
# 方法二
[root@clsn scripts]# array=(1 2 3)
[root@clsn scripts]# for i in `eval echo {1..${#array[@]}}`;do echo ${array[i-1]};done
1
2
3

增：数组添加

[root@clsn scripts]# stu[3]=004
[root@clsn scripts]# echo ${stu[@]}
001 002 003 004

改：数组修改

[root@clsn scripts]# stu[2]=000
[root@clsn scripts]# echo ${stu[@]}
001 002 000 004

删：数组删除

[root@clsn scripts]# unset stu[2]
[root@clsn scripts]# echo ${#stu[@]}
3
[root@clsn scripts]# echo ${stu[@]}
001 002 004

1.6.4 将命令的结果赋值给数组

dir=(`ls`)
dir=($(ls))

命令定义数组

[root@clsn scripts]# COM=(`ls`)
[root@clsn scripts]# echo ${COM[@]}
bianliang.sh case cfb.sh

1.6.1 数组定义格式

[root@clsn scripts]# a=(1 2 3 )
[root@clsn scripts]# b=(1 2 3 4 )
[root@clsn scripts]# echo ${a[@]}
1 2 3
[root@clsn scripts]# echo ${b[@]}
1 2 3 4

1.6.2 数组的本质就是一个变量，只是这个变量存了多个值

${array[@]} 所有元素
${#array[@]}  数组长度
${array[i]}  单个元素，i是下标

1.6.3 【练习题】批量检查多个网站地址是否正常

要求：

使用shell数组方法实现，检测策略尽量模拟用户访问。
每10秒钟做一次所有的检测，无法访问的输出报警。
待检测的地址如下
http://www.cnblogs.com/clsn/
http://blog.znix.top
http://blog.nmtui.com
http://10.0.0.7

脚本内容：

[root@clsn scripts]# cat check_url.sh 
#!/bin/bash
#
url=(
http://www.cnblogs.com/clsn/
http://blog.znix.top
http://blog.nmtui.com
http://10.0.0.7
)
while true 
  do
    for i in ${url[@]} 
      do 
      #curl $i &>/dev/null
      a=$(curl -I -w "%{http_code}\n" -o /dev/null -s $i)
      if [ $a -ne 200 ]
        then
          echo "$url 异常"
      fi
    done
    sleep 10
done

1.7 Shell 函数

　　shell一个非常重要的特性是它可作为一种编程语言来使用。因为shell是一个解释器，所以它不能对为它编写的程序进行编译，而是在每次从磁盘加载这些程序时对它们进行解释。而程序的加载和解释都是非常耗时的。

　　针对此问题，许多shell（如BourneAgainShell）都包含shell函数，shell把这些函数放在内存中，这样每次需要执行它们时就不必再从磁盘读入。shell还以一种内部格式来存放这些函数，这样就不必耗费大量的时间来解释它们。

函数的作用就是把程序里多次调用相同代码的部分定义成一份，然后起个名字，所有的调用都只用这名字就可以了，修改代码时，只需要改变函数体内的代码即可。

1.7.1 使用函数的优势

　　🐟 把相同的程序段定义成函数，可以减少代码量。

　　🐟 增加程序的可读、易读性

　　🐟 实现程序功能的模块化

1.7.2 定义函数

function clsn(){
    echo "http://blog.znix.top"
}


znix(){
    echo "http://www.znix.top "
}

说明：

　　1、可以带function clsn() 定义，也可以直接clsn() 定义,不带任何参数。

　　2、参数返回，可以显示加：return 返回，如果不加，将以最后一条命令运行结果，作为返回值。 return后跟数值n(0-255)

　　3、执行函数就是将函数名放到定义的函数之后即可

将函数加载到当前窗口执行：

[root@clsn function]# . fun1.sh
[root@clsn function]# zn
znew  znix 
[root@clsn function]# znix
test
[root@clsn function]# clsn
http://blog.znix.top

1.7.3 引用函数

脚本内容


[root@clsn function]# cat  fun2.sh
#!/bin/bash
#
Fun_File=/server/scripts/function/fun1.sh
[ -f $Fun_File ] && . $Fun_File
clsn

脚本执行结果

[root@clsn function]# sh  fun2.sh
http://blog.znix.top

1.7.4 函数传参

脚本内容：

[root@clsn function]# cat fun3.sh 
#!/bin/bash
#

function clsn(){
    echo "Hi "
}
CLSN(){
    echo "Hello "
    echo  $0
    echo  $1
    echo  $2

}
clsn
CLSN xi  xi

脚本执行结果

[root@clsn function]# sh fun3.sh 
Hi 
Hello 
fun3.sh
xi
xi

1.7.5 $0 永远的脚本名称

function clsn(){
    echo "http://blog.znix.top $1 $2"
    echo $0
}

znix(){
    echo "test" 
}
clsn $1 $2

执行结果

[root@clsn function]# sh  fun1.sh 
http://blog.znix.top  
fun1.sh

1.7.6 函数中return的用法

脚本内容：

[root@clsn function]# cat  fun3.sh 
#!/bin/bash
#

function clsn(){
    echo "Hi "
}
CLSN(){
    echo "Hello "
    echo  $0
    echo  $1
    echo  $2
    return 4
    echo "xxixiixxiix"

}
clsn
CLSN xi  xi 
echo $?

脚本执行结果

[root@clsn function]# sh fun3.sh
Hi 
Hello 
fun3.sh
xi
xi
4

return命令说明：

return: return [n]
    从一个 shell 函数返回。
    
    使一个函数或者被引用的脚本以指定的返回值 N 退出。
    如果 N 被省略，则返回状态就是
    函数或脚本中的最后一个执行的命令的状态。
    
    退出状态：
    返回 N，或者如果 shell 不在执行一个函数或引用脚本时，失败。

1.7.7 自定义常用函数库

#!/bin/bash
#

# 脚本初始化
function scripts_init(){
  prog=`basename $0 .sh`
  LockFile=/var/lock/subsys/${prog}.lock  # 使用锁文件
  LogFile=/var/log/${prog}.log  # 脚本记录日志
  PidFile=/var/run/${prog}.pid  # 记录进程号，可以管理脚本

  [ -f $LockFile ] && echo "There $LockFile is exist!!" && exit 1 ||touch $LockFile
  [ ! -f $LogFile ] && touch $LogFile
  [ -f $PidFile ] && echo "There $PidFile is exist!!" && exit 2|| echo $$ > $PidFile
}

# 记录日志
function writelog(){
  Date=$(date "+%F_%T")
  ShellName=`basename $0`
  Info=$1
  echo "$Date : ${ShellName} : ${Info}" >> ${LogFile}
}

# 脚本退出扫尾
function closeout(){
  [ -f $LockFile ] && rm -f $LockFile 
   [ -f $PidFile ]&& rm -f $PidFile
}

# 判断输入是整数
function int_judge(){
  fun_a=$1
  expr $fun_a + 1 &>/dev/null
  RETVAL=$?
  return $RETVAL
}

# 判断输入非空
function input_judge(){
  RETVAL=0
  fun_a=$1
  [ ${#fun_a} -eq 0 ]&& RETVAL=1
  return $RETVAL
}

basename命令

取出文件名称

[root@clsn function]# basename /server/scripts/zhuajiu.sh 
zhuajiu.sh
[root@clsn function]# basename /server/scripts/zhuajiu.sh  .sh 
zhuajiu

$$ 参数

取出脚本运行时的pid, 脚本运行的当前进程ID号

[root@clsn function]# echo $$
37208
[root@clsn function]# ps -ef |grep 37208
root      37208  37206  0 08:39 pts/0    00:00:00 -bash
root      38578  37208  1 10:33 pts/0    00:00:00 ps -ef
root      38579  37208  0 10:33 pts/0    00:00:00 grep --color=auto 37208

引用自定义函数库示例：

[root@clsn function]# head -22  fun3.sh 
#!/bin/bash
#

. /server/scripts/userfun.sh

scripts_init 
i=1
while ((i<=10))
  do 
   uptime
   ((i++))
   sleep 1
done
closeout

1.8 shell脚本的调试

1.8.1 脚本调试技巧　　

调试技巧1：使用dos2unix处理脚本
从windows编辑的脚本到Linux下需要使用这个命令
dos2unix windows.sh


调试技巧2：使用echo命令调试
在变量读取或修改的前后加入echo $变量，也可在后面使用exit退出脚本，这样可以不用注释后面的代码


调试技巧3：sh -x 脚本  ==》全局调试
sh -x  scripts.sh


调试技巧4：局部调试
set -x
要调试的脚本内容
set +x

1.8.2 Shell调试技巧小结　　

　　①要记得首先用dos2unix对脚本格式化。
　　②直接执行脚本根据报错来调试，有时报错不准确。
　　③sh -x调试整个脚本，显示执行过程。
　　④set -x和set +x调试部分脚本（在脚本中设置）
　　⑤echo输出变量及相关内容，然后紧跟着exit退出，不执行后面程序的方式，一步步跟踪脚本，对于逻辑错误比较好用。
　　　　   写法： echo $var;exit 
　　⑥最关键的是语法熟练、编码习惯、编程思想，将错误扼杀在萌芽之中，减轻调试负担，提高效率。

奔跑的大西吉

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Shell 编程

1.1 前言1.1.1为什么学ShellShell脚本语言是实现Linux/UNIX系统管理及自动化运维所必备的重要工具，Linux/UNIX系统的底层及基础应用软件的核心大都涉及Shell脚本的内容。每一个合格的Linux系统管理员或运维工程师，都需要能够熟练地编写Shell脚本语言，并能够阅读系统及各类软件附带的Shell脚本内容。只有这样才能提升运维人员的工作效率，适应曰益复杂...
复制链接

扫一扫

专栏目录