第十五章 Linux Shell 编程

15.1 Shell 变量

了解：Shell的功能
了解：Shell的种类
了解：Shell的调用
了解：Shell变量的概念
了解：Shell变量的定义
了解：Shell数组变量
了解：Shell内置变量
了解：双引号和单引号
了解：Shell变量作用域

15.1.1 shell的概念

Shell 的英文含义是<外壳>

Shell 是<命令解释器程序>的统称，专门用于对<用户命令>进行解释，从而让内核可以理解并执行，因此 Shell就是<用户>与<内核>交互的<桥梁>

Shell 功能如下：

● 接收　用户命令

● 调用　相应的应用程序

● 解释并交给内核去处理

● 返还　内核处理结果

人机交互程序，命令解释器，翻译官，让内核理解我们输入的命令

在这里插入图片描述

15.1.2 shell 的种类

Shell 的种类有多种：

MS-DOS（本身就是一个Shell）

Windows的Shell：Windows Explorer（图形化）、cmd（命令行）

UNIX的Shell：sh、bash、csh、ksh等等（平时我们所说的Shell，多指UNIX的Shell）

sh程序:

<sh程序>是shell的一种，它遵循<Unix POSIX 标准>，从而具备<UNIX可移植性>。

<sh程序>是<其他 UNIX Shell>的基础，各类<UNIX系统>均可很好的支持。大部分shell都是有sh 改进而来，最强的是/bin/bash也是默认的

bash程序:

<bash程序>是<sh程序>的增强版，也是<大多数Linux系统>的<默认Shell>。

15.1.3 shell 的调用

chsh -l					## 查看：系统可用的 Shell
echo $SHELL 			## 查看默认的shell  也是放内嵌命令的地方 一般是 /bin/bash永久更改：用户的登录Shell							
useradd user01
chsh -s /bin/sh user01	## 永久更改user01用户的登录 Shell
cat /etc/passwd			## 查看更改结果		显示调用shell
bash -c date			## 显式调用bash，来执行date命令
sh -c date				## 显式调用sh，来执行date命令隐式调用shell	用的最多
date   					## 隐式调用<用户默认的Shell>，来执行date命令
vi test.sh				
#!/bin/bash				## 在Shell脚本中，申明本脚本所调用的Shell
date

15.1.4 Shell 变量赋值与引用

变量：就是一个<进程>中用于<存储数据>的<内存实体>，它对应着一个<内存存储空间>。

<变量名>只能包括：<字母>、<数字>和<_下划线>，并且，<变量名>不能以<数字>开头。

定义Shell变量

var01="123"				## 直接赋值
var02="${var01}456"		## 引用<其他变量值>来赋值
var03="`date`			## 引用<命令屏显输出>来赋值
echo "$var01"			## 显示<变量值>  123 
echo "$var02"			## 显示<变量值>  123456
echo "$var03"			## 显示<变量值>  显示时间，注意显示的是定义变量的时间，而不是echo 这里的时间

15.1.5 Shell 数组变量

Shell 数组变量：就是一组同姓不同名的<变量集合>，彼此用<索引下标>加以区分。

Shell 数组变量：分为两类

