shell编程最新总结大全

亦凉 2022-02-20 06:31 372阅读 0赞

## Shell知识教程 ##

**1. Shell编程**

>  Shell 是一个用 C 语言编写的程序，它是用户使用 Linux 的桥梁。Shell 既是一种命令语言，又是一种程序设计语言。  
> **Shell脚本**  
>  Shell 脚本（shell script），是一种为 shell 编写的脚本程序。  
>  业界所说的 shell 通常都是指 shell 脚本，（java文本文件）

**2.Shell环境**

>   Shell 编程跟 java、php 编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。(Linux系统中自带编译器)  
> .java —>javac xx.java java

**Linux 的 Shell 编程解析器种类众多，常见的有**：

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

![在这里插入图片描述][2019041216021749.png]

>  本教程关注的是 Bash，也就是 Bourne Again Shell，由于易用和免费，Bash 在日常工作中被广泛使用。同时，**Bash 也是大多数Linux 系统默认的 Shell脚本解析器。**（必须有/bin/bash：不然无法编写shell,想无jvm无法编写 java程序一样）  
>  在一般情况下，人们并不区分 Bourne Shell 和 Bourne Again Shell，所以，像 **\#!/bin/sh**，它同样也可以改为 **\#!/bin/bash**。

**3. 第一个shell脚本**

Linux中的shell脚本 ---->文件   xx.sh---->shell脚本

1.  编写Shell脚本

>   打开文本编辑器(可以使用 vi/vim 命令来创建文件)，新建一个文件 [test.sh][]，扩展名为 sh（sh代表shell），扩展名并不影响脚本执行，见名知意就好，如果你用 php 写 shell 脚本，扩展名就用 php 好了。

输入一些代码，第一行一般是这样：

#!/bin/bash
    echo "Hello World !"

> **\#! 是一个约定的标记，它告诉系统这个脚本需要什么解释器来执行，即使用哪一种 Shell。**  
> **echo 命令用于向窗口输出文本**。

1.  运行 Shell 脚本

*  **作为可执行程序**  `./text.sh`  
    将上面的代码保存为 [test.sh][]，并 cd 到相应目录：  
    `chmod +x ./test.sh #使脚本具有执行权限`  
    `chmod 777 ./tesh.sh 权限（rwx） 这两种修改权限方法都可以`  
    `./test.sh #执行脚本`
    
    > 注意，一定要写成 ./test.sh，而不是 [test.sh][]，运行其它二进制的程序也一样，直接写 [test.sh][]，linux 系统会去 系统默认PATH 里寻找有没有叫 [test.sh][] 的，，你的当前目录通常不在 PATH 里，所以写成 [test.sh][] 是会找不到命令的，要用 ./test.sh 告诉系统说，就在当前目录找。
 *  **作为解释器参数**   `/bin/bash/text.sh`  
    这种运行方式是，直接运行解释器，其参数就是 shell 脚本的文件名，如：
    
        /bin/sh/bash test.sh
        /bin/php test.php
    
    这种方式运行的脚本，不需要在第一行指定解释器信息`#!/bin/bash`，写了也没用。

1.  **Shell变量**

*  显示当前shell中所有变量：**set**命令显示出系统所有的变量（JAVA\_HOME）  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDEyMjg5_size_16_color_FFFFFF_t_70]
 *  定义变量时，变量名不加美元符号`（$，PHP语言中变量需要）`，如：  
    `your_name="runoob.com"`  
    `$JAVA_HOEM:path是在引用变量`

