shell

shell

脚本运行

脚本的执行 

        　格式： bash 脚本.sh 或 sh 脚本.sh 。

1. [root@node01 ~]# ls -l
2. total 4
3. -rw-r--r-- 1 root root 33 May 29 11:57 hello.sh
4. [root@node01 ~]# bash hello.sh
5. Hello World!
6. [root@node01 ~]# sh hello.sh
7. Hello World!

        格式： source 脚本.sh 或 . 脚本.sh

1. [root@node01 ~]# ls -l
2. total 4
3. -rw-r--r-- 1 root root 33 May 29 11:57 hello.sh
4. [root@node01 ~]# . hello.sh
5. Hello World!
6. [root@node01 ~]# source hello.sh
7. Hello World!

        绝对路径  脚本.sh  (必须给执行权限)

        区别 ：

　bash 或 sh 执行脚本时会新开一个 bash，不同 bash 中的变量无法共享。而 source 或 . 是在同一个 bash 里面执行的，所以变量可以共 享。

shell基础

注释

单行注释        

　        要在 bash 中编写单行注释，必须在注释的开头使用井号 # 。

1. #!/bin/bash
2. # 我是注释

多行注释

        有两种方法可以在 bash 脚本中插入多行注释：

        通过在 << COMMENT 和 COMMENT 之间加上注释，可以在 bash 脚本中编写多行注释。

        也可以通过将注释括在 : ' 和单引号 ' 之间来编写多行注释。

1. #!/bin/bash
2. << EOF
3. 我是注释
4. 我是注释
5. 我是注释
6. EOF
8. echo "Hello World!"

        提示：EOF 表示 End Of File，表示文件结尾，这里代指从哪开始到哪结束。EOF 只是一个

名称而已，可以使用任意非关键字名称进行替 换，例如 COMMENT，通常都使用 EOF 。

        

1. #!/bin/bash
2. :  '     #有空格
3. 我是注释
4. 我是注释
5. 我是注释
6. '
7. echo "Hello World"

变量 

        　Shell 声明变量的语法格式如下：

1. variable=value
2. variable='value'
3. variable="value"

        　Shell 也支持将命令的执行结果赋值给变量，常见的有以下两种方式：

1. variable=`command`
2. variable=$(command)

引号

1. #!/bin/bash

2. name="zhangsan"
3. echo 'My name is ${name}'
4. echo "My name is ${name}"

        运行结果

1. My name is ${name}
2. My name is zhangsan 

位置参数 

        运行 Shell 脚本文件时我们还可以给它传递一些参数，这些参数在脚本文件内部可以使用 $n

的形式来接收。例如， $1 表示第一个参 数， $2 表示第二个参数，依次类推。        

        注意：如果参数个数太多，达到或者超过了 10 个，那么就得用 ${n} 的形式来接收了，例如 ${10} 、 ${23} 。 {} 的作用是为了帮助解释器识别参数的边界，这跟使用变量时加 {} 是一样的效果。

·        范例 test.sh：

1. #!/bin/bash
2. echo "name: $1"
3. echo "age: $2"

        运行 test.sh，并附带参数：

1. [root@node01 ~]# bash test.sh zhangsan 18
2. name: zhangsan
3. age: 18

特殊变量  

字符串

定义

        字符串可以由" "包含，也可以由' '包含