第一类：普通数组，即：数字下标，有序数组 (最常用）

第二类：关联数组，即：命名下标，无序数组 (不常用）

定义：Shell数组变量（普通数组）

a=()					## 只定义不赋值
a=("a" "b" "c") 		## 赋值需要空格隔开，下标从0开始
a=(
a
b
c
)						## 同上
a[0]="a"
a[1]="b"
a[5]="c"				## 赋值单个数组

引用：Shell数组变量（普通数组），里面的都是数组而不是单个变量

echo $a					## 读取第一个数组元素值，即下标0
echo ${a[n]}			## 读取下标n的数组元素值，n是数字
echo ${a[*]}			## 读取全部数组元素值
echo ${a[@]}			## 读取全部数组元素值 常用于循环脚本echo ${a[*]:n}			## 从下标n开始，读取后面全部数组元素值
echo ${a[*]:n:m}	    ## 从下标n开始，读取m个数组元素值
例如：
echo ${a[*]:0:3}		## 显示下标 0 1 2 的值
echo ${a[*]:1:3}		## 显示下标 1 2 3 的值
echo ${a[*]:2:4}		## 从下标2开始，读取4个数据的值，2 3 4 5 echo ${!a[*]}			## 列出所有元素的下标（因为定义数组时候可不一定按下标顺序来定义）
echo ${#a[*]}			## 显示数组有多少元素数量，相当于有多少下标 有10个元素则 输出10
echo ${#a[1]}			## 显示a[1]里面的值有多少位数，比如a[1]=100,则输出 3

echo ${#a[*]} 		## 在判断某不确定命令有多少数组时，去抓取做循环很好

${a[@]} 使用例子，数组一个个打印出来

#!/bin/bash
Service="1,2,3,4,5"
# 使用逗号分割字符串为数组 赋值给service
IFS=',' read -r -a service <<< "$Service"# 将数组每个值赋值给 test
for test in "${service[@]}"; doecho "$test"
done

15.1.6 删除 shell 变量

语法：unset 变量名

比如：unset a 删除a 或者删除a数组

15.1.7 执行shell 脚本

共享<父进程>执行法：source test.sh 或者 . test.sh （可使用 export 刷新环境变量）

独立<子进程>执行法：bash test.sh 或者 sh test.sh

./test.sh（需要x权限）或者 /root/test.sh（需要x权限）

置换<父进程>执行法：exec ./test.sh（需要x权限）或者 exec /root/test.sh（需要x权限）

15.1.8 shell 内置变量

（命令行参数）

Shell 内置变量：就是<Shell命令解释器程序>固有的<变量>，无需定义便可以直接引用。（系统自带变量）

常用的Shell内置变量：

$0			## Shell脚本自身的<文件名>和<调用路径>
$1 -- $n	## Shell脚本的<命令行参数>，$1是第1参数、$2是第2参数，以此类推## 从${10}开始参数需要强制使用花括号{}括起来
$*   $@		## Shell脚本的<所有命令行参数>的<列表>## 如Shell脚本接收了$1 $2两个参数，则 $* 等于$1 $2
$#			## Shell脚本的<命令行参数>的<总个数>
$?			## 保存上一个命令的return状态返回值 0表示成功运行，1表示有问题
$!			## 保存的是最近一个后台进程的 PID (可存储pid遍历判断) <<命令 & pid=$!>>
$$			## Shell脚本自身的<PID进程号>

例子：

vim test.sh
#!/bin/bash  
echo "$* ## 表示这个程序的所有参数 " 
echo "$# ## 表示这个程序的参数个数" 
echo "$$ ## 表示程序的进程 ID " 
echo "执行命令 ls & pid=\$!"
ls & pid=$!	 ## pid=$!这里 pid 是一个变量
echo "${pid} ## 这里的\${pid}则是\$!" 
echo "$! ## 执行上一个后台指令的 PID"
echo "$? ## 表示上一个程序执行返回结果 "
echo -e "## 显示<本Shell脚本>=$0"
echo -e "## 格式输出：指定的<命令行参数>=$1\t$2\t$3"## \t 是正则表达式，表示水平制表符bash test.sh aa bb cc dd ee		## 执行脚本且写5个参数 终端如下显示
[root@dj tmp]# bash test.sh aa bb cc dd ee
aa bb cc dd ee ## 表示这个程序的所有参数 
5 	 ## 表示这个程序的参数个数
1143 ## 表示程序的进程 ID 
执行命令 ls & pid=$!
1144 ## 这里的${pid}则是$!
1144 ## 执行上一个后台指令的 PID
0 	 ## 表示上一个程序执行返回结果 
## 显示<本Shell脚本>=test.sh
## 格式输出：指定的<命令行参数>=aa	bb	cc## 注意 aa bb cc dd ee 是新写的五个变量，可以用五个下标表示

$! 使用例子

检查k8s部署状态

export service=$(echo $service | base64 -d)
export Test_Version=$(echo $Test_Version | base64 -d)# 执行 kubectl rollout status 命令并等待100秒
kubectl rollout status deployment/${service}-rpc${Test_Version} -n go & pid=$!# 等待命令执行完毕或超时（100秒）
sleep 100# 检查命令执行状态
if kill -0 $pid > /dev/null 2>&1; thenecho "-------------部署未完成，超时打印日志-------------"# 获取部署的所有 Pod 名称pod_names=$(kubectl get pods -l app=${service}-rpc${Test_Version} -n go -o=jsonpath='{.items[*].metadata.name}')# 打印每个 Pod 的日志for pod in ${pod_names}; doecho "Logs for pod ${pod}:"kubectl logs ${pod} -n godoneexit 1
elseecho "部署成功"
fi

15.1.9 双引号和单引号

<""双引号> 是：<部分引用>，可以识别<特殊符号>

<''单引号> 是：<完全引用>，不能识别<特殊符号>

举例：

终端显示如下
[root@dj tmp]# a=abc
[root@dj tmp]# echo "${a}"
abc
[root@dj tmp]# echo '${a}'	 ## 单引号 不能识别特殊符号 比如 $ 符
${a}
[root@dj tmp]# echo ${a}
abc

15.1.10 `` 或 $() 命令替换

$() 或 `` 命令替换：将<字符串>中的<命令>，置换为<命令>的<屏显输出>

`` 命令替换：是sh的语法，兼容性最高

$()命令置换：是bash语法，sh不支持所以一般使用反引号 ``

a="ls -l"
echo $a							会输出 ls -la=`ls -l`	或者  a=$(ls -l)
echo $a 						会输出 ls -l命令列出的内容

15.1.11 shell 变量作用域 export

Shell 变量作用域：指的是一个<Shell变量>的<有效范围>。

按<Shell 变量作用域>分类：

Shell 本地变量：仅在<本进程>中生效的<Shell变量>。

Shell 环境变量：仅在<本进程>中生效，又可被<子进程>继承并生效的<Shell变量>。

也就是说如果开两个远程连接，在第一个远程连接定义本地变量，另外一个远程连接用不了该本地变量，但是如果是环境变量，可以通过继承去使用该环境变量。

注意：<Shell 数组变量>不可定义为<Shell 环境变量>。

本地变量定义方法：

a=“123”

环境变量定义方法：

export a="123"        ## 定义变量a为Shell 环境变量   一般使用这个declare -x b="456"    ## 定义变量b为Shell 环境变量

例子证明

a=123				## 定义本地变量
vim test.sh 		## 写一个脚本证明## 脚本相当于一个子进程，因为脚本也可以使用另外一个远程连接来写#!/bin/bash	
echo $a				   在脚本里面运行bash test.sh			
## 发现并无 123 输出
## 说明本地变量不能给子进程使用，只能给创建a的进程使用

export b=123		## 定义环境变量
vim test.sh 		## 写一个脚本证明## 脚本相当于一个子进程，因为脚本也可以使用另外一个远程连接来写#!/bin/bash	
echo $b					在脚本里面运行bash test.sh			发现有123显示在终端上，说明环境变量可在脚本里面也可运行## 注意：因为前面用 a 设置本地变量，所以设置环境变量不能使用 a ，否则会出错，因为环境变量虽然会覆盖本地变量的a，但是其实在配置文件里面还会存在本地变量a为123
## 这时就会出现 在脚本里面运行的时候，会运行本地变量的 a 而不是环境变量的 a 从而导致一样没有123显示，这样就无法判断

Linux 系统中设置环境变量例子 .env文件

export LOCAL_DEBUG=0
export NACOS_HOST=120.79.2.53
export NACOS_PASSWD=nacos
export NACOS_USERNAME=nacos
export NACOS_NAMESPACEID=datahub
export NACOS_DATAID=BehaviorDataReceiver
export NACOS_LOGLEVEL=debug
export NACOS_GROUP=DEFAULT_GROUP
export NACOS_LOGDIR=nacos_log
export NACOS_CACHEDIR=nacos_cache

执行 source .env 加载该配置文件

注意：这是一个包含环境变量的配置文件，不是脚本

一般环境变量可以在运行应用程序时被读取，以便配置应用程序的行为或连接数据库、服务等

.env 也可以加载也可以写在 k8s yaml 的env 里面，一般使用该配置文件用于快速测试能否连接

15.2 echo 标准错误输出重定向符管道符

15.2.1 echo 命令

功能：将<参数>写到<标准输出>。

语法：echo [-neE] [参数 …]

选项参数：

-n   ## 不追加换行符  ☚ 默认情况下，两条命令结合起来会追加换行符
-e   ## 启用：反斜杠转义

echo 支持的常用<反斜杠字符>如下：

\n   	## 换行
\t   	## 横向制表符
\r	 	## 用于表示回车符   一般用于循环覆盖前面的内容比如 echo -e "\r" 表示输出一个回车符
回车符会将光标移动到当前行的开头位置，使得后续输出会覆盖当前行的内容。这在一些需要实现文本动态更新或进度条效果的场景中特别有用。
比如 倒数计时

[root@server ~]# a=`df -h`
[root@server ~]# echo $a
文件系统 容量 已用 可用 已用% 挂载点 devtmpfs 475M 0 475M 0% /dev tmpfs 487M 0 487M 0% /dev/shm tmpfs 487M 7.7M 479M 2% /run tmpfs 487M 0 487M 0% /sys/fs/cgroup /dev/mapper/centos-root 18G 1.5G 17G 9% / /dev/sda2 1014M 138M 877M 14% /boot tmpfs 98M 0 98M 0% /run/user/0[root@server ~]# echo "$a"		## 加上双引号
文件系统                 容量  已用  可用 已用% 挂载点
devtmpfs                 475M     0  475M    0% /dev
tmpfs                    487M     0  487M    0% /dev/shm
tmpfs                    487M  7.7M  479M    2% /run
tmpfs                    487M     0  487M    0% /sys/fs/cgroup
/dev/mapper/centos-root   18G  1.5G   17G    9% /
/dev/sda2               1014M  138M  877M   14% /boot
tmpfs                     98M     0   98M    0% /run/user/0## 侧面说明了在赋予变量的时候，还是按照命令的格式，而不是变成空格一行输出，变成一行是echo的原因

-n选项：

[root@dj ~]# echo "1"; echo "2"; echo "3"	## 会换行
1
2
3
[root@dj ~]# echo -n "1"; echo -n "2"; echo "3"
123与之相似还有 命令|tr -d   还有 命令| sed ':y;N;s/\n//g;b y'
比如 echo `ifconfig`

-e 和 \t 选项

[root@dj tmp]# echo  "123\t456\n789"
123\t456\n789
[root@dj tmp]# echo -e "123\t456\n789"
123	456
789[root@dj ~]# echo -e "1\t2\t3"
1	2	3
[root@dj ~]# echo -e 1\t2\t3			
1t2t3								## 注意：不加双引号不行，-e 不起作用

echo 1.txt | rm -rf			## 这样不行，因为echo只是输出给 rm 接收，它不一定会接收## 不行就添加 xargs

倒计时覆盖

#!/bin/bash
for i in {5..1}
do		echo  -n  "还有$i秒，幸运儿究竟是谁"	## 不换行输出echo  -ne "\r\r"     			   ## 覆盖输出 不加的话会显示全部 一个\r就可以sleep 1							   ## 不加的话运行会显示[root@dj tmp]# 究竟是谁，(还有$i秒) 被覆盖了
done

15.2.2 标准输入标准输出标准错误输出

标准输入：就是通过<I/O字符终端设备，如：键盘)输入的<信息>。(输入是没错的) （0 表示）

标准输出：命令执行成功之后，在屏幕上输出的<命令结果显示信息>。（1 表示）

标准错误输出：命令执行失败之后，在屏幕上输出的<命令错误提示信息>。(2 表示)

（& 表示全部，无论正确还是错误信息）

ls  1>> 1.txt			## 把ls 展现的正确输出结果 追加到 1.txt
sksoefsl  2>> 1.txt		## 把展示出来的错误信息 追加到 1.txt
ls  &>> 1.txt			## 无论是正确还是错误的，该命令的输出全部追加到 1.txt

对于不需要的信息，我们可以写入黑洞，不占内存，黑洞路径是 /dev/null ，比如

yum -y install tree &> /dev/null
echo $?					## 查看上条命令成功与否，0为成功，1为失败

省略不写相当于是标准输出1

常用于丢弃输出，然后自定义显示

命令 > /dev/null 2>&1

ls -waadaw > /dev/null 2>&1			## 标准输出1重定向到/dev/null## 标准错误输出2重定向到标准输出1
或									
ls -waadaw &> /dev/null 			## 将标准输出和标准错误都重定向到/dev/null

15.2.3 >、>> 标准错误输出重定向

重定向：改变<命令>的<标准输出/标准错误输出>的<输出方向>，不输出到<屏幕>，而是输出到<文件>。

★ > 重定向符：覆盖式重定向

★ >> 重定向符：追加式重定向

<标准输出>重定向，主要用于保存<命令执行成功的结果信息>，便于后期引用。

echo "123" > 1.txt	     	## 覆盖式重定向
echo "456" >> 1.txt      	## 追加式重定向

<标准错误输出>重定向，主要用于保存<命令执行失败的错误信息>，便于查阅分析

yum instll wget -y 2> 1.txt     	## 覆盖式重定向
yum updata -y 2>> 1.txt       		## 追加式重定向

<标准输出/标准错误输出>重定向，静默执行命令不输出内容

yum update -y &> /dev/null          ## 方法1：&代表<标准输出/标准错误输出>
yum update -y 1> /dev/null 2>&1     ## 方法2：2代表标准错误输出；1代表标准输出## 2给1，1给/dev/null，这个世界就安静了

15.2.4 <、<< 标准重定向输出

★ < 输入重定向：从<指定文件>中，读取数据，输入到<指定文件>中

★ << 输入重定向：从<标准输入>中，读取数据，输入到<指定文件>或<指定命令>中

< 输入重定向例子：

覆盖式输入

echo "aaa" > 1.txt
cat > 3.txt < 1.txt				## 将1.txt里面的内容写进3.txt并覆盖

追加式输入

cat >> 3.txt < 1.txt

<< 输入重定向例子

cat << 
EOF
This is a test.
Hello, world!
EOF## 会直接在终端输出
This is a test.
Hello, world!

将111222追加到 3.txt

cat << EOF >> 3.txt
111222
EOF

15.2.5 | 管道符

管道符：像流水线一样，将一个<命令>的<标准输出>，作为另一个<命令>的<标准输入>。

echo "1.txt" | touch -        	## 创建 1.txt文件  不一定成功
echo "1.txt" | xargs touch		## 创建 1.txt

15.2.6 生成随机数 $RANDOM

使用 $R A N D OM 变量：$ RANDOM 是一个环境变量，它可以在每次被调用时生成一个 0 到 32767（2^15-1）之间的随机整数。可以通过以下脚本来生成一个随机数：

最简单命令：echo $RANDOM

原理：

#!/bin/bash
random_number=$RANDOM
echo "随机数：$random_number"
##随机数 生成 0 到 32767 的某一个数

例子1：随机生成 0 到 2的随机数

#!/bin/bash
echo $[RANDOM%3]
相当于对 3 取余，只有 0  1  2  产生
##运行脚本 生成  0  1   2  三个随机数，可拿来做数组下标，做一个随机生成名字喊人回答问题的代码

随机字符 /dev/urandom 生成随机字符

[root@dj tmp]# cat /dev/urandom |tr -dc [:alnum:] |head -c 8nRSCSps2
[root@dj tmp]# cat /dev/urandom |tr -dc [:alnum:] |head -c 8
yCGqVAzq[root@dj tmp]#

例子2 随机生成石头剪刀布，赢了退出，输了继续比

思想：做一个死循环，如果满足条件就 break 退出该循环，while true 也可以

[root@dj tmp]# cat 2.sh

#!/bin/bash
echo "我们一起来玩石头剪刀布吧"
xt=1
while (($xt<3))
doxt=$[RANDOM%3]read -e -p "请输入您的选择(0:石头 1:剪刀 2:布)：" aif [[ $a == 0 ]]thenecho "您出的是石头"if (($xt==1))thenecho "我出的是剪刀,恭喜宁赢了,欢迎下次再来pk"breakelif (($xt==0))thenecho "不好意思我出的也是石头,平局喔,请继续"elseecho "不好意思我出的是布,您输了,请继续"fielif [[ $a == 1 ]]thenecho "您出的是剪刀"if (($xt==2))thenecho "我出的是布,恭喜宁赢了,欢迎下次再来pk"breakelif (($xt==1))thenecho "不好意思我出的也是剪刀,平局喔,请继续"elseecho "不好意思我出的是石头,您输了,请继续"fielif [[ $a == 2 ]]thenecho "您出的是布"if (($xt==0))thenecho "我出的是石头,恭喜宁赢了,欢迎下次再来pk"breakelif (($xt==2))thenecho "不好意思我出的也是布,平局喔,请继续"elseecho "不好意思我出的是石头,您输了,请继续"fielseecho "输入错误，请重新输入"fi
done
##注意：输入那里的 if 判断必须使用 [[ ]] ,如果是 (( )),如果输入大于3的数字会正常，但是输入字母会默认成石头

例子3 随机点名

#!/bin/bash
for i in {2..1}
doecho  -n  还有$i秒，幸运儿究竟是谁 !!echo  -ne "\r\r"     sleep 1
doneecho  " "clearname=(`cat /root/name.txt`)name_list=${#name[*]}			## 数组有多少元素赋值给它，假如有5个元素则为5name_index=$[RANDOM%$name_list]echo -n "${name[$name_index]}" 	## 根据下标找人echo  ""## 注意：name.txt 里面放的是名单 一行一个名字，还有 name_list 是里面存放是数字，而不是名字
## xt=$[RANDOM%3]可以换成 ((xt=RANDOM%3)) 或者 let "xt=RANDOM%3"

例子4 猜1到1000的随机数

#!/bin/bash
target=$[$RANDOM%1000+1]while true
doread -p "请输入一个数字（1到1000）： " n# 检查输入是否为整数if ! [[ $n =~ ^[0-9]+$ ]]; thenecho "请输入有效的数字！"continuefi# 判断猜测结果if [ $guess -eq $n ]; thenecho "恭喜你，猜对了！"breakelif [ $guess -lt $n ]; thenecho "猜的数字太小了，请继续猜！"elseecho "猜的数字太大了，请继续猜！"fidone

15.3 通配符、正则、grep

15.3.1 通配符

通配符：是Shell自身的一种特殊语句，实现<路径名展开 pathname expansion>展开功能。

用于：模糊搜索<文件>。

* 		## 表示0或多个的<任意字符>  （相当于正则里面  .*）
?		## 表示单个<任意字符>	   （相当于正则  .）
[ ] 	## 表示匹配<字符列表或范围>中的<单个字符>（和正则里面一样）
[xyz]  	## 设置可选的<字符列表>
[x-y]  	## 设置可选的<字符范围>
[^xyz]  ## 表示不选择x、y、z；
^ 		## 表示不匹配，^ 必须是第一个字符

举例：

cd /tmp; rm -rf *; mkdir dir1 dir2 dir3; touch file1 file2 file3
## 通过<路径名展开 pathname expansion>的<通配符>来列出<目录或文件>ls -l -d dir[1-3]
ls -l file[1-3]rm -rf ???          ## 删除当前目录下所有的任意3个字符命名的文件

15.3.2 正则表达式

1 正则表达式（Regular Expression）的概念

正则表达式：描述了<目标字符串>的<匹配模式(pattern)>。

注意：<正则表达式>和<Shell 通配符>不是一回事！

生活比喻：

我们要在一群人中找一个人，但是我只知道他是湖北武汉人，姓催，因此我们只能这样说：“那个"姓催的武汉人”，请出来，我们有事找你"。在这段话中，"姓催的武汉人"就是一个生活中的<正则表达式>。

2 正则表达式的种类

基本正则：是<标准的元字符集>，是其他<正则>的<子集>。

扩展正则：是<扩展的元字符集>，包含着<标准元字符+扩展元字符>。 -E

Perl正则 -P

3 认识：正则元字符

元字符	基本	扩展	功能说明
^	✔	✔	匹配：行首 ^s 以s开头
$	✔	✔	匹配：行尾 s$ 以s结尾
.	✔	✔	匹配：任意单个字符
?	✘	✔	匹配：<前一项>出现<0次或1次>
+	✘	✔	匹配：<前一项>出现<1次或多次>
*	✔	✔	匹配：<前一项>出现<0次或多次> .* 代表0个或多个任意单个字符
[ ]	✔	✔	匹配：<字符列表>中的<任意一个字符> 注意：在 [ ] 中，字符中间的 - 有着<特殊含义> [-] 匹配：＜字符范围＞中的＜任意一个字符＞ [-] 匹配：依照＜字典顺序＞到达＜指定字符＞截止的＜所有字符＞ [^] 匹配：＜字符集合＞外的＜任意一个字符＞　　在 [ ] 中，开头第一个 ^ 有着<特殊含义> 　　在 [ ] 中，<其余字符>均为<原义字符>
( )	✘	✔	定义：<正则分组>
\|	✘	✔	设置：逻辑或
{ }	✘	✔	{n} 匹配：<前一项>出现<ｎ次>，ｎ可以设为0 {n,} 匹配：<前一项>最少出现<ｎ次>，ｎ可以设为0 {,m} 匹配：<前一项>最多出现<ｍ次> {n,m} 匹配：<前一项>最少出现<ｎ次>，最多出现<ｍ次>
<	✔	✔	匹配：<单词>的<左边界字符>
>	✔	✔	匹配：<单词>的<右边界字符>
\b	✔	✔	匹配：<单词>的<左边界字符>或<右边界字符>
\B	✔	✔	匹配：<单词>的<非左边界字符>或<非右边界字符>
\d	✘	✘	匹配：单个<数字字符> ☚ 仅属于：<perl 正则元字符集>
\D	✘	✘	匹配：单个<非数字字符> ☚ 仅属于：<perl 正则元字符集>
\w	✔	✔	匹配：单个<单词的字符>，如：字母、数字、_下划线
\W	✔	✔	匹配：单个<非单词的字符>
\s	✔	✔	匹配：单个<空白字符>，包含：水平／垂直制表符
\S	✔	✔	匹配：单个<非空白字符>
\t	✘	✘	匹配：水平制表符 ☚ 仅属于：<perl 正则元字符集>
\v	✘	✘	匹配：垂直制表符 ☚ 仅属于：<perl 正则元字符集>
\f	✘	✘	匹配：换页符 ☚ 仅属于：<perl 正则元字符集>

4 认识：转义符 \

转义符：恢复<元字符>的<原义>，还原为<本义字符>。

举例说明：

^ 	## 匹配行首，比如 s^ 是匹配 s
\^  ## 表示这是一个 ^本义字符，它不再是 ^元字符，而是^本身意思$ 	## 匹配行尾，比如 s 是匹配 s
\$  ## 表示：这是一个 $本义字符，它不再是 $元字符。

15.3.3 grep命令

grep命令的功能：三剑客 (grep sed awk ,其中 tr 称为小sed，cut称为小awk)

注意：grep只能列出文件想要看的精准内容，不能用grep修改

逐行扫描<文本文件>或者<标准输出/标准错误输出>的<每一行>。

通过<关键字>和<正则表达式>，来筛选出<匹配的行>，然后标准输出<匹配的整行>。

注意：通过匹配行内的某些特征去匹配那一行，使用 -o 则只输出匹配的字符

语法：grep [选项] <关键字和正则表达式> [文件名 | -]

文件名指定需要读取的<文件名>

表示准备接收<标准输入> 具备这功能的命令，可以接收 | 管道符

选项：

-E		## 采用：扩展正则  egrep 相当于 grep -E
-P		## 采用：Perl正则
-i		## 忽略：大小写
-o		## 仅输出：匹配的<字符串>  不写都是输出满足匹配的行
-c		## 统计：匹配的行数 ☚ 注意：不是输出的行数 有多少行输出多少几  可拿来统计个数
-v		## 输出：不匹配的<行>
-l		## 列出：包含<匹配字符串>的<文件名>
-L		## 列出：不包含<匹配字符串>的<文件名>
-r		## 执行：目录递归操作 ☚ 仅与 -l 或 -L 配合使用
-w		## 选项表示只匹配整个单词，而不是部分匹配
--exclude=FILE_PATTERN		## 排除：指定的文件名，仅可使用<通配符>
--exclude-dir=PATTERN		## 排除：指定的目录名，仅可使用<通配符>

-c 例子更多使用 wc -l

[root@dj exports.d]# grep -c '' /tmp/passwd   有49行
49

例子：查看文件，去除注释和空行扩展正则

egrep -v "^\s*(#|$)" /etc/passwd 	## 以 0个或多个 空格 开头，然后接 # 号  或者  直接结尾

-w 例子

netstat -tunlp | grep -w "22"## 会匹配 22 的内容，但是 222，223 122 这种不会被匹配

15.4 各种常用辅助命令

15.4.1 sort、uniq、wc 命令

sort 命令：排序

☛ 命令选项说明

-g		## 按<一般数值>排序
-n		## 按<字符串数值>排序
-r		## 逆序排序（默认升序） -gr 就是按数字降序排序  重要
-f		## 忽略<字母大小写>
-b		## 忽略<前导的空白区域>
-k		## 按照指定字段进行排序 sort -k 2 file.txt 按第二字段进行排序
-o		## 将<排序结果>回写入<原文件>，例如：cat 1.txt

★ uniq 命令：分组汇总

有相同的行就去重。

-c  			## 去重的同时统计出现多少次
uniq -c    		## 常用于查找ip访问最多

★ wc 命令：统计

☛ 命令选项说明

不加选项，分别表示行数、单词数量和字节数  比如 wc  /etc/passwd
-l		## 统计：行数
-W		## 统计：单词数
-c		## 统计：字节数
-m		## 统计：字符数
-L		## 显示：最长行的长度

一般组合使用是找相同排序去重在排序

统计并显示次数出现前十的ip access_log 是文件名

[root@dj ~]# cat access_log | awk '{print $1}'| sort -r | uniq -c | sort -gr | head -101055 192.168.1.25509 192.168.1.14360 192.168.1.37303 192.168.1.12262 192.168.1.41254 192.168.1.21242 192.168.1.8234 192.168.1.5203 192.168.1.31195 192.168.1.30

netstat -anlp|grep 80|grep tcp|awk ‘{print $5}’|awk -F: ‘{print $1}’|sort|uniq -c|sort -nr|head -n20

三个一起使用能发挥重大作用，一个排序一个去重一个分组

例子：

lastb | sort -k 3 -k 1 | uniq -c | sort -k 1   ## 统计显示：<lastb命令>查看到的登录失败信息ss -tan |sort | uniq -c			## 统计显示网络连接信息
cat /etc/passwd | wc -l			## 统计显示/etc/passwd 文件的行数
cat /etc/passwd | wc -m			## 统计显示/etc/passwd 文件的字符数

统计显示：网络连接信息：没排序和排序和排序去重的区别对比

[root@dj ~]# ss -tan
State       Recv-Q Send-Q           Local Address:Port                    Peer Address:Port              
LISTEN      0      5                192.168.122.1:53                                *:*                  
LISTEN      0      128                      	*:22                                *:*                  
LISTEN      0      128             	   	127.0.0.1:631                               *:*                  
LISTEN      0      100                  127.0.0.1:25                                *:*                  
LISTEN      0      128                    		*:111                               *:*                  
ESTAB       0      0                192.168.58.150:22                    192.168.58.1:50395             
ESTAB       0      0                192.168.58.150:22                    192.168.58.1:50298             
ESTAB       0      0                192.168.58.150:22                    192.168.58.1:50288             
ESTAB       0      0                192.168.58.100:22                    192.168.58.1:51760             
ESTAB       0      0                192.168.58.150:22                    192.168.58.1:50394             
ESTAB       0      0                192.168.58.100:22                    192.168.58.1:51684             
ESTAB       0      0                192.168.58.100:22                    192.168.58.1:51761             
LISTEN      0      128                       [::]:22                               [::]:*                  
LISTEN      0      128                     	[::1]:631                              [::]:*                 
LISTEN      0      100                      [::1]:25                               [::]:*                  
LISTEN      0      128                       [::]:111                              [::]:* [root@dj ~]# ss -tan |sort   (排序后)
ESTAB      0      0      192.168.58.100:22                 192.168.58.1:51684              
ESTAB      0      0      192.168.58.100:22                 192.168.58.1:51760              
ESTAB      0      0      192.168.58.100:22                 192.168.58.1:51761              
ESTAB      0      0      192.168.58.150:22                 192.168.58.1:50288              
ESTAB      0      0      192.168.58.150:22                 192.168.58.1:50298              
ESTAB      0      0      192.168.58.150:22                 192.168.58.1:50395              
ESTAB      0      36     192.168.58.150:22                 192.168.58.1:50394              
LISTEN     0      100      [::1]:25                    [::]:*                  
LISTEN     0      100    127.0.0.1:25                       *:*                  
LISTEN     0      128          *:111                      *:*                  
LISTEN     0      128       [::]:111                   [::]:*                  
LISTEN     0      128    127.0.0.1:631                      *:*                  
LISTEN     0      128      [::1]:631                   [::]:*                  
LISTEN     0      128          *:22                       *:*                  
LISTEN     0      128       [::]:22                    [::]:*                  
LISTEN     0      5      192.168.122.1:53                       *:*                  
State      Recv-Q Send-Q Local Address:Port               Peer Address:Port  [root@dj ~]# ss -tan |sort | uniq -c	(去重后)1 ESTAB      0      0      192.168.58.100:22                 192.168.58.1:51684              1 ESTAB      0      0      192.168.58.100:22                 192.168.58.1:51760              1 ESTAB      0      0      192.168.58.100:22                 192.168.58.1:51761              1 ESTAB      0      0      192.168.58.150:22                 192.168.58.1:50288              1 ESTAB      0      0      192.168.58.150:22                 192.168.58.1:50298              1 ESTAB      0      0      192.168.58.150:22                 192.168.58.1:50395              1 ESTAB      0      36     192.168.58.150:22                 192.168.58.1:50394              1 LISTEN     0      100      [::1]:25                    [::]:*                  1 LISTEN     0      100    127.0.0.1:25                       *:*                  1 LISTEN     0      128          *:111                      *:*                  1 LISTEN     0      128       [::]:111                   [::]:*                  1 LISTEN     0      128    127.0.0.1:631                      *:*                  1 LISTEN     0      128      [::1]:631                   [::]:*                  1 LISTEN     0      128          *:22                       *:*                  1 LISTEN     0      128       [::]:22                    [::]:*                  1 LISTEN     0      5      192.168.122.1:53                       *:*                  1 State      Recv-Q Send-Q Local Address:Port               Peer Address:Port

15.4.2 cut、tr 命令

cut 命令小awk

功能：将<每个文件>中<每一行>的<匹配部分>打印到<标准输出>。

语法：cut OPTION… [FILE]…

注意：字符是一个整体，一个字符可能占一个字节，也可能占几个字节。a是字符也是字节

汉字是字符，但一个汉字不止占一个字节

编码utf -8 的情况下，一个汉字占3个字节

常用选项：

-b, --bytes=LIST       		## 按<字节>进行选择，不承认<分隔符>
-n               			## 和 -b选项 一起使用：不分割<多字节字符>，如：汉字
-c, --characters=LIST     	## 按<字符>进行选择，不承认<分隔符>
-f, --fields=LIST       	## 按<字段>进行选择，承认<分隔符>，以<分隔符>区分<字段>## 除非指定了-s选项，否则，还会打印任何不包含<分隔符>的<行>
-s, --only-delimited    	## 不打印没有包含<分界符>的<行>
-d, --delimiter=DELIM 		## 设置单个<自定义分隔符>，需使用<单引号 或 双引号>## 默认为Tab制表符## 连续多个<分隔符>，只有第1个有效，剩余的视为<普通字符>## 只能和 -f选项 一起使用--complement               	## 补全选中的<字节、字符、字段>
--output-delimiter=TRING  	## 使用指定的字符串作为输出分界符，默认采用输入的分界符## 针对 -b,-c,-f 这三个选项，只能使用其中的一个
## <输入顺序>将作为<读取顺序>，<每行字符串>仅能输入一次
## 每一个<LIST列表>，都是一个<范围值>，可以使用<,逗号>来分隔<多个范围值>
## <范围值>的格式如下：N   				## 仅仅<第N个>的<字节、字符、域>
N-  				## 从<第N个>到<行尾>之间(包括<第N个>)的所有<字节、字符、字段>
N-M 				## 从<第N个>到<第M个>之间(包括<第M个>)的所有<字节、字符、字段>
-M  				## 从<第1个>开始到<第M个>之间(包括<第M个>)的所有<字节、字符、字段>
N1,N2,N3,N-,N-M,-M ...	## 可以使用<,逗号>来分隔<多个范围值>

如果没有<文件参数>，或者<文件>不存在时，则从<标准输入>读取

这说明：cut 命令可以接收 | 管道符

测试：按<字节>进行选择，不承认<分隔符>

echo -e "123456789\nabcdefghi\nABCDEFGHI" > /tmp/1.txt
cut -b 5 /tmp/1.txt      ## 只输出每一行的<第5个字节>
cut -b 2-5 /tmp/1.txt    ## 输出从<第2个字节>到<第5个字节>之间的内容
cut -b 5- /tmp/1.txt     ## 输出从<第5个字节>到<行尾>之间的内容
cut -b -5 /tmp/1.txt     ## 输出从<第1个字节>到<第5个字节>之间的内容
cut -f 1 -d ":" passwd	 ## 输出每行的第一个字段

2 tr 命令小sed

功能：从<标准输入>中替换、缩减、删除<字符>，并将<结果>写到<标准输出>。

特点：是针对<单个字符>在<SET1字符集>中进行<匹配操作>，然后通过<SET2字符集>进行<位置映射>的<替换操作>，

而不是针对<整个字符串>进行<相关操作>。

语法：tr [选项]… SET1 [SET2]

常用选项：

-c, -C, --complement  	## 取代所有不属于<SET1字符集>的字符
-d, --delete      		## 删除所有属于<SET1字符集>的字符 tr -d 任何内容转为一行输出
-s, --squeeze-repeats   ## 去重把<连续重复的字符>以<单独一个字符>表示
-t, --truncate-set1     ## 参照<SET2字符集>的个数，先截短<SET1字符集>，然后执行<替换操作>
--help       		    ## 显示此帮助信息并退出
--version      	        ## 显示版本信息并退出

<SET1字符集>：指定要替换或删除的<原字符集>，一旦匹配了<原字符集>，则对<该字符>予以<相关处理>，否则，

就予以保留。

当执行替换操作时，必须使用参数<SET2字符集>指定替换的<目标字符集>。

但执行删除操作时，不需要参数<SET2字符集>。

<SET2字符集>：指定要替换成的<目标字符集>

<SET1字符集>和<SET2字符集>都是一组<字符串>，一般都可按照字面含义理解。

基本原理图：

echo "0123456789" | tr "9876543210" "12345"　　## 输出结果：5555554321

在这里插入图片描述

如果第二行没有第一行的内容，直接不变写入，

如果第二行存在第一行的内容，相当于把第二行的内容替换成第三行的

如果有第二行但是第三行没有替换对应的，则替换成第三行最后一个字符

语法练习

echo -e "112233445566778899\nabcdefghiABC\nABCDEFGHIabc" > /tmp/1.txt
cat /tmp/1.txt | tr "a-c" "A-C"    	## 针对每一行，将<a,b,c>替换为<A,B,C>，然后执行<标准输出>
cat /tmp/1.txt | tr "0-9" "1"       ## 针对每一行，将<所有数字>替换为<1>，然后执行<标准输出>
cat /tmp/1.txt | tr "a-zA-Z" "9"  	## 针对每一行，将<所有字母>替换为<9>，然后执行<标准输出>
cat /tmp/1.txt | tr -d "a-zA-Z"   	## 针对每一行，将<所有字母>删除，然后执行<标准输出>
cat /tmp/1.txt | tr -s "0-9"        ## 针对每一行，去除所有重复的<数字>，然后执行<标准输出>
cat /tmp/1.txt | tr -t "abc" "12"  	## 针对每一行，参照<SET2字符集>的个数，先截短<SET1字符集>，然后执行<替换操作>## 即：SET1=abc，SET=12(长度为2个字符)，因此，只将<a,b>替换<1,2>
cat /tmp/1.txt | tr -c -d 1-4,'\n',a-b  	## 针对<每一行>，删除不是<1,2,3,4,a,b,\n换行符>的<其他字符># 大小写转换
echo "ABCDEFGHIJKLMNOPQRSTUVWXYZ" | tr "A-Z" "a-z"
# 加密解密
echo "123456" | tr "0123456789" "987654321"   ## 加密，加密输出结果为：876543
echo "876543" | tr "987654321" "0123456789"   ## 解密，解密输出结果为：123456

15.4.3 read 命令脚本常用

功能：接收<键盘输入>，并保存到<指定的变量>中,即作用于输入变量定义，类似于c语言的scan，c ++ 的cin

注意：read命令不能在<while read 循环语句>中使用

选项：

-i "string"   	## 缓冲区文字，用于设置<默认输入值> 
-e       		## 交互式输入，允许<backspace键>回退
-p "string"   	## 设置<提示输入的说明文字> 必有  ep 一般一起使用
-s       		## 不显示<输入内容，包括：换行符>（常用于输入密码） 可以设置密码	
-a array_name  	## 将<word单词>赋值给<array_name数组变量>，<数组下标>从 0 开始 一般和 for循环使用，和-ep 混用要注意
-r       		## 不允许<反斜杠>转义<任何字符>

例子

-i

read -i "/usr/local/nginx" -ep "请您输入 nginx 的安装目录(例如 /usr/local/nginx):" a
## 会显示  请您输入 nginx 的安装目录(例如 /usr/local/nginx):/usr/local/nginx

vim 1.sh

#!/bin/bash
read  -p "请输入您要创建的文件名:" g
touch $g#!/bin/bash
read -e "txt" -p "请输入您要创建的文件名:" g		## 输错时候，允许回退   -e 
touch $g#!/bin/bash	
read -e -i "txt" -p "请输入您要创建的文件名:" g	## 必须输入有txt的才可以  -i
touch $g## 将输入的<参会的人员名单列表>依次保存在<dj 数组变量>中  
read -e -a dj -p "请输入<参会的人员名单列表>："
echo ${dj[*]}

read -a例子

vim 1.sh
#!/bin/bash# 提示用户输入一行以空格分隔的字符串
echo "请输入一行以空格分隔的字符串："
read -a array# 打印数组的每个元素
echo "数组的元素如下："
for element in "${array[*]}"
doecho "$element"
donebash 1.sh aa bb cc  会打印 aa bb cc 一行打印一个

#!/bin/bash
echo "您可以一次创建一个或多个目录，用空格隔开"
read -ep "创建的共享目录名是(如test1):" -a gx
for i in ${gx[*]}
domkdir -p /$i
done随便输入创建 1个 或 多个目录

以 , 分隔例子

#!/bin/bashdir_paths="/,/go-data,/alidata,/k8s-alidata" # 字符串IFS=',' read -r -a dir_array <<< "$dir_paths"# 遍历每个目录for dir_path in "${dir_array[@]}"; doecho $dir_path# 使用 df 命令获取磁盘使用率，并提取使用率百分比# df_used=$(df -h "$dir_path" | awk 'NR==2 {print $5}' | sed 's/%//')# echo "$dir_path: $df_used%"done

15.4.4 sleep wait 命令

1 sleep 命令 & 把要运行的内容脚本等等甩后台运行

功能：暂停一段时间，时间单位可以是 s m h d，默认是 s(秒)

举例：

sleep 10s 				## 暂停 10 秒，直接作用不了
sleep 10s &				## 在后台暂停 10 秒

2 wait 命令

功能：

wait命令是用来阻塞<当前进程>的执行，直至<当前进程的指定子进程>或者<当前进程的所有子进程>返回状态为0，执行结束之后，方才继续执行。

使用 wait命令可以在<bash脚本>的<多进程>执行模式下，起到一些<特殊控制>的作用。

注意：wait命令仅仅针对<当前父进程>的<子进程>方可生效！

语法：wait [进程号或作业号]，例如：wait 或 wait 23 或 wait %1

备注：

wait 不带<任何的进程号或作业号> ，则会阻塞<当前进程>，直至<当前进程的所有子进程>全部执行结束

wait 23 阻塞<当前进程>，直至<指定的PID子进程>执行结束

wait %1 阻塞<当前进程>，直至<指定JOB作业任务>执行结束

#!/bin/bash
echo "当前父进程PID号 = $$"
echo "当前开始时间是：$(date)"
sleep 60 &
echo "该 sleep 60 子进程PID号 = $!"
sleep 120 &
echo "该 sleep 120 子进程PID号 = $!"
wait
echo "当前结束时间是：$(date)"

15.5.5 dirname、basename

dirname 功能：输出文件路径的根路径到父路径

basename 功能：输出文件路径的文件名

dirname  1/2/3/4/5		## 输出1/2/3/4
basename 1/2/3/4/5  	## 输出5	无论有没有该文件路径都会这样输出

15.5.6 xargs 命令

功能：xargs命令可以通过<| 管道符>接受<字符串>，并将<接收到的字符串>依据<默认空格>分割成<许多参数>，然后，将<这些参数>作为<命令行参数>传递给<后面的命令>，<后面命令>则可以使用这些<命令行参数>来执行。

作用：管道符 | 对于不支持标准输入的命令(比如 rm )，无法传输文件，使用该命令即可例如：

echo “1.txt” | rm -rf   ## 操作失败，因为 rm 无法感知 1.txt 是文件名还是字符串
echo "1.txt" |xargs rm	## 成功删除当前目录下的1.txt文件

选项：

-d   		## 指定分隔符，不写的情况下默认是以 空格（包括制表符等等）为分隔符
echo '11@22@33' | xargs -d '@' echo		## 指定 @ 为分隔符 输出 11 22 33
-p			## 输出<即将要执行的完整命令>，询问<是否执行>  可拿来查看将要输出什么但是不输出
-n			## 设置<每次传递>的<命令行参数>的<个数>，可以<分批传输，分批执行>
echo '11@22@33@44@55' | xargs -n 2 -d '@' echo  ## 11 22 33 44 55 将分成<两次>传送，分成<三次>执行-E 			## 仅仅传递<指定命令行参数>之前的<命令行参数>
echo '11 22 33 44' | xargs -E '33' echo			## 输出 11  22 如果加 -p 就会询问## 注意：【-E选项】不能和【-d选项】一起使用，如果一起使用，则【-E选项】无效。即便【-d选项】指定的是<空格>也是如此。

15.5 shell 算数计算

15.5.1 计算简单格式

1 整数计算 ((…)) 和 let " " $[ ]必须使用该格式才可以进行计算和相关操作

使用 + - * / % < > 需要使用该格式，专门使用拿来定义表达式

n=1;((n=n+1));echo $n			## 输出2
n=1;let n-n+1;echo $n			## 输出2   let是内嵌命令let "x=10, y=5, z=x+y"				
echo $z							## 输出 15((x=100/10))   let "x=100/10"   x=$[100/10] 	## 将100/10赋值给x
例子：
[root@dj tmp]# ((x=100/10))
[root@dj tmp]# echo $x
10
[root@dj tmp]# ((x=100/5))
[root@dj tmp]# echo $x
20[root@dj tmp]# let "x=100/10"
[root@dj tmp]# echo $x
10
[root@dj tmp]# let "x=100/5"
[root@dj tmp]# echo $x
20[root@dj tmp]# x=$[100/10]
[root@dj tmp]# echo $x
10
[root@dj tmp]# x=$[100/5]
[root@dj tmp]# echo $x
20

2 浮点数计算 bc 外部命令

yum -y install bc				## 外部命令要安装
echo "10/3"						## 输出 10/3
echo "10/3" | bc				## 输出 3 默认是整数
echo "scale=2;10/3" | bc		## 输出 3.33    scale 是指定 输出小数后多少位，默认是0，即输出整数
echo "scale=3;10/3" | bc		## 输出 3.333

运算速率： [let命令] 等价于 ((…)) ；大于 [bc命令]

15.5.2 算数计算表达式：操作符（重要）

有 a++ a-- ++a --a + - * / % **(幂)

! 逻辑取反

let "x=1, y=2, z=(x<y)"			## 判断语句
echo $z							## 输出 1  ，布尔类型中 1 代表正确let "x=1, y=2, z=!(x<y)"		## 判断语句
echo $z							## 输出 0  ，布尔类型中 0 代表错误

~ 按位取反

let "x=2, y=~x" 		## y=~x 就是：按位取反
echo "y=$y" 			## 计算结果：y=-3

<< 和 >> 对应的二机制数移位

let "x=1, y=x<<1" 			 ## x<<1 就是：按位左移1位   二进制 01 左移变成 10 ，变回十进制就是 2
echo "y=$y" 		    	 ## 计算结果： y=2  输出  y=2而不是输出2[root@dj tmp]# let "x=6, y=x>>1"	## 右移动  二进制 110 右移变成 11  即 3
[root@dj tmp]# echo $y
3

& 逻辑与 | 逻辑或 ^ 逻辑异或都是二进制的对比

&  						## 双 1 为 1 ，否则为 0
|  						## 有 1 为 1 ，全 0 为 0
^  						## 相同为 0 ，不同 为 1  
let "x=(10^12)"			## 二进制分别是 1010  1100  得到 0110 即 6
echo $x    				## 输出 6

<赋值>操作符： =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=

=     	## 例句：let "x=1+2"
*=    	## 例句：let "x*=2"  等价于 let "x=x*2"
/=    	## 例句：let "x/=2"  等价于 let "x=x/2"
%=    	## 例句：let "x%=2"  等价于 let "x=x%2"
+=    	## 例句：let "x+=2"  等价于 let "x=x+2"
-=    	## 例句：let "x-=2"  等价于 let "x=x-2"
<<=		## 例句：let "x<<=2" 等价于 let "x=x<<2"
>>=   	## 例句：let "x>>=2" 等价于 let "x=x>>2"
&=    	## 例句：let "x&=2"  等价于 let "x=x&2"
^=    	## 例句：let "x^=2"  等价于 let "x=x^2"
|=    	## 例句：let "x|=2"  等价于 let "x=x|2"

15.6 shell 条件判断

1 算数条件判断表达式

<, <=, >, >= 		  ## 小于，小于等于，大于，大于等于
==, != 				  ## 等于，不等于expr1?expr2:expr3 	  ## 根据<条件判断>结果，来予以<赋值>if expr1; then expr2 ; else expr3 ; fi
expr1 && expr2 || expr3

意思是：如果怎么样，那么就怎么样，否则就这样

((x=($a<$b)?$a*10:$b*100))		## 如果 $a小于$b，则 x=$a*10，否则 x=$b*100 ## 三目运算符
a=1
b=2
echo $x							## 测试发现 输出 10

2 字符条件判断表达式

<整数>判断（正负整数）

-eq 	## 等于　　，如：arg1 -eq arg2
-ne 	## 不等于　，如：arg1 -ne arg2
-gt 	## 大于　　，如：arg1 -gt arg2
-ge 	## 大于等于，如：arg1 -ge arg2
-lt 	## 小于　　，如：arg1 -lt arg2
-le 	## 小于等于，如：arg1 -le arg2

<字符串>判断

-z string 			## 判断<字符串>长度是否为<0字节>？（长度为<0字节>，则为true真）
str=""; if [[ -z $str ]]; then echo "true"; else echo "false"; fi    	
## 显示结果：ture
str="123"; if [[ -z $str ]]; then echo "cxk"; else echo "ikun"; fi 		
## 显示结果：ikun注意：中括号之间一定要加空格string  		## 判断：<字符串>长度是否为<非0字节>？（长度为<非0字节>，则为true真）
-n string 		## 判断：<字符串>长度是否为<非0字节>？（长度为<非0字节>，则为true真）## 备注：-n 可以省略
str=""; if [[ -n $str ]]; then echo "true"; else echo "false"; fi   	
## 显示结果：false
str="123"; if [[ $str ]]; then echo "true"; else echo "false"; fi    	
## 显示结果：truestring1 = string2 	## 判断：是否相同？（如：str01□=□str02，str01□==□str02）## =等于符号 是为了确保与【POSIX系统】的兼容一致性（在test命令中应该用 =）
string1 == string2 	## 判断：是否相同？（如：str01□=□str02，str01□==□str02）    	
string1 != string2 	## 判断：是否不相同？（如：str01□!=□str02）
string1 < string2 	## 判断：是否在string2之前？（注意：按字典排序）（如：str01□<□str02）
string1 > string2 	## 判断：是否在string2之后？（注意：按字典排序）（如：str01□>□str02）

3 正则条件判断表达式

<正则条件表达式>：<操作符>

=~ 扩展正则表达式 ## 判断：是否匹配<扩展正则表达式>

注意：

在 =~ 扩展正则表达式中，=~ 左右两边各有一个<空格>

在 =~ 扩展正则表达式中，<扩展正则表达式>不要使用<""双引号>和<''单引号>

在 =~ 扩展正则表达式中，如果需要匹配<空格>，则需要使用<\转义符>

以下是扩展正则表达式

n="1.1.1.1"; [[ $n =~ ^([0-9]{1,3}(\.|$)){4} ]] && echo "符合" || echo "不符合"
n="1.1.1.1"; if [[ $n =~ ^([0-9]{1,3}(\.|$)){4} ]];then echo "符合"; else echo "不符合"; fi
## 显示结果：符合n="1..1.1"; [[ $n =~ ^([0-9]{1,3}(\.|$)){4} ]] && echo "符合" || echo "不符合"
n="1..1.1"; if [[ $n =~ ^([0-9]{1,3}(\.|$)){4} ]];then echo "符合"; else echo "不符合"; fi
## 显示结果：不符合   ..不符合要求n="1.1.1.1111"; [[ $n =~ ^([0-9]{1,3}(\.|$)){4} ]] && echo "符合" || echo "不符合"
n="1.1.1.1111"; if [[ $n =~ ^([0-9]{1,3}(\.|$)){4} ]];then echo "符合"; else echo "不符合"; fi
## 显示结果：不符合    1111不符合要求，范围是 0 到 999n="1.1 1.1.1"; [[ $n =~ ^([0-9]{1,3}(\.|$)){4} ]] && echo "符合" || echo "不符合"
n="1.1 1.1.1"; if [[ $n =~ ^([0-9]{1,3}(\.|$)){4} ]];then echo "符合"; else echo "不符合"; fi
## 显示结果：不符合		5个数不符合要求，最多四个str="/testdir/subdir"; if [[ $str =~ ^~?/ ]]; then echo "true"; else echo "false"; fi
## 显示结果：true				  ##这里的~表示家目录，0或1个以 ~ 开头，然后是 / ，满足条件
str="testdir/subdir"; if [[ $str =~ ^~?/ ]]; then echo "true"; else echo "false"; fi
## 显示结果：false

注意：

grep 命令既支持<扩展正则表达式>，又支持<Perl正则表达式>！

if 命令 =~ 仅支持<扩展正则表达式>，不支持<Perl正则表达式>！

使用grep来检验：<文件路径或目录路径>的<规范性>

要求1 可以且只能：以【/斜杠】开头或结尾，所有【/斜杠】不能重复,设计<Perl正则表达式>为：^/?

要求2 两个【/斜杠】之间，不能存在：【/斜杠】、【空格】、【Tab符】、【'或"单双引号】,设计<Perl正则表达式>为：

^(/?[^/\s\"\']+)+/?$			## 第二个 ^ 是取反的不匹配  \" 表示 "

要求3 如果路径中需要包含<空格>，则必须：在<整个路径的最外层>添加【""双引号】,设计<Perl正则表达式>为：

^[\"]{1}(/?[^\"\']+)+/?[\"]{1}$

注意：下面的写法实际上输出不是以 ” ” 开头和结尾，所以不要被后面的匹配 ‘’ ‘’ 给骗了

str="/testdir/subdir"
echo $str | grep -oP "(^(/?[^/\s\"\']+)+/?$|^[\"]{1}(/?[^\"\']+)+/?[\"]{1}$)" && echo "匹配" || echo "不匹配"
## 显示结果：匹配str="  /testdir/subdir"  ## <赋值语句>会自动去掉<字符串>前后的<空格>
echo $str | grep -oP "(^(/?[^/\s\"\']+)+/?$|^[\"]{1}(/?[^\"\']+)+/?[\"]{1}$)" && echo "匹配" || echo "不匹配"
## 显示结果：匹配    是匹配前面的   而不是匹配后面的str="/test  dir/subdir"
echo $str | grep -oP "(^(/?[^/\s\"\']+)+/?$|^[\"]{1}(/?[^\"\']+)+/?[\"]{1}$)" && echo "匹配" || echo "不匹配"
## 显示结果：不匹配str="/testdir//subdir"
echo $str | grep -oP "(^(/?[^/\s\"\']+)+/?$|^[\"]{1}(/?[^\"\']+)+/?[\"]{1}$)" && echo "匹配" || echo "不匹配"
## 显示结果：不匹配str="\"/test  dir/sub dir\""
echo $str | grep -oP "(^(/?[^/\s\"\']+)+/?$|^[\"]{1}(/?[^\"\']+)+/?[\"]{1}$)" && echo "匹配" || echo "不匹配"
## 显示结果：匹配str="\"/test  dir/sub dir/\""
echo $str | grep -oP "(^(/?[^/\s\"\']+)+/?$|^[\"]{1}(/?[^\"\']+)+/?[\"]{1}$)" && echo "匹配" || echo "不匹配"
## 显示结果：匹配  这才是 匹配后面的  以双引号开头，双引号结尾

4 多个条件判断表达式

组合符

&& 逻辑与

|| 逻辑或

示例1：组合使用多个<算数条件表达式>

(((1<2)&&(2<3)))    或者     [[ ( 1 < 2 ) && ( 2 < 3 ) ]]
echo $?          ## 结果显示：<算数条件表达式>的<状态返回值>为<0>  判断上条命令运行结果，正确返回 0，错误返回1  和布尔类型相反
(((2<1)||(2<3)))
echo $?          ## 结果显示：<算数条件表达式>的<状态返回值>为<0>

示例2：组合使用多个<字符条件表达式>

[[ "a" == "a" ]] && [[ "b" == "b" ]]
echo $?          ## 结果显示：<字符条件表达式>的<状态返回值>为<0>
[[ "a" == "a" ]] || [[ "a" == "b" ]]
echo $?          ## 结果显示：<字符条件表达式>的<状态返回值>为<0>

5 test 条件判断命令（判断文件）

这里可以拿来判断文件是否存在，是什么类型的文件，是否为空文件等等

test 和 [[ ]] 用法一样

1 判断：任意类型的文件（Linux一切皆文件）

-a filename 			## 如果filename存在，不管文件是什么类型，则为true真
-e filename 			## 如果filename存在，不管文件是什么类型，则为true真
-s filename 			## 如果filename存在，并且是<非空文件(长度 > 0字节)>，不管文件是什么类型，则为true真
[[ -a /etc/passwd ]]  或者   test -a /etc/passwd
比如：
if test -e filename; thenecho "文件存在"
fi# 或者使用 [[ ]]
if [[ -e filename ]]; thenecho "文件存在"
fi

2 判断：特定类型的文件（Linux一切皆文件）

-f filename 		## 如果filename存在，且为<常规文件>，则为true真
-d filename    		## 如果filename存在，且为<目录>，则为true真
-b filename    		## 如果filename存在，且为<块文件>，则为true真
-c filename			## 如果filename存在，且为<字符设备文件>，则为true真
-S filename 		## 如果filename存在，且为<socket套接字文件>，则为true真
-p filename 		## 如果filename存在，且为<命名管道文件>，则为true真
-h filename 		## 如果filename存在，且为<符号链接文件>，则为true真
-L filename 		## 如果filename存在，且为<符号链接文件>，则为true真## 注意：<符号链接文件>不是<硬链接文件>

3 判断：文件的属性（Linux一切皆文件）

-r filename 		## 如果针对filename，<当前用户>拥有<r读权限>，则为true真
-w filename 		## 如果针对filename，<当前用户>拥有<w写权限>，则为true真
-x filename 		## 如果针对filename，<当前用户>拥有<x可执行权限>，则为true真
-u filename 		## 如果filename设置了<SUID权限位>，则为true真
-g filename 		## 如果filename设置了<SGID权限位>，则为true真
-k filename 		## 如果filename设置了<SBIT权限位>，则为true真
-O filename 		## 如果filename的<所有者>是<当前用户>，则为true真
-G filename 		## 如果filename的<所有者>是<当前用户>的<主要组>，则为true真
-N filename 		## 如果filename在<最后一次读取>之后被修改，则为True真
-t fd 				## 如果<fd文件描述符>关联着一个<终端>，则为True真例如：test -t 0      ## 文件描述符0：是关联着<终端>的<标准输入>
例如：test -t 1      ## 文件描述符1：是关联着<终端>的<标准输出>
例如：test -t 2      ## 文件描述符2：是关联着<终端>的<标准错误输出>

4 判断：文件的对比（Linux一切皆文件）

file01 -nt file02 		## 如果file01比 file02新，则为true真
file01 -ot file02 		## 如果file01比 file02旧，则为true真
file01 -ef file02 		## 如果file01和file02是同一个文件，则为true真## 主要是依据file01和file02各自的inode编号，来判断是否为<硬链接文件/软连接文件>？

5 判断：字符串 STRING 代表字符串，不是特指

-z STRING 			## 判断：<字符串>是否为<空>？   
-n STRING 			## 判断：<字符串>是否为<非空>？
STRING1 = STRING2 	## 判断：<字符串>是否为<相等>？
STRING1 != STRING2 	## 判断：<字符串>是否为<不相等>？
STRING1 < STRING2 	## 基于<字典>来判断：<字符串1>是否小于<字符串2>？
STRING1 > STRING2 	## 基于<字典>来判断：<字符串1>是否大于<字符串2>？

6 判断：数值

arg1 OP arg2		## 比较：arg1和arg2这两个<算数值>## OP是<操作符>，取值范围是：-eq等于、-ne不等于、-lt小于、-le小于等于、-gt大于、-ge大于等于。

7 判断：其他

-o OPTION 			## 如果指定的<set内建的Shell选项>已经<启用>，则为true真
例如：
[ -o history ] && echo $?  ## 判断是否启用了<set内建的Shell选项：history功能>？
-v VAR 					   ## 如果一个<VAR变量>已被<定义并赋值>，则为true真

8 逻辑操作

! EXPR ## 执行：逻辑取反

EXPR1 -a EXPR2 ## 执行：逻辑与

EXPR1 -o EXPR2 ## 执行：逻辑或

举例：

[ -d /tmp -a -d /etc ] && echo $?
[ -d /tmp -o -d /dir01 ]  && echo $?

6 [ ] 和 [[ ]] 的区别

建议用 [[ ]]

[ ] ：它是一个<命令>，是<test 内嵌命令>的<简写形式>。
[[ ]] ：它不是一个<命令>，只是一个中的<关键字>，[[ ]] 结构比 [ ] 结构更加通用。

[[ ]] 用法：里面每一个参数都要隔开，严格按照格式，不能紧贴着，包括不能贴着两边

双中括号[[]]是bash shell中的关键词，相对于[]有以下特点和优势：

[[ ]] 结构比[ ]结构更加通用。在[[和]]之间所有的字符都不会发生文件名扩展或者单词分割，但是会发生参数扩展和命令替换。支持字符串的模式匹配，使用=~操作符时甚至支持shell的正则表达式。字符串比较时可以把右边的作为一个模式，而不仅仅是一个字符串，比如[[ hello == hell? ]]，结果为真。[[ ]] 中匹配字符串或通配符，不需要引号。使用[[ ... ]]条件判断结构，而不是[... ]，能够防止脚本中的许多逻辑错误。比如，&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中，但是如果出现在[ ]结构中的话，会报错。bash把双中括号中的表达式看作一个单独的元素，并返回一个退出状态码。实际上，原理就是，在双中括号中，可以使用=~进行shell的正则匹配，找出右边的字符串是否在左边的字符串中。但是需要注意的是，双中括号在bash中可以使用，在sh中会报找不到的错，这是一个大坑。

7 if 条件判断语句

注意：if 之后判断一次，不能直接用来做循环，循环得用 for 和 while

1 语法

语法1：

if 条件; then 操作; [elif 条件; then 操作;] ... [else 操作;] fi
注意： elif 和 else  如果不需要可以不写，看条件选一个完成，完不成都选择

语法2 :

if 条件; then操作
[elif 另外满足的条件; then操作]
... ...
[else操作]
fi

语法3 ：常用

if 条件
then操作
elif 条件
then操作
... ...
else操作
fi
注意： if 和 elif 都需要加 then   ，else 不需要加 then  ,开头 if  结尾   fi

2 工作原理

按序依次检查：<if COMMANDS;语句块>和<elif COMMANDS;语句块>的<状态返回值>

如果 <状态返回值> = 0　，则执行：<then COMMANDS;语句块>

如果 <状态返回值> = 非0，则执行：<else COMMANDS;语句块>

3 例子

以下例子全用脚本来写

输入1就1，输入2就2 输入别的就空格

#!/bin/bash
read -e -p "请输入一个数字：" a
if (( $a==1 ))
thenecho "你输入的是1"
elif (( $a==2 ))
thenecho "你输入的是2"
elseecho " "
fi
注意：这里条件判断使用 [[ ]]  也可以

字符条件判断

a="ABC"
b="CBA"
if [[ $a < $b ]]
thenecho "<a变量值>的<字符串编码数>小于<b变量值>"
elif [[ $a == $b ]]
thenecho "<a变量值>的<字符串编码数>等于<b变量值>"
elseecho "<a变量值>的<字符串编码数>大于<b变量值>"
fi

字符条件判断，，输入 no 输出yes，输入yes输出no

#!/bin/bash
read -e -p "请输入： " a
if [[ $a == "yes" ]]
thenecho "no"
elif [[ $a == "no" ]]
thenecho "yes"
elseecho "你是人才吗"
fi

定义 holiday_name 字符串变量记录节日名称（字符串判断）

如果是 情人节 应该 买玫瑰／看电影

如果是 平安夜 应该 买苹果／吃大餐

如果是生日应该 买蛋糕

其他的日子每天都是节日啊……

#!/bin/bash
read -e -p "请输入节日名称：" holiday_name
if [[ $holiday_name == "情人节" ]]
thenecho "如果是$holiday_name应该买玫瑰"
elif [[ $holiday_name == "平安夜" ]]
thenecho "如果是$holiday_name应该买苹果"
elif [[ $holiday_name == "生日" ]]
thenecho "如果是$holiday_name应该买蛋糕"
elseecho "其他的日子每天都是节日啊……"
fi

判断是否有 /etc/passwd 文件存在 (test判断)

#!/bin/bash
if [[ -a /etc/passwd ]]
thenecho "存在"
elseecho "不存在"
fi

判断数组是否含有某变量在其中（正则表达判断）

#!/bin/bash  
a="abc"
char_list=("bcd" "abc" "xyz")
if [[ ${char_list[*]} =~ $a ]] 			## =~ 匹配正则
then										echo "$a包含在字符串序列中"
elseecho "$a不包含在字符串序列中"
fi

8 case 条件判断命令

1 功能

根据匹配的<PATTERN模式>，有选择的执行<COMMANDS命令>

case 与 if 的不同在于：case只做一次<条件判断>，if可做多次<条件判断>

2 语法

case $a in												  case $a in
判断条件1 )													判断条件1 )操作															操作
;;														  ;&
判断条件2 )													判断条件2 )操作															操作					
;;														  ;&
……														  ……
;;														  ;&
* )														  * )操作															操作
;;														  ;&
esac													  esac#注意：case里面不需要 then ;;          ## 表示一旦匹配，则不继续往下执行<其他PATTERN模式>的<指令>;&          ## 表示即便匹配，也会继续往下执行<其他PATTERN模式>的<指令>(无论是否匹配)

3 例子

使用脚本来写，和 if 用法差不多

#!/bin/bash
read -e -p "请输入你的年龄 = " age
case $age in[0-9])echo "你是儿童";;1[0-9])echo "你是青少年";;2[0-9])echo "你正值壮年";;[3-5][0-9])echo "你步入中年了";;[6-8][0-9])echo "你是个老人了";;9[0-9]|1[0-9][0-9])echo "你是个神仙了";;*)echo "你是人还是鬼？";;
esac