> 注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，**变量名的命名须遵循如下规则**：
> 
>  *  命名只能使用英文字母，数字和下划线，首个字符不能以数字开头。
>  *  中间不能有空格，可以使用下划线（\_）。
>  *  不能使用标点符号。
> 
> **有效的 Shell 变量名示例如下：**
> 
>  *  RUNOOB
>  *  LD\_LIBRARY\_PATH
>  *  \_var
>  *  var2
> 
> **无效的变量命名：包含了特殊字符**
> 
>  *  ?var=123
>  *  user\*name=runoob
> 
> **除了显式地直接赋值，还可以用语句给变量赋值，如**：
> 
> ![在这里插入图片描述][20190412170359183.png]  
> 以上语句将 /etc 下目录的文件名循环出来，赋值给变量 file

1.  使用变量  
    使用一个定义过的变量，只要在变量名前面加美元符号即可，如：
    
        your_name="qinjx"
        echo $your_name
        echo ${your_name}
    
    变量名外面的花括号是可选的，加不加都行，加花括号是为了帮助解释器识别变量的边界，比如下面这种情况：
    
        for skill in Ada Coffe Action Java; do
          echo "I am good at ${skill}Script"
        done
    
    如果不给skill变量加花括号，写成echo “I am good at $skillScript”  
    已定义的变量，可以被重新定义，如： 相当于java中给变量从新赋值
    
        your_name="tom"
        echo $your_name
        your_name="alibaba"
        echo $your_name
    
    这样写是合法的，但注意，第二次赋值的时候不能写`$your_name="alibaba"`，使用变量的时候才加美元符（$）。
2.  只读变量  
    使用 readonly 命令可以将变量定义为只读变量，只读变量的值不能被改变。  
    下面的例子尝试更改只读变量，结果报错：
    
        #!/bin/bash
        myUrl="http://www.google.com"
        readonly myUrl
        myUrl="http://www.runoob.com"
    
    > 运行脚本，结果如下：  
    > /bin/sh: NAME: This variable is read only.
3.  删除变量  
    使用 unset 命令可以删除变量。语法：
    
        unset variable_name
    
    变量被删除后不能再次使用。unset 命令不能删除只读变量。
    
    > **实例**  
    > \#!/bin/sh  
    > myUrl=“[http://www.runoob.com][http_www.runoob.com]”  
    > unset myUrl  
    > echo $myUrl  
    > 以上实例执行将没有任何输出。
4.  变量类型
    
    > **运行shell时，会同时存在三种变量：**  
    > 1.) 局部变量 局部变量在脚本或命令中定义，仅在当前shell实例中有效，其他shell启动的程序不能访问局部变量。类似于java中的私有化  
    > 2.) 环境变量 所有的程序，包括shell启动的程序，都能访问环境变量，有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。（所有的shell脚本启动的时候都能访问得到环境变量）  
    > 3.) shell变量 shell变量是由shell程序设置的特殊变量。shell变量中有一部分是环境变量，有一部分是局部变量，这些变量保证了shell的正常运行
    
    > **export 变量名** 可把变量提升为全局环境变量，可供其他shell程序使用
5.  Shell字符串
    
    > 字符串是shell编程中最常用最有用的数据类型（除了数字和字符串，也没啥其它类型好用了），字符串可以用单引号，也可以用双引号，也可以不用引号。单双引号的区别跟PHP类似。

