shell脚本

shell脚本

一.shell脚本基础

1.三种处理逻辑

三种处理逻辑

顺序执行：程序按从上到下顺序执行

选择执行：程序执行过程中，根据条件的不同，进行选择不同分支继续执行

循环执行：程序执行过程中需要重复执行多次某段语句

2.linux中常见的shell

bash:基于gun的框架下发展的shell

csh:类似c语言的shell

tcsh:整合了csh提供了更多功能

sh:已经被bash替换

nologin:让用户无法登录

bash （/bin/bash）是目前大多数Linux 版本采用的默认shel

shell脚本的作用

将简单的命令组合完成复杂的工作,自动化执行命令,提高工作效率

减少手工命令的重复输入，一定程度上避免人为错误

将软件或应用的安装及配置实现标准化

用于实现日常性的,重复性的运维工作,如:文件打包压缩备份,监控系统运行状态并实现告警等

3.什么是shell脚本

就是将命令按顺序一一列出，最后自动执行

执行需要权限，也可以直接使用绝对路径

脚本其实不复杂，通用脚本环境改变后依然可以使用的脚本

shell脚本的构成：

脚本申明：第一行开头的#！/bin/bash 表示此行以下的代码语句通过bash运行

注释：以#开头的语句表示注释

可执行语句：命令

[root@localhost opt]#vim hw.sh
#!/bin/bash
cd /boot
echo "当前的目录位于:"
pwd
~                                                                                                                          
~                                                                                                                          
~   
[root@localhost opt]#bash hw.sh 
当前的目录位于:
/boot

执行方式：

指定解释器执行（无须权限），相当于新开一个bash环境，执行完自动结束

路径执行：需要执行权限

source 和 . 不推荐，会影响当前bash环境

脚本可以补全 ：
做软连接
修改 path 路径
都需要 执行权限

4.脚本错误调试

bash -n 脚本名称 （不在当前目录下加绝对路径） 检查语法错误
bash -x 脚本名称 （不在当前目录下加绝对路径） 逻辑错误

1.命令错误

不影响接下来命令的执行

2.语法错误

会影响接下来命令的执行

3.逻辑错误

只能自己优化，排查

5.重定向和管道符

重定向

类型	设备文件	文件描述编号	默认设备
标准输入	/dev/stdin	0	键盘
标准输出	/dev/stdout	1	显示器
标准错误输出	/dev/stderr	2	显示器

• 标准输入：从该设备接收用户输入的数据
• 标准输出：通过该设备向用户输出数据
• 标准错误：通过该设备报告执行出错信息

重定向的意思就是 ，不通过标准输出到屏幕上，输出到你指定的位置

类型	操作符	用途
重定向输入	<	从指定的文件读取数据，而不是从键盘输入
重定向输出	1>	将输出结果保存到指定的文件（覆盖原有内容）
>>	将输出结果追加到指定的文件尾部
标准错误输出	2>	将错误信息保存到指定的文件（覆盖原有内容）
2>>	标准错误输出结果追加到指定的文件尾部
混合输出	&>无论对错都可以重定向	将标准输出、标准错误的内容保存到同一个文件中

管道符：略

6.变量

自定义变量：由用户自己定义，修改和使用

区分大小写

不能使程序中的保留字和内置变量：如：if, for，hostname 命令 a=

只能使用数字、字母及下划线，且不能以数字开头，注意：不支持短横线 “ - ”，和主机名相反

不要使用内置的变量，使用英文尽量使用词义通俗易懂，PATH

大驼峰 StudentFirstName

小驼峰 studentFirstName

下划线 student_name

name='value'
变量名=变量值
直接字串：name='root'
变量引用：name="$USER"
命令引用：name=`COMMAND` 或者 name=$(COMMAND)
注意：变量赋值是临时生效，当退出终端后，变量会自动删除，无法持久保存，脚本中的变量会随着脚本结束，也会自动删除

变量引用：
$name
${name}

弱引用和强引用
"$name " 弱引用，其中的变量引用会被替换为变量值
'$name ' 强引用，其中的变量引用不会被替换为变量值，而保持原字符串

赋值时使用双引号(" ")可以直接调用变量

