shell脚本

shell脚本

shell变量

1. 命名规则：
   • 首字为字母，其余字母大小写，数字加_。并且不能用bash中的关键字
2. 语法：
   • 自定义的变量名=“变量值”【其中"="两边不能有空格】
   • for 变量名 in 集合【集合可以都列出来，也可以是通过语句查询得到】
3. 示例：
   • $>str=“I love my country! I love China!”
   • $>for file in `ls /home`
4. 使用变量
   • $>echo ${str}【echo $str】
   • 【输出：I love my country! I love China!】
5. 只读变量
   • $>China=“I love China!”
   • $>readonly China【readonly China=“I love China!”】
   • 【这样就成了只读变量，无法使用unset 变量名删除】
   • 【但是所有变量都可以在关闭Terminal后自动删除】
6. 删除变量
   • $>unset str

变量类型

1. 局部变量：仅在当前Terminal有效，关闭Terminal则自动销毁
2. 环境变量：所有的程序都能访问的变量
3. shell变量：是由shell程序设置的特殊变量，有一部分是局部变量，一部分是环境变量

---

shell字符串

1. 单引号：纯文本【变量会失效，不可以使用转义字符】

2. 双引号：可以有变量，可以用转义字符

3. 拼接字符串：

   1. [双引字符串] [${变量}]【字符串与变量之间没有间隔】

      • 【案例：】

        $>str="mumu"
        $>greeting="hello, "${str}"."
        $>echo $greeting
        

        [hello, mumu.]

4. 将变量写在字符串中

   • 【案例：】

   $>str="mumu"
   greet="hello, ${str}."
     $>echo $greeting
   

   [hello, mumu.]

5. 获取字符串长度

   1. ${变量:Index:Length}【字符间没有间隔，Index：从0开始，Length：长度】
      • 【案例：】

   $>str="I love China"
   $>str_China="${str:7:5}"
   $>echo str_China【$>echo ${str:7:5}】
   

6. 查找子字符串

   $>echo `expr index "${变量} " 待查序列`【结果是以1为开始】
   

   【查找待查序列的任意一个第一次出现的位置】

   【这里使用的是反引号】

   • 【案例：】

     $>str="I love China"
     $>echo `expr index "${str} " ieo
     

---

shell数组

【bash只支持一维数组，从0开始编号】

1. 定义数组

   1. 数组名=(值1 值2 … 值n)

      【例如：】

array_name=(value0 value1 value2)
或
array_name=(
value0
value1
value2
)

2. 单独给各个分量赋值

   【例如：】

array_name[0]=value0
array_name[0]=value1
array_name[0]=value2

2. 读取数组

   1. ${数组名[下标]}

      【例如：】

$>value=${array_name[1]}
$>echo ${array_name[@]}【使用@符号可以获取数组中的所有元素】

3. 获取数组的长度
   1. 获取数组长度

   $>length=${#array_name[@]}或
   $>length=${#array_name[*]}

​ 2. 获取单个数组长度

  $>length=${#array_name[1]}【#也可用于查看其他变量的长度】

---

shell注释

【以#开头就是注释】

【若是一大段代码，可以将其定义成函数，不调用就不生效】

---

shell传递参数

1. shell脚本【test.sh】

#! /bin/bash
#by: geekLin

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

2. 执行

$>chmod +x test.sh
$>./test.sh 4 5 6
【参数依次为4 5 6，${0}：表示脚本名】

3. 结果

shell传递参数示例！
执行的脚本名：./test.sh
第一个参数为：4
第二个参数为：5
第三个参数为：6

参数	说明
${0}	表示执行的脚本名
${number}	表示第几个参数【1为起始】
$#	执行脚本时传递参数的个数
$*	将传入放入的参数以空格分隔的方式拼接成字符串
$@	将传入放入的参数以空格分隔的方式拼接成字符串
$$	运行脚本当前的进程号
$!	后台运行的最后一个进程的进程号
$?	显示最后命令的退出状态。0表示没有错误。
$*只传递一个字符串	$@传递N个参数字符串及空格间隔【“9” “5” “2” “7”】

4. 示例

#!/bin/bash
#by: geekLin

echo "Shell 传递参数实例！";

echo "参数个数为：$#";

echo "传递参数字符串显示【空格分隔】：$*";

echo "传递参数字符串显示【空格分隔】：$@";

echo "运行脚本当前的进程号：$$";

echo "后台运行的最后一个进程的进程号：$!";

echo "显示最后命令退出状态，0表示没有错误：$?";

5. 示例结果

Shell 传递参数实例！
参数个数为：4
传递参数字符串显示【空格分隔】：9 5 2 7
传递参数字符串显示【空格分隔】：9 5 2 7
运行脚本当前的进程号：2963
后台运行的最后一个进程的进程号：
显示最后命令退出状态，0表示没有错误：0

---

shell基本运算符

【expr是一款表达式计算工具，使用反引号包含，且表达式与运算符之间必须有空格】

1. 算术运算符【a=10，b=20】

运算符	举例
+	$>result=`expr $a + $b`【30】
-	$>result=`expr $a - $b`【-10】
*	$>result=`expr $a * $b`【200】
/	$>result=`expr $a / $b`【0，只进行整数运算】
%	$>result=`expr $a % $b`【10】
=	$>a=$b
==	$>result=`expr $a == $b`【0】
!=	$>result=`expr $a != $b`【1】

• 【示例：】

  • shell脚本

    #!/bin/bash
    #by: geekLin
    
    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 $a / $b`
    echo "a / b : $val" 
    
    val=`expr $a % $b`
    echo "a % b : $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
    a / b : 0
    a % b : 10
    a 不等于 b
    

