第一章 Linux高级命令和Shell编程
1. Linux高级命令
该章节的所有操作都在/export/data/shell目录进行，请提前创建该目录.
|
mkdir -p /export/data/shell/ |
1.1. 重定向命令
1、重定向>
Linux 允许将命令执行结果重定向到一个文件，本应显示在终端上的内容保存到指定文件中。如：ls >test.txt ( test.txt 如果不存在，则创建，存在则覆盖其内容 )。
案例：
将/目录下文件的详情保存到test.txt文件中
|
ll / > test.txt |
查看文件内容：cat test.txt
|
总用量 28 lrwxrwxrwx. 1 root root 7 3月 31 06:05 bin -> usr/bin dr-xr-xr-x. 5 root root 4096 3月 31 06:22 boot drwxr-xr-x. 3 root root 18 5月 12 09:15 data drwxr-xr-x. 20 root root 3320 5月 10 15:48 dev drwxr-xr-x. 132 root root 8192 5月 12 10:27 etc drwxr-xr-x. 3 root root 18 5月 7 20:25 export drwxr-xr-x. 3 root root 20 4月 9 10:16 home drwxr-xr-x. 2 root root 6 11月 5 2016 media drwxr-xr-x. 5 root root 41 4月 7 16:23 opt dr-xr-xr-x. 206 root root 0 5月 10 15:47 proc dr-xr-x---. 24 root root 4096 5月 12 15:43 root drwxr-xr-x. 38 root root 1180 5月 10 15:48 run lrwxrwxrwx. 1 root root 8 3月 31 06:05 sbin -> usr/sbin drwxr-xr-x. 2 root root 6 11月 5 2016 srv dr-xr-xr-x. 13 root root 0 5月 10 15:48 sys drwxrwxrwt. 25 root root 4096 5月 12 16:32 tmp drwxr-xr-x. 13 root root 155 3月 31 06:05 usr drwxr-xr-x. 20 root root 282 3月 31 06:22 var |
根据结果发现 命令的执行结果已经写入test.txt文件中了。
2、重定向>>
>>这个是将输出内容追加到目标文件中。如果文件不存在，就创建文件；如果文件存在,则将新的内容追加到那个文件的末尾，该文件中的原有内容不受影响。
案例:
现在有个文件1.txt，内容如下,现在将整个文件的内容追加到上一个案例的test.txt文件中
|
Hadoop HDFS MapReduce Zookeeper Hive HBase |
实现方式:
|
cat 1.txt >> test.txt |
查看test.txt内内容:cat test.txt
|
总用量 28 lrwxrwxrwx. 1 root root 7 3月 31 06:05 bin -> usr/bin dr-xr-xr-x. 5 root root 4096 3月 31 06:22 boot drwxr-xr-x. 3 root root 18 5月 12 09:15 data drwxr-xr-x. 20 root root 3320 5月 10 15:48 dev drwxr-xr-x. 132 root root 8192 5月 12 10:27 etc drwxr-xr-x. 3 root root 18 5月 7 20:25 export drwxr-xr-x. 3 root root 20 4月 9 10:16 home drwxr-xr-x. 2 root root 6 11月 5 2016 media drwxr-xr-x. 5 root root 41 4月 7 16:23 opt dr-xr-xr-x. 206 root root 0 5月 10 15:47 proc dr-xr-x---. 24 root root 4096 5月 12 15:43 root drwxr-xr-x. 38 root root 1180 5月 10 15:48 run drwxr-xr-x. 2 root root 6 11月 5 2016 srv dr-xr-xr-x. 13 root root 0 5月 10 15:48 sys drwxrwxrwt. 25 root root 4096 5月 12 16:32 tmp drwxr-xr-x. 13 root root 155 3月 31 06:05 usr drwxr-xr-x. 20 root root 282 3月 31 06:22 var drwxr-xr-x. 3 root root 17 4月 8 16:17 xxx doop HDFS MapReduce Zookeeper Hive HBase |
通过查看结果发现test.txt中已经有了1.txt文件的内容，实现了追加.
1.2. cut命令
cut：文件内容查看命令，cut命令可以从一个文本文件或者文本流中提取文本列。
cut命令参数解释
|
参数 |
解释 |
|
-b |
按字节选取 忽略多字节字符边界 |
|
-c |
仅显示行中指定范围的字符 |
|
-d |
自定义分隔符，默认为制表符 |
|
-f |
与-d一起使用，指定显示哪个区域。 |
|
-n |
与“-b”选项连用，不分割多字节字符； |
|
--complement |
补足被选择的字节、字符或字段； |
|
--out-delimiter=<字段分隔符> |
指定输出内容是的字段分割符； |
|
--help |
显示指令的帮助信息； |
|
--version |
显示指令的版本信息。 |
实例：
如有一个学生报表信息文件stu.txt，包含id、name、age、score.
|
id name age score 01 tom 18 78 02 jack 20 85 03 bill 16 90 04 mary 24 77 05 anna 21 85 |
1) 使用-d和-f显示文件中的指定的列
|
#显示id列 [root@node1 shell]# cut -d " " -f 1 stu.txt id 01 02 03 04 05
#显示name和age列 [root@node1 shell]# cut -d " " -f 2,3 stu.txt name age tom 18 jack 20 bill 16 mary 24 anna 21 |
解释:
-d “ ” ：用来指定文件字段之间的分隔符，如果文件的分隔符是制表符则不需要指定该参数
-f 数字 ：用来指定哪一列
2) --complement 选项提取指定字段之外的列（打印除了第二列之外的列）
|
[root@node1 shell]# cut -d " " -f 2 --complement stu.txt id age score 01 18 78 02 20 85 03 16 90 04 24 77 05 21 85 |
3) 指定字段的字符或者字节范围
cut命令可以将一串字符作为列来显示，字符字段的记法：
N-：从第N个字节、字符、字段到结尾；
N-M：从第N个字节、字符、字段到第M个（包括M在内）字节、字符、字段；
-M：从第1个字节、字符、字段到第M个（包括M在内）字节、字符、字段。
|
#打印第1个到第3个字符： [root@node1 shell]# cut -c 1-4 stu.txt id n 01 t 02 j 03 b 04 m 05 a
#打印前2个字符： [root@node1 shell]# cut -c -2 stu.txt id 01 02 03 04 05
#打印从第5个字符开始到结尾 [root@node1 shell]# cut -c 5- stu.txt ame age score om 18 78 ack 20 85 ill 16 90 ary 24 77 nna 21 85 |
1.3. wc命令
wc命令：统计行数 单词数 字节数
在默认的情况下，wc将计算指定文件的行数、字数以及字节数。
命令使用格式为：
wc 文件名
wc命令参数
|
参数 |
解释 |
|
-l |
统计行数 |
|
-c |
统计字节数 |
|
-w |
统计单词数 |
|
-m |
统计字符数 |
实例：
有个文件test_wc.txt,内容如下:
|
1 11 222 bbb 333 aaa bbb 444 aaa bbb ccc 555 aaa bbb ccc ddd 666 aaa bbb ccc ddd eee |
1) 统计指定文件行数、字数、字节数
|
[root@node1 shell]# wc test_wc.txt 6 21 85 test_wc.txt #01.txt文件: 行数为6, 单词数为21, 字节数为85 |
2) 查看根目录下有多少个文件
|
[root@node1 shell]# ls / | wc -w 24 |
1.4. awk命令
1.4.1. 简介
awk是一种处理文本文件的命令，是一个强大的文本分析工具，它支持分段,默认每行按空格或TAB分割。简单来说awk就是把文件逐行的读入，以空格为默认分隔符将每行切片，切开的部分再进行各种分析处理。
awk有3个不同版本: awk、nawk和gawk，未作特别说明，一般指gawk，gawk 是 AWK 的 GNU 版本。
awk其名称得自于它的创始人 Alfred Aho 、Peter Weinberger 和 Brian Kernighan 姓氏的首个字母。实际上 AWK 的确拥有自己的语言： AWK 程序设计语言 ， 三位创建者已将它正式定义为“样式扫描和处理语言”。它允许您创建简短的程序，这些程序读取输入文件、为数据排序、处理数据、对输入执行计算以及生成报表，还有无数其他的功能。
语法:
awk [选项参数] 'script' var=value file(s)
或
awk [选项参数] -f scriptfile var=value file(s)
选项参数说明：
-F 指定输入文件的分隔符
-v var=value or --asign var=value 赋值一个用户定义变量。
-f scripfile or --file scriptfile 从脚本文件中读取awk命令。
运行方式：
l 命令行方式
awk [-F field-separator] 'commands' input-file(s)
其中，commands 是真正awk命令，[-F域分隔符]是可选的。 input-file(s) 是待处理的文件。 在awk中，文件的每一行中，由域分隔符分开的每一项称为一个域。通常，在不指名-F域分隔符的情况下，默认的域分隔符是空格。
l 脚本方式
将所有的awk命令插入一个文件，并使awk程序可执行，然后awk命令解释器作为脚本的首行，通过键入脚本名称来调用。 相当于shell脚本首行的：#!/bin/sh 可以换成：#!/bin/awk。
变量分配:
默认情况下，awk 会将如下变量分配给它在文本行中发现的数据字段：
l $0 代表整个文本行；
l $1 代表文本行中的第 1 个数据字段；
l $2 代表文本行中的第 2 个数据字段；
l $n 代表文本行中的第 n 个数据字段。
print和printf
awk中同时提供了print和printf两种打印输出的函数。
其中print函数的参数可以是变量、数值或者字符串。字符串必须用双引号引用，参数用逗号分隔。如果没有逗号，参数就串联在一起而无法区分。这里，逗号的作用与输出文件的分隔符的作用是一样的，只是后者是空格而已。
printf函数，其用法和c语言中printf基本相似,可以格式化字符串,输出复杂时，printf更加好用，代码更易懂。
1.4.2. 入门案例
默认每行按空格或TAB分割，使用$n来获取段号
有个文件test_awk.txt,内容如下:
|
aa 111 333 bbb 444 555 ccc 666 777 888 ddd 999 222 999 |
l 案例1: 打印test_awk.txt第1段
|
awk '{print $1}' test_awk.txt |
l 案例2: 打印出test_awk.txt的第1,2,3段
|
awk '{print $1,$2,$3}' test_awk.txt |
l 案例3:打印出1.txt的第1,2,3段，并且使用#号连接
|
awk '{print $1"#"$2"#"$3}' test_awk.txt |
1.4.3. 段之间的连接符OFS
OFS用来指定输出记录分隔符
案例1::打印1,2,3段，指定#为连接符
|
awk '{OFS="#"}{print $1,$2,$3}' test_awk.txt |
1.4.4. 指定分隔符
-F 来指定分隔符
准备工作,现在有个文件test_awk2.txt，内容如下：
|
aaa:111:333 bbb:444:555 ccc:666:777:888 ddd:999:222:999:cccc |
l 案例1: 打印出test_awk2.txt的第1段
|
awk -F ':' '{print $1}' test_awk2.txt |
l 案例2: 打印出test_awk2.txt的所有段
|
awk -F ':' '{print $0}' test_awk2.txt |
l 案例3: 打印出test_awk2.txt的第1,3段
|
awk -F ':' '{print $1,$3}' test_awk2.txt |
1.4.5. 内容匹配
这里的内容匹配需要使用正则表达式,常用的正则表达式规则如下:
1、^linux 以linux开头的行
2、$php 以php结尾的行
3、. 匹配任意单字符
4、.+ 匹配任意多个字符
5、 .* 匹配0个或多个字符(可有可无)
6、 [0-9a-z] 匹配中括号内任意一个字符
7、 (linux)+ 出现多次Linux单词
8、 (web){2} web出现两次以上
9、\ 屏蔽转义
实例：
l 案例1: 匹配test_awk2.txt中包含cc的内容
|
awk '/cc/' test_awk2.txt |
l 案例2: 匹配test_awk2.txt中第1段包含cc的内容
|
awk -F ':' '$1 ~ /cc/' test_awk2.txt |
l 案例3: 匹配test_awk2.txt中第1段包含至少连续两个c的内容
|
awk -F ':' '$1 ~ /cc+/' test_awk2.txt |
l 案例4: 在test_awk2.txt中如果匹配到abc就打印第1,3段，如果匹配到ccc,就打印第1,3,4段
|
awk -F ':' '/aaa/ {print $1,$3} /ccc/ {print $1,$3,$4}' test_awk2.txt |
l 案例4: 在test_awk2.txt中如果匹配到aaa或者ddd,就打印全部内容
|
awk -F ':' '/aaa|ddd/ {print $0}' test_awk2.txt |
1.4.6. 段内容判断
在awk命令中，支持很多运算符,使用这些运算符可以进行段内容判断
|
运算符 |
解释 |
|
= += -= *= /= %= ^= **= |
赋值 |
|
?: |
C条件表达式 |
|
|| |
逻辑或 |
|
&& |
逻辑与 |
|
~ 和 !~ |
匹配正则表达式和不匹配正则表达式 |
|
< <= > >= != == |
关系运算符 |
|
空格 |
连接 |
|
+ - |
加，减 |
|
* / % |
乘，除与求余 |
|
+ - ! |
一元加，减和逻辑非 |
|
^ *** |
求幂 |
|
++ -- |
增加或减少，作为前缀或后缀 |
|
$ |
字段引用 |
|
in |
数组成员 |
l 案例1：在test_awk2.txt中如果第3段等于222就打印所有内容
|
awk -F ':' '$3==222 {print $0}' test_awk2.txt |
l 案例2：在test_awk2.txt中如果第3段等于333就打印第一段
|
awk -F ':' '$3==333 {print $1}' test_awk2.txt |
l 案例3：在test_awk2.txt中如果第3段大于等于300就打印第一段
|
awk -F ':' '$3==333 {print $1}' test_awk2.txt |
l 案例4：在test_awk2.txt中如果第5段不等于cccc就打印全部
|
awk -F ':' '$5!="cccc" {print $0}' test_awk2.txt |
l 案例5：在test_awk2.txt中如果第1段等于ccc，并且第2段大于300就打印全部
|
awk -F ':' '$1=="ccc" && $2>300 {print $0}' test_awk2.txt |
l 案例6：在test_awk2.txt中如果第1段等于ccc，并且第2段匹配666就打印全部
|
awk -F ':' '$1=="ccc" && $2==666 {print $0}' test_awk2.txt |
1.4.7. 段之间的比较
l 案例1：在test_awk2.txt中如果第3段小于第4段就打印全部
|
awk -F ':' '$3<$4 {print $0}' test_awk2.txt |
l 案例2：在test_awk2.txt中如果第2段等于第4段就打印全部
|
awk -F ':' '$2==$4 {print $0}' test_awk2.txt |
1.4.8. NR行号和NF段数
|
NF |
一条记录的字段的数目 |
|
NR |
已经读出的记录数，就是行号，从1开始 |
l 案例1：打印test_awk2.txt全部内容显示行号
|
awk -F ':' '{print NR " : " $0}' test_awk2.txt |
l 案例2：打印test_awk2.txt全部内容显示段数
|
awk -F ':' '{print NF " : " $0}' test_awk2.txt |
l 案例3：打印test_awk2.txt前2行，并显示行号 （用二种不同的方式实现）
nl命令在linux系统中用来计算文件中行号
|
nl test_awk2.txt | head -2 awk -F ':' 'NR<=2 {print NR " " $0}' test_awk2.txt |
l 案例4：打印test_awk2.txt前2行，并且第1段匹配 aaa或者eee，打印全部，打印行号 （用两种方式）
|
nl test_awk2.txt | head -2 | awk -F ':' '$1 ~ /aaa|eee/' 或者 awk -F ':' 'NR<=2 && $1 ~ /aaa|eee/ {print NR " " $0}' test_awk2.txt |
l 案例5: 从test_awk2.txt的前3行中匹配出第2段等于 666，并显示行号
|
awk -F ':' 'NR<=3 && $2==666 {print $0}' test_awk2.txt |
l 案例6: 从test_awk2.txt前3行，把第1段内容替换为itheima，指定分隔符为|，显示行号
|
awk -F ':' '{OFS="|"} NR<=3 && $1="itheima" {print NR " " $0}' test_awk2.txt |
1.4.9. 分段求和
awk 中还可以指定脚本命令的运行时机。默认情况下，awk 会从输入中读取一行文本，然后针对该行的数据执行程序脚本，但有时可能需要在处理数据前运行一些脚本命令，这就需要使用 BEGIN 关键字。BEGIN 会强制 awk 在读取数据前执行该关键字后指定的脚本命令。
l 案例1: 对test_awk2.txt中的第2段求和
|
awk -F ':' 'BEGING{}{total=total+$2}END{print total}' test_awk2.txt |
1.4.10. 综合案例
l 案例1: 对统计awk目录下所有文本文件的大小
|
ll | awk 'BEGIN{}{total=total+$5} END{print(total)}' |
l 案例2 :打印99乘法表
|
awk 'BEGIN{ for(i=1;i<=9;i++){ for(j=1;j<=i;j++){ printf("%dx%d=%d%s", i, j, i*j, "\t" ) } printf("\n") } }' |
l 案例3:求总成绩
awk的代码还可以放在一个脚本中，脚本的后缀是.awk，执行脚本的语法: awk -f 脚本名 源文件
需求:
有个文件score.txt，记录每个学生的成绩，要计算学生总成绩，文件内容如下:
|
Marry 2143 78 84 77 Jack 2321 66 78 45 Tom 2122 48 77 71 Mike 2537 87 97 95 Bob 2415 40 57 62 |
代码:
cal.awk
|
#!/bin/awk -f #运行前 BEGIN { math = 0 english = 0 computer = 0
printf "NAME NO. MATH ENGLISH COMPUTER TOTAL\n" printf "---------------------------------------------\n" } #运行中 { math+=$3 english+=$4 computer+=$5 printf "%-6s %-6s %4d %8d %8d %8d\n", $1, $2, $3,$4,$5, $3+$4+$5 } #运行后 END { printf "---------------------------------------------\n" printf " TOTAL:%10d %8d %8d \n", math, english, computer printf "AVERAGE:%10.2f %8.2f %8.2f\n", math/NR, english/NR, computer/NR } |
执行脚本并查看结果:
|
[root@node1 shell]# awk -f cal.awk score.txt NAME NO. MATH ENGLISH COMPUTER TOTAL --------------------------------------------- Marry 2143 78 84 77 239 Jack 2321 66 78 45 189 Tom 2122 48 77 71 196 Mike 2537 87 97 95 279 Bob 2415 40 57 62 159 --------------------------------------------- TOTAL: 319 393 350 AVERAGE: 63.80 78.60 70.00 |
2. Shell编程
2.1. 简介
shell脚本执行方式Shell 是一个用 C 语言编写的程序，通过 Shell 用户可以访问操作系统内核服务。它类似于 DOS 下的 command 和后来的 cmd.exe。Shell 既是一种命令语言，又是一种程序设计语言。
Shell script 是一种为 shell 编写的脚本程序。Shell 编程一般指 shell脚本编程，不是指开发 shell 自身。
Shell 编程跟 java、php 编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。
Linux 的 Shell 种类众多，一个系统可以存在多个 shell，可以通过 cat /etc/shells 命令查看系统中安装的 shell。
Bash 由于易用和免费，在日常工作中被广泛使用。同时，Bash 也是大多数Linux 系统默认的 Shell。
2.2. 快速入门
新建 /export/data/shell/hello.sh 文件
|
#!/bin/bash echo 'hello world' |
#! 是一个约定的标记，它告诉系统这个脚本需要什么解释器来执行，即使用哪一种 Shell。注意，在shell脚本中除了第一行的#表示特殊格式外，其他地方的#一般表示注释。
echo命令用于向窗口输出文本。
2.3. 解释器
Java需要虚拟机解释器, 同理 shell脚本也需要解析器，查看Linux系统支持的解释器:
|
[root@node1 shell]#cat /etc/shells /bin/sh /bin/bash /sbin/nologin /bin/dash /bin/tcsh /bin/csh |
常见Shell解释器:
sh： 的全称是 Bourne shell，由 AT&T 公司的 Steve Bourne开发，为了纪念他，就用他的名字命名了。sh 是UNIX 上的标准 shell，很多 UNIX 版本都配有 sh。sh 是第一个流行的 Shell。
Bash:从名称可以看出是Bsh的升级版本，是著名的开源软件项目，目前大多数的Linux版本都使用Bash 作为默认的Shell程序，当运行Shell程序时，实际运行的是Bash程序
Csh:是因使用C语言的语法风格而得名，在用户的命令行交互界面上进行了很多改进，并增加了历史，别名，文件名替换，作业掏等功能，相比Bsh，Csh在更加适用为 用户提供命令交互操作
在现代的 Linux上，sh 已经被 bash 代替，/bin/sh往往是指向/bin/bash的符号链接。
如果你希望查看当前 Linux 的默认 Shell，那么可以输出 SHELL 环境变量：
|
[root@node1 shell]# echo $SHELL /bin/bash |
输出结果表明默认的 Shell 是 bash。
2.4. shell脚本执行方式
shell脚本有三种执行方式:
l 方式一：sh执行
sh执行，进入脚本的工作目录，然后使用对应的sh或bash来执行脚本，这种执行方式，脚本文件不需要具有可执行权限。
|
[root@node1 ~]# cd /export/data/shell/ [root@node1 shell]#sh hello.sh hello world |
l 方式二：工作目录执行
执行脚本时，先进入到脚本所在的目录，然后使用 ./脚本方式执行，这种执行方式，必须保证脚本文件具有可执行权限。
|
[root@node1 ~]#cd /export/data/shell/ [root@node1 shell]# chmod +x hello.sh [root@node1 shell]# ./hello.sh hello world |
l 方式三：绝对路径执行
绝对路径中执行，指的是直接从根目录/到脚本目录的绝对路径，这种执行方式，必须保证脚本文件具有可执行权限。
|
[root@node1 ~]# /export/data/shell/hello.sh hello world |
2.5. shell的数据类型
字符串：
字符串是shell编程中最常用最有用的数据类型，字符串可以用单引号，也可以用双引号，也可以不用引号。建议使用双引号，因为双引号里可以有变量和特殊字符，可以按照变量和特殊字符去使用。
声明字符串类型的变量：
整数型：
在Shell中所有的变量默认都是字符串型。默认情况下，所有的数值都是不能进行运算的，如果想要进行数学运算，可以使用“$((运算式))”或“$[运算式]”方式运算（后续讲）。
2.6. 变量
2.6.1. 简介
shell变量是一种很“弱”的变量，默认情况下，一个变量保存一个串，shell不关心这个串是什么含义。所以若要进行数学运算，必须使用一些命令例如let、declare、expr、双括号等。
在shell中有3种变量：用户变量、环境变量、特殊变量，其中用户变量在编程过程中使用量最多，环境变量主要是在程序运行时需要设置，特殊变量在对参数判断和命令返回值判断时会使用，。
l 变量的定义语法:
变量名=变量值
l 变量的定义需遵循的规则
1) 变量名可以由字母、数字和下画线组成，但是不能以数字开头。
2) 在 Bash中，变量的默认类型都是字符串型，如果要进行数值运算，则必须使用特殊命令。
3) 变量用等号"="连接值，"="左右两侧不能有空格。
4) 变量值中如果有空格，则需要使用单引号或双引号包含，如 test="hello world!"。双引号括起 来的内容"$"和反引号者都拥有特殊含义，而单引号括起来的内容都是普通字符。
5) 在变量值中，可以使用转义符"\"。
6) 不能使用bash里的关键字（可用help命令查看保留关键字）。
2.6.2. 用户变量
2.6.2.1. 定义变量
在对变量赋于字符串值时，建议使用引号将其包裹。如果字符串中存在空格，请一定要使用单引号或双引号将整个内容包裹。注意：单引号里的内容原封不动的输出，双引号里有变量的调用则会调用变量
|
[root@node1 shell]# username="itcast" |
2.6.2.2. 访问变量
要对变量进行调用时，在变量名前加美元符号$
|
[root@node1 shell]# echo $username itcast |
如果需要增加变量的值，那么可以进行变量值的叠加。不够变量需要用双引号包含"$变量名"或${变量名}
|
[root@node1 ~]# username="itcast" [root@node1 ~]# echo $usernamedb.log #这种方式不可以 .log [root@node1 ~]# echo "$username"db.log #可以 itcastdb.log [root@node1 ~]# echo ${username}db.log #可以 itcastdb.log |
l 测试脚本
脚本内容:test1.sh
|
#! /bin/bash string="I am shell" num=5 echo "a=${num},string=${string}" |
执行脚本
|
[root@node1 shell]# sh test1.sh a=5,string=I am shell |
2.6.2.3. 变量的其他赋值方式
1) 可以使用read关键字从键盘获取内容赋值给变量
2) 可以通过$(linux命令)或者$`linux命令`来执行linux命令，并将命令的执行结果赋值给变量
脚本内容:test2.sh
|
#! /bin/bash echo "who are you?" read name #从键盘获取变量的值 pwd_string=$(pwd) #将当前的绝对路径赋值给pwd_string变量 date_string=`date` #将当前时间赋值给date_string变量 echo "hello, $name" echo $pwd_string echo $date_string |
执行脚本
|
[root@node1 shell]# sh test2.sh who are you? itcast hello, itcast /export/data/shell 2020年 05月 10日 星期日 16:50:21 CST |
2.6.2.4. 只读变量
使用 readonly 命令可以将变量定义为只读变量，只读变量的值不能被改变。
下面的例子尝试更改只读变量，结果报错：
test3.sh
|
#!/bin/bash myUrl="http://www.google.com" readonly myUrl myUrl="http://www.runoob.com" |
运行脚本，结果如下：
|
/bin/sh: NAME: This variable is read only. |
2.6.2.5. 删除变量
使用 unset 命令可以删除变量。语法：
unset variable_name
变量被删除后不能再次使用。unset 命令不能删除只读变量。
实例:
test4.sh
|
#!/bin/sh myUrl="http://www.runoob.com" unset myUrl echo $myUrl |
以上实例执行将没有任何输出。
2.6.3. 环境变量
当shell程序启动时，都自动设置一组变量，这组变量就是环境变量。shell中的所有命令都可以使用这些变量，环境变量可以在/etc/profile中设置,环境变量的名字习惯上使用大写字母。
2.6.3.1. 常见的环境变量
可以使用env命令查看所有的系统环境变量
|
[root@node1 shell]# env XDG_SESSION_ID=2 HOSTNAME=node1 SELINUX_ROLE_REQUESTED= TERM=xterm SHELL=/bin/bash HISTSIZE=1000 SSH_CLIENT=192.168.88.5 8047 22 CONDA_SHLVL=0 SELINUX_USE_CURRENT_RANGE= SSH_TTY=/dev/pts/0 USER=root |
常见的环境变量：
PATH 决定了shell将到哪些目录中寻找命令或程序
HOME 当前用户主目录
HISTSIZE 历史记录数
LOGNAME 当前用户的登录名
HOSTNAME 指主机的名称
SHELL 当前用户Shell类型
LANGUGE 语言相关的环境变量，多语言可以修改此环境变量
MAIL 当前用户的邮件存放目录
PS1 基本提示符，对于root用户是#，对于普通用户是$
2.6.3.2. 自定义环境变量
1) vi /etc/profile ,在文件末尾加上要定义的环境变量，语法如下：
export 变量名=变量值
|
export SERVICE_HOST=www.itcast.cn |
2) wq 退出
3) source /etc/profile
4) 输入 env 查看环境变量，是否有自己定义的环境变量。
5) 使用环境变量
环境变量的使用方式和普通变量是一样的:$环境变量名
|
[root@node1 shell]# echo $SERVICE_HOST www.itcast.cn |
2.6.4. 特殊变量
我们可以在执行 Shell 脚本时，向脚本传递参数，这时候可以使用特殊变量来获取参数，Shell常用的特殊变量如下:
|
变量 |
解释 |
|
$# |
命令行参数的个数 |
|
$n |
$1表示第一个参数，$2表示第二个参数，以此类推 |
|
$0 |
当前程序的名称 |
|
$? |
前一个命令或许或函数的返回码 |
|
$* |
以“参数1 参数2 。。。”形式保存所有参数 |
|
$@ |
以“参数1”“参数2”。。。形式保存所有参数 |
|
$$ |
本程序的（进程ID号）PID |
|
$! |
上一个命令的PID |
实例:
以下实例我们向脚本传递三个参数，并分别输出，其中 $0 为执行的文件名：
test5.sh
|
#!/bin/bash echo "Shell 传递参数实例！"; echo "执行的文件名：$0"; echo "第一个参数为：$1"; echo "第二个参数为：$2"; echo "第三个参数为：$3"; echo "参数个数为：$#"; echo "传递的参数作为一个字符串显示*：$*"; |
执行脚本:
|
[root@node1 shell]# chmod +x test5.sh [root@node1 shell]# ./test5.sh aaa bbb ccc Shell 传递参数实例！ 执行的文件名：./test5.sh 第一个参数为：aaa 第二个参数为：bbb 第三个参数为：ccc 参数个数为：3 传递的参数作为一个字符串显示*：aaa bbb ccc |
$* 与 $@ 区别:
相同点：都是引用所有参数。
不同点：只有在双引号中体现出来。假设在脚本运行时写了三个参数 1、2、3，，则 " * " 等价于 "1 2 3"（传递了一个参数），而 "@" 等价于 "1" "2" "3"（传递了三个参数）。
2.7. 字符串
字符串是shell编程中最常用最有用的数据类型（除了数字和字符串，也没啥其它类型好用了），字符串可以用单引号，也可以用双引号，也可以不用引号。
2.7.1. 单引号
|
name='乔布斯' str='我很崇拜$name' echo $str |
输出结果为:
我很崇拜$name
单引号字符串的限制：
单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的,单引号字串中不能出现单独一个的单引号（对单引号使用转义符后也不行），但可成对出现，作为字符串拼接使用。
2.7.2. 双引号
|
name="乔布斯" str="我很崇拜$name" echo $str |
输出结果为：
我很崇拜 乔布斯
双引号的优点：
1) 双引号里可以有变量
2) 双引号里可以出现转义字符
2.7.3. 拼接字符串
2.7.3.1. 使用双引号拼接
test6.sh
|
#!/bin/bash yourname="吴恩达" wenhou_1="你好,$yourname ." wenhou_2="你好,"$yourname" ." wenhou_3="你好,\"$yourname\" ." echo $wenhou_1 $wenhou_2 $wenhou_3 |
输出结果为：
你好,吴恩达 . 你好,吴恩达 . 你好,"吴恩达" .
2.7.3.2. 使用单引号拼接
test7.sh
|
#!/bin/bash yourname="乔布斯" wenhou_4='你好,$yourname.' wenhou_5='你好,'$yourname.'' wenhou_6='你好,"$yourname" .' echo $wenhou_3 $wenhou_4 $wenhou_5 |
输出结果:
你好,$yourname. 你好,乔布斯. 你好,"$yourname" .
2.7.4. 获取字符串长度
test8.sh
|
#!/bin/bash string="jobs" echo ${string} # 输出结果: jobs echo ${#string} # 输出结果: 4 |
2.7.5. 提取子字符串
以下实例从字符串第 2 个字符开始截取 4 个字符：
test9.sh
|
#!/bin/bash string="敢于亮剑决不后退" echo ${string:2:2} # 输出结果为: 亮剑 |
2.7.6. 查找子字符串
查找字符 i 或 o 的位置(哪个字母先出现就计算哪个)：
test10.sh
|
#!/bin/bash string="i am a boy" echo `expr index "$string" am` # 输出是: 3 |
注意： 以上脚本中 ` 是反引号(Esc下面的)，而不是单引号 '，不要看错了哦。
2.8. 算术运算符
2.8.1. 简介
Shell 和其他编程一样，支持包括：算术、关系、布尔、字符串等运算符。原生 bash 不支持简单的数学运算，但是可以通过其他命令来实现，例如expr。expr 是一款表达式计算工具，使用它能完成表达式的求值操作。
例如，两个数相加：
|
val=`expr 2 + 2` echo $val |
注意：
表达式和运算符之间要有空格，例如 2+2 是不对的，必须写成 2 + 2。
完整的表达式要被` `包含，注意不是单引号，在 Esc 键下边。
下表列出了常用的算术运算符，假定变量 a为10，变量b为20：
|
运算符 |
说明 |
举例 |
|
+ |
加法 |
expr $a + $b 结果为 30。 |
|
- |
减法 |
expr $a - $b 结果为 -10。 |
|
* |
乘法 |
expr $a \* $b 结果为 200。 |
|
/ |
除法 |
expr $b / $a 结果为 2。 |
|
% |
取余 |
expr $b % $a 结果为 0。 |
|
= |
赋值 |
a=$b 将把变量 b 的值赋给 a。 |
|
== |
相等。用于比较两个数字，相同则返回 true。 |
[ a == b ] 返回 false。 |
|
!= |
不相等。用于比较两个数字，不相同则返回 true。 |
[ a != b ] 返回 true。 |
注意：条件表达式要放在方括号之间，并且要有空格，例如: [a==b] 是错误的，必须写成 [ a == b ]。
2.8.2. 例子
test11.sh
|
#!/bin/bash a=4 b=20 #加法运算 echo expr $a + $b #减法运算 echo expr $a - $b #乘法运算，注意*号前面需要反斜杠 echo expr $a \* $b #除法运算 echo $a / $b #此外，还可以通过$(())、$[]进行算术运算。 echo "a = $a" c=$((a+b)) d=$[a+b] echo "c = $c" echo "d = $d" |
2.9. 流程控制
Shell提供了丰富的语句判断方式，包括数字，字符串和文件。
2.9.1. 语句判断
2.9.1.1. 数字：
|
运算符 |
说明 |
|
-eq |
检测两个数是否相等，相等返回 true。 |
|
-ne |
检测两个数是否不相等，不相等返回 true。 |
|
-gt |
检测左边的数是否大于右边的，如果是，则返回 true。 |
|
-lt |
检测左边的数是否小于右边的，如果是，则返回 true。 |
|
-ge |
检测左边的数是否大于等于右边的，如果是，则返回 true。 |
|
-le |
检测左边的数是否小于等于右边的，如果是，则返回 true。 |
2.9.1.2. 字符串:
|
判断符 |
说明 |
|
-n STRING |
字符串长度不为零 |
|
-z STRING |
字符串长度为0 |
|
= |
判断两个字符串是否一样 |
|
!= |
判断两个字符串是否不一样 |
2.9.1.3. 文件
|
判断符 |
说明 |
|
-f |
存在且是普通文件 |
|
-d |
存在且是目录 |
|
-h |
存在且是符号链接 |
|
-e |
文件存在 |
|
–r |
文件存在并且可读 |
|
–w |
文件存在并且可写 |
|
–x |
文件存在并且可执行 |
2.9.2. if语句
2.9.2.1. if
if 语句语法格式：
|
if condition then command1 command2 ... commandN fi |
例子：
1）判断当前系统是否有多个ssh进程，如果有则打印true
test12.sh
|
#!/bin/bash if [ $(ps -ef | grep -c "ssh") -gt 1 ] then echo "true" fi |
2）判断/media/cdrom文件是否存在，若不存在就去创建这个目录
test13.sh
|
#!/bin/bash DIR="/media/cdrom" if [ ! -e $DIR ] then mkdir -p $DIR fi |
2.9.2.2. if else
if else 语法格式：
|
if condition then command1 command2 ... commandN else command fi |
实例:
1) 根据年龄判断是否成年
test14.sh
|
#!/bin/bash read -p "Enter your age(1-100）：" age if [ $age -ge 18 ] then echo '已经成年！' else echo '未成年!'
fi |
2）if else语句经常与test命令结合使用
test 命令允许你做各种测试并在测试成功或失败时返回它的退出状态码（为0表示为真，为1表示为假）。使用这个状态码，可以让 Bash 对测试的结果做出反应。
test 命令的语法为：
test EXPRESSION
或
[ EXPRESSION ]
test15.sh
|
#!/bin/bash num1=$[2*3] num2=$[1+5] if test $[num1] -eq $[num2] then echo '两个数字相等!' else echo '两个数字不相等!' fi |
2.9.2.3. if else-if else
if else-if else 语法格式：
|
if condition1 then command1 elif condition2 then command2 else commandN fi |
实例:
1) 以下实例判断两个变量是否相等：
test16.sh
|
#!/bin/bash echo "请输入a的值:" read a
echo "请输入b的值:" read b if [ $a == $b ] then echo "a 等于 b" elif [ $a -gt $b ] then echo "a 大于 b" elif [ $a -lt $b ] then echo "a 小于 b" else echo "没有符合的条件" fi
|
2)输入成绩,判断成绩“优”“良”“中”
test17.sh
|
#!/bin/bash read -p "Enter your score（0-100）：" n #-p参数表示给出提示信息 if [ $n -ge 85 ] && [ $n -le 100 ] ; then echo "优" elif [ $n -ge 70 ] && [ $n -le 84 ] ; then echo "良" elif [ $n -ge 60 ] && [ $n -le 69 ] ; then echo "中" else echo "差" fi |
2.9.3. for循环
与其他编程语言类似，Shell支持for循环。
2.9.3.1. 格式1-字符型循环
for循环一般格式为：
|
for 变量 in 值1 值2 值3… do 程序 done |
当变量值在列表里，for循环即执行一次所有命令，使用变量名获取列表中的当前取值。命令可为任何有效的shell命令和语句。in列表可以包含替换、字符串和文件名。
in列表是可选的，如果不用它，for循环使用命令行的位置参数。
实例:
1)顺序输出当前列表中的数字：
test18.sh
|
#!/bin/bash for loop in 1 2 3 4 5 do echo "The value is: $loop" done |
输出结果：
|
The value is: 1 The value is: 2 The value is: 3 The value is: 4 The value is: 5 |
2) 顺序输出字符串中的字符
test19.sh
|
#!/bin/bash for str in 'This is a string' do echo $str done |
输出结果：
|
This is a string |
3）打印/root目录下所有文件的名字
test20.sh
|
#!/bin/bash for file in $(ls /root) do echo $file done |
4）求1-100的和
test21.sh
|
#!/bin/bash s=0 #从1加到100 for(( i=1;i<=100;i=i+1)) #定义循环100次 do #每次循环给变量s赋值 s=$(($s+$i)) done #输出从1加到100的和 echo "The sum of 1+2+..+100 is : $s" |
2.9.3.2. 格式2-数字性循环
该格式的语法如下：
|
for ((初始值；循环控制条件；变量变化)） do 程序 done |
需要注意以下几点：
初始值：在循环开始时，需要给某个变量赋予初始值，如 i=1。
循环控制条件：用于指定变量循环的次数，如 i<=100，则只要 i 的值小于等于 100，循环就会继续。
变量变化：每次循环之后，变量该如何变化，如 i=i+1，代表每次循环之后，变量的值都加 1。
语法二和其他语言中的 for 循环类似，也就是事先决定循环次数的固定循环。
实例:
test22.sh
|
#!/bin/bash for ((i = 0; i <= 5; i++)) do echo "welcome $i times" done |
2.9.4. while循环
while循环用于不断执行一系列命令，也用于从输入文件中读取数据；命令通常为测试条件。其格式为：
|
while 条件 do 程序 done |
1)案例1
以下是一个基本的while循环，测试条件是：如果int小于等于5，那么条件返回真。int从0开始，每次循环处理时，int加1。运行上述脚本，返回数字1到5，然后终止。
test23.sh
|
#!/bin/bash num=1 while(( $num<=5 )) do echo $num let "num++" done |
运行脚本，输出：
|
1 2 3 4 5 |
使用中使用了 Bash let 命令，它用于执行一个或多个表达式，变量计算中不需要加上 $ 来表示变量，具体可查阅：Bash let 命令。
2）案例2
求1-100的和
test24.sh
|
#!/bin/bash i=1 sum=0 while [ $i -le 100 ] do let sum=sum+$i let i++ done echo $sum |
2.9.5. 无限循环
无限循环语法格式：
|
while : do command done |
或者
|
while true do command done |
或者
|
for (( ; ; )) |
2.9.6. case语句
Shell case语句为多选择语句。可以用case语句匹配一个值与一个模式，如果匹配成功，执行相匹配的命令。case语句格式如下：
|
case 值 in 模式1) command1 command2 ... commandN ;; 模式2） command1 command2 ... commandN ;; esac |
case工作方式如上所示。取值后面必须为单词in，每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后，其间所有命令开始执行直至 ;;。
取值将检测匹配的每一个模式。一旦模式匹配，则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式，使用星号 * 捕获该值，再执行后面的命令。
下面的脚本提示输入1到4，与每一种模式进行匹配：
test25.sh
|
#!/bin/bash echo '输入 1 到 4 之间的数字:'
echo '你输入的数字为:' read aNum case $aNum in 1) echo '你选择了 1' ;; 2) echo '你选择了 2' ;; 3) echo '你选择了 3' ;; 4) echo '你选择了 4' ;; *) echo '你没有输入 1 到 4 之间的数字' ;; esac |
输入不同的内容，会有不同的结果
2.9.7. 跳出循环
在循环过程中，有时候需要在未达到循环结束条件时强制跳出循环，Shell使用两个命令来实现该功能：break和continue。
2.9.7.1. break
break命令允许跳出所有循环（终止执行后面的所有循环）。
下面的例子中，脚本进入死循环直至用户输入数字大于5。要跳出这个循环，返回到shell提示符下，需要使用break命令。
test26.sh
|
#!/bin/bash
while : do echo -n "输入 1 到 5 之间的数字:"
read aNum
case $aNum in 1|2|3|4|5) echo "你输入的数字为 $aNum!" ;; *) echo "你输入的数字不是 1 到 5 之间的! 游戏结束" break ;; esac done |
执行以上代码，输出结果为：
|
输入 1 到 5 之间的数字:3 你输入的数字为 3! 输入 1 到 5 之间的数字:7 你输入的数字不是 1 到 5 之间的! 游戏结束 |
2.9.7.2. continue
continue命令与break命令类似，只有一点差别，它不会跳出所有循环，仅仅跳出当前循环。
对上面的例子进行修改：
test27.sh
|
#!/bin/bash
while :
do
echo -n "输入 1 到 5 之间的数字: "
read aNum
case $aNum in
1|2|3|4|5) echo "你输入的数字为 $aNum!" ;; *) echo "你输入的数字不是 1 到 5 之间的!" continue echo "游戏结束" ;; esac done |
运行代码发现，当输入大于5的数字时，该例中的循环不会结束，语句 echo "**游戏结束"** 永远不会被执行。
2.10. 函数
2.10.1. 语法
linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。
shell中函数的定义格式如下：
|
[ function ] funname() { action; [return int;] } |
说明：
1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。
2、参数返回，可以显示加：return 返回，如果不加，将以最后一条命令运行结果，作为返回值。 return后跟数值n(0-255）
实例：
1）定义一个函数并进行调用
test28.sh
|
#!/bin/bash demoFun(){ echo "这是我的第一个 shell 函数!" } echo "-----函数开始执行-----" demoFun echo "-----函数执行完毕-----" |
输出结果：
|
-----函数开始执行----- 这是我的第一个 shell 函数! -----函数执行完毕----- |
3）定义一个带有return语句的函数
test29.sh
|
#!/bin/bash
funWithReturn(){
echo "这个函数会对输入的两个数字进行相加运算..."
echo "输入第一个数字: " read aNum echo "输入第二个数字: "
read anotherNum echo "两个数字分别为 $aNum 和 $anotherNum !"
return $(($aNum+$anotherNum))
}
funWithReturn
echo "输入的两个数字之和为 $? !" |
输出类似下面：
|
这个函数会对输入的两个数字进行相加运算... 输入第一个数字: 1 输入第二个数字: 2 两个数字分别为 1 和 2 ! 输入的两个数字之和为 3 ! |
函数返回值在调用该函数后通过 $? 来获得。
注意：所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分，直至shell解释器首次发现它时，才可以使用。调用函数仅使用其函数名即可。
2.10.2. 函数参数
在Shell中，调用函数时可以向其传递参数。在函数体内部，通过 的形式来获取参数的值，例如，1表示第一个参数，$2表示第二个参数...
带参数的函数示例：
test30.sh
|
#!/bin/bash funWithParam(){ echo "第一个参数为 $1 !" echo "第二个参数为 $2 !" echo "第十个参数为 $10 !" echo "第十个参数为 ${10} !" echo "第十一个参数为 ${11} !" echo "参数总数有 $# 个!" echo "作为一个字符串输出所有参数 $* !" }
funWithParam 1 2 3 4 5 6 7 8 9 34 73 |
输出结果：
|
第一个参数为 1 !
第二个参数为 2 !
第十个参数为 10 !
第十个参数为 34 !
第十一个参数为 73 !
参数总数有 11 个!
作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73 ! |
注意，不能获取第十个参数，获取第十个参数需要{10}。当n>=10时，需要使用${n}来获取参数。
2.11. 数组
2.11.1. 定义数组
数组中可以存放多个值。Bash Shell 只支持一维数组（不支持多维数组），初始化时不需要定义数组大小（与 PHP 类似）。
与大部分编程语言类似，数组元素的下标由0开始。
Shell 数组用括号来表示，元素用"空格"符号分割开，语法格式如下：
array_name=(value1 ... valuen)
实例:
test31.sh
|
#!/bin/bash
my_array=(A B "C" D)
#我们也可以使用下标来定义数组:
array_name[0]=value0
array_name[1]=value1
array_name[2]=value2 |
2.11.2. 读取数组
读取数组元素值的一般格式是：
|
${array_name[index]} |
2.11.3. 实例
test32.sh
|
#!/bin/bash
my_array=("A" "B" "C" "D")
echo "第一个元素为: ${my_array[0]}"
echo "第二个元素为: ${my_array[1]}"
echo "第三个元素为: ${my_array[2]}"
echo "第四个元素为: ${my_array[3]}"
|
执行脚本，输出结果如下所示：
|
$ chmod +x test.sh $ ./test.sh
第一个元素为: A 第二个元素为: B 第三个元素为: C 第四个元素为: D |
2.11.4. 获取数组中的所有元素
使用@ 或 * 可以获取数组中的所有元素，例如：
test33.sh
|
#!/bin/bash
my_array[0]=“A” my_array[1]=“B” my_array[2]=“C” my_array[3]=“D”
echo "数组的元素为: ${my_array[*]}" echo "数组的元素为: ${my_array[@]}" |
执行脚本，输出结果如下所示：
|
$ chmod +x test.sh $ ./test.sh
数组的元素为: A B C D 数组的元素为: A B C D |
2.11.5. 获取数组的长度
获取数组长度的方法与获取字符串长度的方法相同，例如：
test34.sh
|
#!/bin/bash my_array[0]=A my_array[1]=B my_array[2]=C my_array[3]=D
echo "数组元素个数为: ${#my_array[*]}" echo "数组元素个数为: ${#my_array[@]}" |
执行脚本，输出结果如下所示：
|
$ chmod +x test.sh $ ./test.sh
数组元素个数为: 4 数组元素个数为: 4 |
2.11.6. 遍历d
2.11.6.1. 方式一
test35.sh
|
#!/bin/bash
my_arr=(AA BB CC)
for var in ${my_arr[*]} do echo $var done |
2.11.6.2. 方式二
test36.sh
|
#!/bin/bash
my_arr=(AA BB CC) my_arr_num=${#my_arr[*]} for((i=0;i<my_arr_num;i++)); do echo "-----------------------------" echo ${my_arr[$i]} done |
2.12. select
2.12.1. 简介
select表达式是bash的一种扩展应用，擅长于交互式场合。用户可以从一组不同的值中进行选择：
|
select var in ... ; do commond done .... now $var can be used ... |
注意：
select 是个无限循环，因此要记住用 break 命令退出循环，或用exit 命令终止脚本
2.12.2. 实例
下面是一个简单的示例：
test37.sh
|
#!/bin/bash
echo "What is your favourite OS?" PS3="Please enter your choice:" select var in "Linux" "Gnu Hurd" "Free BSD" "Other" do break; done echo "You have selected $var" |
这里PS3作为select语句的shell界面提示符，注意：PS3一定要定义在select语句的前面
该脚本的运行结果如下：
|
What is your favourite OS? 1) Linux 2) Gnu Hurd 3) Free BSD 4) Other Please enter your choice:3 You have selected Free BSD |
2.12.3. select和case的综合练习
test38.sh
|
#!/bin/bash echo "你想学习什么语言?" PS3="请输入你的选择:" # 设置提示字符串 select var in java c++ shell python; do case $var in "java") echo "恭喜你选择成功.java最牛" ;; "c++") echo "驱动开发 网络优化 go 语言" ;; "shell") echo "运维必会" ;; python) echo "人工智能" esac break # 如果这里没有break 将会进行无限循环 done echo "你选择的是:$var" |
2.13. 加载其它文件的变量
2.13.1. 简介
和其他语言一样，Shell 也可以包含外部脚本。这样可以很方便的封装一些公用的代码作为一个独立的文件。
Shell 文件包含的语法格式如下：
|
. filename # 注意点号(.)和文件名中间有一空格 或 source filename |
2.13.2. 练习
定义两个文件 demo1.sh和demo2.sh，在test1中定义一个变量arr=(java c++ shell),在demo2中对arr进行循环打印输出。
第一步: vim demo1.sh
|
#!/bin/bash my_arr=(AA BB CC) |
第二步: vim demo2.sh
|
#!/bin/bash source ./test1.sh # 加载test1.sh 的文件内容 for var in ${my_arr[*]} do echo $var done |
第三步: 执行demo2.sh
|
sh demo2.sh |
好处 :
1. 数据源和业务处理分离
2. 复用代码扩展性更强
2.14. shell脚本综合案例
2.14.1. 猜字游戏
2.14.1.1. 规则
游戏规则为：程序内置一个1到100 之间的数字作为猜测的结果，由用户猜测此数字。用户每猜测一次，由系统提示猜测结果：大了、小了或者猜对了；直到用户猜对结果，则提示游戏结束。
2.14.1.2. 代码
guess_number.sh
|
#!/bin/bash #生成100以内的随机数 提示用户猜测 猜对为止 #random 系统自带，值为0-32767任意数 #随机数1-100 num=$[RANDOM%100+1] #read 提示用户猜数字 #if判断 while : do read -p "计算机生成了一个 1‐100 的随机数,你猜: " cai if [ $cai -eq $num ] then echo "恭喜,猜对了" exit elif [ $cai -gt $num ] then echo "不巧,猜大了" else echo "不巧,猜小了" fi done |
2.14.2. 一键安装jdk
2.14.2.1. 思路
|
第1步：提示用户安装jdk
第2步：删除centos自带的jdk
第3步：创建/export/server目录，进入目录
第4步：下载jdk安装包
第5步：解压jdk，删除压缩包
第6步：设置环境变量
第7步：加载环境变量
第8步：提示用户安装成功，查看java的版本 |
2.14.2.2. 代码
jdk_install.sh
|
#!/bin/bash # 1.提示安装jdk echo "现在开始安装jdk" sleep 1 # 休眠1秒钟 # 2.删除centos自带的jdk oldjava=` rpm -qa | grep java ` for old in ${oldjava}; do # echo $old rpm -e --nodeps $old done # 3.创建安装目录/export/server, 进入安装目录 java_path="/export/server" if [ ! -d $java_path ] then mkdir -p $java_path fi cd $java_path # 4.下载jdk安装包 if [ ! -f jdk-8u141-linux-x64.tar.gz ] then cp /export/software/jdk-8u141-linux-x64.tar.gz ./ fi # 5.解压缩安装包,删除安装包 if [ ! -f jdk1.8.0_141 ] then tar -zxvf jdk-8u141-linux-x64.tar.gz rm -rf jdk-8u141-linux-x64.tar.gz fi # 6.设置环境变量 JAVA_HOME="/export/server/jdk1.8.0_141" if ! grep "JAVA_HOME=$JAVA_HOME" /etc/profile then echo "-------------------- path = $PATH" # JAVA_HOME echo "--------------JAVA_HOME------------------" echo "export JAVA_HOME=$JAVA_HOME" | tee -a /etc/profile # PATH echo "--------------PATH------------------------" echo "export PATH=:$JAVA_HOME/bin:$PATH" | tee -a /etc/profile fi # 7.加载环境变量 source /etc/profile # 8.提示用户安装成功,查看jdk安装版本 echo "恭喜您,jdk安装成功!" java -version |
这里的tee命令,表示将前边的命令的输出作为输入并将内容写入文件中，-a表示追加写入
注意：运行该脚本之前，需要将jdk安装包上传到/export/software目录
2.14.3. 数据库定时备份
2.14.3.1. 需求
1)每天凌晨1:15备份 数据库 itcast_shop到 /export/data/db目录
2)备份开始和备份结束能够给出相应的提示信息
3)备份后的文件要求以备份时间为文件名，并打包成 .tar.gz 的形式，比如：
2020-05-12_021501.tar.gz
4) 在备份的同时，检查是否有10天前备份的数据库文件，如果有就将其删除
2.14.3.2. 代码
mysqldump_demo.sh
|
#!/bin/bash #完成数据库的定时备份 #备份的路径 BACKUP=/export/data/db #当前时间作为文件名 DATETIME=$(date +%Y_%m_%d_%H%M%S) #可以通过输出变量来调试 echo $DATETIME #使用变量的时候，也可以用{}花括号的方式把变量名包起来，如下： echo ${DATETIME}
echo "---------------------开始备份数据库---------------------" echo "---------------------备份的路径是$BACKUP/$DATETIME.tar.gz---------------------" #主机ip地址 HOST=192.168.88.100 #数据库用户名 DB_USER=root #数据库密码 DB_PWD=123456 #数据库名 DATABASE=itcast_shop #创建备份路径 #如果备份的文件夹路径存在的话，就直接使用，否则就创建 [ ! -d "${BACKUP}/${DATETIME}" ] && mkdir -p "${BACKUP}/${DATETIME}" #执行mysql的备份数据库的指令 mysqldump -u${DB_USER} -p${DB_PWD} --host=${HOST} ${DATABASE} | gzip > ${BACKUP}/${DATETIME}/${DATETIME}.sql.gz #打包备份文件 cd ${BACKUP} tar -czvf ${DATETIME}.tar.gz ${DATETIME} #删除临时目录 rm -rf ${BACKUP}/${DATETIME} #删除10天前的备份文件 find ${BACKUP} -mtime +10 -name "*.tar.gz" -exec rm -rf {} \; echo "-------------------------备份成功-------------------------" |
代码说明:
- 代码中HOS、DB_USER、DB_PWD这三个变量的值要根据自己的情况来设置
- mysqldump就是系统内置的用来备份数据库的工具
- 语句find ${BACKUP} -mtime +10 -name "*.tar.gz" -exec rm -rf {} \; 解释:
1）find命令只是来查找匹配的文件，如果查到文件之后还需要进一步的操作，则需要添加-exec参数，{}表示find查询出来的文件名字。
2）-exec 参数后面跟的是要执行的command命令，它的终止是以;为结束标志的，所以这句命令后面的分号是不可缺少的，考虑到各个系统中分号会有不同的意义，所以前面加反斜杠。
3）-mtime 文件状态修改时间 ，-mtime +10：表示10天前的文件
2.14.3.3. 运行脚本
|
[root@node1 shell]# vim mysqldump_demo.sh [root@node1 shell]# chmod +x mysqldump_demo.sh [root@node1 shell]# ./mysqldump_demo.sh 2020_05_12_102918 2020_05_12_102918 ---------------------开始备份数据库--------------------- ---------------------备份的路径是/export/data/db/2020_05_12_102918.tar.gz--------------------- mysqldump: [Warning] Using a password on the command line interface can be insecure. 2020_05_12_102918/ 2020_05_12_102918/2020_05_12_102918.sql.gz -------------------------备份成功------------------------- |
2.14.3.4. 结果查看
|
1:进入数据库备份目录 [root@node1 shell]# cd /export/data/db/ [root@node1 db]# ls 2020_05_12_102918.tar.gz
2:解压备份压缩包 [root@node1 db]# tar -zxvf 2020_05_12_102918.tar.gz 2020_05_12_102918/ 2020_05_12_102918/2020_05_12_102918.sql.gz [root@node1 db]# ls 2020_05_12_102918 2020_05_12_102918.tar.gz
3:进入解压后目录 [root@node1 db]# cd 2020_05_12_102918/ [root@node1 2020_05_12_102918]# ls 2020_05_12_102918.sql.gz
4:解压sql脚本压缩包 [root@node1 2020_05_12_102918]# gzip -d 2020_05_12_102918.sql.gz [root@node1 2020_05_12_102918]# ls 2020_05_12_102918.sql
5:查看sql脚本内容 [root@node1 2020_05_12_102918]# vim 2020_05_12_102918.sql |
查看sql脚本内容，发现备份成功!
2.14.3.5. 定时执行
这里配置定时任务，需要使用Linux的定时工具crontab，crontab语法如下:
在以上各个字段中，还可以使用以下特殊字符：
星号（*）：代表所有可能的值，例如month字段如果是星号，则表示在满足其它字段的制约条件后每月都执行该命令操作。
逗号（,）：可以用逗号隔开的值指定一个列表范围，例如，“1,2,5,7,8,9”
中杠（-）：可以用整数之间的中杠表示一个整数范围，例如“2-6”表示“2,3,4,5,6”
正斜线（/）：可以用正斜线指定时间的间隔频率，例如“0-23/2”表示每两小时执行一次。同时正斜线可以和星号一起使用，例如*/10，如果用在minute字段，表示每十分钟执行一次。
实现步骤:
- 命令行输入crontab -e 进入编辑模式
- 编辑，写入以下内容
|
15 1 * * * /export/data/shell/mysqldump_demo.sh |
- wq保存退出即可
- 配置定时任务调度成功！这样的话，每天的凌晨 1:15就会自动的备份数据库