赋值时使用单引号(’ ')$只会被认为是字符$ 不会调用变量

赋值时使用(``反撇在tab上面）命令替换，提取命令执行后的输出结 果 和$( ) 用法相同

{}可以分隔变量值

变量追加值：

格式

变量名+=追加值

read  -p

从键盘输入的内容变成变量

[root@localhost opt]# read -p "现在的时间是" time
现在的时间是9点  

[root@localhost opt]# vim 1.sh
#!/bin/bash
echo -n "请输入你的信息"
read info
echo $info

变量作用范围：

默认情况下，新定义的变量只在当前的shell环境中有效，因此称为局部变量，当进入子程序或新的shell环境中，局部变量将无法再起作用。

可以通过内部命令export将指定的变量为全局变量，使用户定义的变量在所子shell环境中可以继续使用

位置变量：通过命令行给脚本传递参数

$1 … $n 注意 10 以上的位置变量 ${10}

echo "$1"            位置1
echo "$2"            位置2
echo "${10}"         位置10
echo "$10"           位置1和0
echo "$*"            将所有项当成一个值
echo "$@"            所有项
echo "$0"            脚本自身
echo "$#"            后面参数的个数

执行脚本时后面跟着的参数一次代表$1.....

预定义变量：Bash中内置的一类变量，不能修改

系统帮你定义好了 拿来用就可以了，你不需要知道为什么，记住

• $*：表示所有位置参数的内容看成一个整体返回 返回所有
• $@：表示所有位置参数的内容分割成n份，每份作为一个独立的个体返回 返回所有
• $?：表示前一条命令执行后的返回状态，返回值为 0 表示执行正确，返回任何非 0值均表示执行出现异常
• $#：表示命令行中位置参数的总个数
• $0：表示当前执行的脚本或程序的名称 当前脚本的名字
• $$：当前进程id
• $!: 后台任务最后一个id

只读变量：只可以读取不可以更改

变量值不允许修改（重新赋值）的情况

无法使用 unset删除

环境变量：由系统维护，用于设置工作环境

1. 由系统提前创建，用来设置用户的工作环境
2. 可以使用env查看环境变量
3. 需要记住的常用环境变量

[root@localhost ~]#env
//可以看到所有

$USER 表示用户名称

$HOME 表示用户的宿主目录

$LANG 表示语言和字符集

$PWD 表示当前所在工作目录

$PATH 表示可执行用户程序的默认路径

• 可以使子进程（包括孙子进程）继承父进程的变量，但是无法让父进程使用子进程的变量
• 一旦子进程修改从父进程继承的变量，将会新的值传递给孙子进程
• 一般只在系统配置文件中使用，在脚本中较少使用

配置文件位置在

/etc/profile如果修改此文件会作用于所有用户

~/.bash_profile 用户独立的配置文件，修改这个文件只作用于当前用户

可以用来长期变更或设置环境变量

7.整数的运算

expr只能进行整数的运算

格式： expr 变量1 运算符 变量2 [运算符 变量3]

运算符：

加法 +

减法 -

乘法 \ *

除法 /

取余 （取模）%

(1) let var=算术表达式
let sum=1+2
sum=1+2
(2) $((var=算术表达式)) 和上面等价
((sum=1+2))
echo $sum
(3) var= $[算术表达式]
(4) var=$((算术表达式))
(5) var=$(expr arg1 arg2 arg3 ...)
(6) var= `expr arg1 arg2 arg3 ...`
(7) echo '算术表达式' | bc



seq -s+ 10   //表示从1到10以+号分隔全部显示

随机数生成器变量：

$RANDOM   取值范围：0-32767

[root@localhost ~]#man bash




$[RANDOM%33+1]
[root@localhost ~]# echo $[RANDOM%34+1]
9
[root@localhost ~]#echo -e "\E[1;30mhello\E[0m"
#颜色
[root@localhost ~]# echo -e "\E[1;$[RANDOM%7+31]mhello\E[0m"
#随机颜色
[root@localhost ~]#echo $(expr $RANDOM % 33 + 1)
#注意运算符附近都要有空格

二.条件语句

1.测试

test 测试条件表达式是否成立

格式1：test  条件表达式
格式2：[  条件表达式  ]
注意[]空格，否则会失败
测试 是否成功使用 $?  返回值
[ 操作符 文件或目录 ]
help test

操作符：
-d：测试是否为目录（Directory）
-e：测试目录或文件是否存在（Exist）
-a：测试目录或文件是否存在（Exist）
-f：测试是否为文件（File）
-r：测试当前用户是否有权限读取（Read）
-w：测试当前用户是否有权限写入（Write）
-x：测试当前用户是否有权限执行（eXcute）
-L: 测试是否为软连接文件

属性测试补充：
-s FILE #是否存在且非空
-t fd #fd 文件描述符是否在某终端已经打开
-N FILE #文件自从上一次被读取之后是否被修改过
-O FILE #当前有效用户是否为文件属主
-G FILE #当前有效用户是否为文件属组

条件测试：判断某需求是否满足，需要由测试机制来实现，专用的测试表达式需要由测试命令辅助完成

测试过程，实现评估布尔声明，以便用在条件性环境下进行执行

若真，则状态码变量 $? 返回0

若假，则状态码变量 $? 返回1

[root@localhost opt]#test -d /data/logs/
[root@localhost opt]#echo $?
0
[root@localhost opt]#test -f /data/logs/
[root@localhost opt]#echo $?
1
[root@localhost opt]#test -r /etc/shadow
[root@localhost opt]#echo $?
0
[root@localhost opt]#ll /etc/shadow
----------. 1 root root 1239 8月   8 14:48 /etc/shadow
//实际效果，不是表面显示，注意root权限
//root执行权限别人没有root也没有，别人有root也有
[root@localhost opt]#[ ! -e /etc/shadow ]
[root@localhost opt]#echo $?
1
[root@localhost opt]#[ ! -a /etc/shadow ]
[root@localhost opt]#echo $?
0
//-e与-a的区别，建议使用-e

2.比较整数数值

[ num1 操作符 num2]

-eq：第一个数等于（Equal）第二个数

-ne：第一个数不等于（Not Equal）第二个数

-gt：第一个数大于（Greater Than）第二个数

-lt：第一个数小于（Lesser Than）第二个数

-le：第一个数小于或等于（Lesser or Equal）第二个数

-ge：第一个数大于或等于（Greater or Equal）第二个数

3.字符串比较

=：字符串内容相同

!=：字符串内容不同，! 号表示相反的意思

-z：字符串内容为空

-n: 字符是否存在

格式：

[ 字符串1 = 字符串2 ] 是否相同

[ 字符串1 != 字符串2 ] 是否不相同

[ -z 字符串 ] 是否为空

[ -n 字符串 ] 字符是否存在

[root@localhost opt]#str1=aaa
[root@localhost opt]#str2=bbb
[root@localhost opt]#[ str1 = str2 ]
[root@localhost opt]#echo $?
1
[root@localhost opt]#[ $USER = root ]
[root@localhost opt]#echo $?
0

4.逻辑测试

-a或&&：逻辑与，“而且”的意思全真才为真

-o或||：逻辑或，“或者”的意思一真即为真

!：逻辑否

格式1：[ 表达式1 ] 操作符 [ 表达式2 ] …
格式2：命令1 操作符 命令2 …

cmd1 && cmd2  .....
//&&需要同时满足两边的要求，才会返回正确
//全真才为真，有一个假就返回假
//第一个为真时才会执行第二个，得到最终结果，否则只执行到错误的那一个，后面的不执行


[root@localhost opt]#[ 1 = 2 ]&&echo true
[root@localhost opt]#echo $?
1
[root@localhost opt]#[ 1 != 2 ]&&echo true
true

cmd1 || cmd2 ........
//||只要有一个满足要求，就返回正确
//一真即为真
//只要执行结果为真，就直接返回此结果，不执行后续
//当前执行为假，执行后续，全部为假才返回假

[root@localhost opt]#[ 1 = 2 ]||echo true
true
[root@localhost opt]#[ 1 = 2 ]||echo true||echo false
true
[root@localhost opt]#[ 1 = 2 ]||[ 2 = 3 ]
[root@localhost opt]#echo $?
1

5.双中括号

[[ 表达式 ]]

== 左侧字符串是否和右侧的PATTERN相同
注意:此表达式用于[[ ]]中，PATTERN为通配符
=~ 左侧字符串是否能够被右侧的正则表达式的PATTERN所匹配
注意: 此表达式用于[[ ]]中；扩展的正则表达式

[root@localhost ~]#FILE=test.txt
[root@localhost ~]#[[ "$FILE" == *.txt ]]
[root@localhost ~]#echo $?
0
[root@localhost ~]#FILE=test.zip
[root@localhost ~]#[[ "$FILE" =~ ^zip]]
[root@localhost ~]#echo $?
1
[root@localhost ~]#[[ "$FILE" != *.log ]]
[root@localhost ~]#echo $?
0

6.（）{}

（CMD1;CMD2;…）和 {空格CMD1;CMD2;…; } 都可以将多个命令组合在一起，批量执行

[root@localhost ~]#( cd /data;ls )
test.log
[root@localhost ~]#pwd
/root
[root@localhost ~]#{ cd /data;ls; }
test.log
[root@localhost data]#pwd
/data

（）会开启子shell
{}不会开始子shell

[root@localhost data]#name=aaa
[root@localhost data]#( name=bbb;echo $name );echo $name
bbb
aaa
[root@localhost data]#name=aaa
[root@localhost data]#{ name=bbb;echo $name; };echo $name
bbb
bbb

7.if语句

分支结构

单分支

if 判断条件;

then   条件为真的分支代码

fi

双分支

if 判断条件; then
 条件为真的分支代码

else
 条件为假的分支代码

fi



#!/bin/bash
use=`df -h|tr -s ' '|cut -d ' ' -f5|tail -n +2|tr -d %|sort -rn|head -n 1`


if [ $use -gt 1 ]
then
echo "磁盘快满了"|mail -s test [email protected]
else
echo “磁盘正常”

fi


检查磁盘使用量，邮件报警功能

多分支

if 判断条件1
then
 条件1为真的分支代码

elif 判断条件2
then
 条件2为真的分支代码

elif 判断条件3;then
 条件3为真的分支代码

...
else
 以上条件都为假的分支代码

fi


#!/bin/bash
read -p "输入你的成绩(0-100)"  num

if [ $num -ge 85 -a $num -le 100 ]
then
echo "6666"
elif [ $num -ge 70 -a $num -le 84 ]
then
echo "海星"
elif [ $num -ge 0 -a $num -le 69 ]
then
echo "remake"
else
echo "输入错误"
bash $0
fi

8.case

case支持glob风格的通配符：

• 任意长度任意字符
  ? 任意单个字符
  [0-9] 指定范围内的任意单个字符
  | 或者，如: a|b

格式：
case WORD in [PATTERN [| PATTERN]...) COMMANDS ;;]... esac

case 变量引用 in
PAT1)
 分支1
 ;;