2. 关系运算符

运算符	说明	举例
-eq	==	[$a -eq $b]
-ne	!=	[$a -ne $b]
-gt	>	[$a -gt $b]
-lt	<	[$a -lt $b]
-ge	>=	[$a -ge $b]
-le	<=	[$a -le $b]
		需要搭配if使用

• 【示例：】

  • shell脚本

    #!/bin/bash
    #by: geekLin
    
    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
    

3. 布尔运算符

运算符	说明	举例
!	非运算	[ !$a -eq $b]【1】【 !的左侧有空格才生效】
-o	或运算	[$a -lt 20 -o $b -gt 100]【1】
-a	与运算	[ $a -lt 20 -a $b -gt 100 ]【0】

• 【示例：】

  • shell脚本

    #!/bin/bash
    #by: geekLin
    
    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 -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 -eq 20: a 等于 b
    10 小于 100 且 20 大于 15 : 返回 true
    10 小于 100 或 20 大于 100 : 返回 true
    10 小于 5 或 20 大于 100 : 返回 false
    

4. 逻辑运算符

运算符	说明	举例
&&	AND	[[ $a -lt 100 && $b -gt 100 ]]
||	OR	[[ $a -lt 100 || $b -gt 100 ]]

• 【示例：】

  • shell脚本

    #!/bin/bash
    #by: geekLin
    
    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
    

5. 字符串运算符【a=“abc”，b=“efg”】

运算符	说明	举例
=	相等	[$a = $b]
!=	不相等	[$a != $b]
-z	检测长度是否为0，为0：true	[ -z $a]
-n	检测长度是否为0，为0：false	[ -n $a]
string	字符串不为空，true	[$a]

• 【示例：】

  • shell脚本

    #!/bin/bash
    #by: geekLin
    
    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 : 字符串不为空
    

6. 文件测试运算符

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

• 【示例：】

  • shell脚本

    #!/bin/bash
    #by: geekLin
    
    file="/home/hadoop/mumu/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
    

  • 结果：

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

shell echo命令

【用于字符串的输出】

1. 显示普通字符串：

   echo "I love China"【echo I love China】
   

2. 显示转义字符：

   echo "\"It is a test\"" 
   

   • 结果：“It is a test”

3. 显示变量：

   • 使用read命令从标准输入读取一行

     #!/bin/bash
     #by: geekLin
     
     read name
     echo "$name, I love China!"
     

     [hadoop@master mumu]$ ./test.sh 
     geekLin
     geekLin, I love China!
     