1.  由单引号包围的字符串都会原样输出，即使是变量也无效。
2. 单引号包围的字符串中不能出现 '  ,即使对单引号转义（\'）也不行。
3. 如果双引号中包含了变量，他会解析以后输出。
4. 双引号包含的字符串中可以出现双引号，只要他被转义(\")就行。
5. 不被引号包围的字符串出现变量时，他会解析。例如：
6. 字符串中不能出现空格，否则会把空格后面的当成另一个字符串，例如：echo "a b c"

长度       

        在 Shell 中获取字符串长度很简单，具体方法如下：

1. [root@node01 ~]# name=mrhelloworld
2. [root@node01 ~]# echo ${#name}
3. 12

拼接

        案例

1. #！/bin/bash
2. name="zhangsan"
3. age=18
4. str1=$name$age # 中间不能有空格
5. str2="$name $age" # 如果被双引号包围，那么中间可以有空格
6. str3=$name": "$age # 中间可以出现别的字符串
7. str4="$name: $age" # 这样写也可以
8. str5="${name}同学: ${age}岁" # 这个时候需要给变量名加上大括号
9. echo $str1
10. echo $str2
11. echo $str3
12. echo $str4
13. echo $str5

        运行结果 

1. [root@node01 ~]# bash test.sh
2. zhangsan18
3. zhangsan 18
4. zhangsan: 18
5. zhangsan: 18
6. zhangsan同学: 18岁

截取

如果想从字符串的左边开始计数，那么截取字符串的具体格式如下 

1. ${string:start:length} 

　范例： 

1. [root@node01 ~]# name=mrhelloworld
2. [root@node01 ~]# echo ${name:2}
3. helloworld
4. [root@node01 ~]# echo ${name:2:5}
5. hello

如果想从字符串的右边开始计数，那么截取字符串的具体格式如下

1. ${string:0-start:length}

         范例：

1. [root@node01 ~]# name=mrhelloworld
2. [root@node01 ~]# echo ${name:0-5}
3. world
4. [root@node01 ~]# echo ${name:0-10}
5. helloworld
6. [root@node01 ~]# echo ${name:0-10:5}
7. hello

总结 

数组 

定义 

        在 Shell 中，用括号 () 来表示数组，数组元素之间用 空格 来分隔。由此，定义数组的一般形式为：

1. arr=(20 56 "mrhelloworld")  

获取 

        获取数组元素的值，一般使用下面的格式：

1. ${array_name[index]}  

        其中，array_name 是数组名，index 是下标。例如： 

1. [root@node01 ~]# echo ${arr[2]}
2. mrhelloworld

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

1. [root@node01 ~]# echo ${arr[*]}
2. 20 56 mrhelloworld
3. [root@node01 ~]# echo ${ages[@]}
4. 24 19 12

长度  

　所谓数组长度，就是数组元素的个数。使用 @ 或 * 可以获取数组中的所有元素，然后使用 # 来

获取数组元素的个数，所以获取数组长 度的语法如下：

1. [root@node01 ~]# echo ${#arr[@]}
2. 3
3. [root@node01 ~]# echo ${#ages[*]}
4. 3

　如果某个元素是字符串，还可以通过指定下标的方式获得该元素的长度，如下所示：

1. [root@node01 ~]# echo ${#arr[2]}
2. 12

 拼接

 　拼接数组的思路是：先利用 @ 或 * ，将数组展开成列表，然后再合并到一起。具体格式如下：

1. array_new=(${array1[@]} ${array2[@]})
2. array_new=(${array1[*]} ${array2[*]})

　两种方式是等价的，选择其一即可。其中，array1 和 array2 是需要拼接的数组，array_new 是

拼接后形成的新数组。 

        案例 

1. #!/bin/bash
2. array1=(23 56)
3. array2=(99 "mrhelloworld")
4. array_new=(${array1[@]} ${array2[*]})
5. echo ${array_new[@]} # 也可以写作 ${array_new[*]}

        运行结果如下 

1. [root@node01 ~]# bash test.sh
2. 23 56 99 mrhelloworld

删除 

        在 Shell 中，使用 unset 关键字来删除数组元素，具体格式如下： 

1.  unset array_name[index]

        其中，array_name 表示数组名， index 表示数组下标。

        

        如果不写下标只写数组名，则表示删除整个数组，所有元素都会消失。

        范例 test.sh：

1. #!/bin/bash
2. arr=(23 56 99 "mrhelloworld")
3. unset arr[1]
4. echo ${arr[@]}
5. unset arr
6. echo ${arr[*]}
7. echo '--------------------'

        运行结果如下 

1. [root@node01 ~]# bash test.sh
2. 23 99 mrhelloworld
3. --------------------

shell高级

shell运算符 

算数运算符 

         但是，Shell 和其它编程语言不同，Shell 不能直接进行算数运算，必须使用数学计算命令，

这让初学者感觉很困惑，也让有经验的程序 员感觉很奇葩。expr 是一款表达式计算工具，使用它

能完成表达式的求值操作。

 

1. #!/bin/bash
2. a=10
3. b=20
5. val=$(expr $a + $b)
6. echo "a + b : $val"
8. val=`expr $a - $b`
9. echo "a - b : $val"
11. val=`expr $a \* $b`
12. echo "a * b : $val"
14. val=`expr $b / $a`
15. echo "b / a : $val"
17. val=`expr $b % $a`
18. echo "b % a : $val"
20. if [ $a == $b ]
21. then
22. echo "a 等于 b"
23. fi
25. if [ $a != $b ]
26. then
27. echo "a 不等于 b"
28. fi

关系运算符 

运算符	说明	举例
-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

 

 

 

 

 

 

 

 

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

1. #!/bin/bash
2. a=10
3. b=20
5. if [ $a -eq $b ]
6. then
7.    echo "$a -eq $b : a 等于 b"
8. else
9.   echo "$a -eq $b: a 不等于 b"
10. fi
12. if [ $a -ne $b ]
13. then
14.    echo "$a -ne $b: a 不等于 b"
15. else
16.    echo "$a -ne $b : a 等于 b"
17. fi
19. if [ $a -gt $b ]
20. then
21.    echo "$a -gt $b: a 大于 b"
22. else
23.    echo "$a -gt $b: a 不大于 b"
24. fi
26. if [ $a -lt $b ]
27. then
28.    echo "$a -lt $b: a 小于 b"
29. else
30.    echo "$a -lt $b: a 不小于 b"
31. fi
33. if [ $a -ge $b ]
34. then
35.    echo "$a -ge $b: a 大于或等于 b"
36. else
37.    echo "$a -ge $b: a 小于 b"
38. fi
40. if [ $a -le $b ]
41. then
42.    echo "$a -le $b: a 小于或等于 b"
43. else
44.    echo "$a -le $b: a 大于 b"
45. fi

逻辑运算符 

       ① !, "非"运算符，表达式为true，则返回false，否则返回true。 

1. #!/bin/bash
2. a=10
3. b=20
5. if [ $a != $b ]
6. then
7.     echo "$a != $b : a 不等于 b"
8. else
9.     echo "$a == $b: a 等于 b"
10. fi

        ② -o ,"或"运算符，有一个条件为true,则返回true

1. if [ $a -lt 100 -o $b -gt 100 ]
2. then
3.     echo "$a 小于 100 或 $b 大于 100 : 返回 true"
4. else
5.     echo "$a 小于 100 或 $b 大于 100 : 返回 false"
6. fi

 

        ③-a ,"与"运算符，两个条件都满足才返回true 

1. if [ $a -lt 100 -a $b -gt 15 ]
2. then
3.     echo "$a 小于 100 且 $b 大于 15 : 返回 true"
4. else
5.     echo "$a 小于 100 且 $b 大于 15 : 返回 false"
6. fi

 字符串运算符

 

1. #!/bin/bash
2. a="abc"
3. b="efg"

        # "="  相等

1. if [ $a = $b ]
2. then
3.     echo "$a = $b : a 等于 b"
4. else
5.     echo "$a = $b: a 不等于 b"
6. fi

        #"!="  不等

1. if [ $a != $b ]
2. then
3.     echo "$a != $b : a 不等于 b"
4. else
5.     echo "$a != $b: a 等于 b"
6. fi

        #"z"  字符串长度为0

1. if [ -z $a ]
2. then
3.     echo "-z $a : 字符串长度为 0"
4. else
5.     echo "-z $a : 字符串长度不为 0"
6. fi

        #"-n"  字符串长度不为0

1. if [ -n "$a" ]
2. then
3.     echo "-n $a : 字符串长度不为 0"
4. else
5.     echo "-n $a : 字符串长度为 0"
6. fi

文件测试运算符 

 test命令

shell流程控制 

        if 

1. #!/bin/bash
2. a=10
3. b=20
5. #这个案例看着有点像java中的switch语句
6. if [ $a == $b ]
7. then
8.     echo "a 等于 b"
9. elif [ $a -gt $b ]     
10. then
11.     echo "a 大于 b"
12. elif [ $a -lt $b ]     
13. then
14.     echo "a 小于 b"
15. else     
16.     echo "没有符合的条件"
17. fi

1. 当从其他格式的系统传过来文件时，要查看状态（格式）
2. set ff 检查格式 fileformat=
3. 然后再把格式改为对应系统的格式
4. windows 为dos
5. linux 为nginx

         case

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

1. #!/bin/bash
2. echo '输入 1 到 4 之间的数字:'
3. echo '你输入的数字为:'
4. read num
5. case $num in
6.     1)
7.          echo '你选择了 1'
8.          ;;
9.     2)
10.          echo '你选择了 2'
11.          ;;
12.    3)
13.          echo '你选择了 3'
14.          ;;
15.    4)
16.          echo '你选择了 4'
17.         ;;
18.    *)
19.         echo '你没有输入 1 到 4 之间的数字'
20.        ;;
21. esac

 

        for 

        当变量值在列表里，for 循环即执行一次所有命令，使用变量名获取列表中的当前取值。

        

        命令可为任何有效的shell命令和语句。 in 列表可以包含替换、字符串和文件名。

        in列表是可选的，如果不用它， for 循环使用命令行的位置参数。

 

 