输入1就1，输入2就2 输入别的显示您真是一个大聪明

#!/bin/bash
read -e -p "请输入一个数字 " a
case $a in
1 )
echo "您输入的是1"
;;
2 )
echo "您输入的是2"
;;
* )
echo "您真是一个大聪明"
;;
esac

输入 yes 就输出no

#!/bin/bash
read -e -p "请输入： " a
case $a in
"yes")echo "no"
;;
"no")echo "yes"
;;
*)echo "你是人才吗"
;;
esac

9 ; && ||

符号	功能	例句
; 分号	在一行中，依次执行多个命令, 不管<左边命令>是否执行成功，都将执行<右边命令>	echo “ $x "; ec h o "$ PATH”
&&	条件判断：<&&左边命令>的<状态返回值>为 0(满足)，方可执行<&&右边的命令>	echo “ $KaTeX parse error: Expected 'EOF', got '&' at position 4: x" &̲& echo "$ PATH”
\|\|	条件判断：<\|\|左边命令>的<状态返回值>为非0(不满足)，方可执行<\|\|右边的命令>	echo “ $x "∣∣ ec h o "$ PATH”

例子

[ -d /tmp ] && rm -rf /tmp/* || echo "没有这个目录"
[ -d /tmp ] || echo "没有这个目录" && rm -rf /tmp/*## 两个意思一样：有没有/tmp 目录，有的话删除 /tmp/目录下所有文件，没有的话就输出 没有这个目录  （第一个好理解）

组合条件判断

[ -d /tmp -a -d /etc ] && echo "两个目录均存在" || echo "至少其中一个目录不存在"
[ -d /tmp -o -d /dir01 ] && echo "其中一个目录一定存在" || echo "两个目录均不存在"

15.7 shell 循环控制

15.7.1 for 循环

for 里面判断条件是一些数学算数判断循环，如果是字符这方面，要到 if 里面去判断

注意： for 循环里面可以嵌套 if 和 for 循环

类似于

for ……								类似于   if [[  ]]
do											then	……											……
done										fi

语法 1 ： for ((EXPR1; EXPR2; EXPR3)) ; do COMMANDS ; done

#!/bin/bash
for ((n=1;n<3;n++))
dotouch $n.txt
done
创建 1.txt  2.txt

语法 2：for 变量 [in 单词序列] ; do COMMANDS; done i为变量 for i in ……

#!/bin/bash
for a in 1 2 3 4 55			或者  for a in {1..10}
doecho "$a"
done

死循环

for ((;;)); doecho "这是一个死循环，按Ctrl + c结束"
done						## 初始值，条件，增量都不写或者for ((i=1;;i++)); doecho "这是一个死循环，按 Ctrl + c 终止"
done						## 不写循环条件或者for ((i=1;i<=10;)); doecho "这是一个死循环，按 Ctrl + c 终止"
done						## 不写增量

强制 y

#!/bin/bash
for ((;;))
doif [[ $Y != "y" ]]thenread -e -p "请输入(y/n)：" Yelseexitfi
done

强制玩原神

#!/bin/bash
for ((;;))
doif [[ $Y != "玩" ]]thenread -e -p "你玩原神吗？ (玩/不玩)" Yelseexitfi
done## 注意：因为要使该循环无限运行，使用要使 for 运行死循环，在使用if判断退出循环

使用ping命令去测试整个 192.168.1.0 网段，将能ping通的机器ip写到/tmp/ok.txt .将不能ping通的ip写到/tmp/no.txt （本公司网段）

将 ping 成功或者错误的信息丢进黑洞，每一个 ping 跑3遍即可，不然太慢了

#!/bin/bash
for ((a=1;a<256;a++))
doif ping 192.168.1.$a -c 3 &>> /dev/nullthenecho 192.168.1.$a >> ok.txtelseecho 192.168.1.$a >> no.txtfi
done
## -c 3 表示显示3次即可，不然ping 会一直显示在屏幕上，没学进程只能开新窗口解决
## 注意：& 要紧贴 重定向符号，表示全部信息，无论正确错误的信息都丢尽黑洞 /dev/null
## ping的过程很久，因为有 255 个ip ，可以开两个新窗口 tail -f /tmp/ok.txt 和 tail -f /tmp/no.txt 实时查看

15.7.2 while 循环

满足条件就继续循环，不满足就中止循环

for能做的while也可以，for不能的while也可以

语法：

初始值定义
while 条件
do……
done						## 最好有初始值定义，不然无法进入该循环

强制 y

#!/bin/bash
Y="n"
while [[ $Y != "y" ]]
doread -e -p "请输入(y/n)：" Y
done如果用 for 循环来做，如下，需要先让for进入死循环
#!/bin/bash
for ((;;))
doif [[ $Y != "y" ]]thenread -e -p "请输入(y/n)：" Yelseexitfi
done

强制玩原神

#!/bin/bash
a="随便写"
while [[ $a != "玩" ]]; doread -e -p "你玩原神吗[玩/不玩]: " a
done[root@dj tmp]# bash 3.sh
你玩原神吗[玩/不玩]: 玩
[root@dj tmp]# bash 3.sh
你玩原神吗[玩/不玩]: 不玩
你玩原神吗[玩/不玩]: 不玩

死循环

while true; doecho "OK"
done

手动创建用户，并核对二次密码

y="no"
while [[ $y == "no" ]]; doread -e -p "请输入用户名=" usernameread -e -s -p "请输入密码(不少于8个字符)=" aechoread -e -s -p "请再次输入密码(不少于8个字符)=" bechoif [[ $a == $b ]]; thenecho "OK，你本次密码设置有效"echo "$username:$a" | chpasswdy="yes"elseclearecho "NO，你的两次密码不一致，请重新输入！"y="no"fi
done

创建十个用户，分别叫user1-user5，批量设置密码，pass1-pass5
如果用户已存在则输出用户已存在，如果用户不存在则创建用户设置密码

#!/bin/bash
zh=1
while (($zh <= 10))	
doif id user$zh &> /dev/null					then										echo "用户user${zh}已经存在"    elseuseradd user$zhmm=$zhecho "user$zh:pass$mm" | chpasswdecho "用户user${zh}创建成功"echo "用户密码设置成功"fi((zh++))
done
## 如果用户存在，那么 if 会执行成功，把id user$zh 命令成功的信息写进黑洞，然后运行第一个
## 如果用户不存在，那么 if 会执行失败，把报错信息写进黑洞，然后运行第二个

计算 1+2+3+……+100 = 5050

#!/bin/bash
num=0
n=1
while ((n<=100))
do((num=num+n))((n++))
doneecho $num或者#!/bin/bash
num=0
for ((n=1;n<=100;n++))
do((num=num+n))
doneecho $num

15.7.3 while read 循环语句

语法1：遍历<标准输入>的<行>循环

COMMANDS | while read VAR; do COMMANDS; done

了解即可...

语法2：遍历<文件>的<行>循环

while read VAR; do COMMANDS; done < FILE

15.7.4 until 循环语句

直到<条件满足>，就终止循环

不满足条件就一直循环，满足就中止和 while 相反

所以当 until 和 while 条件范围相反，完成的内容其实是一样的

强制 y

Y="n"
until [[ $Y == "y" ]] 
doread -e -p "请输入(y/n)：" Y
done

15.7.5 continue 命令

功能：中止本次循环，但是不会中止本轮全部循环，会直接跳转到下一次循环 跳过的意思

语法： continue [N] 终止<本轮循环>

● 仅在<N层嵌套循环体>语句结构中，发挥作用，可以终止<当前循环体>的<第N层上级循环体>

● <第1层>就是<循环体自身>，即：continue 1 等同于 continue

要知道 continue和break还有exit的区别

# 打印 1 到 10 之间的奇数
#!/bin/bash
for ((i=1; i<=10; i++))
doif ((i % 2 == 0))thencontinuefiecho $i
done
##如果是偶数就不满足条件，直接中断本次循环到下一次循环判定

15.7.6 break 命令

功能：中止本轮全部循环，直接退出循环 停止的意思

语法： break [N] 终止<整个循环>

● 仅在<N层嵌套循环体>语句结构中，发挥作用，可以终止<当前循环体>的<第N层上级循环体>

● <第1层>就是<循环体自身>，即：break 1 等同于 break

和exit 区别：break之后退出该循环，但是会执行循环外面的内容

exit 直接跳出脚本，当前面使用了exit ，后面的内容直接不生效

如果循环外部后面没有内容，那exit 和 break 都可以使用

# 示例：找到第一个大于 5 的数字
#!/bin/bash
numbers=(1 2 3 4 5 6 7 8 9 10)for num in ${numbers[*]}
do# 如果数字大于 5，则打印并终止循环if [[ $num > 5 ]]thenecho "找到第一个大于 5 的数字：$num"break  #exit # 如果把break 替换为 exit ，那循环外面的内容则无用，即后面那句话不会显示fi
done
echo "break就显示，exit不显示"[root@dj ~]# bash 5.sh
找到第一个大于 5 的数字：6
break就显示，exit不显示[root@dj ~]# vim 5.sh	改成exit保存后
[root@dj ~]# bash 5.sh
找到第一个大于 5 的数字：6本来要循环10次，找到大于5的直接中止循环

15.8 sed 三剑客之一

15.8.1 命令简介

重要：可修改匹配的行或者匹配的内容返回文件，玩出花来的正则表达式

sed 是一个用于过滤并转换文本行的流编辑器

sed 和 vi 的区别：

vi 是<交互式>的<文本编辑器>

sed 是<非交互式>的<文本流编辑器>，接受<input输入字符流>，然后过滤并转换，最后输出<output输出字符流> 适合脚本和dockerfile

注意：sed 和 vi 有一些命令是通用的，比如替换 s///

sed 是一个基于<行>字符流，执行<整行处理>的<文本处理工具>

awk 是一个基于<行>字符流，精细到<列处理>的<文本处理工具>

15.8.2 工作原理

重点理解：

逐行输入、逐行处理、逐行输出。（从左到右，从上到下，一般原文件不会改变）
在<模式空间>：暂存数据、处理数据、输出数据、清空数据

在这里插入图片描述

15.8.3 sed 的运用

注意：sed 里面替换那里不能使用 \s 做制表符，可以使用 \t ，因为 s有替换的意思 \s 会转义成s 和 s一样

功能：匹配某一行，也可以进行操作修改，或者对行内的某一些内容修改

语法：

sed [options] script filename

sed [options] -f script filename

sed 选项 ’ 地址范围和子命令(正则) ’ 文件名

注意：要修改文件的话必须在后面接文件名，如果是前面用| ，那么不能修改，因为只是对前面匹配到的字符串进行操作而不是原文件

选项

-r					## 使用扩展正则
-e					## 可以同时对文件执行多个 子命令  ## 如-e 'script01' -e 'script02' -e 'script03'
-n 					## 抑制 sed命令 的标准输出，因为不使用该命令对文件操作会输出文件原内容和操作的内容
-i					## 回写 标准输出到源文件，是覆盖式回写 （修改原文件）
-i.bak				## 修改原文件之前进行备份
-f   				## 后接sed脚本，指定执行的sed脚本
\< \>				## 单词边界 ，比如 \<root\> 仅匹配root## rootab wadroot 这种不匹配，重要

-e 作用

打印pass文件的第1行和第3行
sed '1p;3p' /tmp/pass  或 sed -e '1p' -e '3p' /tmp/pass 删除第一行和最后一行
sed '1d;$d' pass打印最后一行，原理：删除第一到倒数第二行即可    sed '$!d' pass
sed '!$d' pass  和  sed '1,($-1)d' pass  都不行，必须如上所示

-n 的作用

[root@dj ~]# sed  '' /tmp/passwd
[root@dj ~]# sed -n '' /tmp/passwdsed -n '$p' /tmp/passwd 		## 输出最后一行打印出来
sed -ni '1,5p' passwd 			## 把文件内容改成原文件内容前五行
sed -r 's/^([a-zA-Z0-9]+)([^a-zA-Z0-9])([a-zA-Z0-9]+)/\3\2\1/'		## 交换第一个和第三个单词

常用的sed 子命令

i\		      	    	##  不写\也行 在指定行新建上一行写入内容
c\						## 在指定行替换写入内容，常用，用这个进行匹配并替换整行内容
a\						## 在指定行新建下一行写入内容  追加
r\					    ## 在指定行新建下一行写入指定文件的内容 插入
比如 
sed '1a 1.txt' passwd   ## 会在passwd文件第一行下面写入 "1.txt"	
sed '1r 1.txt' passwd	## 会在passwd文件第一行下面写入文件1.txt里面的内容!						## 放在命令面前取反		
d						## 删除，写在要删除的内容的后面
p						## 打印，写在要打印的内容的后面
q						## q 匹配到 第5行就退出地址范围：
1   				## 就是处理第1行
$   				## 处理最后一行
1,5					## 处理1到5行  sed '1,5p' 1.txt
2~2 				## 从第2行开始,每隔1行  注意：2~1 相当于 2,$  ,第二行到最后一行
2~5					## 从第二行开始，每隔4行
3,+5   				## 处理3-8行或者以正则表达式匹配的作为地址范围（精确处理）
1)、/正则表达式/     一般出现 /   /    不是正则表达式 就是  替换				
如：/^root/
2)、/正则表达式1/,/正则表达式2/		表示从第一次匹配到正则表达式1开始到第一次匹配到正则表达式2之间的所有行
如：/^r/,/^s/  或者   '/^root/,/^b.*n$/p'匹配那一行改为禁用模式
sed -r -i '/^[ \t]*SELINUX=/c\SELINUX=disabled' /etc/selinux/config		
注意：如果匹配到范围开头，但是范围结尾匹配不到，那会匹配开头那行到最后一行如果匹配到范围结尾，没有匹配到开头，那就匹配不到s/被替换/替换/   s|||  s###   s@@@ 替换
g 			## 全局替换 一行的全局  vi需要在前面加 % ，这个不用，因为默认是替换所有行的第一个关键字（g写在后面）
i  			## 查找时忽略大小写
n  			## 第n个被匹配到的   n表示数字
&			## 表示将要被替换关键字   
sed -r 's/l..e/&r/' 1.txt		##  &代表前面的 l..e   .代表任意单个字符
\1  \2		## 如果被替换的内容使用了(),即正则分组进行分成几组## 那么 \1 \2 分别表示第一组和第二组
注意：g 写在后面，& 和 \1 这些写在 替换 那里，()和别的正则 或者 地址范围写在 被替换 那里y///        ## 也是替换，但是如果找不到被替换的，会把被替换的分开出来找
s/abc/ABC/	## 把abc替换成 ABC	,前提要有 abc 整体
y/abc/ABC/	## 把a替换成A ,b替换成B,c替换成C仅将 root替换ROOT，但是rootab不会匹配到替换成 ROOTab
sed 's/\<root\>/ROOT/g' pass
注意：使用 s###的时候，如果匹配内容有 / ，那么不需要使用转义字符进行转义

分别指定第一行写入123456 查看 i c a 的区别

[root@dj ~]# sed  '' /tmp/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin       ## 原内容,后面还有很多行省略...[root@dj ~]# sed  '1i\123456' /tmp/passwd
123456
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin[root@dj ~]# sed  '1c\123456' /tmp/passwd
123456
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin[root@dj ~]# sed  '1a\123456' /tmp/passwd
root:x:0:0:root:/root:/bin/bash
123456
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin难点：
[root@dj tmp]# sed '/^root/a\hello\nworld' /tmp/passwd    ## \n 是换行符
root:x:0:0:root:/root:/bin/bash
hello
world
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin意思：匹配以 root开头    a\ (格式，下一行新建行写入)

查看 d p 的作用，删除第1到2行，从第一行开始，每隔一行进行打印里面包括简单的地址范围

[root@dj ~]# sed  '1,2d' /tmp/passwd
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin[root@dj ~]# sed  '1~2p' /tmp/passwd
root:x:0:0:root:/root:/bin/bash
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin

地址范围难点正则表达式

匹配以root开头的所有行并打印
[root@dj tmp]# sed -r '/^root/p' /tmp/passwd  
root:x:0:0:root:/root:/bin/bash
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin匹配以root开头那一行开始  以^b为开头那一行为结尾，打印
[root@dj tmp]# sed -r '/^root/,/^b/p' /tmp/passwd  
root:x:0:0:root:/root:/bin/bash
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin匹配从r开头那一行开始，到b开头 n结尾那一行结束并打印
[root@dj tmp]# sed -r '/^root/,/^b.*n$/p' /tmp/passwd  
root:x:0:0:root:/root:/bin/bash
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin

替换内容难点 s/// ,如果替换内容有 / ，可以改成 s###测试

cat 1.txt	## 查看原文件内容
hello like 
my love 		[root@dj tmp]# sed -r 's/l..e/&r/' 1.txt	## &代表前面的 l..e 即like和love
hello liker
my lover[root@dj tmp]# sed -r 's/l(.)(.)e/\2\1s/' 1.txt
hello kis						## 难点：ik 和 ov满足匹配，并被分为两组			
my vos							## 将匹配的内容，替换成 正则的 第二组 + 第一组 加 r## i 是第一组 k是第2组 ，第二行的o是第一组，v是第二组删除每一行倒数第二个字符
[root@dj tmp]# sed -r 's#(.)(.)$#\2#' /tmp/passwd  
root:x:0:0:root:/root:/bin/bah
bin:x:1:1:bin:/bin:/sbin/nologn
daemon:x:2:2:daemon:/sbin:/sbin/nologn## 匹配倒数最后两个字符分两组，然后替换成第2组，第1组（倒数第二个字符）就没了将passwd文件的每一行 第二个字符和倒数第二个字符替换
sed -r -e 's/^(.)(.)(.*)(.)(.)$/\1\4\3\2\5/' passwd  ## 无-e也行，只有一个子命令注意：在这里如果要\1\2之间有空格，可使用空格键和 \t,\s不行，会和s一样在 \1 \2 之间输出s，因为s有替换的功能，\s相当于转义成s

15.9 awk 命令

15.9.1 awk 命令简介

1、awk的特点和作用
格式化文本，对文本进行比较复杂的格式处理（此格式化是变成有格式，而不是删除内容的格式化）

2、awk的程序结构（也就是语法结构）
语法：awk 选项 ‘BEGIN{命令} pattern{命令}END{命令}’ 文件名

AWK 是一种解释执行的编程语言，它非常的强大，被设计用来专门处理文本数据。

AWK 的名称是由它们设计者的名字缩写而来 —— Afred Aho, Peter Weinberger 与 Brian Kernighan。

GNU/Linux 发布的 AWK 版本通常被称之为 GNU AWK，由自由软件基金（ Free Software Foundation, FSF）负责开发维护的

目前总共有如下几种不同的 AWK 版本。

AWK 这个版本是 AWK 最原初的版本，它由 AT&T 实验室开发。

NAWK NAWK(New AWK)是 AWK 的改进增强版本。

GAWK GAWK 即 GNU AWK，所有的 GNU/Linux 发行版都包括 GAWK，且 GAWK 完全兼容 AWK 与 NAWK。

CentOS 7 中，<awk命令>就是<gawk命令>的<符号链接文件>

★ AWK 可以做非常多的工作，下面只是其中的一小部分：

文本处理

生成格式化的文本报告

进行算术运算

字符串操作

以及其它更多

15.9.2 awk 工作原理

★ AWK 执行的流程非常简单：读（Read）、执行（Execute）与重复（Repeat）

★ AWK 分为三个功能代码块：

(1) BEGIN {…;…;…}开始块 ☚ 可选

(2) pattern {…;…;…}主体块 ☚ 必选重要

(3) END {…;…;…} 结束块 ☚ 可选

15.9.3 awk 基本运用

1 原理

1. 了解：BEGIN {…;…;…} 开始块

注意：<BEGIN开始块>是可选的，你的程序可以没有<BEGIN开始块>。

开始块的语法： BEGIN {awk-commands}

同一行多个<awk子命令>用<;分号>隔开

功能：顾名思义，<开始块>就是在<程序启动>时的<执行代码>，并且它在<整个过程>中只<执行一次>。

一般情况下，我们在<开始块>中<初始化>一些<变量>，BEGIN 是 AWK 的关键字，因此它必须是大写的。

2 了解 pattern {…;…;…} 主体块 （重要）

主体块是必有的

主体部分的语法： pattern {awk-commands}

同一行多个<awk子命令>用<;分号>隔开

在<主体块>没有<关键字>的存在，pattern 表示<模> ，但是pattern不是关键字。（使用awk不用写，默认’ ’ 里面就是主体块）

功能：对于<每一个输入的行>都会执行一次<主体部分的命令>，但是，我们可以将其限定在指定的<pattern模>中。

<pattern模>可以是：

/正则表达式/		awk '/pattern/ {print $0}' file   ## 打印 主体块的全部内容
关系表达式		awk 'END{print $0}' file 		  ## 打印最后一行

多个 pattern模的运用：

pattern1&&pattern2          ## 表示逻辑与（AND），既要匹配pattern1，也要匹配pattern2
pattern1||pattern2          ## 表示逻辑或（OR），或者匹配pattern1，或者匹配pattern2
pattern1?pattern2:pattern3	## 表示如果pattern1匹配为ture，则执行 pattern2匹配，否则，则执行 pattern3匹配
(pattern)                   ## 表示限定pattern的范围
!pattern                    ## 表示不匹配pattern
pattern1,pattern2           ## 表示从匹配pattern1的行开始，到匹配pattern2的行结束##  通过<正则表达式>来表示<一个字段的结尾>，可以使用<$符号>，因为awk将<每一个字段>当做<一个个的小行>。

例子

cat >1.txt <<EOF
tcp  1.2.3.4
tcp6 1.2.3.4
EOF匹配第一个字段以tcp字符串结尾的行
[root@dj tmp]# cat 1.txt | awk '$1~/tcp$/{print}'	
tcp  1.2.3.4## ~/tcp$/ 表示正则匹配以 tcp 结尾的字符串匹配第一字段(列)以6结尾的行
[root@dj tmp]# cat 1.txt | awk '$1~/6$/{print}'			
tcp6 1.2.3.4## ~ 表示后面正则匹配的对象是匹配前面的内容，而不是全文匹配，这里是对第一字段进行匹配

3. 了解：END {…;…;…} 结束块

注意：<END结束块>是可选的，你的程序可以没有<END结束块>。

结束块的语法： END {awk-commands} ☚ 同一行多个<awk子命令>用<;分号>隔开

顾名思义，<结束块>是在程序结束时执行的代码，并且它在整个过程中只执行一次。

END 也是 AWK 的关键字，它也必须大写。

2 awk 简单语法和例子

用法选项介绍

可以精准定义某一行某一列的某一内容。

语法 awk ’ {print } ’ 1.txt

注意： { } 外面左边匹配行，NR匹配行号或者 ~匹配正则，定义行。{ }里面匹配列(字段)

语法：

awk 选项 ‘’ 文件名注意：’ '里面写操作命令或者内置变量，比如 ‘NR==1 {print $1}’
命令 | awk 选项 ‘’
命令 | xargs awk 选项 ‘’

选项：

-F 		## 指定分割符，不写默认以空白为分隔符    常用
例如 
-F ":" ,以：为分隔符    
-F ":|/" ,以：或者 / 作为分隔符-v		## 自定义变量

内置变量:

NR 		## 指定行 默认全部行  ## 如  NR==2 文件第二行， NR > 2 第三行到结尾  {print NR}输出行号
\t  	## 是TAB键
\n  	## 是换行符
$1  	## 是内置变量，$0表示一整行，$1表示每行的第1列，$2表示每行的第2列
$0这个变量包含执行过程中当前行的文本内容NF 		 表示每一行的字段数，默认分隔符是空白  {print NF} 打印每行的字段数
$NF		 当前行最后一个字段的值		{print $NF}	打印每一行最后一个字段
$(NF-1)  当前行倒数第二个字段的值FIELDWIDTHS		## 定义每个数据字段宽度 
FS				## 输入列字段分隔符（默认是空格）
RS				## 输入行分隔符（默认是换行符\n）
OFS				## 输出列字段分隔符（默认值是空格），可替换分隔符输出，不能修改源文件
ORS				## 输出行分隔符（默认值是换行符\n）

例子：不常用

OFS:  也是修改分隔符，不过在BEGIN 里面使用 例如 把 ：作为分隔符，并改成 @ 显示出来
[root@dj tmp]# awk -F ":" 'BEGIN{OFS="@"} {print $1,$2,$4}' passwd
root@x@0
bin@x@1
daemon@x@2if (条件表达式){动作}else if(条件表达式){动作}else{动作}
awk -F ":" '{if($3==0){print $0" 这是root用户"}else if(($3>0)&&($3<1000)){print $0" 这是系统用户"}else{print $0" 这是普通用户"}}' /etc/passwd案例：
awk '{max=$1;for(i=2;i<=4;i++){if($i>max){max=$i}}print max}' /tmp/number
awk  -F : 'NR==1{for(i=1;i<=NF;i++){print $i}}' /etc/passwd

1 主体用法案例

下面语法都是只使用了主体而没有使用 BEGIN 和 END

例子自定义变量

用户自定义变量
定义变量和引用变量，均不需要加$符号(推荐使用小写)
例子：
[root@exercise1 opt]# awk 'BEGIN{var="1"}{print var}' a2.txt
1
1   
使用选项定义变量
[root@exercise1 opt]# awk -v var=1 '{print var}' a2.txt
1
1
## 有多少行就输出多少个1，在主体里面有多少行 就打印多少次打印passwd行数
awk '{n++;}END{print n}' /etc/passwd
或者
awk -v n=0 '{n++}END{print n}' passwd

例子 NR

打印passwd文件的奇数行和偶数行  还有行号显示
awk 'NR%2==0{print NR,$0}' /tmp/passwd		## 偶数行 括号里面的 NR 表示打印行号
awk 'NR%2!=0{print NR,$0}' /tmp/passwd		## 注意：$0 是打印全部内容把第一行的字段换行显示出来
awk  -F : 'NR==1{for(i=1;i<=NF;i++){print $i}}' /etc/passwd

例子 -F 和 print 还有 printf

df -h | awk '{print $5}' 				## 输出每一行的第五字段的内容
awk -F ":" '{print "随便输出"}' passwd	 ## 输出每一行，写着 随便输出 ，有多少行就输出多少个 随便输出
awk -F ":/" '{print $1}' passwd			## 输出以 :/ 作为分隔符的第一个字段
awk -F ":|/" '{print $1}' passw			## 输出以 : 或者 / 为分隔符 的第一字段## 注意：如果两个分隔符连在一起，那么会假设两分隔符之间的内容是空白，会输出空白行指定 df -h 的第6行 第5字段（列），默认是空格为分隔符
[root@dj tmp]# df -h | awk 'NR==6{print "你的根分区用了"$5}' 
你的根分区用了0%			大于第2行的每一行的第5字段打印出来
df -h | awk 'NR>2{print "你的根分区用了"$5}'  自定义第1字段占15字符左对齐，第7字段左对齐
awk -F ":" '{printf "%15-s %-s\n",$1,$5}' passwd    ## 类似于c语言输出， %s 表示 十进制整数 %-s 表示左对齐  %8-s 表示左对齐，且占8个字符位置

查工资

[root@dj tmp]# cat 1.txt 
工资条
姓名     工号   银行卡号   基本工资       绩效      五险一金   
小明     121   45678789   3500        5000      -1000      
小小明    123   45678987   2500        3000      -800      
[root@dj tmp]# awk 'NR>2{print $1"的工资是"$4+$5+$6}' 1.txt
小明的工资是7500
小小明的工资是4700

2 BEGIN+主体+END 结合使用案例

## 创建一个名为 test.txt 的文件（其中包括序列号、学生名字、课程名称与所得分数）。
cat > /tmp/test.txt <<EOF
1)    Amit     Physics    80
2)    Rahul    Maths      90
3)    Shyam    Biology    87
4)    Kedar    English    85
5)    Hari     History    89
EOF[root@dj ~]# awk '($4>=80)&&($4<86){print}' /tmp/test.txt 
1)    Amit     Physics    80
4)    Kedar    English    85## 输出<文件中的内容>，同时输出<表头信息>即输出  序号  姓名  课程  分数
[root@dj ~]# awk 'BEGIN {printf "序号\t姓名\t课程\t分数\n"} {print $1"\t"$2"\t"$3"\t"$4} END {print "###打印结束###"}' /tmp/test.txt
序号	姓名	课程	分数
1)	Amit	Physics	80
2)	Rahul	Maths	90
3)	Shyam	Biology	87
4)	Kedar	English	85
5)	Hari	History	89
###打印结束###示例6：##pattern1?pattern2:pattern3（条件表达式）
条件?满足就做这个:不满足就做这个
## 显示Amit同学成绩大于等于80成绩单，同时，也显示成绩大于等于90的其他同学的成绩单
awk '/Amit/?($4>=80):($4>=90){print}' /tmp/test.txt示例7：!pattern（逻辑非）
## 显示非English课程的成绩单
awk '!/English/{print}' ~/test.txt示例8：pattern1,pattern2（地址对）
## 显示成绩单中从Amit同学到Shyam同学的行
awk '/Amit/,/Shyam/{print}' /tmp/test.txt## 创建一个名为 students.txt 的文件（其中包括学生名字、性别、籍贯、年龄）。
cat >/tmp/students.txt <<EOF
张三 男 湖北 12岁
李丽 女 湖北 12岁
李丽 女 山西 12岁
李丽 女 北京 12岁
王五 男 湖北 12岁
EOF
[root@dj ~]# awk 'BEGIN{print "姓名\t性别\t地址\t年龄"} {print $1"\t"$2"\t"$3"\t"$4} END{print "##原神玩家列表##"}' /tmp/students.txt 
姓名	性别	地址	年龄
张三	男	湖北	12岁
李丽	女	湖北	12岁
李丽	女	山西	12岁
李丽	女	北京	12岁
王五	男	湖北	12岁
##原神玩家列表##

判断问题

判断uid小于等于10 输出 aaa 大于10 输出 bbb （多个方法）
awk -F: '{$3<10?USER="aaa":USER="bbb";print $1,USER}' /etc/passwd判断uid小于等于10 输出 user 大于10 输出 pass
awk -F: '{if($3<10){print "user=>"$1}else{print "pass=>"$1}}' /etc/passwd判断 普通用户系统用户root用户
awk -F ":" '{if($3==0){print $0" 这是root用户"}else if(($3>0)&&($3<1000)){print $0" 这是系统用户"}else{print $0" 这是普通用户"}}' /etc/passwd

3 awk 的变量使用

[root@server144 ~]# echo $name						## 这里的 $ 是通配符
root
[root@server144 ~]# cat /etc/passwd|awk -F ':' '/^$name/{print $1}'			
## 开了正则 $ 是正则
[root@server144 ~]# cat /etc/passwd|awk -F ':' '/^\$name/{print $1}'		
## 转义了  是$ ,无任何意义
[root@server144 ~]# cat /etc/passwd|awk -F ':' '/^"$name"/{print $1}'		
## 无法输出	  和 第一条一样
[root@server144 ~]# cat /etc/passwd|awk -F ':' '/^'$name'/{print $1}'		
## 成功 
root

15.10 函数的使用

函数的声明

语法1：

function 变量名 {

命令

}

语法2：

变量名(){

命令

}

#!/bin/bash
sbsb(){echo "eb"}echo "6666666"
sbsb
声明函数 sbsb  并使用

函数的传参

例子

 #!/bin/bash
a(){
echo "$1 $2 $3 "
}
a 123 $2 789
[root@dj tmp]# bash 7.sh abc 456 awfa
123 456 789 
对于脚本来说 $1 是固定123  $3 是固定 789   ，而$2 没有规定，在运行脚本后面的 $2的位置 是456