4. 显示换行

   #!/bin/bash
   #by: geekLin
   
   echo -e "geekLin \n"【-e 开启转义】 
   echo "I love China!"
   

   [hadoop@master mumu]$ ./test.sh 
   geekLin
   
   I love China!
   

5. 显示不换行

   #!/bin/bash
   #by: geekLin
   
   echo -e "geekLin \c"
   echo "I love China!"
   

   [hadoop@master mumu]$ ./test.sh 
   geekLin I love China!
   

6. 显示结果定向至文件

   $>echo "I love China!" > myfile 
   

7. 原样输出字符串，不进行转义或取变量(用单引号)

   $>echo '$name\"'
   

   $name\"
   

8. 显示命令执行结果

   echo `date`
   

   [hadoop@master mumu]$ echo `date`
   2019年 07月 28日 星期日 17:56:42 CST
   

---

shell printf命令

#!/bin/bash
#by: geekLin

printf "%-10s %-8s %-4s\n" 姓名 性别 体重kg
printf "%-10s %-8s %-4.2f\n" 郭靖 男 66.1234
printf "%-10s %-8s %-4.2f\n" 杨过 男 48.6543
printf "%-10s %-8s %-4.2f\n" 郭芙 女 47.9876

#!/bin/bash
#by: geekLin

printf "%-10s %-8s %-4s\n" 姓名 性别 体重kg
printf "%-10s %-8s %-4.2f\n" 郭靖 男 66.1234
printf "%-10s %-8s %-4.2f\n" 杨过 男 48.6543
printf "%-10s %-8s %-4.2f\n" 郭芙 女 47.9876

姓名     性别   体重kg
郭靖     男      66.12
杨过     男      48.65
郭芙     女      47.99

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

#!/bin/bash
#by: geekLin

echo "format-string 为双引号" 
printf "%d %s\n" 1 "abc"
echo -e "\n单引号与双引号效果一样"
printf '%d %s\n' 1 "abc"
echo -e "\n没有引号也可以输出"
printf %s abcdef
echo -e "\n\n格式只指定了一个参数，但多出的参数仍然会按照该>格式输出"
echo "format-string 被重用"
printf %s abc def
printf "%s\n" abc def
printf "%s %s %s\n" a b c d e f g h i j
echo -e "\n如果没有 arguments，那么 %s 用 NULL 代替，%d 用 0 代替"
printf "%s and %d \n"

[hadoop@master mumu]$ ./test.sh 
format-string 为双引号
1 abc

单引号与双引号效果一样
1 abc

没有引号也可以输出
abcdef

格式只指定了一个参数，但多出的参数仍然会按照该格式输出
format-string 被重用
abcdefabc
def
a b c
d e f
g h i
j  

如果没有 arguments，那么 %s 用 NULL 代替，%d 用 0 代替
 and 0

• printf 的转义序列

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

---

shell test 命令

【和expr类似，比expr简单】

1. 关系运算符

#!/bin/bash
#by: geekLin

num1=100
num2=100

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

[hadoop@master mumu]$ ./test.sh 
两个数相等！

2. 算数运算符

#!/bin/bash
#by: geekLin

a=5
b=6

result=$[a+b]
echo "result为: $result"

[hadoop@master mumu]$ ./test.sh 
result为: 11

3. 字符串测试

#!/bin/bash
#by: geekLin

num1="China"
num2="china"
if test $num1 = $num2
then
    echo '两个字符串相等!' 
else
    echo '两个字符串不相等!' 
fi

[hadoop@master mumu]$ ./test.sh 
两个字符串不相等!

4. 文件测试

#!/bin/bash
#by: geekLin

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

[hadoop@master mumu]$ ./test.sh 
文件不存在!

5. 逻辑运算符

#!/bin/bash
#by: geekLin

cd /home/hadoop/mumu
if test -e ./test.sh -o -e ./bash
then
    echo '有一个文件存在!' 
else
    echo '两个文件都不存在' 
fi

[hadoop@master mumu]$ ./test.sh 
有一个文件存在!

---

shell流程控制