1. #!/bin/bash
2. for loop in 1 2 3 4 5
3. do
4.     echo "The value is: $loop"
5. done
7. # 反例
8. for str in 'This is a string','hello moto'   #不能有逗号，系统会把逗号认作字符串
9. do
10.     echo $str
11. done
13. for i in node01 node02 node03
14. do
15.     echo $i
16. done

         while

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

1. # Bash let 命令，它用于执行一个或多个表达式，变量计算中不需要加上 $ 来表示变量
2. #!/bin/bash
4. i=1
5. while(( $i<=5 ))
6. do
7.     echo $i
8.     let "i++"
9. done

        break 

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

1. #!/bin/bash
3. while :
4. do
5.     echo -n "输入 1 到 5 之间的数字:"
6.     read aNum
7.     case $aNum in
8.         1|2|3|4|5)
9.             echo "你输入的数字为 $aNum!"
10.             ;;
11.         *)
12.             echo "你输入的数字不是 1 到 5 之间的! 游戏结束"
13.             break
14.             ;;
15.      esac
16. done

        continue 

         continue 命令不会跳出所有循环，仅仅跳出当前循环。

1. #!/bin/bash
3. while :
4. do
5.     echo -n "输入 1 到 5 之间的数字: "
6.     read aNum
7.     case $aNum in
8.          1|2|3|4|5)
9.                echo "你输入的数字为 $aNum!"
10.                ;;
11.         *)
12.               echo "你输入的数字不是 1 到 5 之间的!"
13.               continue
14.               echo "游戏结束"
15.               ;;
16.      esac
17. done

 shell函数

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

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

        参数返回，可以显示加：return 返回，如果不加，将以最后一条命令运行结果，作为返回值。

  

 

