Shell脚本

这里写目录标题
Shell脚本
1.Shell脚本简介
2.Shell
2.1 Shell 脚本的解释器
2.2  脚本的编写规范
2.3 执行脚本的三种方式
2.4变量的声明
2.5变量的引用
2.6删除变量  只读变量
2.7字符串使用
2.8字符串长度及截取
2.9脚本参数传递
2.10算数运算符
2.11流程控制if
2.12关系运算符
2.13循环
2.14接收控制台数据
2.15数组
2.16文件加载

1.Shell脚本简介
Shell 是一个用 C 语言编写的程序，通过 Shell 用户可以访问操作系统内核服务。Shell 既是一种命令语言，又是一种程序设计语言。Shell script 是一种为 shell 编写的脚本程序。Shell 编程一般指 shell脚本编程，不是指开发 shell 自身。Shell 编程跟 java、php 编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。Linux 的 Shell 解释器 种类众多，一个系统可以存在多个 shell，可以通过 cat /etc/shells 命令查看系统中安装的 shell解释器。Bash 由于易用和免费，在日常工作中被广泛使用。同时，Bash 也是大多数Linux 系统默认的 Shell。
2.Shell
2.1 Shell 脚本的解释器
/bin/sh
/bin/bash
/sbin/nologin
/bin/dash
/bin/tcsh
/bin/csh

2.2  脚本的编写规范
首行描述解释器    #!/bin/bash
2.3 执行脚本的三种方式
1、bash   脚本名称    脚本参数	

2、  sh   脚本名称    脚本参数	

3、  ./脚本名称    脚本参数【./脚本名称之间没有空格】【chmod  777  脚本名称】
2.4变量的声明
变量名=”值”【中间不能有空格】	

变量名要求    字母或下划线或数字（开头不能是数字）构成
2.5变量的引用
使用$ 或 ${}引用变量
2.6删除变量  只读变量
删除 	unset 变量名

只读	readonly  变量名
2.7字符串使用
双引号(””)：内部可以使用变量	

单引号(‘’)：内部所有的原样输出	

反引号(``)：表示可执行
2.8字符串长度及截取
长度：  echo ${#skill}	

截取：	echo ${str:2:2}  【在第二个字符开始截取截取两位】
2.9脚本参数传递
bash   脚本名   参数1  参数2  参数3  。。。。。。

脚本内		

$0		脚本名称		

$1		参数1

$2		参数2

$n		参数n

$*		所有参数

$#		参数的个数
2.10算数运算符
加法计算  expr 2 + 2	

乘法计算   expr 2 \* 2
2.11流程控制if
if [ $a -gt 10 ];then	

代码1	

elif [ $a -lt 10 ];then	

代码2	

else	代码3	

fi
2.12关系运算符

2.13循环
For 循环		

For  aa  in XXXX		

do			

循环体		

done
While循环		

While  条件 ;

do			

循环体		

done
跳出循环	

跳出所有循环		break	

跳出当前循环，进入下一次循环	continue
case ()
case  值  in 		

     	   结果1)			结果1对应的操作;;		

结果2)			结果2对应的操作;;		

结果3)			结果3对应的操作;;	

esac
2.14接收控制台数据
read  变量名

函数的使用	

函数声明：	

[function]  函数名(){		

函数体		

$参数1		

$参数2		

$参数3

}
函数调用		函数名   参数1  参数2  参数3
2.15数组
数组声明：		数组名称=(元素1 元素2 元素3 元素4)	

数组的使用		

单个使用	echo  数组名[角标]  【角标从0开始】		

遍历数组	

for var in ${my_arr[*]}

do

echo $var

done
2.16文件加载
在文件中添加  .   脚本名称 或者 source  脚本名称

#!/bin/bash

source ./test1.sh  # 加载test1.sh 的文件内容

sed在处理文本时是逐行读取文件内容，读到匹配的行就根据指令做操作，不匹配就跳过。

sed是Linux下一款功能强大的非交互流式文本编辑器，可以对文本文件进行增、删、改、查等操作，支持按行、按字段、按正则匹配文本内容，灵活方便，特别适合于大文件的编辑。本文主要介绍sed的一些基本用法，并通过shell脚本演示sed的使用实例。

1.sed的使用方法，调用sed 命令的语法有两种：

一.在命令行指定sed指令对文本进行处理：sed +选项  ‘指令’ 文件

二.先将sed指令保存到文件中，将该文件作为参数进行调用：sed   +选项  -f  包含sed指令的文件  文件

sed的常用选项：

-r：使用扩展正则表达式

-e：它告诉sed将下一个参数解释为一个sed指令，只有当命令行上给出多个sed指令时才需要使用-e选项

-f：后跟保存了sed指令的文件

-i：直接对内容进行修改，不加-i时默认只是预览，不会对文件做实际修改

-n：取消默认输出，sed默认会输出所有文本内容，使用-n参数后只显示处理过的行

sed中的编辑命令：

a:追加  向匹配行后面插入内容

c:更改  更改匹配行的内容

i:插入  向匹配行前插入内容

d:删除  删除匹配的内容

s:替换  替换掉匹配的内容

p:打印  打印出匹配的内容，通常与-n选项和用

=:用来打印被匹配的行的行号

n:读取下一行，遇到n时会自动跳入下一行

r,w：读和写编辑命令，r用于将内容读入文件，w用于将匹配内容写入到文件

2.sed命令实例：

示例1：向文件中添加或插入行

sed '3ahello' 1.txt   #向第三行后面添加hello，3表示行号



sed '/123/ahello' 1.txt #向内容123后面添加hello，如果文件中有多行包括123，则每一行后面都会添加



sed  '$ahello'  1.txt  #在最后一行添加hello



sed '3ihello'  1.txt    #在第三行之前插入hello



sed '/123/ihello'  1.txt   #在包含123的行之前插入hello，如果有多行包含123，则包含123的每一行之前都会插入hello



sed '$ihello'  1.txt     #在最后一行之前插入hello



示例2：更改文件中指定的行

sed  '1chello'  1.txt  #将文件1.txt的第一行替换为hello



sed  '/123/chello'  1.txt  #将包含123的行替换为hello



sed '$chello'  1.txt  #将最后一行替换为hello



示例3：删除文件中的行

sed  '4d'  1.txt    #删除第四行



sed '1~2d' 1.txt   #从第一行开始删除，每隔2行就删掉一行，即删除奇数行



sed   '1,2d'  1.txt   #删除1~2行