1. 分支语句

   1. if

      • if [conditionthen];
        command1
        command2
        …
        commandN

        fi

   #!/bin/bash
   #by: geekLin
   
   if [ $(ps -ef | grep -c "ssh") -gt 1 ]; then
           echo "true";
   fi
   
   
   a=10
   
   if [ $a -gt 1 ]; then
           echo "$a 比1大";
           echo "只能和常量比，不能和变量比";
   fi
   

   [hadoop@master mumu]$ ./test.sh 
   true
   10 比1大
   只能和常量比，不能和变量比
   

   2. if else

      • if [condition]; then
        command1
        command2
        …
        commandN

        else
        command

        fi

   3. if elif else

      • if [condition]; then
        command1

        elif [condition2]; then
        command2

        else
        commandN

        fi

      #!/bin/bash
      #by: geekLin
      
      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
      

      [hadoop@master mumu]$ ./test.sh 
      a 小于 b
      

2. for循环

   for var in item1 item2 … itemN

   do
   command1
   command2
   …
   commandN

   done

#!/bin/bash
#by: geekLin

for loop in 1 2 3 4 5
do
    echo "The value is: $loop"
done

for str in 'I love China!'
do
    echo $str
done

The value is: 1
The value is: 2
The value is: 3
The value is: 4
The value is: 5
I love China!

3. while语句

   while condition

   do
   command

   done

#!/bin/bash
#by: geekLin

i=1
while(( $i<=5 ))
do
    echo $i 
    let "i++"
done
【变量计算中不需要加上 $ 来表示变量】

[hadoop@master mumu]$ ./test.sh 
1
2
3
4
5

#!/bin/bash
#by: geekLin

echo '按下 <CTRL-D> 退出' 
echo -n '输入你最喜欢的网站名: '
while read FILM
do
    echo "是的！$FILM 是一个好网站"
done
【ctrl+C | ctrl+D : 退出输入】

[hadoop@master mumu]$ ./test.sh 
按下 <CTRL-D> 退出
输入你最喜欢的网站名: baidu
是的！baidu 是一个好网站
github
是的！github 是一个好网站
【可以一直输入，直到输入退出命令】

• 无限循环

while :do 
    command
done 
或
while true
do
	command
done
或
for (( ; ; )) 

4. until循环

   【until 循环执行一系列命令直至条件为真时停止】

   until condition

   do
   command

   done

5. case

   【它需要一个esac作为结束标记，每个case 分支用右圆括号，用两个分号表示 break】

   case 值 in

   模式1)
   command1

   ​ command2
   ​ …
   ​ commandN
   ​ ;;

   模式2）
   command1
   command2
   …
   commandN
   ;;

   esac

#!/bin/bash
#by: geekLin

echo '输入 1 到 4 之间的数字:' 
echo '你输入的数字为:' 
read Num
case $Num in
    1)
        echo '你选择了 1'
        ;;
    2)
        echo '你选择了 2' 
        ;;
    3)
        echo '你选择了 3' 
        ;;
    4)
        echo '你选择了 4' 
        ;;
    *)
        echo '你没有输入 1 到 4 之间的数字' 
        ;;
esac

[hadoop@master mumu]$ ./test.sh 
输入 1 到 4 之间的数字:
你输入的数字为:
1
你选择了 1
[hadoop@master mumu]$ ./test.sh 
输入 1 到 4 之间的数字:
你输入的数字为:
5
你没有输入 1 到 4 之间的数字

6. 跳出循环

   1. break

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

      [hadoop@master mumu]$ ./test.sh 
      输入 1 到 5 之间的数字:5
      你输入的数字为 5!
      输入 1 到 5 之间的数字:9
      你输入的数字不是 1 到 5 之间的! 游戏结束
      

   2. continue

      #!/bin/bash
      #by: geekLin
      
      while : 
      do
              echo -n "输入 1 到 5 之间的数字:" 
              read Num
              case $Num in
                  1|2|3|4|5)
                      echo "你输入的数字为 $Num!" 
                      ;;
                  *)
                      echo "你输入的数字不是 1 到 5 之间的! 游戏结束" 
                          continue
                      ;;
              esac
      done
      

      [hadoop@master mumu]$ ./test.sh 
      输入 1 到 5 之间的数字:2
      你输入的数字为 2!
      输入 1 到 5 之间的数字:9
      你输入的数字不是 1 到 5 之间的! 游戏结束
      输入 1 到 5 之间的数字:3
      你输入的数字为 3!
      输入 1 到 5 之间的数字:
      【并未结束游戏】
      