PAT2)
 分支2
 ;;
...
*)
 默认分支
 ;;
 esac
 
 
 
 read -p "请输入你的分数" score

case $score in
100)
echo "$score 66666"
;;
[89][0-9])
echo "$score 海星"
;;
[67][0-9])
echo "$score 一般"
;;
[0-9]|[1-5][0-9])
echo "$score remake"
;;
*)
echo "输入有误"
esac
 
 
 

9.echo

echo命令

echo -n   表示不换行输出
echo -e   表示输出转义符
常用的转义符

选项	作用
\r	光标移至行首，并且不换行
\s	当前shell的名称，如bash
\t	插入Tab键，制表符
\n	输出换行
\f	换行，但光标仍停留在原处
\	表示插入"\"本身转义
\b	表示退格 不显示前一个字符
\c	抑制更多的输出或不换行

echo -e "n\n\n\n\n\nw"|fdisk /dev/sdb
//自动硬盘分区

[root@yyds opt]#echo -e "12345\b678"
1234678
//退格删除前面的字符
[root@yyds opt]#echo -e "12345\b\b678"
123678
[root@yyds opt]#echo -e "12345\b\b\b\b678"
16785
//注意退格键和末尾的字符相关

[root@yyds opt]#echo -e "1234\c5678"
1234[root@yyds opt]#
//包括换行符都被删除

