shell脚本命令最强整合

目录

• 1.注释
• 2.echo
  • 转义字符
  • 结果定向至文件
  • 原样字符串输出，单引号
  • 当前日期
• 3.变量类型
  • 使用变量-$
  • 只读变量-readonly
  • 删除变量-unset
• 4.shell字符串
  • 单/双引号
  • 拼接字符串
  • 字符串长度-#
  • 字符串截取-：
  • 查找字符串坐标-expr
• 5.shell数组
  • 定义/读取数组
  • 数组长度
• 6.Shell 传递参数-\(?,\)*,\(#,\)\(,\)@,$-
• 7.Shell 基本运算符
  • 算术运算符
  • 字符串运算
  • 关系运算符
  • 布尔运算
  • 逻辑运算符-||,&&
  • 文件测试运算符
• 8.printf
• 9.test命令
  • 数值测试
  • 字符串测试
  • 文件测试
• 10.流程控制
  • if else
  • if else-if else
  • for 循环
  • while 语句
  • break/continue
• 11.shell函数
  • 监控输入-read
  • 无参函数
  • 有参函数
• 12.shell输入/输出重定向
  • 输出重定向-ls/cat结果输出到文件
  • 输入重定向
  • /dev/null 文件-执行命令但不显示
• 13.shell文件包含(类似import导包)
• 14.set -e 防止误操作

1.注释

以 # 开头的行就是注释，会被解释器忽略。

通过每一行加一个 # 号设置多行注释，像这样：

单行注释：

#--------------------------------------------
# 这是一个注释
# slogan：学的不仅是技术，更是梦想！
#--------------------------------------------
##### 用户配置区 开始 #####
#
#
# 这里可以添加脚本描述信息
# 
#
##### 用户配置区 结束  #####

多行注释：

:<<EOF
注释内容...
注释内容...
注释内容...
EOF

2.echo

echo 指令与print类似，都是用于字符串的输出。命令格式：

echo "It is a test"

转义字符

echo "\"It is a test\""  # "It is a test"

结果定向至文件

echo "It is a test" > myfile.txt

原样字符串输出，单引号

echo \'$name\"\'  # $name\"

当前日期

echo `date` # Wed Dec 15 16:59:34 CST 2021
echo `date +\'%Y%m%d%H%M\'` # 202112151659

3.变量类型

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

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

使用变量-$

your_name="qinjx"
echo $your_name
echo ${your_name}


############
qinjx
qinjx

只读变量-readonly

#!/bin/bash
myUrl="https://www.google.com"
echo "1:"$myUrl
readonly myUrl
myUrl="https://www.runoob.com"
echo "2:"$myUrl

############
1:https://www.google.com
./cicd.sh: line 5: myUrl: readonly variable
2:https://www.google.com

删除变量-unset

#!/bin/sh
myUrl="https://www.runoob.com"
unset myUrl
echo $myUrl

4.shell字符串

字符串是shell编程中最常用最有用的数据类型（除了数字和字符串，也没啥其它类型好用了），字符串可以用单引号，也可以用双引号，也可以不用引号。

单/双引号

# 单引号
str1=\'this is a string1\'
echo $str1 # this is a string1


# 双引号
name="jeff"
str2="this is a string2 \"${name}\""
echo $str2 # this is a string2 "jeff"


双引号的优点：
双引号里可以有变量
双引号里可以出现转义字符

拼接字符串

your_name="jeff"
# 使用双引号拼接
greeting_1="hello, "$your_name" !"  # hello, jeff !
greeting_2="hello, ${your_name} !"  # hello, jeff !
echo $greeting_1  $greeting_2


# 使用单引号拼接
greeting_3=\'hello, \'$your_name\' !\' # hello, jeff !
greeting_4=\'hello, ${your_name} !\' # 不可以
echo $greeting_3  $greeting_4

#####结果####
hello, jeff ! hello, jeff !
hello, jeff ! hello, ${your_name} !

字符串长度-#

your_name="jeff"
echo ${#your_name} #输出 4

字符串截取-：

your_name="hello jeff"
echo ${your_name:0:5} # 输出 hello
echo ${your_name:6:11} # 输出 jeff

查找字符串坐标-expr

your_name="hello jeff"
echo `expr index "$your_name" o` # 输出5

######
mac报错，linux未报错

在 MAC 中 shell 的 expr 语法是：$((表达式))

5.shell数组

bash支持一维数组（不支持多维数组），并且没有限定数组的大小。

类似于 C 语言，数组元素的下标由 0 开始编号。获取数组中的元素要利用下标，下标可以是整数或算术表达式，其值应大于或等于 0。

定义/读取数组

### 数组元素用"空格"符号分割开
array_name=(jeff chary)
echo ${array_name[0]} # jeff

数组长度

array_name=(jeff chary)
# 方式一 @
echo ${#array_name[@]} # 输出 2
# 方式儿 *
echo ${#array_name[*]} # 输出 2
# 数组中元素长度
echo ${#array_name[0]} # 输出 4

6.Shell 传递参数-\(?,\)*,\(#,\)\(,\)@,$-

我们可以在执行 Shell 脚本时，向脚本传递参数，脚本内获取参数的格式为：$n。n 代表一个数字，1 为执行脚本的第一个参数，2 为执行脚本的第二个参数，以此类推……

echo "Shell 传递参数实例！";
echo "执行的文件名：$0";
echo "第一个参数为：$1";
echo "第二个参数为：$2";
echo "第三个参数为：$3";
##############
[root@sg-14 pod]# ./cicd.sh  1 2 3
Shell 传递参数实例！
执行的文件名：./cicd.sh
第一个参数为：1
第二个参数为：2
第三个参数为：3

另外，还有几个特殊字符用来处理参数：

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

7.Shell 基本运算符

算术运算符

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

两点注意：
表达式和运算符之间要有空格，例如 2+2 是不对的，必须写成 2 + 2，这与我们熟悉的大多数编程语言不一样。
完整的表达式要被 包含，注意这个字符不是常用的单引号，在 Esc 键下边。

运算符	说明	举例
+	加法	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=10
b=20

val=`expr $a + $b`
echo "a + b : $val"

val=`expr $a - $b`
echo "a - b : $val"

val=`expr $a \* $b`
echo "a * b : $val"

val=`expr $b / $a`
echo "b / a : $val"

val=`expr $b % $a`
echo "b % a : $val"

if [ $a == $b ]
then
   echo "a 等于 b"
fi
if [ $a != $b ]
then
   echo "a 不等于 b"
fi

######结果######
a + b : 30
a - b : -10
a * b : 200
b / a : 2
b % a : 0
a 不等于 b

字符串运算

下表列出了常用的字符串运算符，假定变量 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="abc"
b="efg"

if [ $a = $b ]
then
   echo "$a = $b : a 等于 b"
else
   echo "$a = $b: a 不等于 b"
fi
if [ $a != $b ]
then
   echo "$a != $b : a 不等于 b"
else
   echo "$a != $b: a 等于 b"
fi
if [ -z $a ]
then
   echo "-z $a : 字符串长度为 0"
else
   echo "-z $a : 字符串长度不为 0"
fi
if [ -n "$a" ]
then
   echo "-n $a : 字符串长度不为 0"
else
   echo "-n $a : 字符串长度为 0"
fi
if [ $a ]
then
   echo "$a : 字符串不为空"
else
   echo "$a : 字符串为空"
fi

#####结果#######
abc = efg: a 不等于 b
abc != efg : a 不等于 b
-z abc : 字符串长度不为 0
-n abc : 字符串长度不为 0
abc : 字符串不为空

关系运算符

假定变量 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=10
b=20

if [ $a -eq $b ]
then
   echo "$a -eq $b : a 等于 b"
else
   echo "$a -eq $b: a 不等于 b"
fi
if [ $a -ne $b ]
then
   echo "$a -ne $b: a 不等于 b"
else
   echo "$a -ne $b : a 等于 b"
fi
if [ $a -gt $b ]
then
   echo "$a -gt $b: a 大于 b"
else
   echo "$a -gt $b: a 不大于 b"
fi
if [ $a -lt $b ]
then
   echo "$a -lt $b: a 小于 b"
else
   echo "$a -lt $b: a 不小于 b"
fi
if [ $a -ge $b ]
then
   echo "$a -ge $b: a 大于或等于 b"
else
   echo "$a -ge $b: a 小于 b"
fi
if [ $a -le $b ]
then
   echo "$a -le $b: a 小于或等于 b"
else
   echo "$a -le $b: a 大于 b"
fi

######结果#######
10 -eq 20: a 不等于 b
10 -ne 20: a 不等于 b
10 -gt 20: a 不大于 b
10 -lt 20: a 小于 b
10 -ge 20: a 小于 b
10 -le 20: a 小于或等于 b

布尔运算

下表列出了常用的布尔运算符，假定变量 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。

实例：

a=10
b=20

if [ $a != $b ]
then
   echo "$a != $b : a 不等于 b"
else
   echo "$a == $b: a 等于 b"
fi
if [ $a -lt 100 -a $b -gt 15 ]
then
   echo "$a 小于 100 且 $b 大于 15 : 返回 true"
else
   echo "$a 小于 100 且 $b 大于 15 : 返回 false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
then
   echo "$a 小于 100 或 $b 大于 100 : 返回 true"
else
   echo "$a 小于 100 或 $b 大于 100 : 返回 false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
then
   echo "$a 小于 5 或 $b 大于 100 : 返回 true"
else
   echo "$a 小于 5 或 $b 大于 100 : 返回 false"
fi

######结果#####
10 != 20 : a 不等于 b
10 小于 100 且 20 大于 15 : 返回 true
10 小于 100 或 20 大于 100 : 返回 true
10 小于 5 或 20 大于 100 : 返回 false

逻辑运算符-||,&&

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

运算符	说明	举例
&&	逻辑的 AND	[[ $a -lt 100 && $b -gt 100 ]] 返回 false
||	逻辑的 OR	[[ $a -lt 100 || $b -gt 100 ]] 返回 true

实例：

a=10
b=20

if [[ $a -lt 100 && $b -gt 100 ]]
then
   echo "返回 true"
else
   echo "返回 false"
fi

if [[ $a -lt 100 || $b -gt 100 ]]
then
   echo "返回 true"
else
   echo "返回 false"
fi

#######结果######
返回 false
返回 true

文件测试运算符

文件测试运算符用于检测 Unix 文件的各种属性。

属性检测描述如下：

操作符	说明	举例
-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。

其他检查符：

• -S: 判断某文件是否 socket。
• -L: 检测文件是否存在并且是一个符号链接。

实例：

变量 file 表示文件 ./test.sh，它的大小为 100 字节，具有 rwx 权限。下面的代码，将检测该文件的各种属性：

file="./test.sh"
if [ -r $file ]
then
   echo "文件可读"
else
   echo "文件不可读"
fi
if [ -w $file ]
then
   echo "文件可写"
else
   echo "文件不可写"
fi
if [ -x $file ]
then
   echo "文件可执行"
else
   echo "文件不可执行"
fi
if [ -f $file ]
then
   echo "文件为普通文件"
else
   echo "文件为特殊文件"
fi
if [ -d $file ]
then
   echo "文件是个目录"
else
   echo "文件不是个目录"
fi
if [ -s $file ]
then
   echo "文件不为空"
else
   echo "文件为空"
fi
if [ -e $file ]
then
   echo "文件存在"
else
   echo "文件不存在"
fi

#######结果########
文件可读
文件可写
文件不可执行
文件为普通文件
文件不是个目录
文件不为空
文件存在

8.printf

printf解释

9.test命令

Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。

数值测试

参数	说明
-eq	等于则为真
-ne	不等于则为真
-gt	大于则为真
-ge	大于等于则为真
-lt	小于则为真
-le	小于等于则为真

实例：

num1=100
num2=100
if test $[num1] -eq $[num2]
then
    echo \'两个数相等！\'
else
    echo \'两个数不相等！\'
fi


#######结果########
两个数相等！

字符串测试

参数	说明
=	等于则为真
!=	不相等则为真
-z 字符串	字符串的长度为零则为真
-n 字符串	字符串的长度不为零则为真

实例：

num1="ru1noob"
num2="runoob"
if test $num1 = $num2
then
    echo \'两个字符串相等!\'
else
    echo \'两个字符串不相等!\'
fi
#######结果########
两个字符串不相等!

文件测试

参数	说明
-e 文件名	如果文件存在则为真
-r 文件名	如果文件存在且可读则为真
-w 文件名	如果文件存在且可写则为真
-x 文件名	如果文件存在且可执行则为真
-s 文件名	如果文件存在且至少有一个字符则为真
-d 文件名	如果文件存在且为目录则为真
-f 文件名	如果文件存在且为普通文件则为真
-c 文件名	如果文件存在且为字符型特殊文件则为真
-b 文件名	如果文件存在且为块特殊文件则为真

实例：

cd /bin
if test -e ./bash
then
    echo \'文件已存在!\'
else
    echo \'文件不存在!\'
fi

#######结果########
文件已存在!

另外，Shell 还提供了与( -a )、或( -o )、非( ! )三个逻辑操作符用于将测试条件连接起来，其优先级为： ! 最高， -a 次之， -o 最低。例如：

cd /bin
if test -e ./notFile -o -e ./bash
then
    echo \'至少有一个文件存在!\'
else
    echo \'两个文件都不存在\'
fi

#######结果########
至少有一个文件存在!

10.流程控制

if else

if condition
then
    command1 
    command2
    ...
    commandN 
fi

if else-if else

if condition1
then
    command1
elif condition2 
then 
    command2
else
    commandN
fi

实例1：

a=10
b=20
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:

num1=$[2*3]
num2=$[1+5]
if test $[num1] -eq $[num2]
then
    echo \'两个数字相等!\'
else
    echo \'两个数字不相等!\'
fi

for 循环

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

实例1：

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：循环5次

for i in `seq 1 5`
do
    echo $i
done
########结果###########
1
2
3
4
5

实例3:1-100中所有偶数

for((i=1;i<100;i++))
do
  if((i%2==0))
  then
    echo $i
fi
done

while 语句

while condition
do
    command
done

实例：

int=1
while(( $int<=5 ))
do
    echo $int
    let "int++"  # 修改全局变量
done

break/continue

跳出循环/跳过本次循环


while :
do
    echo -n "输入 1 到 5 之间的数字:"
    read aNum
    case $aNum in
        1|2|3|4|5) echo "你输入的数字为 $aNum!"
        ;;
        *) echo "你输入的数字不是 1 到 5 之间的! 游戏结束"
            break
        ;;
    esac
done

11.shell函数

linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。

• 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。
• 2、参数返回，可以显示加：return 返回，如果不加，将以最后一条命令运行结果，作为返回值。 return后跟数值n(0-255

监控输入-read

funWithReturn(){
    echo "相加运算："
    echo "输入第一个数字: "
    read aNum
    echo "输入第二个数字: "
    read anotherNum
    echo "两个数字分别为 $aNum 和 $anotherNum"
    return $(($aNum+$anotherNum))
}


funWithReturn
echo "数字之和为 $?"

#######结果##########
相加运算：
输入第一个数字: 
1
输入第二个数字: 
1
两个数字分别为 1 和 1
数字之和为 2

无参函数

# 定义函数
function demoFun1() {
    echo "这是我的第一个 shell 函数!"
}

# 不带function
demoFun2() {
    echo "这是我的第二个 shell 函数!"
}
# 调用
demoFun1
demoFun2

##########结果#############
这是我的第一个 shell 函数!
这是我的第二个 shell 函数!

实例1:两数之和

funWithReturn(){
    echo "相加运算："
    echo "输入第一个数字: "
    read aNum
    echo "输入第二个数字: "
    read anotherNum
    echo "两个数字分别为 $aNum 和 $anotherNum"
    return $(($aNum+$anotherNum))
}


funWithReturn
echo "数字之和为 $?"

#######结果##########
相加运算：
输入第一个数字: 
1
输入第二个数字: 
1
两个数字分别为 1 和 1
数字之和为 2

有参函数

funWithParam(){
    echo "第一个参数为 $1 !"
    echo "第二个参数为 $2 !"
    echo "第三个参数为 $3 !"
    echo "参数总数有 $# 个!"
    echo "所有参数 $* !"
}

funWithParam 1 2 3 4 5

#########结果##############
第一个参数为 1 !
第二个参数为 2 !
第三个参数为 3 !
参数总数有 5 个!
所有参数 1 2 3 4 5 !

12.shell输入/输出重定向

重定向命令列表如下：

命令	说明
command > file	将输出重定向到 file。
command < file	将输入重定向到 file。
command >> file	将输出以追加的方式重定向到 file。
n > file	将文件描述符为 n 的文件重定向到 file。
n >> file	将文件描述符为 n 的文件以追加的方式重定向到 file。
n >& m	将输出文件 m 和 n 合并。
n <& m	将输入文件 m 和 n 合并。
<< tag	将开始标记 tag 和结束标记 tag 之间的内容作为输入。

输出重定向-ls/cat结果输出到文件

ls > test.sh   # 清空文件，再写入
ls >> test.sh  # 末尾追加到test.sh
cat cicd.sh >> test.sh

输入重定向

和输出重定向一样，Unix 命令也可以从文件获取输入，语法为：

command1 < file1

这样，本来需要从键盘获取输入的命令会转移到文件读取内容。

注意：输出重定向是大于号(>)，输入重定向是小于号(<)。

实例：

接着以上实例，我们需要统计 users 文件的行数,执行以下命令：

$ wc -l users
       2 users

也可以将输入重定向到 users 文件：

$  wc -l < users
       2 

注意：上面两个例子的结果不同：第一个例子，会输出文件名；第二个不会，因为它仅仅知道从标准输入读取内容。

command1 < infile > outfile

同时替换输入和输出，执行command1，从文件infile读取内容，然后将输出写入到outfile中。

/dev/null 文件-执行命令但不显示

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

$ command > /dev/null

/dev/null 是一个特殊的文件，写入到它的内容都会被丢弃；如果尝试从该文件读取内容，那么什么也读不到。但是 /dev/null 文件非常有用，将命令的输出重定向到它，会起到"禁止输出"的效果。

如果希望屏蔽 stdout 和 stderr，可以这样写：

$ command > /dev/null 2>&1

13.shell文件包含(类似import导包)

Shell 文件包含的语法格式如下：

. filename   # 注意点号(.)和文件名中间有一空格

或

source filename

实例：

test.sh中定义一个相加sum函数

# test.sh中
sum(){
  num=`expr $1 + $2`
  echo "两数之和为:$num"
}

cicd.sh中调用sum函数

. ./nginx/test.sh
sum 1 2

#######结果##########
两数之和为:3

14.set -e 防止误操作

set -e之后的shell语句出现错误，整个脚本立即退出，那么就可以避免一些脚本的危险操作

set -e