sed  '1,2!d'  1.txt   #删除1~2之外的所有行



sed  '$d'   1.txt      #删除最后一行



sed  '/123/d'   1.txt   #删除匹配123的行



sed  '/123/,$d'  1.txt  #删除从匹配123的行到最后一行



sed  '/123/,+1d'  1.txt   #删除匹配123的行及其后面一行



sed  '/^$/d'    1.txt    #删除空行



sed   '/123\|abc/!d'  1.txt    #删除不匹配123或abc的行，/123\|abc/ 表示匹配123或abc ，！表示取反



sed  '1,3{/123/d}'   1.txt     #删除1~3行中，匹配内容123的行，1,3表示匹配1~3行，{/123/d}表示删除匹配123的行



示例4：替换文件中的内容

sed  's/123/hello/'   1.txt   #将文件中的123替换为hello，默认只替换每行第一个123



sed  's/123/hello/g'  1.txt #将文本中所有的123都替换为hello



sed 's/123/hello/2'   1.txt  #将每行中第二个匹配的123替换为hello



sed  -n 's/123/hello/gpw  2.txt'   1.txt    #将每行中所有匹配的123替换为hello，并将替换后的内容写入2.txt



sed  '/#/s/,.*//g'  1.txt   #匹配有#号的行，替换匹配行中逗号后的所有内容为空  (,.*)表示逗号后的所又内容



sed  's/..$//g'  1.txt  #替换每行中的最后两个字符为空，每个点代表一个字符，$表示匹配末尾  （..$）表示匹配最后两个字符



sed 's/^#.*//'  1.txt      #将1.txt文件中以#开头的行替换为空行，即注释的行  ( ^#)表示匹配以#开头，（.*）代表所有内容



sed 's/^#.*//;/^$/d'  1.txt  #先替换1.txt文件中所有注释的空行为空行，然后删除空行，替换和删除操作中间用分号隔开



sed 's/^[0-9]/(&)/'   1.txt   #将每一行中行首的数字加上一个小括号   (^[0-9])表示行首是数字，&符号代表匹配的内容

或者  sed 's/\(^[0-9]\)/(\1)/'   1.txt  #替换左侧特殊字符需钥转义，右侧不需要转义，\1代表匹配的内容



sed  's/$/&'haha'/'  1.txt   # 在1.txt文件的每一行后面加上"haha"字段



示例5：打印文件中的行

sed  -n '3p'  1.txt   #打印文件中的第三行内容



sed  -n '2~2p'  1.txt   #从第二行开始，每隔两行打印一行，波浪号后面的2表示步长



sed -n '$p'  1.txt  #打印文件的最后一行



sed -n '1,3p'  1.txt  #打印1到3行



sed  -n '3,$p'  1.txt  #打印从第3行到最后一行的内容



sed  -n '/you/p'  1.txt   #逐行读取文件，打印匹配you的行



sed  -n '/bob/,3p'  1.txt  #逐行读取文件，打印从匹配bob的行到第3行的内容

sed  -n  '/you/,3p'  1.txt  #打印匹配you 的行到第3行，也打印后面所有匹配you 的行



sed  -n '1,/too/p'  1.txt    #打印第一行到匹配too的行

sed  -n  '3,/you/p'  1.txt   #只打印第三行到匹配you的行



sed  -n '/too/,$p'  1.txt  #打印从匹配too的行到最后一行的内容



sed  -n '/too/,+1p'  1.txt    #打印匹配too的行及其向后一行，如果有多行匹配too，则匹配的每一行都会向后多打印一行



sed  -n '/bob/,/too/p'  1.txt   #打印从匹配内容bob到匹配内容too的行



示例6：打印文件的行号

sed  -n "$="   1.txt   #打印1.txt文件最后一行的行号（即文件有多少行，和wc -l 功能类似）



sed  -n '/error/='  1.txt     #打印匹配error的行的行号

sed  -n '/error/{=;p}'   1.txt    #打印匹配error的行的行号和内容（可用于查看日志中有error的行及其内容）



示例7：从文件中读取内容

sed  'r 2.txt'  1.txt  #将文件2.txt中的内容，读入1.txt中，会在1.txt中的每一行后都读入2.txt的内容



sed '3r 2.txt'  1.txt       #在1.txt的第3行之后插入文件2.txt的内容（可用于向文件中插入内容）



sed  '/245/r   2.txt'   1.txt    #在匹配245的行之后插入文件2.txt的内容，如果1.txt中有多行匹配456则在每一行之后都会插入



sed  '$r  2.txt'   1.txt     #在1.txt的最后一行插入2.txt的内容



示例8：向文件中写入内容

sed  -n  'w 2.txt'   1.txt   #将1.txt文件的内容写入2.txt文件，如果2.txt文件不存在则创建，如果2.txt存在则覆盖之前的内容



sed   -n '2w  2.txt'   1.txt   #将文件1.txt中的第2行内容写入到文件2.txt



sed  -n -e '1w  2.txt'  -e '$w 2.txt'   1.txt   #将1.txt的第1行和最后一行内容写入2.txt

sed  -n -e '1w  2.txt'  -e '$w  3.txt'  1.txt   #将1.txt的第1行和最后一行分别写入2.txt和3.txt



sed  -n  '/abc\|123/w  2.txt'    1.txt   #将1.txt中匹配abc或123的行的内容，写入到2.txt中



sed  -n '/666/,$w 2.txt'   1.txt   #将1.txt中从匹配666的行到最后一行的内容，写入到2.txt中



sed  -n  '/xyz/,+2w  2.txt'     1.txt     #将1.txt中从匹配xyz的行及其后2行的内容，写入到2.txt中



示例9：sed 在shell脚本中的使用

实例1：替换文件中的内容

#!/bin/bash