date

date查看当前系统时间

-d 你描述的日期，显示指定字符串所描述的时间，而非当前时间

%F 完整日期格式，等价于 %Y-%m-%d

% T 时间（24小时制）（hh:mm:ss）

三.循环语句

循环含义

将某代码段重复运行多次，通常有进入循环的条件和退出循环的条件

重复运行次数

• 循环次数事先已知
• 循环次数事先未知

1.for

执行机制:遍历

执行机制：
依次将列表中的元素赋值给“变量名”; 每次赋值后即执行一次循环体; 直到列表中的元素耗尽，循环结束如果省略 [in WORDS ... ] ，此时使用位置参数变量 in "$@"

for 已知循环次数

for  tlj（变量）   循环次数（取值列表）

do
需要循环的事件

done

格式2：
for (( 表达式1; 表达式2; 表达式3 )); do 命令; done

for ((expr1;expr2;expr3))
do
       command
done

expr1：定义变量并赋初值
expr2：决定是否循环
expr3：决定循环变量如何改变，决定循环什么时候退出

for i in {1..10}
> do
> echo $i
> done
1
2
3
4
5
6
7
8
9
10


#!/bin/bash
for ((a=1;a<=9;a++))
do
for ((i=1;i<=$a;i++))
do
echo -e "${a}*${i}=$[i*a]\t\c"
done
echo
done
//九九乘法表

