Linux Shell编程 总结

文章目录

怎么运行shell脚本

java 需要 虚拟机解释器, 同理 shell脚本也需要 解析器

cat /etc/shells 
查看所有shell解释器

内容如下：

/bin/sh   
/bin/bash
/sbin/nologin 
/bin/dash
/bin/tcsh
/bin/csh

省略用法：

sh test.sh  #sh是bash的快捷方式
bash test.sh
#为啥可以省略/bin?
#因为PATH环境变量中增加了/bin

./test.sh 
./文件名也能运行

Shell的变量

定义变量
name=“zhangsan”
(等号两边不能有空格)

变量名的命名须遵循如下规则：
命名只能使用英文字母，数字和下划线，首个字符不能以数字开头。
中间不能有空格，可以使用下划线（_）。
不能使用标点符号。
不能使用bash里的关键字（可用help命令查看保留关键字）。

使用变量
使用一个定义过的变量，只要在变量名前面加美元符号即可，如：
name=“zhangsan”
echo $name
echo ${name}
变量名外面的花括号是可选的，加花括号是为了帮助解释器识别变量的边界

删除变量
使用 unset 命令可以删除变量。语法：
unset variable_name
变量被删除后不能再次使用。unset 命令不能删除只读变量。

Shell字符串

字符串可以用单引号，也可以用双引号，也可以不用引号。

单引号字符串的限制：
单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的；
单引号字串中不能出现单独一个的单引号（对单引号使用转义符后也不行），但可成对出现，作为字符串拼接使用。

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

获取字符串长度

