Shell常用招式大全之入门篇

╰半橙微兮° 2022-08-02 01:18 9阅读 0赞

本教程分为入门篇，命令篇和实战篇，结合平时工作中使用Shell的经验编写。以实例为主，侧重于应用，总结了一些实用的技巧。

以下为本教程的《入门篇》，适于初学者快速入门以及老手查缺补漏。

# 第一招 HelloWorld #

## 第一式：echo ##

echo "Hello World"
    
    echo -n "Hello World"    # 不带换行
    
    echo -e '\e[0;33;1mHello\e[0m World'   # 带颜色的玩法
    echo -e '\e[0;33;4mHello\e[0m World'   # 带颜色+下划线
    echo -e '\e[0;33;5mHello\e[0m World'   # 带颜色+闪烁

格式为 \\e\[背景色;前景色;高亮格式m，请阅读详细文档后使用正确的姿势进行装逼。

# 第二招 判断 #

## 第一式：if ##

if true
    then
        echo "Hello World"
    else
        echo "Bug"
    fi
    
    if false
    then
        echo "Hello World"
    elif true
    then
        echo "Bug"
    else
        echo "Bee"
    fi

### 判断原理 ###

`if、elif`会执行它后面跟着的命令，然后看返回值是否为`0`，如果为`0`则执行`then`下面的语句块，否则执行`else`下面的语句块。

[casheywen@ubuntu:~]$ true
    [casheywen@ubuntu:~]$ echo $?
    0
    [casheywen@ubuntu:~]$ false
    [casheywen@ubuntu:~]$ echo $?
    1

> **注：**
> 
> 1.  `true、fals`e事实上也为一个命令，`true`的返回码必为`0`，`false`的返回码必为`1`
> 2.  `$?`为`shell`内置变量，用于存放上一个命令的返回码

## 第二式： test、\[ \]和\[\[ \]\] ##

`test、[ ]、[[ ]]`实际上都是shell中的命令、执行之后会返回true(0) 或 false(1)，而这几个命令与if相结合可以达到我们所需要的许多判断功能，例如测试字符串是否为空的三种写法：

s="";
    if [ -z ${s} ]
    then
        echo "empty"
    fi
    
    if [[ -z ${s} ]]
    then
       echo "empty"
    fi
    
    if test -z ${s}
    then
       echo "empty"
    fi

事实上，if 后的`[ ]、[[ ]]、test`命令都是可以单独执行的，而根据 if 的判断原理，后续执行哪个分支也是由`[ ]、[[ ]]、test` 的返回值来决定的，以下是单独执行它们的效果：

[casheywen@ubuntu:~]$ s=""
    [casheywen@ubuntu:~]$ [ -z "${s}" ]
    [casheywen@ubuntu:~]$ echo $?
    0
    [casheywen@ubuntu:~]$ s="abc"
    [casheywen@ubuntu:~]$ test -z "${s}"
    [casheywen@ubuntu:~]$ echo $?
    1
    [casheywen@ubuntu:~]$ s="123"
    [casheywen@ubuntu:~]$ [[ 100 -lt ${
        s} ]]
    [casheywen@ubuntu:~]$ echo $?
    0

在性能方面`[ ]`和`test`性能基本相同，`[[ ]]` 性能是最高的，为前两者的5倍左右（以-d运算符测试），所以建议尽量使用 `[[ ]]` 提高脚本性能。

### 文件测试 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th align="left">描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>-e filename</td> 
   <td align="left">如果filename存在，则为真</td> 
   <td>[ -e /var/log/syslog ]</td> 
  </tr> 
  <tr> 
   <td>-d filename</td> 
   <td align="left">如果filename为目录，则为真</td> 
   <td>[ -d /tmp/mydir ]</td> 
  </tr> 
  <tr> 
   <td>-f filename</td> 
   <td align="left">如果filename为常规文件，则为真</td> 
   <td>[ -f /usr/bin/grep ]</td> 
  </tr> 
  <tr> 
   <td>-L filename</td> 
   <td align="left">如果filename为符号链接，则为真</td> 
   <td>[ -L /usr/bin/grep ]</td> 
  </tr> 
  <tr> 
   <td>-r filename</td> 
   <td align="left">如果filename可读，则为真</td> 
   <td>[ -r /var/log/syslog ]</td> 
  </tr> 
  <tr> 
   <td>-w filename</td> 
   <td align="left">如果filename可写，则为真</td> 
   <td>[ -w /var/mytmp.txt]</td> 
  </tr> 
  <tr> 
   <td>-x filename</td> 
   <td align="left">如果filename可执行，则为真</td> 
   <td>[ -x /usr/bin/grep ]</td> 
  </tr> 
  <tr> 
   <td>filename1 -nt filename2</td> 
   <td align="left">如果filename1 比filename2新， 则为真</td> 
   <td>[ /tmpinstall/services -nt /etc/services ]</td> 
  </tr> 
  <tr> 
   <td>filename1 -ot filename2</td> 
   <td align="left">如果filename1 比 filename2 旧，则为真</td> 
   <td>[ /boot/bzImage -ot /arch/i386/boot/bzImage ]</td> 
  </tr> 
 </tbody> 
</table>

### 字符串比较 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th align="left">描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>-z string</td> 
   <td align="left">如果 string 长度为零，则为真</td> 
   <td>[ -z “${myvar}”]</td> 
  </tr> 
  <tr> 
   <td>-n string</td> 
   <td align="left">如果 string 长度非零，则为真</td> 
   <td>[ -n “${myvar}” ]</td> 
  </tr> 
  <tr> 
   <td>string1 = string2</td> 
   <td align="left">如果 string1 与 string2 相同，则为真</td> 
   <td>[ “${myvar}” = “abc” ]</td> 
  </tr> 
  <tr> 
   <td>string1 != string2</td> 
   <td align="left">如果 string1 与 string2 不同，则为真</td> 
   <td>[ “${myvar}” != “abc” ]</td> 
  </tr> 
  <tr> 
   <td>string1 &lt; string2</td> 
   <td align="left">如果 string1 小于 string2，则为真</td> 
   <td>[[ “${myvar}” &lt; “abc” ]] 或者 [ “${myvar}” \&lt; “abc”]</td> 
  </tr> 
  <tr> 
   <td>string1 &gt; string2</td> 
   <td align="left">如果 string1 大于 string2, 则为真</td> 
   <td>[[ “${myvar}” &gt; “abc” ]] 或者 [ “${myvar}” \&gt; “abc” ]</td> 
  </tr> 
 </tbody> 
</table>

> **注意：**
> 
> 1.  在字符串两遍加上`“”`防止出错
> 2.  `<` 和 `>`是字符串比较，不要错用成整数比较
> 3.  如果是在 `[ ]` 中使用 `<` 和 `> ,` 需要将它们写成 `\<` 和 `\>`

### 整数比较 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>num1 -eq num2</td> 
   <td>等于</td> 
   <td>[ 3 -eq $mynum ]</td> 
  </tr> 
  <tr> 
   <td>num1 -ne num2</td> 
   <td>不等于</td> 
   <td>[ 3 -ne $mynum ]</td> 
  </tr> 
  <tr> 
   <td>num1 -lt num2</td> 
   <td>小于</td> 
   <td>[ 3 -lt $mynum ]</td> 
  </tr> 
  <tr> 
   <td>num1 -le num2</td> 
   <td>小于等于</td> 
   <td>[ 3 -le $mynum ]</td> 
  </tr> 
  <tr> 
   <td>num1 -ge num2</td> 
   <td>大于等于</td> 
   <td>[ 3 -ge $mynum ]</td> 
  </tr> 
 </tbody> 
</table>

## 第三式： &&、|| ##

<table> 
 <thead> 
  <tr> 
   <th>&amp;&amp;可以用来对两个判断语句求与</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>if [ -n "abc" ] &amp;&amp; [ -n "aa"]</code></td> 
  </tr> 
  <tr> 
   <td><code>if [[ -n "abc ]] &amp;&amp; [[ -n "aa" ]]</code></td> 
  </tr> 
  <tr> 
   <td><code>if test -n "abc" &amp;&amp; test -n "aa"</code></td> 
  </tr> 
  <tr> 
   <td><code>if [[ -n "abc" &amp;&amp; -n "aa" ]]</code></td> 
  </tr> 
 </tbody> 
</table>

注：只有`[[ ]]`才允许把`&&`写在里面

**小技巧**  
`&&、||`还可以用来拼接命令，达到按前一个命令成功与否决定是否执行后一个命令的效果

cd /data && ls         # 当`cd /data`返回0(即成功)时才执行后面的`ls`
    cd /data || cd /root   # 当`cd /data`返回非0(即失败)时才执行后面的`cd /root`

# 第三招： 循环 #

## 第一式：if ##

for i in {
       1..100}
    do
        echo ${i}
    done

> **注：**
> 
> 1.  \{1..100\}属于通配的一种写法，展开会是1 2 3 … 100（1~100以空格隔开）这样的字串。
> 2.  例如for i in 1 2 3;这样的语句，for会将1、2、3依次赋值于i进行循环，而对于通配的情况，for则会将通配展开后将里面的每一项依次赋值于i进行循环。

for i in `seq 100`
    do
        echo ${i}
    done
    
    for i in `seq 1 2 100`
    do
        echo ${i}
    done

> **注：**
> 
> 1.  `seq`本身为一个命令，用于输出数字组成的序列，如`seq 100`会生成并输出`1 2 3 ... 100`（1~100以换行符隔开）这样的序列，而`seq 1 2 100`则会生成并输出`1 3 5 ... 99`（以1开始，2为公差的等差数列中小于100的项，以换行符隔开）。
> 2.  反引号(`)之间的命令会被执行，其输出结果会转换成一个变量，故上面的`for in`会依次取出`seq`的执行结果赋值于`i\`进行循环。

for ((i = 0; i < 100; i++))
    do
        echo ${i}
    done
    
    for ((i = 0; i < 100; i+= 2))
    do
        echo ${i}
    done

> **注：**
> 
> 以上与C语言式的for循环语法基本相同，区别在于双重括号：`(( ))`

## 第二式：while、until ##

i=0
    while [[ ${i} -lt 100 ]]
    do
        echo ${i}
        ((i++))
    done

i=0
    until [[ ${i} -ge 100 ]]
    do
        echo ${i}
        ((i++))
    done

> **注：**
> 
> `while`和`until`的判断原理与`if`是类似的，它会执行并它后面跟着的命令，不同点在于：
> 
>  *  `while`是后面语句返回值为`0`，则执行循环中的语句块，否则跳出循环;
>  *  `until`则是后面语句返回值非`0`，则执行循环中的语句块，否则跳出循环。

# 第四招：变量 #

## 第一式：整数 ##

--------------------

### 整数的运算 ###

--------------------

方法较多，此处只列举最浅显易懂，并且效率最高的办法——直接将符合C语言语法的表达式放到(( ))中即可达到对整数的计算目的：

echo $(( 1+1 ))        # 最简单的1+1
    echo $(( (1+2)*3/4 ))  # 表达式中还可以带括号
    echo $(( 1<<32 ))      # 左移右移也支持，但仅限于-4294967296~4294967296之间的数值
    echo $(( 1&3 ))        # &、^、|、~ 这样的位操作亦支持
    (( i=1+2 ))            # 将1+2计算出结果后赋值给i，后续若`echo ${i}`会得到3
    (( i++ ))              # 变量i自增1
    (( i+=3 ))             # 变量i自增3
    # ...                  # 还有很多，不再详列

> **注：**
> 
> 进行整数运算的方法还有：`expr`、`$[]`、`let`等`shell`等内置命令，也可调用`bc`、`python`等外部工具进行更复杂的数学运算

## 第二式：字符串 ##

--------------------

### 替换 ###

--------------------

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>${string/old/new}</td> 
   <td>string中第一个old替换为new</td> 
  </tr> 
  <tr> 
   <td>${string//old/new}</td> 
   <td>string中所有old替换为new</td> 
  </tr> 
 </tbody> 
</table>

[casheywen@ubuntu:~]# s="i hate hate you"
    [casheywen@ubuntu:~]# echo ${s/hate/love}
    i love hate you
    [casheywen@ubuntu:~]# echo ${s//hate/love}
    i love love you

### 截取子串 ###

--------------------

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>${string:n}</td> 
   <td>string从下标n到结尾的子串</td> 
  </tr> 
  <tr> 
   <td>${string:n:m}</td> 
   <td>string从下标n开始长度为m的子串</td> 
  </tr> 
  <tr> 
   <td>${string::m}</td> 
   <td>string从下标0开始长度为m的子串</td> 
  </tr> 
 </tbody> 
</table>

[casheywen@ubuntu:~]# s="0123456789"
    [casheywen@ubuntu:~]# echo ${s:3}
    3456789
    [casheywen@ubuntu:~]# echo ${s::3}
    012
    [casheywen@ubuntu:~]# echo ${s:0:3}
    012
    [casheywen@ubuntu:~]# echo ${s:2:5}
    23456

### 通配删除 ###

--------------------

通配删除，即按通配符，删除掉字符串中符合条件的一部分

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>${string#pattern}</td> 
   <td>string从左到右删除pattern的最小通配</td> 
  </tr> 
  <tr> 
   <td>${string##pattern}</td> 
   <td>string从左到右删除pattern的最大通配</td> 
  </tr> 
  <tr> 
   <td>${string%pattern}</td> 
   <td>string从右向左删除pattern的最小通配</td> 
  </tr> 
  <tr> 
   <td>${string%%pattern}</td> 
   <td>string从右向左删除pattern的最大通配</td> 
  </tr> 
 </tbody> 
</table>

> **注：**
> 
> 1.  此处通配规则参考通配符一览表
> 2.  最小通配和最大通配的区别：  
>     最小通配：符合通配的最小子串  
>     最大通配：符合通配的最大子串  
>     例如string值为/00/01/02/dir，对于通配/\*/，其最小通配为/00/，而最大通配/00/01/02/

[casheywen@ubuntu:~]# s="/00/01/02/dir"
    [casheywen@ubuntu:~]# echo ${s#/*/}
    01/02/dir
    [casheywen@ubuntu:~]# echo ${s##/*/}
    dir
    [casheywen@ubuntu:~]# 
    [casheywen@ubuntu:~]# s="abc/cde/efg"
    [casheywen@ubuntu:~]# echo ${s%/*}
    abc/cde
    [casheywen@ubuntu:~]# echo ${s%%/*}
    abc
    [casheywen@ubuntu:~]# 
    [casheywen@ubuntu:~]# s="/00/01/02/dir"
    [casheywen@ubuntu:~]# echo ${s#/*/}
    01/02/dir
    [casheywen@ubuntu:~]# echo ${s##/*/}
    dir
    [casheywen@ubuntu:~]# s="abc/cde/efg"
    [casheywen@ubuntu:~]# echo ${s%/*}
    abc/cde
    [casheywen@ubuntu:~]# echo ${s%%/*}
    abc

**小技巧**

*  获取文件名：$\{path\#\#\*/\} (相当于basename命令的功能)
 *  获取目录名：$\{path%/\*\} (相当于dirname命令的功能)
 *  获取后缀名：$\{path\#\#\*.\}

[casheywen@ubuntu:~]# s="/root/test/dir/subdir/abc.txt"
    [casheywen@ubuntu:~]# echo ${s##*/}
    abc.txt
    [casheywen@ubuntu:~]# echo ${s%/*}
    /root/test/dir/subdir
    [casheywen@ubuntu:~]# echo ${s##*.}
    txt

## 第三式：数组 ##

--------------------

### 普通数组 ###

--------------------

a=()         # 空数组
    a=(1 2 3)    # 元素为1,2,3的数组
    echo ${#a[*]}  # 数组长度
    echo ${a[2]}   # 下标为2的元素值（下标从0开始）
    a[1]=0         # 给下标为1的元素赋值
    
    # 遍历数组
    for i in ${a[*]}
    do
        echo ${i}
    done
    
    unset a        # 清空数组

### 关联数组 ###

--------------------

关联数组可以用于存储`key-value`型的数据，其功能相当于`C++`中的`map`或`python`中的`dict`。

declare -A a        # 声明关联数组（必须有此句）
    a=(["apple"]="a1" ["banana"]="b2" ["carrot"]="c3")   # 初始化关联数组
    echo ${#a[*]}       # 获取元素个数
    echo ${a["carrot"]} # 获取元素值  
    a["durian"]="d4"    # 插入或修改元素
    echo ${!a[*]}       # 获取所有的key
    unset a["banana"]   # 删除元素
    
    # 遍历数组(仅value)
    for i in ${a[*]}
    do
        echo ${i}
    done
    
    # 遍历数组(key和value)
    for key in ${!a[*]}
    do
        echo "${key} ==> ${a[${key}]}"
    done
    
    unset a             # 清空数组

> **注：**
> 
> 1.  关联数组需要bash 4.0以上版本才支持，选用需慎重。查看bash版本用bash –version
> 2.  关联数组必须用declare -A显示声明类型，否则数值会出错。

## 第四式：将命令执行结果存入变量 ##

--------------------

### “与$() ###

--------------------

LINE_CNT=`wc -l test.txt`

LINE_CNT=$(wc -l test.txt)

以上命令均可把`wc -l test.txt`的结果存入`LINE_CNT`变量中

> **注：** ``` `` ``` 和`$( )`都只将命令行标准输出的内容存入变量，如果需要将标准错误内容存入变量，需要用到重定向。

### 换行符处理 ###

--------------------

如果命令执行结果有多行内容，存入变量并打印时换行符会丢失：

[casheywen@ubuntu:~]# cat test.txt
    a
    b
    c
    [casheywen@ubuntu:~]# CONTENT=`cat test.txt`
    [casheywen@ubuntu:~]# echo ${CONTENT}
    a b c

若需要保留换行符，则在打印时必须加上`""`：

[casheywen@ubuntu:~]# CONTENT=`cat test.txt`
    [casheywen@ubuntu:~]# echo "${CONTENT}"      
    a
    b
    c

--------------------

# 第五招：重定向 #

--------------------

## 标准输入流、标准输出流、标准错误流 ##

--------------------

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>英文缩写</th> 
   <th>内容</th> 
   <th>默认绑定位置</th> 
   <th>文件路径</th> 
   <th>Shell中代号</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>标准输入流</td> 
   <td><code>stdin</code></td> 
   <td>程序读取的用户输入</td> 
   <td>键盘输入</td> 
   <td><code>/dev/stdin</code></td> 
   <td><code>0</code></td> 
  </tr> 
  <tr> 
   <td>标准输出流</td> 
   <td><code>stdout</code></td> 
   <td>程序的打印的正常信息</td> 
   <td>终端（<code>terminal</code>），即显示器</td> 
   <td><code>/dev/stdout</code></td> 
   <td><code>1</code></td> 
  </tr> 
  <tr> 
   <td>标准错误流</td> 
   <td><code>stderr</code></td> 
   <td>程序的错误信息</td> 
   <td>终端（<code>terminal</code>），即显示器</td> 
   <td><code>/dev/stderr</code></td> 
   <td><code>2</code></td> 
  </tr> 
 </tbody> 
</table>

## 重定向方式一览表 ##

--------------------

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>cmd &gt; file</td> 
   <td>把stdout重定向的file</td> 
  </tr> 
  <tr> 
   <td>cmd &gt;&gt; file</td> 
   <td>把stdout追加到file</td> 
  </tr> 
  <tr> 
   <td>cmd 2&gt; file</td> 
   <td>把stderr重定向到file</td> 
  </tr> 
  <tr> 
   <td>cmd 2&gt;&gt; file</td> 
   <td>把stderr追加到file</td> 
  </tr> 
  <tr> 
   <td>cmd &amp;&gt; file</td> 
   <td>把stdout和stderr重定向到file</td> 
  </tr> 
  <tr> 
   <td>cmd &gt; file 2&gt;&amp;1</td> 
   <td>把stdout和stderr重定向的file</td> 
  </tr> 
  <tr> 
   <td>cmd &gt;&gt; file 2&gt;&amp;1</td> 
   <td>把stdout和stderr追加到file</td> 
  </tr> 
  <tr> 
   <td>cmd &lt; file1 &gt;file2</td> 
   <td>cmd以file作为stdin，以file2作为sdtout</td> 
  </tr> 
  <tr> 
   <td>cat &lt;&gt; file</td> 
   <td>以读写的方式打开file</td> 
  </tr> 
  <tr> 
   <td>cmd &lt; file</td> 
   <td>cmd命令以file文件作为stdin</td> 
  </tr> 
  <tr> 
   <td>cmd &lt;&lt; delimiter Here document</td> 
   <td>从stdin中读入，直至遇到delimiter分界符</td> 
  </tr> 
 </tbody> 
</table>

## 第一式：重定向标准输出流（stdout） ##

--------------------

**把程序打印的内容输出到文件**

# 以下两种方式都会将`Hello World`写入到hello.txt(若不存在则创建)
    echo "Hello World" > hello.txt   # hello.txt原有的将被覆盖
    echo "Hello World" >> hello.txt  # hello.txt原有内容后追加`Hello World`

## 第二式：重定向标准错误流（stderr） ##

--------------------

**把程序的错误信息输出到文件**

[casheywen@ubuntu:~]# ls +++
    ls: cannot access +++: No such file or directory
    [casheywen@ubuntu:~]# ls +++ > out.txt
    ls: cannot access +++: No such file or directory

上面的`ls +++`后输出的内容为标准错误流中的错误信息，所以即使用`> out.txt`重定向标准输入，错误信息仍然被打印到了屏幕。

# 以下两种方式都会将`ls +++`输出的错误信息输出到err.txt(若不存在则创建)
    ls +++ 2> err.txt    # err.txt原有内容将被覆盖
    ls +++ 2>> err.txt   # err.txt原有内容后追加内容

## 第三式：重定向标准输入流(stdin) ##

--------------------

### 1. 让程序从文件读取输入 ###

以默认从标准输入读取表达式，并进行数学计算的命令bc为例：

[casheywen@ubuntu:~]# bc -q
    1+1
    2

> **注：**
> 
> 1.  `1+1`为键盘输入的内容，`2`为`bc`命令打印的计算结果
> 2.  `bc`后的`-q`参数用于禁止输出欢迎信息
> 3.  以上重定向方法格式为`命令 < 文件路径`

如果我需要把已经存在文件`exp.txt`中的一个表达式输入到`bc`中进行计算，可以采用重定向标准输入流的方法：

bc -q < exp.txt

> **注：**
> 
> 1.  当`exp.txt`中内容为`1+1`时，以上语句输出`2`
> 2.  由于`bc`命令本身支持从文件输入，如不使用重定向，也可用`bc exp.txt`达到相同效果

### 2. 将变量中内容作为程序输入 ###

EXP="1+1"
    bc -q <<< "${EXP}"

> **注：**
> 
> 1.  以上代码等同于执行`bc`并输入`1+1`，得到的输出为`2`。
> 2.  以上重定向方法格式为`命令 <<< 变量内容`

### 3. 将当前shell脚本中的多行内容作为程序的输入 ###

例如在shell中内嵌多行python代码：

python << EOF
    print 'hello from python'
    print 'hello' + 'world'
    EOF
    
    # 内容中支持shell变量
    MSG="shell variable"
    
    python << EOF
    print '${MSG}'
    EOF

> **注：**
> 
> 1.  以上用法可以方便地将某个程序需要的多行输入内容直接包含在当前脚本中
> 2.  支持变量，可以动态地改变多行输入的内容
> 3.  以上重定向方法格式为：`命令 << EOF (换行)...(换行) EOF`，其中的`EOF`换成其它字符串也是有效的，如：`命令 << ABC (换行)...(换行) ABC`的，但通用习惯都使用`EOF`

# 第六招：管道 #

--------------------

## 第一式：管道的基本功能 ##

--------------------

管道的写法为 `cmd1 | cmd2`，功能是依次执行`cmd1`和`cmd2`，并将`cmd1`的标准输出作为`cmd2`的标准输入，例如：

echo "1+1" | bc

这里 `echo "1+1"` 会将`1+1`输出到标准输出，而管道会将`echo`输出的`1+1`作为`bc`命令的标准输入，这样`bc`会读取到`1+1`，最终得到计算结果`2`打印到屏幕。

> **注：**
> 
> 1.  管道可以多级拼接：cmd1 | cmd2 | cmd3 | …
> 2.  管道的返回值为最后一级命令的返回值

## 第二式：管道与while、read组合 ##

--------------------

LINE_NO=0
    cat test.txt | 
    while read LINE
    do
        (( LINE_NO++ ))
        echo "${LINE_NO} ${LINE}"
    done
    
    # echo "${LINE_NO}"

以上代码可以将`test.txt`中每一行标上行标后输出。

> **注：**
> 
> 1.  `read`命令用于从标准输入读取一行并赋值给一个或多个变量，如`read LINE`会从标准输入读取一行并将整行内容赋值给`LINE`变量，`read A B`则会从标准输入读入一行并将这行的第1、2列分别赋值给A、B两个变量（分割符默认为空格或tab，可给`IFS`赋值来更改分割符）
> 2.  末尾注释掉的`echo "${LINE_NO}`“若执行会输出`0`，原因是管道中的`while`语句是执行在子进程中的，不会改变父进程中`LINE_NO`变量的值

## 第三式：管道与xargs组合 ##

--------------------

find . -type f -name *.log | xargs rm

以上代码可以将当前目录及子目录所有后缀名为`.log`的文件

find . -type f -name *.log | xargs -i mv {} /data/log

以上代码可以将当前目录及子目录中所有后缀名为`.log`的文件移动到`/data/log`中

> **注：** `xargs`可以从标准输入读取内容，以之构建并执行另一个命令行

*  xargs直接接命令名称，则将从标准输入读取的所有内容合并为一行构建命令行并执行
 *  xargs加上-i参数，则会每读取一行就构建并执行一个命令行，构建命令行时会将\{\}替换为该行的内容

[casheywen@ubuntu:~]# cat test.txt
    a
    b
    c
    [casheywen@ubuntu:~]# cat test.txt | xargs echo rm 
    rm a b c
    [casheywen@ubuntu:~]# cat test.txt | xargs -i echo rm {}
    rm a
    rm b
    rm c

上例展示了`xargs`构建命令的原理，如果去掉`xargs`后的`echo`，则会执行打印出来的命令

# 第七招：通配 #

--------------------

## shell通配的原理 ##

--------------------

如果你的当前目录中有`1.txt 2.txt 3.txt`三个文件，那么当你执行`ls *.txt`这条命令，`shell`究竟为你做了什么？

其实`shell`会先读取当前目录，然后按`*.txt`的通配条件过滤得到`1.txt 2.txt 3.txt`这个文件列表，然后将这个列表作为参数传给`ls`，即`ls *.txt`相当于`ls 1.txt 2.txt 3.txt`，`ls`命令本身并不会得到`*.txt`这样的参数。

> 注：仅当目录中没有符合`*.txt`通配的文件，`shell`才会将`*.txt`这个字符串当作参数直接传给`ls`命令

所以如果需要列出当前目录中所有的`txt`文件，我们使用`echo *.txt`也同样可以达到目的：

[casheywen@ubuntu:~]# ls *.txt
    1.txt  2.txt  3.txt
    [casheywen@ubuntu:~]# echo *.txt
    1.txt 2.txt 3.txt

> **注：**对于`{ }`通配`shell`不会读取目录并过滤获得文件列表。详细请参考下文。

## 通配符一览表 ##

--------------------

<table> 
 <thead> 
  <tr> 
   <th>字符</th> 
   <th>含义</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>*</td> 
   <td>匹配 0 或多个字符</td> 
   <td><code>a*b</code> a与b之间可以有任意长度的任意字符, 也可以一个也没有, 如aabcb, axyzb, a012b, ab。</td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td>匹配任意一个字符</td> 
   <td><code>a?b</code> a与b之间必须也只能有一个字符, 可以是任意字符, 如aab, abb, acb, a0b。</td> 
  </tr> 
  <tr> 
   <td><code>[list]</code></td> 
   <td>匹配list中的任意单一字符</td> 
   <td><code>a[xyz]b</code> a与b之间必须也只能有一个字符, 但只能是 x 或 y 或 z, 如: axb, ayb, azb。</td> 
  </tr> 
  <tr> 
   <td><code>[!List] [^List]</code></td> 
   <td>匹配 除list 中的任意单一字符</td> 
   <td><code>a[!0-9]b</code> a与b之间必须也只能有一个字符, 但不能是阿拉伯数字, 如axb, aab, a-b。</td> 
  </tr> 
  <tr> 
   <td><code>[c1-c2]</code></td> 
   <td>匹配 c1-c2 中的任意单一字符 如：[0-9] [a-z]</td> 
   <td><code>a[0-9]b</code> 0与9之间必须也只能有一个字符 如a0b, a1b… a9b。</td> 
  </tr> 
  <tr> 
   <td><code>{string1,string2,...}</code></td> 
   <td>枚举sring1或string2(或更多)其一字符串</td> 
   <td><code>a{abc,xyz,123}b</code> 展开成<code>aabcb axyzb a123b</code></td> 
  </tr> 
  <tr> 
   <td><code>{c1..c2} {n1..n2}</code></td> 
   <td>枚举c1-c2中所有字符或n1-n2中所有数字</td> 
   <td><code>{a..f}</code>展开成<code>a b c d e f</code>,<code>a{1..5}</code> 展开成<code>a1 a2 a3 a4 a5</code></td> 
  </tr> 
 </tbody> 
</table>

> **注：**
> 
> 1.  \*、?、\[ \]的通配都会按读取目录并过滤的方式展开通配项目
> 2.  \{ \}则不会有读取目录的过程，它是通过枚举所有符合条件的通配项直接展开的

[casheywen@ubuntu:~]# ls
    1.txt  2.txt  3.txt
    [casheywen@ubuntu:~]# echo *.txt
    1.txt 2.txt 3.txt
    [casheywen@ubuntu:~]# echo {1..5}.txt
    1.txt 2.txt 3.txt 4.txt 5.txt
    [casheywen@ubuntu:~]# ls {1..5}.txt
    ls: cannot access 4.txt: No such file or directory
    ls: cannot access 5.txt: No such file or directory
    1.txt  2.txt  3.txt

## 第一式：\* ##

--------------------

`*`用于通配文件名或目录名中某一部分为任意内容：

rm *.log          # 删除当前目录中所有后缀名为.log的文件
    rm */log/*.log    # 删除所有二级log目录中后缀名为.log的文件

## 第二式：\[\] ##

--------------------

`[]`用于通配文件名或目录名中某个字符为限定范围内或限定范围外的值：

rm Program[1-9]*.log  # 删除当前目录中以Program跟着一个1到9的数字开头，并以.log为后缀名的文件
    du -sh /[^udp]*       # 对根目录中所有不以u、d、p开头的文件夹求取总大小

## 第三式：？ ##

--------------------

`?`用于通配文件名中某处一个任意值的字符：

rm L????.txt    # 通配一个文件名以L开头，后面跟着4个字符，并以.txt结尾的文件：如LAB01.txt

## 第四式：\{\} ##

--------------------

`{ }`也为通配符，用于通配在它枚举范围内的值，由于它是直接展开的，我们可以将它用于批量创建目录或文件，也可以用于生成序列：

**批量生成目录**  
`{}`生成的序列常用语for循环

for ip in 192.168.234.{
       1..255}
    do
        ping ${ip} -w 1 &> /dev/null && echo ${ip} is Alive
    done

> 以上例子用于查找`192.168.234.1~192.168.234.255`整个网段能`ping`通的所有`ip`

# 本文转自 #

--------------------

[Shell常用招式大全之入门篇][Shell]

# 名词解释 #

--------------------

## IFS ##

内部字段分隔符（Internal Field Separator，IFS）是shell脚本中的一个重要概念。IFS是存储定界符的环境变量。它是当前shell环境使用的默认定界字符串，例：

data="name,set,rollno,location" #我们可以使用IFS读取变量中的每一个条目
    oldIFS=$IFS
    IFS=","
    for item in $data
    do
        echo Item:$item
    done
    IFS=$oldIFS
    
    //print
    Item:name
    Item:sex
    Item:rollno
    Item:location

IFS的默认值为空白符（换行符、制表符或者空格）。

[Shell]: http://segmentfault.com/a/1190000002924882