for ((i=0;i<=10;i++))
do
sum=$[i+sum]
done
echo $sum
//1--10累加

//打印正方形
#!/bin/bash
for j in {1..9}
do
for i  in {1..9}
do
echo -e " * \c"
#\c换行
done
echo
#换行
done

2.while和until

我们只知道停止条件，不知道次数，就需要使用while

while
当命令判断为假时停止

until
当命令判断为真时停止

//偶数求和
i=0
sum=0
while [ $i -le 100 ]
do
let sum+=$i
let i+=2
done
echo $sum

//对比for
for ((i=0,sum=0;i<=100;i++))
do
let sum+=$i
done
echo $sum

//累加求和
i=0
sum=0
while [ $i -le 100 ]
do
let sum+=$i
let i++
done
echo $sum

//对比while
i=0
sum=0
until [ $i -gt 100 ]
do
let sum+=$i
let i++
done
echo $sum

双重循环及跳出循环

Break：跳出整个循环

break 概述：跳出当前整个循环或结束当前循环，在 for、while 等循环语句中，用于跳出当前所在的循环体，执行循环体之后的语句，后面如果什么也不加，表示跳出当前循环等价于 break 1，也可以在后面加数字,假设 break3 表示跳出第三层循环.

Continue：跳过本次循环，进行下次循环

continue 概述：忽略本次循环剩余的代码，直接进行下一次循环；在 for、while 等循环语句中，用于跳出当前所在的循环体，执行循环体之后的语句，如果后面加的数字是 1，表示忽略本次条件循环，如果是 2 的话，忽略下来 2 次条件的循环.

cat case.sh

#!/bin/bash

for ((i=0;i<=4;i++)) ; do

echo $i

case $i in

1)

echo "This is one"

;;

2)

continue  //跳出本次循环

echo "This is two"

;;

3)

break  //跳出整个循环

echo "This is three"

;;

4)

echo "This is four"

;;

esac

done

[root@localhost ~]#sh case.sh

0

1

This is one

2

3

exit直接退出

3.菜单

[root@localhost data]#help select
select: select NAME [in 词语 ... ;] do 命令; done
    从列表中选取词并且执行命令。
    
    WORDS 变量被展开，生成一个词的列表。展开的词集合被打印
    在标准错误输出设备上，每个以一个数字做前缀。如果没有 `in WORDS'
    则假定使用`in "$@"'。PS3提示符会被显示并且从标准输入读入一行
    如果该行由被显示的词对应的数字组成，则 NAME 变量被设定为相应
    的词。如果行为空，则 WORDS 变量和提示符被重新显示。如果读取了
    文件结束符，则命令完成。读入任何其他的值会导致 NAME 变量被设定
    为空。读入的行被存放在变量 REPLY 中。COMMANDS 命令在每次选择
    之后执行直到执行一个 break 命令。
    
    退出状态：
    返回最后一个执行的命令的状态。


一定要使用$REPLY

PS1 提示符
PS2 多行重定向
PS3 菜单选择

示例：
[root@localhost ~]#select menu in 配置网卡 配置yum源;do echo $REPLY;done
1) 配置网卡
2) 配置yum源
#? 1
1
#? 2
2
#? ^C

[root@localhost ~]#select menu in 配置网卡 配置yum源;do echo $menu;done
1) 配置网卡
2) 配置yum源
#? 1
配置网卡
#? 2
配置yum源