skill='java' 
echo ${skill} 
# 输出结果: java 
echo ${#skill} 
# 输出结果: 4

提取子字符串

skill='java' 
str="I am goot at $skill" 
echo ${str:2} 
# 输出结果为: am goot at java 
echo ${str:2:2} 
# 输出结果为: am

查找子字符串

str="I am goot at $skill" 
echo `expr index "$str" am` 
# 输出是: 3

Shell传递参数

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

#!/bin/bash 

echo "Shell 传递参数实例！"; 
echo "执行的文件名：$0"; 
echo "第一个参数为：$1"; 
echo "第二个参数为：$2"; 
echo "第三个参数为：$3";

为脚本设置可执行权限，并执行脚本，输出结果如下所示：

$ chmod 755 param.sh 
$ ./param.sh 1 2 3

执行的文件名：./param.sh
第一个参数为：1
第二个参数为：2
第三个参数为：3

特殊字符用来处理参数：

示例：

#!/bin/bash 
echo "Shell 传递参数实例！"; 
echo "第一个参数为：$1"; 
echo "参数个数为：$#"; 
echo "传递的参数作为一个字符串显示：$*";

执行脚本，输出结果如下所示：

$ chmod +x test.sh 
$ ./test.sh 1 2 3 
Shell 传递参数实例！ 
第一个参数为：1 
参数个数为：3 
传递的参数作为一个字符串显示：1 2 3

$* 与 $@ 区别：

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

示例：

#!/bin/bash 

echo "-- $* 演示 ---" 
for i in "$*"; do 
	echo $i 
done 

echo "-- $@ 演示 ---" 
for i in "$@"; do 
	echo $i 
done

执行脚本，输出结果如下所示：

$ chmod +x test.sh 

$ ./test.sh 1 2 3 

-- $* 演示 --- 
1 2 3

-- $@ 演示 --- 
1
2
3

Shell算术运算符

Shell 和其他编程一样，支持包括：算术、关系、布尔、字符串等运算符。

原生 bash **不支持 **简单的数学运算，但是可以通过其他命令来实现，例如expr。

expr 是一款表达式计算工具，使用它能完成表达式的求值操作。

例如，两个数相加：

val=`expr 2 + 2`
echo $val

注意：

表达式和运算符之间要有空格，例如 2+2 是不对的，必须写成 2 + 2。

完整的表达式要被 ` 包含，注意不是单引号，在 Esc 键下边。
下表列出了常用的算术运算符，假定变量 a 为 10，变量 b 为 20：

**注意：**条件表达式要放在方括号之间，并且要有空格，例如: [ a = = a== a==b] 是错误的，必须写成 [ $a == $b ]。

例子：

#!/bin/bash

a=4

b=20

#加法运算

each expr $a + $b

#减法运算

echo expr $a - $b

#乘法运算，注意*号前面需要反斜杠

echo expr $a \* $b

#除法运算

echo $a / $b

 

此外，还可以通过(())、$(())、$[]进行算术运算。

 

 ((a++))

echo "a = $a"

c=$((a + b))

d=$[a + b]

echo "c = $c"

echo "d = $d"

Shell流程控制

if 语句语法格式：

if condition; then
    command1 
    command2
    ...
    commandN 
fi

例子：

[root@hadoop01 export]# cat if_test.sh 
#!/bin/bash

a=20

if [ $a -gt 10 ]; then
        echo "a 大于 10"
fi

末尾的fi就是if倒过来拼写，后面还会遇到类似的。

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

Shell关系运算符

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

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

案例:

[root@hadoop01 export]# cat if_test.sh 
#!/bin/bash

a=20
b=10

# 需求1: 判断 a 是否 100
if [ $a > 100 ]; then
        echo "$a 大于 100"
fi


# 需求2: 判断 a 是否等于 b
if [ $a -eq $b ]; then
        echo "$a 等于 $b"
else
        echo "$a 不等于 $b"
fi

# 需求3: 判断 a 与 b 比较
if [ $a -lt $b ]; then
        echo "$a 小于 $b"
elif [ $a -eq $b ]; then
        echo "$a 等于 $b"
else
        echo "$a 大于 $b"
fi


# 需求4: 判断 (a + 10) 和 (b * b) 比较大小
if test $[ a + 10 ] -gt $[ b * b ]; then
        echo "(a+10) 大于 (b * b)"
else 
        echo "(a+10) 小于或等于 (b*b)"
fi

Shell的for 循环

格式：

for variable in (list); 
do 
    command
    command
    ...
done

练习：
需求1: 遍历 1~5
需求2: 遍历 1~100
需求3: 遍历 1~100之间的奇数
需求4: 遍历 根目录 下的内容

代码如下:

#!/bin/bash

# 需求1: 遍历 1~5
for i in 1 2 3 4 5; do
        echo $i;
done
# 需求2: 遍历 1~100
for i in {1..100}; do
        echo $i
done
# 需求3: 遍历 1~100之间的奇数
for i in {1..100..2}; do
        echo $i
done
# 需求4: 遍历 根目录 下的内容
for f in `ls /`; do
        echo $f
done

Shell的while 语句

while循环用于不断执行一系列命令，也用于从输入文件中读取数据；命令通常为测试条件。其格式为：

while condition; do
    command
done

需求: 计算 1~100 的和

#!/bin/bash

sum=0
i=1
while [ $i -le 100 ]; do
        sum=$[ sum + i]
        i=$[ i + 1 ]
done

echo $sum

运行脚本，输出：

5050

使用了 Bash let 命令，它用于执行一个或多个表达式，变量计算中不需要加上 $ 来表示变量，具体可查阅：。

Shell无限循环

无限循环语法格式：

while true; do
    command
done

例子：需求: 每隔1秒 打印一次当前时间：

#!/bin/bash

while true; do
        date
        sleep 1
done

Shell的case语句(switch)

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

case 值 in

	模式1)
    	command1
    	command2
    	...
    	commandN
    	;;
	模式2）
        command1
    	command2
    	...
    	commandN
    	;;
esac

case工作方式如上所示。取值后面必须为单词in，每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后，其间所有命令开始执行直至 ;;。

取值将检测匹配的每一个模式。一旦模式匹配，则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式，使用星号 * 捕获该值，再执行后面的命令。

下面的脚本提示输入1到4，与每一种模式进行匹配：

echo '输入 1 到 4 之间的数字:'

read aNum

case $aNum in
    1)  echo '你选择了 1'
    ;;

    2)  echo '你选择了 2'
    ;;

    3)  echo '你选择了 3'
    ;;

    4)  echo '你选择了 4'
    ;;

    *)  echo '你没有输入 1 到 4 之间的数字'
    ;;
esac

输入不同的内容，会有不同的结果，例如：

输入 1 到 4 之间的数字:

你输入的数字为:

3

你选择了 3

Shell跳出循环

在循环过程中，有时候需要在未达到循环结束条件时强制跳出循环，Shell使用两个命令来实现该功能：break和continue。

break命令允许跳出所有循环（终止执行后面的所有循环）。

例子：需求: 执行死循环 每隔1秒打印当前时间, 执行10次停止 ：

#!/bin/bash
# 需求: 执行死循环 每隔1秒打印当前时间, 执行10次停止 
i=0;
while true; do
        sleep 1
        echo $i `date +"%Y-%m-%d %H:%M:%S"`

        i=$[ i + 1]
        if [ $i -eq 10 ]; then
                break
        fi
done

continue命令与break命令类似，只有一点差别，它不会跳出所有循环，仅仅跳出当前循环。

例子：需求: 打印 1~30, 注意 跳过3的倍数

#!/bin/bash

# 需求: 打印 1~30, 注意 跳过3的倍数

for i in {1..30}; do
        if test $[ i % 3 ] -eq 0; then
                continue
        fi
        echo $i
done

Shell的函数使用

格式

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

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

例子：

#!/bin/bash

demoFun () {

    echo "这是我的第一个 shell 函数!"

}

echo "-----函数开始执行-----"
demoFun
echo "-----函数执行完毕-----"

在Shell中，调用函数时可以向其传递参数。在函数体内部，通过 $n 的形式来获取参数的值，例如，$1表示第一个参数，$2表示第二个参数…

带参数的函数示例：

#!/bin/bash

funWithParam(){
    echo "第一个参数为 $1 !"
    echo "第二个参数为 $2 !"
    echo "第十个参数为 $10 !"
    echo "第十个参数为 ${10} !"
    echo "第十一个参数为 ${11} !"
    echo "参数总数有 $# 个!"
    echo "作为一个字符串输出所有参数 $* !"
}

funWithParam 1 2 3 4 5 6 7 8 9 34 73

输出结果：

第一个参数为 1 !

第二个参数为 2 !

第十个参数为 10 !

第十个参数为 34 !

第十一个参数为 73 !

参数总数有 11 个!

作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73 !

注意，$10 不能获取第十个参数，获取第十个参数需要${10}。当n>=10时，需要使用${n}来获取参数。

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

Shell的数组

数组中可以存放多个值。Bash Shell 只支持一维数组（不支持多维数组），初始化时不需要定义数组大小（。

与大部分编程语言类似，数组元素的下标由0开始。

Shell 数组用括号来表示，元素用**“空格”**符号分割开，语法格式如下：

array_name=(value1 value2 value3 … valuen)

例子：

#!/bin/bash

my_array=(A B "C" D)

我们也可以使用下标来定义数组:

array_name[0]=value0

array_name[1]=value1

array_name[2]=value2

读取数组元素值的一般格式是：

${array_name[index]}

例子：

#!/bin/bash

my_array=(A B "C" D)

echo "第一个元素为: ${my_array[0]}"

echo "第二个元素为: ${my_array[1]}"

echo "第三个元素为: ${my_array[2]}"

echo "第四个元素为: ${my_array[3]}"

执行脚本，输出结果如下所示：

$ chmod +x test.sh 

$ ./test.sh

第一个元素为: A
第二个元素为: B
第三个元素为: C
第四个元素为: D

获取数组中的所有元素
使用@ 或 * 可以获取数组中的所有元素，例如：

#!/bin/bash

my_array[0]=A
my_array[1]=B
my_array[2]=C
my_array[3]=D

echo "数组的元素为: ${my_array[*]}"
echo "数组的元素为: ${my_array[@]}"

执行脚本，输出结果如下所示：

$ chmod +x test.sh 
$ ./test.sh

数组的元素为: A B C D
数组的元素为: A B C D

获取数组的长度
获取数组长度的方法与获取字符串长度的方法相同，例如：

#!/bin/bash
my_array[0]=A
my_array[1]=B
my_array[2]=C
my_array[3]=D

echo "数组元素个数为: ${#my_array[*]}"
echo "数组元素个数为: ${#my_array[@]}"

执行脚本，输出结果如下所示：

$ chmod +x test.sh 
$ ./test.sh

数组元素个数为: 4
数组元素个数为: 4

遍历数组
方式一：

#!/bin/bash

my_arr=(AA BB CC)

for var in ${my_arr[*]}
do
  echo $var
done

方式二：

my_arr=(AA BB CC)
my_arr_num=${#my_arr[*]}
for((i=0;i<my_arr_num;i++));
do
  echo "-----------------------------"
  echo ${my_arr[$i]}
done

Shell加载其它文件的变量

和其他语言一样，Shell 也可以包含外部脚本。这样可以很方便的封装一些公用的代码作为一个独立的文件。

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

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

练习:定义两个文件 test1.sh和test2.sh，在test1中定义一个变量arr=(java c++ shell),在test2中对arr进行循环打印输出。

第一步: vim test1.sh

#!/bin/bash

my_arr=(AA BB CC)

第二步: vim test2.sh

#!/bin/bash

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

for var in ${my_arr[*]}

do

  echo $var

done

第三步: 执行 test2.sh

sh test2.sh

好处 :

​ 1. 数据源 和 业务处理 分离

​ 2. 复用 代码扩展性更强