---

shell函数

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

[ function ] funname [()]

{

​ action;

​ [return int;]

}

说明：

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

1. 不带返回值

#!/bin/bash
#by: geekLin

demoFun(){
    echo "这是我的第一个 shell 函数!" 
}

echo "-----函数开始执行-----" 

demoFun

echo "-----函数执行完毕-----" 

[hadoop@master mumu]$ ./test.sh 
-----函数开始执行-----
这是我的第一个 shell 函数!
-----函数执行完毕-----

2. 带返回值

#!/bin/bash
#by: geekLin

funWithReturn(){
    echo "这个函数会对输入的两个数字进行相加运算..." 
    echo "输入第一个数字: " 
    read aNum
    echo "输入第二个数字: " 
    read anotherNum
    echo "两个数字分别为 $aNum 和 $anotherNum !" 
    return $(($aNum+$anotherNum))
}

funWithReturn

echo "输入的两个数字之和为 $? !"

[hadoop@master mumu]$ ./test.sh 
这个函数会对输入的两个数字进行相加运算...
输入第一个数字: 
5
输入第二个数字: 
6
两个数字分别为 5 和 6 !
输入的两个数字之和为 11 !

【函数返回值在调用该函数后通过 $? 来获得】

3. 函数参数

【在Shell 中，调用函数时可以向其传递参数。在函数体内部，通过 $n 的形式来获取参数的值】

#!/bin/bash
#by: geekLin

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

[hadoop@master mumu]$ ./test.sh 
第一个参数为 1
第二个参数为 2
第十个参数为 10
第十个参数为 34
第十一个参数为 73
参数总数有 11 个
作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73

注意：

​ 【当n>=10 时，需要使用$n来获取参数，因此通常都使用${n}表示变量就好了。】

4. shell输入输出重定向

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

【0：标准输入，1：标准输出，2：标准错误输出】

$>command 2 > file【将错误信息写入file文件中】

$>command >> file 2>&1【将 stdout 和 stderr 合并后重定向到 file】

$>command < file1 >file2【对 stdin 和 stdout 都重定向】

• Here Document

  【Here Document 是 Shell 中的一种特殊的重定向方式，用来将输入重定向到一个交互式 Shell
  脚本或程序】

  command << delimiter
  document
  delimiter

  【将两个 delimiter 之间的内容(document) 作为输入传递给 command】

  【结尾的 delimiter 一定要顶格写，前面不能有任何字符，后面也不能有任何字符】

#!/bin/bash
#by: geekLin

cat << EOF 
        欢迎来到 
        geekLin的github
        https://github.com/geekLin01
EOF

[hadoop@master mumu]$ ./test.sh 
	欢迎来到 
	geekLin的github
    https://github.com/geekLin01

• /dev/null 文件

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

  $>command > /dev/nul

  【写入到/dev/null的内容都会被丢弃，起到"禁止输出"的效果】

---

shell文件包含

. filename

或

source filename

【点号(.)和文件名中间有一空格】

#!/bin/bash
#by: geekLin


url="https://github.com/geekLin01"

#!/bin/bash
#by: geekLin

. ./test1.sh

echo "geekLin的github：$url"

geekLin的github：https://github.com/geekLin01

---

将shell脚本，设置进PATH

1. 在~下创建一个shellhome | path目录

2. 编写shell脚本【SD.sh】

   #!/bin/bash
   
   halt
   

3. $>chmod +x SD.sh

4. vim ~/.bash_profile

5. 追加

   ​ export SHELLHOME=/home/hadoop/path

   ​ PATH=$PATH:$SHELLHOME/

6. $>source ~/.bash_profile【立即生效】

7. 否则重启生效