四.函数

1.什么是函数

在编写脚本时，有些脚本可以反复使用，可以调用函数来解决

语句块定义成函数约等于别名

函数使用方法：

1. 定义函数
2. 再引用函数

基本格式

function 函数名{

​ 命令序列

}

函数名（）{

命令序列

}

function func_name （） {

…函数体…

}

注意事项

1. 直接写 函数中调用函数 直接写函数名
2. 同名函数 后一个生效
3. 调用函数一定要先定义
4. 只要先定义了调用的 其他函数定义顺序无关

func_name （）{
...函数体...
}

[root@yyds opt]#func1 (){ hostname;date;}
[root@yyds opt]#func1
yyds
2023年 08月 15日 星期二 18:19:33 CST

[root@yyds opt]#vim func.sh

h () {

echo "hello"

}
nihao () {
echo `h`  `w`

}

w () {
echo "world"
}

nihao
[root@yyds opt]#bash func.sh 
hello world

//同名函数会进行覆盖

2.查看函数

[root@yyds opt]#declare -F
declare -f __HOSTNAME
declare -f __SIZE
declare -f __SLAVEURL
declare -f __VOLNAME
declare -f __expand_tilde_by_ref
declare -f __get_cword_at_cursor_by_ref
declare -f __git_aliased_command
declare -f __git_aliases
..............
//函数列表，可以declare -f __HOSTNAME查看内容

3.删除函数

unset func_name

[root@yyds opt]#unset h w nihao

4.函数的返回值

return表示退出函数并返回一个退出值，脚本中可以用$?变量表示该值

使用原则：

函数一结束就去返回值，应为$?变量只返回执行的最后一条命令的退出返回码

退出码必须是0-255，超出的值将为除以256取余

test1 () {
        read -p "请输入一个数字：" num
        return $[$num*2]


}

test1
echo $?

[root@yyds opt]#bash return.sh 
请输入一个数字：34
68

5.函数的传参数

函数变量的作用范围：

函数在shell脚本中仅在当前的shell环境中有效

shell脚本中函数的变量默认全局有效

将变量限定在函数内部使用local命令

#!/bin/bash
sum1 (){
echo $1 
echo $2

}

sum1 $2 $1

[root@yyds opt]#bash chuan.sh 2 5
5
2

//sum1 后面的$2对应这sum1函数里面的$1

[root@localhost opt]# vim demo8.sh
#!/bin/bash
myfun(){
i=8
echo $i

}
myfun

[root@localhost opt]# chmod +x demo8.sh 
[root@localhost opt]# ./demo8.sh 
8
[root@localhost opt]# vim demo8.sh
#!/bin/bash
myfun(){
i=8
echo $i

}
myfun
echo $i
[root@localhost opt]# ./demo8.sh 
8
8
[root@localhost opt]# ./demo8.sh 
8
8
[root@localhost opt]# cat demo8.sh 
#!/bin/bash
myfun(){
i=8
echo $i

}
i=9
myfun

echo $i
[root@localhost opt]# ./demo8.sh 
8
8
[root@localhost opt]# cat demo8.sh 
#!/bin/bash
myfun(){
i=8
echo $i

}
myfun
i=9
echo $i

[root@localhost opt]# ./demo8.sh 
8
9

[root@localhost ~]#name=666
[root@localhost ~]#func1 () { name=99 ; echo $name; }
[root@localhost ~]#func1
99
[root@localhost ~]#echo $name 
99
[root@localhost ~]#name=666;func1 () { local name=99 ;echo $name; };echo $name
#加上local变量即可将变量限制在函数内
666

6.函数文件

建立存放函数的文件

可以建立一个文件用来存储函数，下次要使用函数时可以
. 文件名
函数名
进行使用

7.函数递归

函数调用自己本身的函数

阶乘
使用for循环
#!/bin/bash
sum=1
read -p "请输入一个数:" num
for i in `seq $num`
do
let sum=$[i*sum]
done
echo $sum

函数调用自己
#!/bin/bash
#
fact() {
if [ $1 -eq 0 -o $1 -eq 1 ] 
then
echo 1
else
echo $[$1*$(fact $[$1-1])]
 fi
}
fact $1