1. #!/bin/bash
2. ## 第一个函数------------------------------
3. demoFun(){
4.      echo "这是我的第一个 shell 函数!"
5. }
6. echo "-----函数开始执行-----"
7. demoFun
8. echo "-----函数执行完毕-----"
10. ## 函数返回值------------------------------
11. funWithReturn(){
12.         echo "这个函数会对输入的两个数字进行相加运算..."
13.         echo "输入第一个数字: "
14.         read aNum
15.         echo "输入第二个数字: "
16.         read anotherNum
17.         echo "两个数字分别为 $aNum 和 $anotherNum !"
18.         return $(($aNum+$anotherNum))
19. }
20. funWithReturn
21. # 函数返回值在调用该函数后通过 $? 来获得。
22. echo "输入的两个数字之和为 $? !"
24. ## 函数参数------------------------------
25. funWithParam(){
26.        echo "第一个参数为 $1 !"
27.        echo "第二个参数为 $2 !"
28.        echo "第十个参数为 $10 !" # 错误写法，如果参数个数太多，达到或者超过了 10 个，那么就得用 ${n} 的形式来接收了
29.        echo "第十个参数为 ${10} !" # 正确写法
30.        echo "第十一个参数为 ${11} !"
31.        echo "参数总数有 $# 个!"
32.        echo "作为一个字符串输出所有参数 $* !"
33. }
34. funWithParam a b c d e f g h i j