if [ $# -ne 3 ];then            #判断参数个数

  echo "Usage:  $0 old-part new-part filename"    #输出脚本用法

  exit

fi

sed -i "s#$1#$2#"  $3          #将 旧内容进行替换，当$1和$2中包含"/"时，替换指令中的定界符需要更换为其他符号



实例2：删除文件中的空白行

#!/bin/bash

if [ ! -f $1 ];then         #判断参数是否为文件且存在

   echo "$0 is not a file"

   exit

fi

sed -i "/^$/d"   $1 #将空白行删除



实例3：格式化文本内容

#!/bin/bash

a='s/^  *>//      #定义一个变量a保存sed指令，'s/^ *>//'：表示匹配以0个或多空格开头紧跟一个'>'号的行，将匹配内容替换

s/\t*//                 #'s/\t*//'：表示匹配以0个或多个制表符开头的行，将匹配内容替换

s/^>//               #'s/^>//' ：表示匹配以'>'开头的行，将匹配内容替换

s/^ *//'               #'s/^ *//'：表示匹配以0个或多个空格开头的行，将匹配内容替换

#echo $a

sed "$a" $1        #对用户给定的文本文件进行格式化处理



实用脚本：批量更改当前目录中的文件后缀名：

示例1：

#!/bin/bash

if [ $# -ne 2 ];then               #判断用户的输入，如果参数个数不为2则打印脚本用法

  echo "Usage:$0 + old-file new-file"

  exit

fi

for i in *$1*                         #对包含用户给定参数的文件进行遍历

do

  if [ -f $i ];then

     iname=`basename $i`        #获取文件名

     newname=`echo $iname | sed -e "s/$1/$2/g"`         #对文件名进行替换并赋值给新的变量

     mv  $iname  $newname          #对文件进行重命名

   fi

done

exit 666



示例2：

#!/bin/bash

read -p "input the old file:" old        #提示用户输入要替换的文件后缀

read -p "input the new file:" new

[ -z $old ] || [ -z $new ] && echo "error" && exit      #判断用户是否有输入，如果没有输入怎打印error并退出

for file in `ls *.$old`

do

  if [ -f $file ];then

     newfile=${file%$old}                        #对文件进行去尾

     mv $file ${newfile}$new                   #文件重命名

  fi

done



示例3：

#!/bin/bash

if [ $# -ne 2 ];then        #判断位置变量的个数是是否为2

   echo "Usage:$0  old-file  new-file"

   exit

fi

for file in `ls`                      #在当前目录中遍历文件

do

  if [[ $file =~ $1$ ]];then   #对用户给出的位置变量$1进行正则匹配，$1$表示匹配以变量$1的值为结尾的文件

     echo $file                      #将匹配项输出到屏幕进行确认

     new=${file%$1}             #对文件进行去尾处理，去掉文件后缀保留文件名，并将文件名赋给变量new                  

     mv $file ${new}$2          #将匹配文件重命名为：文件名+新的后缀名

  fi

done



示例4：使用sed匹配文件中的IP地址

sed -nr  '/([0-9]{1,3}\.){3}([0-9]{1,3})/p'  1.txt

 

在公司项目的开发过程中，需要编写shell脚本去处理一个业务，在编写过程中发现自身对shell脚本的知识不够完善，顾整理一下，本文章主要内容来自菜鸟教程 , 也添加了一些知识点


看完这边文章应该就可以独立完成大部分脚本得编写

shell脚本？
在说什么是shell脚本之前，先说说什么是shell。
shell是外壳的意思，就是操作系统的外壳。我们可以通过shell命令来操作和控制操作系统，比如Linux中的Shell命令就包括ls、cd、pwd等等。总结来说，Shell是一个命令解释器，它通过接受用户输入的Shell命令来启动、暂停、停止程序的运行或对计算机进行控制。
shell 是一个应用程序，它连接了用户和 Linux 内核，让用户能够更加高效、安全、低成本地使用 Linux 内核，这就是 Shell 的本质。
shell 本身并不是内核的一部分，它只是站在内核的基础上编写的一个应用程序。
那么什么是shell脚本呢？
shell脚本就是由Shell命令组成的执行文件，将一些命令整合到一个文件中，进行处理业务逻辑，脚本不用编译即可运行。它通过解释器解释运行，所以速度相对来说比较慢。
shell脚本中最重要的就是对shell命令的使用与组合，再使用shell脚本支持的一些语言特性，完成想要的功能。
微信扫下述二维码关注公众号，回复“源码”，即可免费获取“经典飞机大战源码 + 经典像素鸟游戏源码 + 人事管理系统源码 ”！


注释
“# ”开头的就是注释，被编译器忽略

单行注释： #
多行注释： :<<EOF …  EOF  或者  :<<! …  ! （:<< 标识多行注释开始，并指定一个标识符作为开始结束的标志）


变量
变量类型

运行shell时，会同时存在三种变量：

局部变量：局部变量在脚本或命令中定义，仅在当前shell实例中有效，其他shell启动的程序不能访问局部变量。
环境变量：所有的程序，包括shell启动的程序，都能访问环境变量，有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。
shell变量：shell变量是由shell程序设置的特殊变量。shell变量中有一部分是环境变量，有一部分是局部变量，这些变量保证了shell的正常运行

变量操作

创建普通变量： name=“test”  （=两边不可有空格）
创建只可函数体中使用的局部变量： local name=“test” （使用local修饰的变量在函数体外无法访问，并且local只能在函数体内使用）
使用变量： echo $name  或者  echo ${name}  （推荐使用大括号版）
变量重新赋值： name=“new_test”   （将原值覆盖）
只读变量： name=“only_read”  ->   readonly name （使用readonly标识后的变量，不可被修改）
删除变量： unset name;  （删除之后不可访问，删除不掉只读变量）

字符串变量

1）单引号

单引号变量var='test' ，只能原样输出，变量无效
单引号中不能出现一个单独的单引号，转义也不可以

2）双引号

双引号变量var="my name is ${name}"，变量有效
可出现转义符

3）拼接字符串

中间无任何+，之类的字符
name=“this is”" my name";  name=“this is my name”; name=“this” is “my name” 等效
name=‘this is’’ my nam’;  name=‘this is my name’; name=‘this’ is ‘my name’ 等效

4）获取字符串长度

在${}中使用“#”获取长度
name=“test”;
echo ${#name}; # 输出为4

5）提取子字符串

1:4 从第2个开始 往后截取4个字符
::4 从第一个字符开始 往后截取4个字符
name=“this is my name”;
echo ${name:1:4} #输出 his
echo ${name::4} #输出 this

数组
bash只支持一维数组，不支持多维数组

定义数组：array_name=(li wang xiang zhang)   （小括号做边界、使用空格分离）
单独定义数组的元素： array_para[0]=“w”; array_para[3]=“s” （定义时下标不连续也可以）
赋值数组元素：array_name[0]=“zhao”;
获取数组元素：

array_name[0]=“li”
array_name[3]=“zhang”
echo ${array_name[0]}  # 输出"li"
echo ${array_name[1]}  # 输出" "
echo ${array_name[3]}  # 输出"zhang"
echo ${array_name[@]} # 输出"li zhang" 输出数组所有元素，没有元素的下标省略


取得元素个数：${#array_name[@]} 或者 ${#array_name[*]}
取得单个元素长度：${#array_name[1]}


参数传递

获取参数值：

$0 ： 固定，代表执行的文件名
$1 ： 代表传入的第1个参数
$n ： 代表传入的第n个参数


$#：参数个数
$*： 以一个单字符串显示所有向脚本传递的参数。如"$*“用「”」括起来的情况、以"$1 $2 … $n"的形式输出所有参数
$@：与$*相同，但是使用时加引号，并在引号中返回每个参数。
$$：脚本运行的当前进程号
$！：后台运行的最后一个进程的ID
$?： 显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。
$* 与 $@ 区别

相同点：都是引用所有参数。
不同点：只有在双引号中体现出来。假设在脚本运行时写了三个参数 1、2、3，，则 " * " 等价于 “1 2 3”（传递了一个参数），而 “@” 等价于 “1” “2” “3”（传递了三个参数）。




运算符
算数运算

+ 、-、*、\ ： 乘号前必须加\进行转义才可以进行乘法运算
加法运算

val=`expr 2 + 2`  （使用linux命令expr进行辅助运算）
val=$[2+2] （4个空格不是必要的，不同于条件判断）
val=$((2+2))



数字关系运算符

关系运算符只支持数字，不支持字符串，除非字符串的值是数字。

下面假定变量 a 为 10，变量 b 为 20

-eq  ：检测两个数是否相等，相等返回 true。	                    [ $a -eq $b ] 返回 false。
-ne：	检测两个数是否不相等，不相等返回 true。	                 [ $a -ne $b ] 返回 true。
-gt：	检测左边的数是否大于右边的，如果是，则返回 true。     	[ $a -gt $b ] 返回 false。
-lt	： 检测左边的数是否小于右边的，如果是，则返回 true。	     [ $a -lt $b ] 返回 true。
-ge：	检测左边的数是否大于等于右边的，如果是，则返回 true。 	[ $a -ge $b ] 返回 false。
-le	： 检测左边的数是否小于等于右边的，如果是，则返回 true。   	[ $a -le $b ] 返回 true。

字符串运算符

下表列出了常用的字符串运算符，假定变量 a 为 “abc”，变量 b 为 “efg”：

=	：检测两个字符串是否相等，相等返回 true。	[ $a = $b ] 返回 false。
!=	：检测两个字符串是否相等，不相等返回 true。	[ $a != $b ] 返回 true。
-z	：检测字符串长度是否为0，为0返回 true。	[ -z $a ] 返回 false。
-n	：检测字符串长度是否为0，不为0返回 true。	[ -n “$a” ] 返回 true。
$     ：检测字符串是否为空，不为空返回 true。	[ $a ] 返回 true。

布尔运算符

下表列出了常用的布尔运算符，假定变量 a 为 10，变量 b 为 20：

!	：非运算，表达式为 true 则返回 false，否则返回 true。	[ ! false ] 返回 true。
-o	：或运算，有一个表达式为 true 则返回 true。	[ $a -lt 20 -o $b -gt 100 ] 返回 true。
-a	：与运算，两个表达式都为 true 才返回 true。	[ $a -lt 20 -a $b -gt 100 ] 返回 false。

逻辑运算符

以下介绍 Shell 的逻辑运算符，假定变量 a 为 10，变量 b 为 20:

&&	：逻辑的 AND	[[ $a -lt 100 && $b -gt 100 ]] 返回 false
||	：逻辑的 OR	[[ $a -lt 100 || $b -gt 100 ]] 返回 true

文件运算符

-b file	：检测文件是否是块设备文件，如果是，则返回 true。	[ -b $file ] 返回 false。
-c file	：检测文件是否是字符设备文件，如果是，则返回 true。	[ -c $file ] 返回 false。
-d file	：检测文件是否是目录，如果是，则返回 true。	[ -d $file ] 返回 false。
-f file	：检测文件是否是普通文件（既不是目录，也不是设备文件），如果是，则返回 true。	[ -f $file ] 返回 true。
-g file	：检测文件是否设置了 SGID 位，如果是，则返回 true。	[ -g $file ] 返回 false。
-k file	：检测文件是否设置了粘着位(Sticky Bit)，如果是，则返回 true。	[ -k $file ] 返回 false。
-p file	：检测文件是否是有名管道，如果是，则返回 true。	[ -p $file ] 返回 false。
-u file	：检测文件是否设置了 SUID 位，如果是，则返回 true。	[ -u $file ] 返回 false。
-r file	：检测文件是否可读，如果是，则返回 true。	[ -r $file ] 返回 true。
-w file	：检测文件是否可写，如果是，则返回 true。	[ -w $file ] 返回 true。
-x file ：检测文件是否可执行，如果是，则返回 true。	[ -x $file ] 返回 true。
-s file	：检测文件是否为空（文件大小是否大于0），不为空返回 true。	[ -s $file ] 返回 true。
-e file	：检测文件（包括目录）是否存在，如果是，则返回 true。	[ -e $file ] 返回 true。


执行相关
命令替换

命令替换与变量替换差不多，都是用来重组命令行的，先完成引号里的命令行，然后将其结果替换出来，再重组成新的命令行。

执行命令：

`ls  /etc` ：  反引号  （所有的unix系统都支持）
$(ls /etc)   ：  $+()    （部分unix系统不支持）

多个嵌套使用时，从内向外执行


for file in \s /etc\  或  for file in $(ls /etc) 循环中使用

`dirname $0`  获取脚本文件所在的目录

path=$(cd `dirname $0`;pwd)  ： 获取脚本当前所在目录，并且执行cd命令到达该目录，使用pwd获取路径并赋值到path变量

算术运算

$[ ] : 加减乘除,不必添加空格
$(( )) ：加减乘除等,不必添加空格

逻辑判断

[ ] ： 中括号旁边和运算符两边必须添加空格  （可以使用，不推荐）
[[ ]]：中括号旁边和运算符两边必须添加空格  （字符串验证时，推荐使用）
(()) ： 中括号旁边和运算符两边必须添加空格 （数字验证时，推荐使用）
[[]] 和 (())  分别是[ ]的针对数学比较表达式和字符串表达式的加强版。
使用[[ … ]]条件判断结构，而不是[ … ]，能够防止脚本中的许多逻辑错误。比如，&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中，但是如果出现在[ ]结构中的话，会报错。比如可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ]。

[[ ]]中增加模式匹配特效；

(( ))不需要再将表达式里面的大小于符号转义，除了可以使用标准的数学运算符外，还增加了以下符号




输出
echo

仅用于字符串的输出，没有使用printf作为输出的移植性好，建议使用printf
printf

printf 不会像 echo 自动添加换行符，我们可以手动添加 \n

无大括号，直接以空格分隔


格式：printf format-string [arguments...]  其中（format-string: 格式控制字符串、arguments: 参数列表）
案例：printf "%-10s %-8s %-4.2f\n" 郭靖 男 66.1234
%s %c %d %f 都是格式替代符

d：Decimal 十进制整数 对应位置参数必须是十进制整数，否则报错!
s：String 字符串 对应位置参数必须是字符串或者字符型 否则报错
c：Char 字符 对应位置参数必须是字符串或者字符型 否则报错
f：Float 浮点 对应位置参数必须是数字型 否则报错


%-10s ： 指一个宽度为10个字符（-表示左对齐，没有则表示右对齐），任何字符都会被显示在10个字符宽的字符内，如果不足则自动以空格填充，超过也会将内容全部显示出来。
%-4.2f ：指格式化为小数，宽度为4个字符，其中.2指保留2位小数。
转义符：

\a	：警告字符，通常为ASCII的BEL字符
\b	：后退
\c	：抑制（不显示）输出结果中任何结尾的换行字符（只在%b格式指示符控制下的参数字符串中有效），而且，任何留在参数里的字符、任何接下来的参数以及任何留在格式字符串中的字符，都被忽略
\f	：换页（formfeed）
\n	：换行
\r	：回车（Carriage return）
\t	：水平制表符
\v	：垂直制表符
\	：一个字面上的反斜杠字符
\ddd	：表示1到3位数八进制值的字符。仅在格式字符串中有效
\0ddd	：表示1到3位的八进制值字符




流程控制
和Java、PHP等语言不一样，sh的流程控制不可为空，即if或者else的大括号中无任何语句

if else

if

if condition
then
    command1 
    command2
    ...
    commandN 
fi


if else

if condition
then
    command1 
    command2
    ...
    commandN
else
    command
fi


if else-if else

if condition1
then
    command1
elif condition2 
then 
    command2
else
    commandN
fi

for
for var in item1 item2 ... itemN
do
    command1
    command2
    ...
    commandN
done

while

while condition

while condition
do
    command
done


while 无限循环

while :
do
    command
done

until

until 循环执行一系列命令直至条件为 true 时停止。

until 循环与 while 循环在处理方式上刚好相反。
until condition
do
    command
done

case

Shell case语句为多选择语句。可以用case语句匹配一个值与一个模式，如果匹配成功，执行相匹配的命令。

case需要一个esac（就是case反过来）作为结束标记，每个case分支用右圆括号，用两个分号表示break，其中“;;”不是跳出循环，是不在去匹配下面的模式

case语句格式如下：
case 值 in
  模式1)
    command1
    command2
    ...
    commandN
    ;;
  模式2）
    command1
    command2
    ...
    commandN
    ;;
esac

跳出循环

break ：跳出总循环
continue：跳出当前循环，继续下一次循环

定义函数
可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。

函数定义

[ function ] funname()
{
    action;
    [return int;]
}


参数传递

调用函数: fun_name  2 3 4
函数中使用：和shell取用函数相同 $n $# $* $?  或者加上{}



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
echo $?  \# 判断执行是否成功


函数返回值

return字样可存在也可不存在
return 只能为 return [0-255]，此处的返回可作为函数执行的状态，通过$?获取的便是这个返回值
如果不加return ， 则默认最后一条语句的执行状态所为函数执行状态的返回值，如果最后一条语句执行成功，则$?为0，否则不为0


使用函数返回值（Janusgraph图数据库官方启动服务脚本片段）

return返回的数字，只是作为函数执行状态的返回值，也就是接下来$?获取的值
对于类似于下面的BIN=\abs_path``语句，获取的是函数体内所有的echo、printf输出组合成的一个字符串



abs_path() {
    SOURCE="${BASH_SOURCE[0]}"
    while [ -h "$SOURCE" ]; do
        DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
        SOURCE="$(readlink "$SOURCE")"
        [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
    done
    echo "test"  
    echo "$( cd -P "$( dirname "$SOURCE" )" && pwd )"  
    # 此函数的两个echo输出会组合成一个字符串作为下述BIN的值
}

BIN=`abs_path` # BIN赋值函数返回值，如果没有return，则函数中所有的echo、printf输出组合成一个字符串传入BIN
path=${BIN}/nodetool # 可直接使用

输入输出重定向
一般情况下，每个 Unix/Linux 命令运行时都会打开三个文件：

标准输入文件(stdin)：stdin的文件描述符为0，Unix程序默认从stdin读取数据。
标准输出文件(stdout)：stdout 的文件描述符为1，Unix程序默认向stdout输出数据。
标准错误文件(stderr)：stderr的文件描述符为2，Unix程序会向stderr流中写入错误信息。

默认情况下，command > file 将 stdout 重定向到 file，command < file 将stdin 重定向到 file。

如果希望执行某个命令，但又不希望在屏幕上显示输出结果，那么可以将输出重定向到 /dev/null：
输入重定向

bash.sh  < file ： 将脚本的输入重定向到file，由file提供参数

输出重定向

bash.sh  > file ： 将脚本的输出数据重定向到file中，覆盖数据
bash.sh  >> file ： 将脚本的输出数据重定向到file中，追加数据
command >> file 2>&1 ： 将 stdout 和 stderr 合并后重定向到 file

读取外部输入
命令：read arg  （脚本读取外部输入并赋值到变量上）

在shell脚本执行到上述命令时，停止脚本执行并等待外部输入，将外部输入赋值到arg变量上，继续执行脚本
文件引用
引用其他的文件之后，可以使用其变量、函数等等，相当于将引用的文件包含进了当前文件

两种方式：

. file_path\file_name
source file_path\file_name

颜色标识
printf  "\033[32m SUCCESS: yay \033[0m\n";
printf  "\033[33m WARNING: hmm \033[0m\n";
printf  "\033[31m ERROR: fubar \033[0m\n";

输出结果：


长句换行
在shell中为避免一个语句过长，可以使用“\”进行换行

使用“\”换行，在脚本执行过程中还是当做一行一个语句执行，不同于enter直接换行

注意：\ 前添加一个空格 。 \ 后无空格直接换行。

 /mysql/bin/mysql \
  -h test_host  -P 000 \
  -u test_user -ptest_password ;

shell操作mysql
下面案例为登录mysql，并选择操作数据库，之后进行导入数据
 /mysql/mysql/bin/mysql \
  -h test_host  -P 000 \
  -u test_user -ptest_password \
  -e"use test_database; source data_faile; " # -e 代表执行sql语句


-u 用户名

-p 用户密码

-h 服务器ip地址

-D 连接的数据库

-N 不输出列信息

-B 使用tab键 代替 分隔符

-e 执行的SQL语句

退出脚本
命令：exit
在退出脚本时使用不同的错误码，这样可以根据错误码来判断发生了什么错误。

在绝大多数 shell 脚本中，exit 0 表示执行成功，exit 1 表示发生错误。

对错误与错误码进行一对一的映射，这样有助于脚本调试。

命令：set -e 或者 set +e

set -e表示从当前位置开始，如果出现任何错误都将触发exit。相反，set +e表示不管出现任何错误继续执行脚本。

如果脚本是有状态的（每个后续步骤都依赖前一个步骤），那么请使用set -e，在脚本出现错误时立即退出脚本。

如果要求所有命令都要执行完（很少会这样），那么就使用set +e。

shell脚本调试
检查是否有语法错误-n：

bash -n script_name.sh

使用下面的命令来执行并调试 Shell 脚本-x：

bash -x script_name.sh

调试count_odd_number.sh 程序案例：
#!/usr/bin.env bash

# 用于计算数组中奇数的和
# @author liyangyang
# @time 2019/09/17

sum=0
for num in 1 2 3 4;do
    re=${num}%2
    if (( ${re} == 1 ));then
        sum=$[${sum}+${num}]
    fi
done
echo ${sum}


首先检查有无语法错误：

bash -n count_odd_number.sh
没有输出，说明没有错误，开始实际调试：

bash -x count_odd_number.sh
调试结果如下：

+ sum=0
+ for num in 1 2 3 4
+ re=1%2
+ ((  1%2 == 1  ))
+ sum=1
+ for num in 1 2 3 4
+ re=2%2
+ ((  2%2 == 1  ))
+ for num in 1 2 3 4
+ re=3%2
+ ((  3%2 == 1  ))
+ sum=4
+ for num in 1 2 3 4
+ re=4%2
+ ((  4%2 == 1  ))
+ echo 4
4

其中的输出显示了程序执行的每一步，通过观察程序执行的步骤是否满足预期从而达到调试的效果

带有 + 表示的是 Shell 调试器的输出，不带 + 表示程序的输出。
案例：
这是es（ElasticSearch）官方启动服务的脚本，看可不可以理解吧~
#!/usr/bin/env bash

# CONTROLLING STARTUP:
#
# This script relies on a few environment variables to determine startup
# behavior, those variables are:
#
#   ES_PATH_CONF -- Path to config directory
#   ES_JAVA_OPTS -- External Java Opts on top of the defaults set
#
# Optionally, exact memory values can be set using the `ES_JAVA_OPTS`. Note that
# the Xms and Xmx lines in the JVM options file must be commented out. Example
# values are "512m", and "10g".
#
#   ES_JAVA_OPTS="-Xms8g -Xmx8g" ./bin/elasticsearch

source "`dirname "$0"`"/elasticsearch-env

parse_jvm_options() {
  if [ -f "$1" ]; then
    echo "`grep "^-" "$1" | tr '\n' ' '`"
  fi
}

ES_JVM_OPTIONS="$ES_PATH_CONF"/jvm.options

ES_JAVA_OPTS="`parse_jvm_options "$ES_JVM_OPTIONS"` $ES_JAVA_OPTS"

# manual parsing to find out, if process should be detached
if ! echo $* | grep -E '(^-d |-d$| -d |--daemonize$|--daemonize )' > /dev/null; then
  exec \
    "$JAVA" \
    $ES_JAVA_OPTS \
    -Des.path.home="$ES_HOME" \
    -Des.path.conf="$ES_PATH_CONF" \
    -cp "$ES_CLASSPATH" \
    org.elasticsearch.bootstrap.Elasticsearch \
    "$@"
else
  exec \
    "$JAVA" \
    $ES_JAVA_OPTS \
    -Des.path.home="$ES_HOME" \
    -Des.path.conf="$ES_PATH_CONF" \
    -cp "$ES_CLASSPATH" \
    org.elasticsearch.bootstrap.Elasticsearch \
    "$@" \
    <&- &
  retval=$?
  pid=$!
  [ $retval -eq 0 ] || exit $retval
  if [ ! -z "$ES_STARTUP_SLEEP_TIME" ]; then
    sleep $ES_STARTUP_SLEEP_TIME
  fi
  if ! ps -p $pid > /dev/null ; then
    exit 1
  fi
  exit 0
fi

exit $?

推荐阅读：

Git-【技术干货】工作中Git的使用实践

Git - 使用git不知道内部实现机制怎么行

如果转载此博文，请附上本文链接，谢谢合作~ ：https://blog.csdn.net/CSDN___LYY/article/details/100584638


如果感觉这篇文章对您有所帮助，请点击一下“喜欢”或者“关注”博主，您的喜欢和关注将是我前进的最大动力！谢谢大家~

目录

Shell

Shell脚本的执行

Shell脚本编写规范

Shell 中的变量

变量的算术运算

双小括号 (())  数值运算命令的用法

let 运算命令的用法

expr 命令的用法

br 命令的用法

$[] 符号的运算示例

Shell脚本的条件测试

几种条件测试语句

文件测试操作符

字符串测试操作符

整数二元比较操作符

逻辑操作符

测试表达式 test 、[] 、[[]] 、 (()) 的区别

if 条件判断语句

case 条件判断语句

for循环语句

while循环语句

Break、Continue、exit 循环控制语句

Shell脚本执行scrapy爬虫和python脚本

Shell

Shell是一个命令解释器，它的作用是解释执行用户输入的命令及程序等。 用户每输入一条命令，Shell就执行一条。这种从键盘输入命令，就可以立即得到回应的对话方式，称为交互的方式。



当命令或程序语句不在命令行下执行，而是通过一个程序文件来执行时，该程序文件就被称为Shell脚本。 在Shell脚本里内置了很多命令、语句及循环控制，然后将这些命令一次性执行完毕，这种通过文件执行脚本的方式称为非交互的方式。 Shell脚本语言很适合用于处理纯文本型的数据，而Linux系统中几乎所有的配置文件、日志文件，以及绝大对数的启动文件都是纯文本类型的文件。
Shell 脚本的类型

Shell脚本语言是弱类型语言（无须定义变量的类型即可使用），在Unix/Linux中主要有两大类shell: 

一类是 Bourne  shell ,另一类是 C shell

Bourne shell 包括 Bourne shell (sh)、Korn shell(ksh)、Bourne Again Shell 三种类型。 
	
C shell包括csh、tcsh两种类型
查看系统默认的shell： echo  $SHELL

查看系统支持的shell： cat  /etc/shells



Shell脚本的执行

Shell脚本的执行通常可以采用以下几种方式。

1、bash script-name 或 sh script-name     这是当脚本文件本身没有执行权限时常使用的方法

2、path/script-name 或./script-name    在当前路径下执行脚本，需要将脚本文件的权限改为可执行。然后使用脚本的绝对路径或相对路径就可以直接执行脚本了。

3、source script-name 或 .  script-name 这种方法通常是使用source或 “.”(点号）读入或加载指定的Shell脚本文件，然后依次执行指定的Shell脚本中的语句。这些语句将在当前父 shell 脚本进程中执行（其他几种模式都会启用新的进程执行该脚本进程）。

Shell脚本编写规范

Shell脚本的开发规范及习惯非常重要，虽然这些规范不是必须要遵守的，但有了好的规范和习惯，可以大大提升开发效率，并能在后期降低对脚本的维护成本。

1、一个规范的Shell脚本在第一行会指出由哪个程序（解释器）来执行脚本中的内容，这一行内容在Linux bash的编程一般为：#！/bin/bash  或 #!  /bin/sh     bash 与 sh 的区别 , sh 为 bash的软连接，大多数情况下，脚本使用“#！/bin/bash”和“#！/bin/sh”是没有区别的，但更规范的写法是在脚本的开头使用    #！/bin/bash 

2、在shell脚本中，跟在 # 后面的内容表示注释，用来对脚本进行注释说明，注释部分不会被当做程序来执行，仅仅是给开发者和使用者看的，系统解释器是看不到的，更不会执行。注释可以自成一行，也可以跟在脚本命令的后面与命令在同一行。 注释尽量不要使用中文，在脚本中最好也不要有中文。

3、Shell脚本的开头会加版本、版权等信息

# Date：16:29 2018-10-20 
# Author: Create by xiaoxie
# Description: This script function is …… 
# Version： 1.1 

4、在shell脚本中尽量不用中文注释，尽量用英文注释，防止本机或切换系统环境后中文乱码的困扰。

5、Shell脚本的命名应以.sh为扩展名 例如：1.sh

6、成对的符号应尽量一次性写出来，然后退格在符号内增加内容，以防止遗漏。这些成对的符号包括： {}、[]、‘’、“”  等

7、中括号[]两端至少要有1个空格，因此，键入中括号时即留出空格[  ]，然后在退格键入中间内容，并确保两端都至少由一个空格。

8、对于流程控制语句，应一次性将格式写完，再添加内容。 如：一次性完成for循环语句的格式

for
do
     内容
done

9、通过缩进让代码更易读，如：

if 条件内容     
       then         
            内容 
fi 

10、对于常规变量的字符串定义变量值应加双引号，并且等号前后不能有空格，需要强引用的，则用单引号（‘’），如果是命令的引用，则用反引号（``）。



11、脚本中的单引号、双引号及反引号必须为英文状态下的符号。

Shell 中的变量

简单地说，变量就是用一个固定的字符串（也可能是字符、数字等的组合）代替更多、更复杂的内容，该内容里可能还会包含变量、路径、字符串等其他内容。 变量是暂时存储数据的地方及数据标记，所存储的数据存在于内存空间中，通过正确地调用内存中变量的名字就可以读取出与变量对应的数据。

变量的赋值方法为： 先写变量名称，紧接着是 "=" ，最后是值。中间无任何空格。 通过echo命令加上  $变量名，即可输出变量的值。 双引号，以防止出错变量的值一般要加上。

定义变量时变量名建议用大写，如  A=xie     B=99

read  -p  “提示信息”   变量名      #交互式赋值方法 

查看变量内容 echo $A  或  echo ${A}



赋值时使用引号的作用 

双引号：允许通过$符号引用其他变量值
	
单引号：禁止引用其他变量值，$视为普通字符
	
反撇号：命令替换，提取命令执行后的输出结果 全局变量的定义方法 export 变量名


位置参数

位置参数是一种在调用 Shell 程序的命令行中按照各自的位置决定的变量，是在程序名之后输入的参数。 位置参数之间用空格分隔，Shell取第一个位置参数替换程序文件中的 $1，第二个替换 $2 , 依次类推。$0 是一个特殊变量，它的内容是当前这个shell程序的文件名，所以 $0 不是一个位置参数。

假如我现在有一个 1.sh脚本文件，内容如下

#! /bin/bash
echo $1
echo $(($2+$3))


当我执行时，我在文件名后加3个参数



预定义变量

预定义变量和环境变量相类似，也是在Shell一开始就定义的变量，不同的是，用户只能根据shell的定义来使用这些变量，所有预定义变量都是由符号“$”和另一个符号组成。 常见的Shell预定义变量有以下几种。

$# ：位置参数的数量
	
$* ：所有位置参数的内容
	
$? ：命令执行后返回的状态，0表示没有错误，非0表示有错误
	
$$ ：当前进程的进程号
	
$! ：后台运行的最后一个进程号
	
$0 ：当前执行的进程名
假如我现在有一个 1.sh脚本文件，内容如下

#! /bin/bash

echo $1
echo ${2}+${3}

echo $#             #打印出位置参数的数量
echo $*             #打印出位置参数的内容
echo $?             #打印出命令执行后返回的状态
echo $$             #打印出当前进程的进程号
echo $0             #打印出当前进程的进程名


当我执行时，我在文件名后加3个参数



参考文章：Linux中环境变量的设置

变量的算术运算

Shell中常见的算术运算符



Shell 中常见的算术运算命令



双小括号 (())  数值运算命令的用法

双小括号 (()) 的作用是进行数值运算与数值比较，它的效率很高，用法灵活，是Linux下常用的运算操作符。其操作方法如下：





let 运算命令的用法

let运算命令的语法格式为： let 赋值表达式  

let 赋值表达式的功能等同于“((赋值表达式))” 范例：  给变量 i 加8

  

expr 命令的用法

1、expr 用于运算 

   语法：expr 表达式 

   范例：expr 2 + 2 ; expr 2 – 2 ; expr 2  \*  2 ;  expr 2  /  2    
   注意：运算符号和数字之间要有空格！！



2、expr配合变量计算 

expr在Shell中可配合变量进行计算，但需要用反引号将计算表达式括起来。



3、利用 expr 计算字符串的长度



br 命令的用法

bc 是UNIX/Linux下的计算器，除了作为计算器来使用，还可以作为命令行计算工具使用

交互模式 在shell命令行直接输入 bc 及能进入bc语言的交互模式



bc也可以进行非交互式的运算，方法是与 echo 一起使用，所以我们就可以写在脚本里面



$[] 符号的运算示例



Shell脚本的条件测试

通常，在shell的各种条件结构和流程控制结构中都要进行各种测试，然后根据测试结果执行不同的操作，有时候也会与 if 等条件语句相结合，来完成测试判断，以减少程序运行错误。

几种条件测试语句



文件测试操作符

常用文件测试操作符
			
说明
		
-d   ， d的全拼为 directory
			
文件存在且为目录则为真
		
-f   ,   f的全拼为  file
			
文件存在且为文件则为真
		
-e ， e的全拼为 exists
			
文件存在则为真
		
-s ，s的全拼为 size
			
文件存在且大小不为0则为真
		
-r ，r的全拼为 read
			
文件存在且可读则为真
		
-w ，w的全拼为write
			
文件存在且可写则为真
		
-x ，x的全拼为executable
			
文件存在且可执行则为真
		
-L ，L的全拼为link
			
文件存在且为链接文件则为真
		
f1 -nt  f2  ，nt的全拼为 newer than
			
文件f1比文件f2新则为真
		
f1 -ot f2 ，ot的全拼为older than
			
文件f1比文件f2旧则为真
		
注：（()）不能用于文件测试，文件测试一般常用的是 []



字符串测试操作符

常用字符串测试操作符
			
说明
		
-n  
			
若字符串长度不为0，则为真
		
-z
			
若字符串长度为0，则为真
		
“字符串1”  ==  “字符串2”
			
若字符串1等于字符串2，则为真
		
“字符串1”  !=  “字符串2”
			
若字符串1不等于字符串2，则为真
		
注： == 和 !=  两端要有空格  ，（()）不能用于字符测试



整数二元比较操作符

在[]以及test中使用的比较符号
			
在(())和[[]]中使用的比较符号
			
说明
		
-eq
			
== 或 =
			
相等，全拼为  equal
		
-ne
			
!=
			

			
不相等，全拼为 not equal
			
		
-gt
			
>
			
大于，全拼为 greater than
		
-ge
			
>=
			
大于等于，全拼为 greater equal
		
-lt
			
<
			
小于，全拼为 less than
		
-le
			
<=
			
小于等于 ,全拼为less equal
		
"="和"!="也可以在[]中作比较使用，但在[]中使用包含"<"和">"的符号时，需要用反斜线转义，有时不转义虽然语法不会报错，但是结果可能不对。
	
也可以在[[]]中使用包含“-gt”和“-lt”的符号，但是不建议使用
	
比较符号两端也要有空格，[] （()）  [[]]  两端都要有空格


逻辑操作符

在[]和test中使用的操作符
			
在[[]]和(())中使用的操作符
			
说明
		
-a
			
&&
			
and ，与，两端都为真，才为真
		
-o
			
||
			
or ，或， 两端有一个为真，就为真
		
!
			
!
			
not ，非， 两端相反，则结果为真
		


测试表达式 test 、[] 、[[]] 、 (()) 的区别

测试表达式符号
			
test
			
[]
			
[[]]
			
(())
		
边界是否需要空格
			
需要
			
需要
			
需要
			
不需要
		
逻辑操作符
			
! 、-a、 -o
			
! 、-a、 -o
			
! 、&& 、 ||
			
! 、&& 、 ||
		
整数比较操作符
			
-eq 、 -gt 、-lt、-ge 、-le
			
-eq 、 -gt 、-lt、-ge 、-le
			
-eq 、 -gt 、-lt、-ge 、-le 或  = 、>  、< 、 >= 、 <=
			
= 、>  、< 、 >= 、 <=
		
字符串比较操作符
			
= 、 == 、!=
			
= 、 == 、!=
			
= 、 == 、!=
			
不支持
		
文件操作
			
-d、-f、-e、-r、-s、-w、-x、-L、-nt、-ot
			
-d、-f、-e、-r、-s、-w、-x、-L、-nt、-ot
			
-d、-f、-e、-r、-s、-w、-x、-L、-nt、-ot
			
不支持
		
是否支持通配符匹配
			

			
不支持
			
			
不支持
			
支持
			
不支持
		
if 条件判断语句

#####单条件判断##############
if  条件判断
  then 
      命令
else
      命令
fi

#或

if  条件判断;then 
     命令
else
     命令
fi





###双条件判断#####
if 条件判断
  then
      命令
elif 条件判断
  then 
      命令
else
   命令
fi

##或
if 条件判断;then
    命令
elif 条件判断;then 
    命令
else
    命令
fi






if语句对于字符串的匹配



case 条件判断语句

case条件语句相当于多分支的if/elif/ellse条件语句，但是它比这些条件语句看起来更规范更工整，常被应用于实现系统服务启动脚本等企业应用场景中。

case  变量  in
        one)
            命令
;;
        two)
             命令
;;
         *) 
             命令
esac





for循环语句

for  条件
do
   命令
done

##或

for  条件;do
   命令
done

 



while循环语句

while  条件
do
   命令
done



Break、Continue、exit 循环控制语句

break 、continue在条件语句及循环语句（for、while、if等）中用于控制程序走向；而exit则用于终止所有语句并退出当前脚本。

命令
			
说明
		
break   n
			
如果省略 n ，则表示跳出整个循环，n 表示跳出循环的成熟
		
continue n
			
如果省略 n ，则表示跳过本次循环，忽略本次循环的剩余代码，进行循环的下一次循环。n表示退到第 n 层继续循环
		
exit n
			
退出当前 shell 程序，n 为上一次程序执行的状态返回值。n 也可以省略，在下一个 shell 里可通过  $?  接收 exit  n 的n值
		






Shell脚本执行scrapy爬虫和python脚本

#! /bin/bash
cd /opt/project/
scrapy crawl xx
python3 test.py