阶乘
fact() {
  if [ $1 -eq 1 ]
  then
    echo 1
  else
   local temp=$[$1 - 1]
   local result=$(fact $temp)
   echo $[$1 * $result]
  fi
}
read -p "请输入：" n
result=$(fact $n)
echo $result

五.数组

1.基础

定义数组格式：

1. 数组名=（value0 value1 value2 value3 …）

2. 数组名=（[0]=value [1]=value1 [2]=value2 …）

3. 列表名="value0 value1 value2 value3 … "

   数组名=（$列表名)

4. 数组名[0]=“value1”

   数组名[1]=“value2”

   数组名[2]=“value3”

数组的包括数据类型

• 数值型
• 字符型
• 混合型数值加字符

使用" "或’ '定义单引号或双引号括起来

[root@yyds opt]#a=(1 2 3 4 5)
[root@yyds opt]#echo $a
1
//不加下表默认第一个

[root@yyds opt]#echo ${!a[*]}
0 1 2 3 4
//查看下标

[root@yyds opt]#echo ${a[*]}
1 2 3 4 5
//列出所有数值，*和@作用一样

[root@yyds opt]#echo ${#a[@]}
5
//数组长度

[root@yyds opt]#echo ${a[@]:0:5}
1 2 3 4 5
[root@yyds opt]#echo ${a[@]:0:4}
1 2 3 4
[root@yyds opt]#echo ${a[@]:1:5}
2 3 4 5
//${ARRAY[@]:offset:number}
offset #要跳过的元素个数
number #要取出的元素个数
#取偏移量之后的所有元素 
{ARRAY[@]:offset}

2.冒泡排序