*  **单引号** `str='this is a string'`
    
    > 单引号字符串的限制：
    > 
    >  *  单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的；  
    >     （举例：echo ‘$str’:无效引用）
    >  *  单引号字串中不能出现单引号（对单引号使用转义符后也不行）。
 *  **双引号**  
    `your_name='qinjx'`  
    `str="Hello, I know you are \"$your_name\"! \n"`
    
    > **双引号的优点：**
    > 
    >  *  双引号里可以有变量
    >  *  双引号里可以出现转义字符 \\” ”\\
 *  **拼接字符串**
    
        your_name="qinjx"
        greeting="hello, "$your_name" !"
        greeting_1="hello, ${your_name} !"
        echo $greeting $greeting_1
 *  **获取字符串长度**
    
        string="abcd"
        echo ${#string} #输出 4
 *  **提取子字符串**  
    以下实例从字符串第 2 个字符开始截取 4 个字符：  
    下标从0开始
    
        string="runoob is a great site"
        echo ${string:1:4} # 输出 unoo
 *  **查找子字符串**  
    查找字符 “is” 的位置：
    
        string="runoob is a great company"
        echo `expr index "$string" is`  # 输出 8
    
    注意： 以上脚本中 \` 是反引号，而不是单引号 '，不要看错了哦。
    
        反引号：先执行命令 类似于遍历
    
    ![在这里插入图片描述][20190412174609291.png]  
    \#将Linux命令赋予listc，listc的值就是该命令的执行结果  
    ![在这里插入图片描述][20190412174711422.png]  
    \#等价于反引号
    
    > **反引号** 的作用就是将反引号内的Linux命令先执行，然后将执行结果赋予变量。  
    > 需要记住单引号和反引号之间的区别。单引号把Linux命令视为字符集合。反引号会强迫执行Linux命令。

1.  Shell注释  
    **以"\#"开头的行就是注释，会被解释器忽略**。  
    如果在开发过程中，遇到大段的代码需要临时注释起来，过一会儿又取消注释，怎么办呢？  
    **每一行加个\#符号太费力了**

*  **多行注释**
    
    > **多行注释还可以使用以下格式：**  
    > `:<<EOF`  
    > `注释内容...`  
    > `注释内容...`  
    > `EOF`  
    > 除了EOF 还可以使用 ！  
    > `:<<!`  
    > `注释内容...`  
    > `注释内容...`  
    > `!`

**5. Shell传递参数**

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

*  实例  以下实例我们向脚本传递三个参数，并分别输出，其中 $0 为执行的文件名：
    
        echo "Shell 传递参数实例！";
        echo "执行的文件名：$0";
        echo "第一个参数为：$1";
        echo "第二个参数为：$2";
        echo "第三个参数为：$3";
 *  为脚本设置可执行权限，并执行脚本，输出结果如下所示：

$ chmod +x test.sh 
    $ ./test.sh 1 2 3

> 输出结果为：  
> Shell 传递参数实例！  
> 执行的文件名：./test.sh  
> 第一个参数为：1  
> 第二个参数为：2  
> 第三个参数为：3

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

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”（传递了三个参数）。

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

**6. Shell数组**

> Shell作为一种语言 也是能够定义数组的  
> bash支持一维数组（不支持多维数组），并且没有限定数组的大小。  
> 类似与 C 语言，数组元素的下标由 0 开始编号。获取数组中的元素要利用下标，下标可以是整数或算术表达式，其值应大于或等于 0。

1.  定义数组

> 在 Shell 中，用括号来表示数组，数组元素用"空格"符号分割开。定义数组的一般形式为：  
> 数组名=(值1 值2 … 值n)  
> 例如：  
> array\_name=(value0 value1 value2 value3)  
> 或者  
> array\_name=(  
> value0  
> value1  
> value2  
> value3  
> )  
> 还可以单独定义数组的各个分量：  
> array\_name\[0\]=value0  
> array\_name\[1\]=value1  
> array\_name\[n\]=valuen  
> 可以不使用连续的下标，而且下标的范围没有限制。

1.  读取数组

> 读取数组元素值的一般格式是：  
> $ \{数组名\[下标\]\}  
> 例如：  
> valuen=$\{array\_name\[n\]\}  
> 使用 @ 或者*符号可以获取数组中的所有元素，例如：  
> echo $\{array\_name\[@\]\}  
> echo $\{array\_name\[*\]\}

1.  获取数组的长度

> 获取数组长度的方法与获取字符串长度的方法相同，例如：  
> 取得数组元素的个数  
> length=KaTeX parse error: Expected '\}', got '\#' at position 2: \{\#̲array\_name\[@\]\} …\{\#array\_name\[\*\]\}  
> 取得数组单个元素的长度  
> lengthn=$\{\#array\_name\[n\]\}

**7.Shell基本运算符**

> Shell 和其他编程语言一样，支持多种运算符，包括：
> 
>  *  算术运算符
>  *  关系运算符
>  *  布尔运算符
>  *  字符串运算符
>  *  文件测试运算符
> 
>   
>  原生bash不支持简单的数学运算，但是可以通过其他命令来实现，例如 awk 和 expr，expr 最常用。
> 
> **expr 是一款表达式计算工具，使用它能完成表达式的求值操作。**
> 
> 这里是引用

> 例如，两个数相加注意使用的是 反引号 . 而不是单引号 ’  
> ![\#!/bin/bashval=echo "两数之和为 : $val"][bin_bashval_echo _ _ _val]  
> 执行脚本，输出结果如下所示：  
> 两数之和为 : 4  
> 两点注意：
> 
>  *  表达式和运算符之间要有空格，例如 2+2 是不对的，必须写成 2 + 2，这与我们熟悉的大多数编程语言不一样。
>  *  完整的表达式要被 `` 包含，注意这个字符不是常用的单引号，在 Esc 键下边。

1.  算术运算符
    
    下表列出了常用的算术运算符，假定变量 a 为 10，变量 b 为 20：
    
        格式 :expr m + n 或$((m+n)) 都是 先执行运算的 ` expr ...`----->$(())--->$((m+n))
    
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDEyMjg5_size_16_color_FFFFFF_t_70 1]
    
    > 注意：条件表达式要放在方括号之间，并且要有空格，例如: \[ a = = a== a==b\] 是错误的，必须写成 \[ $a == $b \]。
    
    **实例**
    
        注意：   if判断
        if [ $a == $b ]
        then
         echo "a 等于 b"
        fi
        if [ $a != $b ]
        then
           echo "a 不等于 b"
        fi
    
        算术运算符实例如下：
        
        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
    
    > 注意：
    > 
    >  *  乘号( \* )前边必须加反斜杠()才能实现乘法运算；
    >  *  if…then…fi 是条件语句，。
    >  *  在 MAC 中 shell 的 expr 语法是：$((表达式))，此处表达式中的 “\*” 不需要转义 符号 “” 。
2.  关系运算符 返回true或者false

> 关系运算符只支持数字，不支持字符串，除非字符串的值是数字。  
> 下表列出了常用的关系运算符，假定变量 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。

1.  实例
    
        关系运算符实例如下：
        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
2.  布尔运算符
    
    下表列出了常用的布尔运算符，假定变量 a 为 10，变量 b 为 20：  
    ![在这里插入图片描述][20190413160708402.png]
    
        实例
        布尔运算符实例如下：
        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
3.  逻辑运算符
    
    以下介绍 Shell 的逻辑运算符，假定变量 a 为 10，变量 b 为 20:  
    ![运算符	说明	举例&&	逻辑的 AND	\[\[ $a -lt 100 && $b -gt 100 \]\] 返回 false||	逻辑的 OR	\[\[ $a -lt 100 || $b -gt 100 \]\] 返回 true][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
4.  字符串运算符
    
    下表列出了常用的字符串运算符，假定变量 a 为 “abc”，变量 b 为 “efg”：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDEyMjg5_size_16_color_FFFFFF_t_70 2]
    
        实例
        字符串运算符实例如下：
        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 : 字符串不为空

**8. Shell echo命令**

> Shell 的 echo 是用于字符串的输出。命令格式：  
> `echo string “”`  
> 您可以使用echo实现更复杂的输出格式控制。

*  显示普通字符串:
    
        echo "It is a test"
        这里的双引号完全可以省略，以下命令与上面实例效果一致：
        echo It is a test
 *  显示转义字符
    
        echo "\"It is a test\""  注意每个\转意一个
        结果将是:
        "It is a test"
        同样，双引号也可以省略
 *  显示变量
    
        read 命令从标准输入(客户端)中读取一行,并把输入行的每个字段的值指定给 shell 		变量
        #!/bin/sh
        read name 
        echo "$name It is a test"

> 以上代码保存为 [test.sh][]，name 接收标准输入的变量，结果将是:  
> \[root@www ~\]\# sh [test.sh][]  
> OK \#标准输入  
> OK It is a test \#输出  
>   
>   
> **read 命令一个一个词组地接收输入的参数，每个词组需要使用空格进行分隔；**  
> 如果输入的词组个数大于需要的参数个数，则多出的词组将被作为整体为最后一个参数接收。

测试文件 test.sh 代码如下：
    read firstStr secondStr
    echo "第一个参数:$firstStr; 第二个参数:$secondStr"
    执行测试：
    $ sh test.sh 
    一 二 三 四
    第一个参数:一; 第二个参数:二 三 四

实例, 文件 test.sh:
    read -p "请输入一段文字:" -n 6 -t 5 -s password
    echo -e "\npassword is $password"      \n是换行

> 参数说明：  
> \-p 输入提示文字  
> \-n 输入字符长度限制(达到6位，自动结束)  
> \-t 输入限时 5等待时间  
> \-s 隐藏输入内容  
> \-e开启转义字符

> $ sh [test.sh][]  
> 请输入一段文字:  
> password is asdfgh

*  显示换行

echo -e "OK! \n" # -e 开启转义
    echo "It it a test"

> 输出结果：  
> OK!
> 
> It it a test

*  显示不换行

#!/bin/sh
    echo -e "OK! \c" # -e 开启转义 \c 不换行
    echo "It is a test"

> 输出结果：  
> OK! It is a test

*  显示结果定向至文件

echo "It is a test" > myfile

> 显示命令执行结果  
> ``echo `date` ``  
> 注意： 这里使用的是反引号 \`, 而不是单引号 '。  
> 结果将显示当前日期  
> Thu Jul 24 10:08:46 CST 2014

**9.Shell printf命令**

实例如下：
    echo "Hello, Shell"
    	Hello, Shell
    printf "Hello, Shell\n"
    	Hello, Shell

接下来,我来用一个脚本来体现printf的强大功能：  类似于正则表达式
    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位小数。

## Shell test命令 ##

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

*  数值测试  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDEyMjg5_size_16_color_FFFFFF_t_70 3]

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

实例演示：
    num1=100
    num2=100
    if test $[num1] -eq $[num2]
    then
        echo '两个数相等！'
    else
        echo '两个数不相等！'
    fi

> 输出结果：  
> 两个数相等！

代码中的 [] 执行基本的算数运算，如：   `exper ..` $(()) $[..]
    #!/bin/bash
    
    a=5
    b=6
    
    result=$[a+b] # 注意等号两边不能有空格    
    echo "result 为： $result"

> 结果为:  
> result 为： 11

*  字符串测试  
    ![参数	说明=	等于则为真!=	不相等则为真-z 字符串	字符串的长度为零则为真-n 字符串	字符串的长度不为零则为真][-z _-n]
    
        实例演示：
        num1="ru1noob"
        num2="runoob"
        if test $num1 = $num2
        then
           echo '两个字符串相等!'
        else
         echo '两个字符串不相等!'
        fi

> 输出结果：  
> 两个字符串不相等!

*  文件测试  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDEyMjg5_size_16_color_FFFFFF_t_70 4]
    
        实例演示：
        cd /bin
        if test -e ./bash
        then
          echo '文件已存在!'
        else
         echo '文件不存在!'
        fi
    
    > 输出结果：  
    > 文件已存在!
    
    > 另外，Shell还提供了与( -a )、或( -o )、 非( ! )三个逻辑操作符用于将测试条件连接起来，其
    
        cd /bin
        if test -e ./notFile -o -e ./bash
        then
           echo '至少有一个文件存在!'
        else
          echo '两个文件都不存在'
        fi
    
    > 输出结果：  
    > 至少有一个文件存在!

**10.Shell流程控制**

*  if
    
        if 语句语法格式：
        if condition  表达式
        then
        	command1 
        	command2
          ...
         commandN 
        fi
    
        写成一行（适用于终端命令提示符）：
        if [ $(ps -ef | grep -c "ssh") -gt 1 ]; 
        then echo "true";
        fi
    
    > \[ \] 条件判断  
    > Ps -ef：显示所有进程  
    > grep -c：显示进程的数量  
    > \-gt：大于  
    > 末尾的fi就是if倒过来拼写，后面还会遇到类似的。
 *  if else
    
        if else 语法格式：
        if condition
        then
        	command1 
        	 command2
          ...
         commandN
        else
         command
        fi
 *  if else-if else
    
        if else-if else 语法格式：
        if condition1
        then
         command1
        elif condition2    elif---》类似于java中的（else if）
        
        then 
        	command2
        else
        	commandN
        fi
    
        **以下实例判断两个变量是否相等：**
        
        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
    
    > 输出结果：  
    > a 小于 b
    
        if else语句经常与test命令结合使用，如下所示：
        num1=$[2*3]
        num2=$[1+5]
        if test $[num1] -eq $[num2]
        then
        	  echo '两个数字相等!'
        else
        	  echo '两个数字不相等!'
        fi
    
    > 输出结果：  
    > 两个数字相等!
 *  for 循环  
    **与其他编程语言类似，Shell支持for循环。**
    
        for循环一般格式为：
        for var in item1 item2 ... itemN
        do
           command1
           command2
         ...
        	commandN
        done
        写成一行：
        for var in item1 item2 ... itemN; do command1; command2… done;
    
    > 当变量值在列表里，for循环即执行一次所有命令，使用变量名获取列表中的当前取值。命令可为任何有效的shell命令和语句。in列表可以包含替换、字符串和文件名。  
    > in列表是可选的，如果不用它，for循环使用命令行的位置参数。
    
        例如，顺序输出当前列表中的数字：
        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
    
        顺序输出字符串中的字符：
        for str in 'This is a string' ls /etc
        do
        	 echo $str
        done
    
    > 输出结果：  
    > This is a string
 *  while 语句
    
    > while循环用于不断执行一系列命令，也用于从输入文件中读取数据；命令通常为测试条件。其格式为：
    
        while condition
        do
        	command
        done
    
    > 以下是一个基本的while循环，测试条件是：如果int小于等于5，那么条件返回真。int从0开始，每次循环处理时，int加1。运行上述脚本，返回数字1到5，然后终 止。
    
        #!/bin/bash
        int=1
        while(( $int<=5 ))
        do
            echo $int
          let "int++"
        done
    
    > 运行脚本，输出：  
    > 1  
    > 2  
    > 3  
    > 4  
    > 5
    
    > **命令：let**  
    > let 命令是 BASH 中用于计算的工具，用于执行一个或多个表达式，变量计算中不需要加上 $ 来表示变量。如果表达式中包含了空格或其他特殊字符，则必须引起来。  
    > 实例：  
    > 自加操作：let no++  
    > 自减操作：let no–
    
    > 简写形式 let no+=10，let no-=20，分别等同于 **let no=no+10，let no=no-20**。  
    > 以下实例计算 a 和 b 两个表达式，并输出结果：
    
        #!/bin/bash
        let a=5+4
        let b=9-3 
        echo $a $b
    
    > 以上实例执行结果为：  
    > 9 6
    
    > while循环可用于读取键盘信息。下面的例子中，输入信息被设置为变量FILM，按结束循环。  
    > echo ‘按下 退出’  
    > echo -n '输入你最喜欢的学校: ’
    
        while read FILM
        do
        	  echo "是的！$FILM 是一个好学校"
        done
    
    > 运行脚本，输出类似下面：  
    > 按下 退出  
    > 输入你最喜欢的学校:北网  
    > 是的！北网 是一个好学校
 *  无限循环
    
        无限循环语法格式：
        while :
        do
        	 command
        done
        或者
        while true
        do
        	command
        done
 *  until 循环
    
    > until 循环执行一系列命令直至条件为 true 时停止。  
    > until 循环与 while 循环在处理方式上刚好相反。  
    > 一般 while 循环优于 until 循环，但在某些时候—也只是极少数情况下，until 循环更加有用。
    
        until 语法格式:
        until condition   while connn
        do
        	 command
        done
    
    > condition 一般为条件表达式，如果返回值为 false，则继续执行循环体内的语句，否则跳出循环。
    
        以下实例我们使用 until 命令来输出 0 ~ 9 的数字：
        #!/bin/bash
        
        a=0
        
        until [ ! $a -lt 10 ]
        do
           echo $a
          a=`expr $a + 1`
        done
    
    > 运行结果：  
    > 输出结果为：  
    > 0  
    > 1  
    > 2  
    > 3  
    > 4  
    > 5  
    > 6  
    > 7  
    > 8  
    > 9
 *  case
    
    > Shell case语句为多选择语句。可以用case语句匹配一个值与一个模式，如果匹配成功，执行相匹配的命令。case语句格式如下：
    
        case 值 in     for  in 
        模式1)
        	command1
         command2
          ...
          commandN
          ;;
        模式2）
          command1
          command2
          ...
          commandN
         ;;
        esac
    
    > case工作方式如上所示。取值后面必须为单词in，每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后，其间所有命令开始执行直至 ;;。  
    > 取值将检测匹配的每一个模式。一旦模式匹配，则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式，使用星号 \* 捕获该值，再执行后面的命令。
    
    > 下面的脚本提示输入1到4，与每一种模式进行匹配：
    
        echo '输入 1 到 4 之间的数字:'
        echo '你输入的数字为:'
        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使用两个命令来实现该功能：**break和continue。**
 *  break命令
    
    > break命令允许跳出所有循环（终止执行后面的所有循环）。
    
    > 下面的例子中，脚本进入死循环直至用户输入数字大于5。要跳出这个循环，返回到shell提示符下，需要使用break命令。
    
        #!/bin/bash
        while :
        do
           echo -n "输入 1 到 5 之间的数字:"
           read aNum
           case $aNum in
            1|2|3|4|5) echo "你输入的数字为 $aNum!"
            ;;
            *) echo "你输入的数字不是 1 到 5 之间的! 游戏结束"
                break
            ;;
        esac
        done
    
    > 执行以上代码，输出结果为：  
    > 输入 1 到 5 之间的数字:3  
    > 你输入的数字为 3!  
    > 输入 1 到 5 之间的数字:7  
    > 你输入的数字不是 1 到 5 之间的! 游戏结束
 *  continue
    
    > continue命令与break命令类似，只有一点差别，它不会跳出所有循环，仅仅跳出当前循环。
    
        对上面的例子进行修改：
        #!/bin/bash
        while :
        do
        	  echo -n "输入 1 到 5 之间的数字: "
        	  read aNum
        	 case $aNum in
            1|2|3|4|5) echo "你输入的数字为 $aNum!"
            ;;
            *) echo "你输入的数字不是 1 到 5 之间的!"
                continue
                echo "游戏结束"
            ;;
        esac
        done
    
    > 运行代码发现，当输入大于5的数字时，该例中的循环不会结束，语句 echo “游戏结束” 永远不会被执行。
 *  esac
    
    > case需要一个esac（就是case反过来）作为结束标记，  
    > **每个case分支用右圆括号，用两个分号表示break**。

**11.Shell函数**

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

demoFun(){    相当于定义个方法
        echo "这是我的第一个 shell 函数!"
    }
    echo "-----函数开始执行-----"
    demoFun   开始执行方法
    echo "-----函数执行完毕-----"

> 输出结果：  
> \-----函数开始执行-----  
> 这是我的第一个 shell 函数!  
> \-----函数执行完毕-----

> 下面定义一个带有return语句的函数：

funWithReturn(){
        echo "这个函数会对输入的两个数字进行相加运算..."
        echo "输入第一个数字: "
        read aNum
        echo "输入第二个数字: "
        read anotherNum
        echo "两个数字分别为 $aNum 和 $anotherNum !"
        return $(($aNum+$anotherNum))
    }
    funWithReturn
    echo "输入的两个数字之和为 $? !"  函数有返回值 通过 $ ?来获取返回值

> 输出类似下面：  
> 这个函数会对输入的两个数字进行相加运算…  
> 输入第一个数字:  
> 1  
> 输入第二个数字:  
> 2  
> 两个数字分别为 1 和 2 !  
> 输入的两个数字之和为 3 !  
> 函数返回值在调用该函数后通过 $? 来获得。

> 注意：所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分，直至shell解释器首次发现它时，才可以使用。调用函数仅使用其函数名即可。

*  函数参数
    
    > 在Shell中，调用函数时可以向其传递参数。在函数体内部，通过 $n 的形式来获取参数的值，例如，$1表示第一个参数，$2表示第二个参数…
    
        带参数的函数示例：
        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    ./pass.sh
    
    > 输出结果：  
    > 第一个参数为 1 !  
    > 第二个参数为 2 !  
    > 第十个参数为 10 !
    
    > $ 10 不能获取第十个参数，获取第十个参数需要$\{10\}。  
    > 当n>=10时，需要使用 $ \{n\}来获取参数。  
    > 第十个参数为 34 !  
    > 第十一个参数为 73 !  
    > 参数总数有 11 个!  
    > 作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73 !  
    > 注意，$10 不能获取第十个参数，获取第十个参数需要 $ \{10\}。当n>=10时，需要使用 $ \{n\}来获取参数。

[2019041216021749.png]: /images/20220220/20c604c21439454dabb9a7fbf6b5349c.png
[test.sh]: http://test.sh
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDEyMjg5_size_16_color_FFFFFF_t_70]: /images/20220220/676f290c5a5341098d7d4a3237236eab.png
[20190412170359183.png]: /images/20220220/bfc45ab2eb1e468085eb28d9b127f47e.png
[http_www.runoob.com]: http://www.runoob.com
[20190412174609291.png]: /images/20220220/39bd67d217d043e0bd829021bab3c921.png
[20190412174711422.png]: /images/20220220/9784337cc5a641c4be4f6394a60abf03.png
[bin_bashval_echo _ _ _val]: /images/20220220/844c5c293ced4011a6572f729b0b1924.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDEyMjg5_size_16_color_FFFFFF_t_70 1]: /images/20220220/2d2994c5e01d4b8887298b9ec1ba4b29.png
[20190413160708402.png]: /images/20220220/b7d140be33154a789c1481aea7410e47.png
[AND_ _a -lt 100 _ _b -gt 100 _ _ false_ OR_ _a -lt 100 _ _b -gt 100 _ _ true]: /images/20220220/003dfad2b7a34653b18d66e636f76f76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDEyMjg5_size_16_color_FFFFFF_t_70 2]: /images/20220220/3af41d589fd34ff1bc267e57c8f4c369.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDEyMjg5_size_16_color_FFFFFF_t_70 3]: /images/20220220/ca556c3fe0c84650b00766378a755a98.png
[-z _-n]: /images/20220220/19b403dfa60e4d6ab7d13c1ecc607753.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDEyMjg5_size_16_color_FFFFFF_t_70 4]: /images/20220220/92f91db0b24f4017a5a76e0b77ee6a40.png