#!/bin/bash
a=(90 20 30 40 50)
l=${#a[@]}
for ((i=1;i<$l;i++))
do
        for ((j=0;j<$l-1;j++))
        do
        first=${a[$j]}
        k=$[$j+1]
        second=${a[$k]}

        if [ $first -lt $second ]
        then
        temp=$first
        a[$j]=$second
        a[$k]=$temp
        fi
        done
done

echo ${a[@]}

//降序排列


取出最大数   
#!/bin/bash
a=( 10 70 30 40 50 60 )
#定义一个数组
max=${a[0]}

for ((i=0;i<${#a[*]};i++))
do    
if [[ $max -lt ${a[$i+1]} ]]
then
max=${a[$i+1]}
fi
done
echo $max

六.免交互

1.多行重定向

使用I/O重定向的方式将命令列表提供给交互式程序

作为标准输入的一种替代品

语法格式

命令<<   标记

....

......

标记

注意事项

标记可以使用任意的合法字符（通用的字符是EOF）

结尾的标记一定要顶格写，前面不能有任何字符（包括空格）

结尾的标记后面也不能有任何字符（包括空格）

开头标记前后空格会被省略掉

[root@yyds tmp]#wc -l < line 1
> line 2
> EOF
2

//wc -l 统计行数
<

[root@yyds tmp]#read i < hi
> EOF
[root@yyds tmp]#echo $i
hi

//接受输入值然后输出

[root@yyds tmp]#passwd test1 < 123123
> 123123
> EOF

//使用 passwd命令设置密码
EOF 标记之间的两行是输入的密码和确认密码，两行内容必须保持一致，否则密 码设置不成功

cat <centos7.repo
//编写yum仓库的内容

2.expect

是建立在tcl（tool command language）语言基础上的一个工具，常被用于进行自动化控制和测试，解决shell脚本中交互的相关问题

yum install -y expect

格式

expect [选项] [ -c cmds ] [ [ -[f|b] ] cmdfile ] [ args ]

expect中相关命令

spawn 启动新的进程（监控，捕捉）

expect 从进程接收字符串

send 用于向进程发送字符串

exp_continue 匹配多个字符串在执行动作后加此命令

interact 允许用户交互

expect eof直接返回

#!/usr/bin/expect
spawn scp /etc/fstab 192.168.82.101:/mnt
expect {
  "yes/no" { send "yes\n";exp_continue }
  "password" { send "123123\n" }
}

expect eof 
//免交互传输文件

基本命令：

（1）脚本解释器

expect 脚本中首先引入文件，表明使用的事哪一种shell

#！/usr/bin/expect

（2）spawn

spawn 后面通常跟一个Linux执行命令，表示开启一个会话、进程，并跟踪后续交互信息

例： spawn passwd root

（3）expect

判断上次输出结果中是否包含指定的字符串，如果有则立即返回，否则就等待超时时间后返回；只能捕捉有swpan启动的进程输出；

用于接受命令执行后的输出，然后和期望的字符串匹配

（4）send

向进程发送字符串，用于模拟用户的输入：该命令不能自动回车换行，一般要加 \r (回车) 或者\ n

方式一：
expect "密码" {send "123123\r"}     //同一行send部分要有{}

方式二：
expect "密码"  
send "123123\r"                    //换行send部分不需要有{}


方式三：
expect 支持多个分支
expect          //只要匹配了其中一个情况，执行相应的send 语句后退出该expect 语句
只匹配一次
expect
{
{"密码1"  {send "abc123\r"}
{"密码2"  {send "123123\r"}
{"密码3"  {send "123456\r"}

}

(5) 结束符

expect eof

表示交互结束，等待执行结束，退回到原用户，与spawn对应

比如切换到root用户，expect 脚本默认的等待时间是10s，当执行王命令后，默认停留10s后，自动切回原用户.

interact

执行完成后保持交互状态, 把控制权交给控制台，会停留在目标终端而不是退回到原终端，这时候就可以手工操作了，interact后命令不再起作用，比如interact后添加exit，并不会退出root用户。而如果没有interact则登录完成后会退出，而不是留在远程终端上。

使用interact会保持在终端而不会退回原终端，比如切换到root用户，会一直在root用户状态下；比如ssh到另一台服务器，会一直在目标服务器终端而不会切回原服务器。

需要注意的是，expect eof 与 interact 只能二选一。

（6）set

expect 默认的超时时间是10秒，通过set 命令可以设置会话超时时间，若不限制超时时间则应设置为-1

例子： set time out 30

(7) exp_continue

exp_continue 表示允许 expect 继续向下执行指令.

exp_continue附加于某个expect 判断选项之后，可以是该项被匹配后还能继续匹配expect 判断语句内的其他项。exp_continue类似于控制语句的continue语句。表示允许expect继续向下执行命令。

例如：

expect

{

“(yes/no)” {send “yes\r”;exp_continue；}

“*password” {set timeout 300; send “abc123\r”}

}

**注意：**使用exp_continue时，如果跟踪像passwd这样输入密码后就结束进程的命令，expect {}外不要加上expect eof 因为spawn进程结束后悔默认向expect 发送eof，会导致后面的expect eof执行报错

（8）send_user

表示回显命令与echo相同

（9）接收参数（位置变量）

expect 脚本可以接受从bash命令行传递参数，使用 [lindex $argv n]获得。其中你从0开始，分别表示第一个，第二个，第三个…参数

set hostname [lindex $argv 0] 相当于hostname=$1

set password [lindex $argv 1] 相当于passswd=$2

远程拷贝
#!/usr/bin/expect
spawn scp /etc/redhat-release 网络地址:/data
expect {
        "yes/no" { send "yes\n";exp_continue }
        "password" { send  "magedu\n" }
}
expect eof
或者interact

//远程登录
#!/usr/bin/expect
spawn ssh 网络地址
expect {
        "yes/no" { send "yes\n";exp_continue }
        "password" { send  "magedu\n" }
}
interact

//变量
#!/usr/bin/expect
set ip 地址
set user root
set password magedu
set timeout 10
spawn ssh $user@$ip
expect {
        "yes/no" { send "yes\n";exp_continue }
        "password" { send "$password\n" }
}
interact

#!/usr/bin/expect

#设置超时时间
set timeout 5
#参数传入
set hostname  [lindex $argv 0]  
#表示位置变量hostname=$1
set password  [lindex $argv 1] 
#表示位置变量password=$2
#开始追踪命令
spawn su $hostname

expect "密码：" {send "$password\n"}
#免交互执行，捕捉信息并匹配
expect "*]#"
send_user "hello"
#把控制权交给控制台
interact
#expect eof

#!/bin/bash
hostname=$1
password=$2

/usr/bin/expect <

#!/bin/bash
net=192.168.91
net=192.168.91
password=123123
iplist="
101
102
"

for i  in $iplist
do
ip=$net.$i

/usr/bin/expect <