Shell脚本快速入门学习

个人学习整理 ## 简介 Shell是脚本语言，解释型，无需提前编译。 Shel同时也是一个程序，它的一端连接着Linux内核，另一端连接着用户和其他应用程序，也就是说Shell是用户或应用程序与内核沟通的桥梁，  扩展名为`.sh` ```bash #!/bin/bash echo "Hello World !" ``` `#!` 是一个约定的标记，它告诉系统这个脚本需要什么解释器来执行，即使用哪一种 Shell。 `/bin/bash`指明了解释器的具体路径。 `echo` 命令用于向窗口输出文本。 ## 常用的Shell > Shell 既是一种脚本编程语言，也是一个连接内核和用户的软件。 常见的 Shell 有 sh、bash、csh、tcsh、ash 等。 bash shell 是 Linux 的默认 shell，bash 由 GNU 组织开发，保持了对 sh shell 的兼容性，是各种 Linux 发行版默认配置的 shell。 > bash 兼容 sh 意味着，针对 sh 编写的 Shell 代码可以不加修改地在 bash 中运行。 尽管如此，bash 和 sh 还是有一些不同之处： - 一方面，bash 扩展了一些命令和参数； - 另一方面，bash 并不完全和 sh 兼容，它们有些行为并不一致，但在大多数企业运维的情况下区别不大，特殊场景可以使用 bash 代替 sh。 ## 查看Shell Shell是一个程序，一般放在`/bin`或`/user/bin`目录下，Linux系统可用的Shell都可以使用下面命令查看 ```bash user@PxeCtrlSys:~$ cat /etc/shells # /etc/shells: valid login shells /bin/sh /bin/dash /bin/bash /bin/rbash ``` 现在Linux基本都是用的bash Shell，查看Linux的默认shell ```bash user@PxeCtrlSys:~$ echo $SHELL /bin/bash ``` ## 运行方法 - 作为可执行程序 代码保存`test.sh`文本中 ```bash # 进入脚本所在目录，让脚本拥有可执行权限 chmod +x ./test.sh # 执行方式 ./test.sh ``` 一定要写成`./test.sh`，而不是`test.sh`，运行其它二进制的程序也一样，直接写 `test.sh`，linux 系统会去 PATH 里寻找有没有叫 `test.sh` 的，而只有 `/bin`, `/sbin`, `/usr/bin`，`/usr/sbin` 等在 PATH 里，你的当前目录通常不在 PATH 里，所以写成 `test.sh` 是会找不到命令的，要用 `./test.sh` 告诉系统说，就在**当前目录**找。 - 作为解释器参数 直接运行解释器，其参数就是 shell 脚本的文件名 ```bash /bin/sh test.sh # 或者 /bin/bash test.sh ``` # Shell变量 在Bash Shell中，每一个变量的值都是字符串，无论给变量赋值时有没使用引号，值都会以字符串的形式存储，即使将整数或小数赋值给变量，他们也会被视为字符串。 ## 变量赋值 定义变量，三种定义方式，显式赋值 ```bash name="test" name='test' name=test ``` 注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，变量名的命名须遵循如下规则： - 命名只能使用英文字母，数字和下划线，首个字符不能以数字开头。 - 中间不能有空格，可以使用下划线（_）。 - 不能使用标点符号。 - 不能使用bash里的关键字（可用help命令查看保留关键字）。 如果变量值包含空白字符，就必须使用引号包围起来，例如`name="bom smith"` 用语句给变量赋值 ```bash for file in `ls /etc` 或 for file in $(ls /etc) ``` 将`/etc`目录下的文件名循环出来。 ## 使用变量 ```bash name="test" echo $name # 或者加花括号，含义一样，加花括号是为了帮助解释器识别变量的边界 echo ${name} ``` 例如和变量连接的字符 ```bash #!/bin/bash for item in Python Java Shell Bat; do echo "This is ${item}Script" done ``` 运行结果如下 ```python This is PythonScript This is JavaScript This is ShellScript This is BatScript ``` 如果没有花括号，那么变量就是`$itemScript`，其值为空，结果就会错误。推荐加花括号`{}`。 ## 修改变量的值 已定义过的变量可以重新赋值 ```bash #!/bin/bash name='test' echo ${name} # test name="new" echo $name # new ``` 变量赋值不能加`$`符号，只有在使用键盘时才能加`$`。 ## 命令执行结果赋值给变量 支持将命令的执行结果赋值给变量使用，常见的两种方式： ```bash value=`command` # 或 value=$(command) # 默认输出以空白符填充 echo $value # 按照原格式输出，例如有换行符的 echo "$value" ``` 第一种是使用反引号包围起来，第二种是使用`$()`包围起来（推荐使用第二种方式）。`command`是执行命令。 ```bash user@PxeCtrlSys:~$ res=`who` user@PxeCtrlSys:~$ echo $res user pts/0 2019-03-11 09:04 (192.168.96.16) user pts/1 2019-03-11 09:04 (192.168.96.16) user@PxeCtrlSys:~$ res=$(ls /) user@PxeCtrlSys:~$ echo $res bin boot dev etc home initrd.img lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var vmlinuz ``` 执行结果赋值给变量，输出不会自动添加换行符。 如果被替换的命令的输出内容包括多行（也即有换行符），或者含有多个连续的空白符，那么在输出变量时应该将变量用双引号包围，否则系统会使用默认的空白符来填充，这会导致换行无效，以及连续的空白符被压缩成一个。请看下面的代码： ```bash user@PxeCtrlSys:~$ res=`who` # 不用引号包围变量，输出不会自动换行 user@PxeCtrlSys:~$ echo $res user pts/0 2019-03-11 09:04 (192.168.96.16) user pts/1 2019-03-11 09:04 (192.168.96.16) # 使用引号包围变量，输出按照原来的格式 user@PxeCtrlSys:~$ echo "$res" user pts/0 2019-03-11 09:04 (192.168.96.16) user pts/1 2019-03-11 09:04 (192.168.96.16) ``` 为了防止出现格式混乱的情况，建议在输出变量时加上双引号。 ## 只读变量 使用 `readonly` 命令可以将变量定义为只读变量，只读变量的值不能被改变。 下面的例子尝试更改只读变量，结果报错： ```bash #!/bin/bash name='test' readonly name name='new' echo $name ``` 运行结果 ```bash test /tmp/280278210/main.sh: line 4: name: readonly variable # 当改为只读后，再次赋值就会报错 ``` ## 删除变量 使用 `unset` 命令可以删除变量 ```bash #!/bin/bash name='test' unset name echo $name # 执行没有输出 ``` 变量删除后不能再次使用。`unset`命令不能删除只读变量。 ## 变量类型，作用域 运行shell时，会同时存在三种变量： 1. **全局变量** 指变量在当前的整个 Shell 会话中都有效。每个 Shell 会话都有自己的作用域，彼此之间互不影响。在 Shell 中定义的变量，默认就是全局变量。 1. **局部变量** 在 Shell 函数中定义的变量默认也是全局变量，它和在函数外部定义变量拥有一样的效果；要想变量的作用域仅限于函数内部，那么可以在定义时加上`local`命令，此时该变量就成了局部变量。 1. **环境变量** 只在当前 Shell 会话中有效，如果使用export命令将它导出，那么它就在所有的子 Shell 中也有效了。 # Shell字符串 字符串最常用的数据类型，可以用单/双引号，也可以不用引号。 ## 单引号 ```bash str='this is a string' ``` 单引号字符串的限制： - 单引号里面的任何字符都会**原样输出**，单引号字符串里面的变量是无效的，也就是变量那一串就只是字符串； - 单引号字符中不能出现单独一个的单引号（对单引号使用转义符后也不行），但能成对出现，相当于字符串拼接`s='abc\'0e'`，这个就会报错，而`s='abc\'0'e'`会输出`abc\0e` ## 双引号 - 双引号中可以有变量，输出时会先解析里面的变量和命令 - 双引号也可以出现转义字符 ```bash #!/bin/bash name='lr' echo $name s1="my name is $name" echo $s1 s2="my name is "$name"" echo $s2 s3="my name is \"$name\"" echo $s3 # 运行结果 lr my name is lr my name is lr my name is "lr" ``` ## 单/双引号使用场景 建议： - 如果变量的值是数字，那么不加引号`a=1`； - 如果要将字符串原样输出，就用反引号`str='单引号中原样输出${test}'`； - 没有特别要求最好都是用双引号（最常见）。 ## 拼接字符串 字符串的拼接（也称字符串连接或者字符串合并），在 Shell 中你不需要使用任何运算符，将两个字符串并排放在一起就能实现拼接。 ```bash #!/bin/bash name='lr' s1="hello, $name" # 双引号中可以直接使用变量 echo $s1 s2="hello, "$name"" # 相当于两对双引号拼接 echo $s2 s3='hello, $name' # 单引号中变量都当作普通字符串 echo $s3 s4='hello, "$name"' echo $s4 s5='hello, '$name'' # 相当于两对单引号和变量进行拼接 echo $s5 nick='xy' s6=$nick$name # 中间不能有空格 s7="$nick $name" # 如果是双引号包围，就允许中间有空格 s8=$nick"..."$name # 中间可以出现其他字符串 s9="$nick...$name" # 中间也可以这样写 s10="昵称${nick}...${name}名字" echo $s6 echo $s7 echo $s8 echo $s9 echo $s10 # 运行结果 user@PxeCtrlSys:~$ ./test.sh hello, lr hello, lr hello, $name hello, "$name" hello, lr xylr xy lr xy...lr xy...lr 昵称xy...lr名字 ``` ## 获取字符串长度 使用`${#变量名}`获取长度 ```python #!/bin/bash name='lr' echo ${#name} # 运行结果 2 ``` ## 截取字符串 Shell 截取字符串通常有两种方式：从指定位置开始截取和从指定字符（子字符串）开始截取。 ### 从指定位置开始截取 种方式需要两个参数：除了指定起始位置，还需要截取长度，才能最终确定要截取的字符串。 **从字符串左边开始计数**，格式为`${string: start :length}` ```python #!/bin/bash str="I love Python, but I need study Shell" echo ${str:2:7} # 下标以0开始，从第2个开始截取，共截取7个字符 echo ${str:19} # 省略长度，直接从指定位置截取到最后 # 运行结果 love Py I need study Shell ``` **从右边开始计数**，格式为`${string: 0-start :length}` 多了`0-`，这是固定的写法，专门用来表示从字符串右边开始计数。 - 从左边开始计数时，起始数字是 0（这符合程序员思维）；从右边开始计数时，起始数字是 1（这符合常人思维）。计数方向不同，起始数字也不同。 - 不管从哪边开始计数，截取方向都是从左到右。 ```bash echo ${str:0-5:2} # 从右向左数第5个，长度为2的字符串 echo ${str:0-5} # 省略长度，直接从指定位置截取到最后 # 运行结果 Sh Shell ``` ### 从指定字符(子字符串)开始截取 这种截取方式无法指定字符串长度，只能从指定字符（子字符串）截取到字符串末尾。Shell 可以截取指定字符（子字符串）右边的所有字符，也可以截取左边的所有字符。 **使用 # 号截取右边字符**，格式为`${string#*chars}` 其中，`string` 表示要截取的字符，`chars` 是指定的字符（或者子字符串），`*`是通配符的一种，表示任意长度的字符串。`*chars`连起来使用的意思是：忽略左边的所有字符，直到遇见 `chars`（`chars` 不会被截取）。 ```bash #!/bin/bash str="I love Python, but I need study Shell" echo ${str#*,} # 以 , 分割，取右边 echo ${str#*Python,} # 以Python , 分割取右边 echo ${str#I love} # 如果不需要忽略左边的字符，那么也可以不写* echo ${str#*o} # 以o分割，因为字符串有好两个o，那么遇到第一个就结束了 echo ${str##*o} # 使用两个#，就可以匹配到最后一个指定字符（子字符串）右方内容 # 运行结果 user@PxeCtrlSys:~$ ./test.sh but I need study Shell but I need study Shell Python, but I need study Shell ve Python, but I need study Shell n, but I need study Shell ``` 如果希望直到最后一个指定字符（子字符串）再匹配结束，那么可以使用##，具体格式为：`${string##*chars}` **使用 % 截取左边字符**，格式为`${string%chars*}` ```bash #!/bin/bash str="I love Python, but I need study Shell" echo ${str%,*} # 以,分割，取左边 echo ${str%Python,*} # 以Python,分割取左边 echo ${str%Shell} # 如果不需要忽略右边的字符，那么也可以不写* echo ${str%o*} # 以o分割，因为字符串有好两个o，从右往左，那么遇到第一个就结束了 echo ${str%%o*} # 使用两个%%，就可以匹配到从右往左的最后一个指定字符（子字符串）左方内容 # 运行结果 user@PxeCtrlSys:~$ ./test.sh I love Python I love I love Python, but I need study I love Pyth I l ``` ### 截取字符串汇总 | 格式 | 说明 | | -------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | | `${string: start :length} ` | 从 `string` 字符串的左边索引为 `start` 的字符开始，向右截取 `length` 个字符。 | | `${string: start} ` | 从 `string` 字符串的左边索引为 `start` 的字符开始截取，直到最后。 | | `${string: 0-start :length} ` | 从 `string` 字符串的右边第 `start` 个字符开始，向右截取 `length` 个字符。 | | `${string: 0-start} ` | 从 `string` 字符串的右边第 `start` 个字符开始截取，直到最后。 | | `${string#*chars}` | 从 string 字符串第一次出现 `*chars` 的位置开始，截取 `*chars` 右边的所有字符。 | | `${string##*chars}` | 从 string 字符串最后一次出现 `*chars` 的位置开始，截取 `*chars` 右边的所有字符。 | | `${string%*chars}` | 从 string 字符串第一次出现 `*chars` 的位置开始，截取 `*chars` 左边的所有字符。 | | `${string%%*chars} ` | 从 `string` 字符串最后一次出现 `*chars` 的位置开始，截取 `*chars` 左边的所有字符。 | ## 查找字符串 ```python #!/bin/bash str="I love Python, but I need study Shell" echo `expr index "$str" SP` # 查找字符S或者P最先出现的位置，下标以1开始，第8个字符为P，就输入了8 # 运行结果 8 ``` 以上脚本中 ` 是反引号，而不是单引号 ' # Shell数组 bash支持一维数组（但不支持多维数组），并且没有限制数组大小。数组元素的下标从0开始，获取数组元素使用小标，下标可以试整数或算术表达式，其值应大于等于0。 ## 定义数组 用括号表示数组，数组元素用`空格`符号分隔开。 ```bash 数组名=(值1 值2 值3 ... 值n) ``` 或者 ```bash array_name=( value0 value1 ... valuen ) ``` 还可以单独定义数组的各个分量 ```bash array_name[0]=value0 array_name[1]=value1 array_name[n]=valuen ``` 可以不使用连续的下标，而且下标的范围没有限制 ```bash array=([2]=12 [5]=99) echo ${array[0]} # 为空值 echo ${array[2]} # 输出值为12 array[0]=5 # 赋值一个 echo ${array[0]} # 输出值为5 # 获取数组的所有元素 echo ${array[*]} 5 12 99 # 获取数组长度 echo ${#array[*]} 3 ``` ## 读取数组 一般格式 ```bash ${数组名[下标]} ``` 例如`valuen=${array_name[n]}`，输出数组所有元素用`echo ${array_name[@]}` ```bash #!/bin/bash arr[0]=1 arr[2]=2 echo ${arr[@]} # 使用 @ 符号可以获取数组中的所有元素: 1 2 echo ${arr[2]} # 2 echo ${arr[1]} # 没有的值获取为空 ``` 使用`@`或`*`可以获取数组中的所有元素。 ## 获取数组的长度 所谓数组长度，就是数组元素的个数。 利用`@`或`*`，可以将数组扩展成列表，然后使用`#`来获取数组元素的个数，格式为 **`${#array_name[@]}`** 或 **`${#array_name[*]}`** ，其中`array_name` 表示数组名。两种形式是等价的。 ```bash #!/bin/bash arr=(1 2 3 "abc") echo ${#arr[@]} # 获取数组的长度：4 echo ${#arr[*]} # *也可以：4 echo ${#arr[3]} # 获取数组中单独元素的长度：3 ``` 获取数组中元素为字符串的长度`${#arr[2]}`（假设下标为2的元素为字符串），因为获取字符串长度的方法是 `${#string_name}` ## 删除数组的元素或数组 使用 **`unset arr[index]`** 删除数组元素，使用 **`unset arr`** 删除整个数组，所有元素都会消失。 ```bash #!/bin/bash arr=(1 2 3 "abc") echo ${#arr[@]} # 获取数组的长度：4 echo 原来数组的长度为：${#arr[*]} # *也可以：4 echo ${#arr[3]} # 获取数组中单独元素的长度：3 unset arr[1] echo "删除第二个元素后长度为：${#arr[*]}" # 运行结果 user@PxeCtrlSys:~$ ./test.sh 4 原来数组的长度为：4 3 删除第二个元素后长度为：3 ``` ## 数组拼接、合并 将两个数组连接成一个数组。 拼接数组的思路是：先利用@或*，将数组扩展成列表，然后再合并到一起。格式为 **`array_new=(${array1[@]} ${array2[@]})`** 或 **`array_new=(${array1[*]} ${array2[*]})`** ```bash #!/bin/bash arr1=(1 2 3 "abc") arr2=(66) echo "数组1：${arr1[*]}" echo "数组2：${arr2[@]}" new_arr=(${arr1[*]} ${arr2[@]}) echo "合并后的数组为：${new_arr[*]}" # 运行结果 user@PxeCtrlSys:~$ ./test.sh 数组1：1 2 3 abc 数组2：66 合并后的数组为：1 2 3 abc 66 ``` # Shell注释 以`#`开始的行就是注释，会被解释器忽略 通过每一行添加一个`#`来设置多行注释 如果在开发过程中，遇到大段的代码需要临时注释起来，过一会儿又取消注释，怎么办呢？ 每一行加个`#`符号太费力了，可以把这一段要注释的代码用一对花括号括起来，定义成一个函数，没有地方调用这个函数，这块代码就不会执行，达到了和注释一样的效果。 ## 多行注释 ```bash :<<EOF 注释内容... 注释内容... 注释内容... EOF ``` `EOF`也可以使用其他符号 ```bash :<<' 注释内容... 注释内容... 注释内容... ' :<<! 注释内容... 注释内容... 注释内容... ! ``` # Shell脚本传递参数 想脚本传递参数，脚本内获取参数的格式为：`$n`。`n`代表一个数字，1为执行脚本的第一个参数，2为执行脚本的第二个参数，以此类推... ## 给脚本文件传递参数 向脚本传递3个参数，其中**`$0`表示执行的文件名** ```bash user@PxeCtrlSys:~$ vim test.sh user@PxeCtrlSys:~$ chmod +x test.sh # 添加执行权限 user@PxeCtrlSys:~$ ./test.sh 执行的文件名：./test.sh 传递的第一个参数： 传递的第二个参数： 传递的第三个参数： 所有参数： user@PxeCtrlSys:~$ ./test.sh 1 2 执行的文件名：./test.sh 传递的第一个参数：1 传递的第二个参数：2 传递的第三个参数： 所有参数：1 2 user@PxeCtrlSys:~$ ./test.sh 1 2 3 执行的文件名：./test.sh 传递的第一个参数：1 传递的第二个参数：2 传递的第三个参数：3 所有参数：1 2 3 ``` ```bash # test.sh文件内容 #!/bin/bash echo "执行的文件名：$0" echo "传递的第一个参数：$1" echo "传递的第二个参数：$2" echo "传递的第三个参数：$3" echo "所有参数：$*" ``` 如果参数个数太多，达到或者超过了 10 个，那么就得用`${n}`的形式来接收了，例如 `${10}`、`${23}`。`{ }`的作用是为了帮助解释器识别参数的边界，这跟使用变量时加`{ }`是一样的效果。 ## 特殊字符处理参数（特殊变量） | 参数处理 | 说明 | | ------- | ------------------------------------------------------------- | | `$#` | 获取传递到脚本的参数个数 | | `$*` | 以一个单字符串显示所有向脚本传递的参数，如`$*`就和`"$1 $2 $3 ... $n"`输出形式一样 | | `$$` | 脚本运行的当前ID号 | | `$!` | 后台运行的最后一个进程的ID号 | | `$@` | 与`$*`相同，但是使用时加括号，斌仔引号中返回每个参数，`"$1" "$2" … "$n"`形式 | | `$-` | 显示Shell使用的当前选项，与set命令功能相同 | | `$?` | 显示最后命令的退出状态。0表示没有错误，其他任何值表示有错误 | ## $* 和 $@ 的区别 - 相同点：都是引用所有参数 - 不同点：只有在双引号中提现出来。假设在脚本运行时写了三个参数1、2、3，则`*`等价于`"1 2 3"`（传递了一个参数：会将所有的参数从整体上看做一份数据，而不是把每个参数都看做一份数据。），而`@`等价于`"1" "2" "3"`（仍然将每个参数都看作一份数据，彼此之间是独立的） ```bash #!/bin/bash echo "执行的文件名：$0" echo "传递的第一个参数：$1" echo "传递的第二个参数：$2" echo "传递的第三个参数：$3" echo "\$*演示" for i in "$*";do echo $i done echo "\$@演示" for j in $@;do echo $j done # 运行结果 user@PxeCtrlSys:~$ ./test.sh 1 2 3 执行的文件名：./test.sh 传递的第一个参数：1 传递的第二个参数：2 传递的第三个参数：3 $*演示 # 只循环了一次，因为$*当作一个参数 1 2 3 $@演示 # 循环多次，$@当作多个参数 1 2 3 ``` # Shell函数 shell函数格式 ```bash [ function ] funname [()] { action; [return int;] } ``` - 可以带`function func()`定义，也可以直接`func()`定义，不带任何参数。 - 参数返回，可以显示加：`return`返回，如果不加，将以最后一条命令运行结果，作为返回值。`return`后跟数值n（0-255） ## 无返回值函数 ```bash #!/bin/bash func(){ echo "这是一个函数中的内容" } echo "开始调用函数" func echo "调用函数完成" # 运行结果 user@PxeCtrlSys:~$ ./test.sh 开始调用函数 这是一个函数中的内容 调用函数完成 ``` ## 有返回值函数 定义一个带`return`的函数 ```bash #!/bin/bash func(){ echo "请输入两个数，执行加法" echo -n "请输入第一个数：" read num1 echo -n "请输入第二个数：" read num2 # return $[ $num1 + $num2] # 下方表达式也正确 return $(( $num1 + $num2 )) } echo "开始调用函数" func echo "函数返回值为 $?" echo "调用函数完成" # 运行结果 user@PxeCtrlSys:~$ ./test.sh 开始调用函数 请输入两个数，执行加法 请输入第一个数：2 请输入第二个数：3 函数返回值为 5 调用函数完成 ``` 函数返回值在调用该函数后通过 `$?` 来获得。 > 所有函数在使用前必须定义。这就是说必须将函数放在脚本开始部分，直到shell解释器首次发现它时才可以使用。调用函数仅使用其函数名即可。 ## $? 使用方法：返回值或退出状态 `$?`用来获取函数返回值或者上一个命令的退出状态 每一条 Shell 命令，不管是 Bash 内置命令（例如 `test`、`echo`），还是外部的 Linux 命令（例如 `cd`、`ls`），还是自定义的 Shell 函数，当它退出（运行结束）时，都会返回一个比较小的整数值给调用（使用）它的程序，这就是命令的退出状态（exit status）。 `if` 语句的判断条件，从本质上讲，判断的就是命令的退出状态。 ### $? 获取上一次命令退出状态 退出状态，就是上一个命令执行后的返回结果。退出状态是一个数字，一般情况下，大部分命令执行成功会返回 0，失败返回 1，这和C语言的 main() 函数是类似的。 不过，也有一些命令返回其他值，表示不同类型的错误。 ```bash #!/bin/bash echo -n 请输入a： read a echo -n 请输入b： read b (( $a == $b )); echo "退出状态：$?" # 运行结果 user@PxeCtrlSys:~$ ./test.sh 请输入a：1 请输入b：2 退出状态：1 user@PxeCtrlSys:~$ echo $? 0 user@PxeCtrlSys:~$ ./test.sh 请输入a：6 请输入b：6 退出状态：0 user@PxeCtrlSys:~$ echo $? 0 ``` ### $? 获取函数的返回值 ## 给函数传递参数 Shell调用函数也可以向其传递参数。在函数体内部，通过 `$n` 的形式来传递参数。例如`$1`表示第一个参数。`$2`表示第二次参数 ```bash #!/bin/bash func(){ echo "第一个参数：$1" echo "第二个参数：$2" echo "第二个参数：${2}" echo "第五个参数：$5" echo "第10个参数：$10" # 这个相当于第一个参数$1连接一个0 echo "第10个参数：${10}" echo "第11个参数：$11" # 相当于第一个参数$1连接一个1 echo "第11个参数：${11}" echo "参数总数有 $# 个" echo "作为一个地府传输出所有参数：$*" } echo "开始调用函数" func 0 2 3 4 5 23 36 65 99 123 echo "函数返回值为 $?" echo "调用函数完成" # 运行结果 user@PxeCtrlSys:~$ ./test.sh 开始调用函数 第一个参数：0 第二个参数：2 第二个参数：2 第五个参数：5 第10个参数：00 第10个参数：123 第11个参数：01 第11个参数： 参数总数有 10 个 作为一个地府传输出所有参数：0 2 3 4 5 23 36 65 99 123 函数返回值为 0 调用函数完成 ``` > `$10`不能获取到第10个参数，正确用法是`${10}`。**当`n>=10`时，需要使用`${n}`来获取参数**。 处理参数的特殊字符 | 参数处理 | 说明 | | ------- | ------------------------------------------------------ | | $# | 传递到脚本的参数个数 | | $* | 以一个单字符串显示所有向脚本传递的参数 | | $$ | 脚本运行的当前进程ID号 | | $! | 后台运行的最后一个进程的ID号 | | $@ | 与$*相同，但是使用时加引号，并在引号中返回每个参数。 | | $- | 显示Shell使用的当前选项，与set命令功能相同。 | | $? | 显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。 | # Shell基本运算符 支持的运算符 - 算术运算符 - 关系运算符 - 布尔运算符 - 字符串运算符 - 文件测试运算符 原生bash不支持简单的数学运算，但可以使用其他命令实现，例如`awk`、`expr`（最常用） `expr`是一款表达式计算工具，使用它完成表达式的求值操作 例如，两个数量价，注意是反引号，而不是单引号 ```bash #!/bin/bash val=`expr 2+2` echo "求值结果：$val" val=`expr 2 + 2` echo "求值结果：$val" # 运行结果 user@PxeCtrlSys:~$ ./test.sh 求值结果：2+2 求值结果：4 ``` - 表达式和运算符之间要用空格，例如`2+2`是不正确的，需要写成`2 + 2`，这与大多数编程语言不同 - 完整的表达式要被两个反引号\` \`包含. ## 算术运算符 ### 两个数直接加不会进行算术运算 Shell 和其它编程语言不同，Shell 不能直接进行算数运算，必须使用数学计算命令。 默认情况下，Shell 不会直接进行算术运算，而是把`+`两边的数据（数值或者变量）当做字符串，把`+`当做字符串连接符，最终的结果是把两个字符串拼接在一起形成一个新的字符串。这是因为，在Shell如果不特别知名，每一个变量都是字符串，无论赋值的时候有没使用引号，值都会以字符串形式存储，默认情况下不区分变量类型。 ### Shell expr：进行整数计算 ```bash a 不等于 b #!/bin/bash a=2 b=3 echo `expr $a + $b` echo `expr $a - $b` echo `expr $a \* $b` # 做乘法需要添加斜杠转义 echo `expr $b / $a` echo `expr $b % $a` c=$b echo "赋值后c的值：$c" if [ $a == $b ] then echo "a 等于 b" else echo "a 不等于 b" fi if [ $b == $c ] then echo "b 等于 c" fi if [ $a != $b ] then echo "a 不等于 b" fi if [ $c != $b ] then echo "c 不等于 b" fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh 5 -1 6 1 1 赋值后c的值：3 a 不等于 b b 等于 c a 不等于 b ``` | 运算符 | 说明 （例如a=2、b=3） | 举例 | | ----- | ----------------------------------------- | -------------------- | | + | 加法 | \`expr $a + $b\` 结果为 30。 | | - | 减法 | \`expr $a - $b\` 结果为 -10。 | | * | 乘法 | \`expr $a \\* $b\` 结果为 200。 | | / | 除法 | \`expr $b / $a\` 结果为 2。 | | % | 取余 | \`expr $b % $a\` 结果为 0。 | | = | 赋值 | a=$b 将把变量 b 的值赋给 a。 | | == | 相等。用于比较两个数字，相同则返回 true。 | \[ $a == $b \] 返回 false。 | | != | 不相等。用于比较两个数字，不相同则返回 true。 | \[ $a != $b \] 返回 true。 | - 条件表达式要放在方括号之间，并且要有空格，例如: `[$a==$b]` 是错误的，必须写成 **`[ $a == $b ]`**。 - 乘号(`*`)前边必须加反斜杠(`\*`)才能实现乘法运算； - `if...then...fi` 是条件语句 - 在 MAC 中 shell 的 `expr` 语法是：`$((表达式))`，此处表达式中的 "*" 不需要转义符号 "\" ## 数学计算命令 Shell 中常用的六种数学计算方式 | 运算操作符/运算命令 | 说明 | | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | `(())` | 用于整数运算，效率很高，**推荐使用**。 | | `let` | 用于整数运算，和 `(())` 类似。 | | [`$[]` | 用于整数运算，不如 `(())` 灵活。 | | `expr` | 可用于整数运算，也可以处理字符串。比较麻烦，需要注意各种细节，不推荐使用。 | | `bc` | Linux下的一个计算器程序，可以处理整数和小数。Shell 本身只支持整数运算，想计算小数就得使用 `bc` 这个外部的计算器。 | | `declare -i` | 将变量定义为整数，然后再进行数学运算时就不会被当做字符串了。功能有限，仅支持最基本的数学运算（加减乘除和取余），不支持逻辑运算、自增自减等，所以在实际开发中很少使用。 | ### Shell (())：对整数进行数学运算 **`(( ))` 只能进行整数运算**，不能对小数（浮点数）或者字符串进行运算。语法格式 **`((表达式))`** ，就是将数学运算表达式放在`((`和`))`之间。 表达式可以只有一个，也可以有多个，多个表达式之间以逗号`,`分隔。对于多个表达式的情况，以最后一个表达式的值作为整个 `(( ))` 命令的执行结果。 可以使用`$`获取 `(( ))` 命令的结果，这和使用`$`获得变量值是类似的。 | 运算操作符/运算命令 | 说明 | | -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `((a=10+66) ((b=a-15)) ((c=a+b))` | 这种写法可以在计算完成后给变量赋值。以 `((b=a-15))` 为例，即将 `a-15` 的运算结果赋值给变量 `c`。 注意，使用变量时不用加`$`前缀，**`(( ))` 会自动解析变量名**。 | | `a=$((10+66) b=$((a-15)) c=$((a+b))` | 可以在 `(( ))` 前面加上`$`符号获取 `(( ))` 命令的执行结果，也即获取整个表达式的值。以 `c=$((a+b))` 为例，即将 `a+b` 这个表达式的运算结果赋值给变量 `c`。 注意，类似 `c=((a+b))` 这样的写法是错误的，不加`$`就不能取得表达式的结果。 | | `((a>7 && b==c))` | `(( ))` 也可以进行逻辑运算，在 `if` 语句中常会使用逻辑运算。 | | `echo $((a+10))` | 需要立即输出表达式的运算结果时，可以在 `(( ))` 前面加`$`符号。 | | `((a=3+5, b=a+10))` | 对多个表达式同时进行计算。 | 在 `(( ))` 中使用变量无需加上`$`前缀，`(( ))` 会自动解析变量名，这使得代码更加简洁，也符合程序员的书写习惯。 #### 算术运算 ```bash # 直接输出运算结果 user@PxeCtrlSys:~$ echo $((1+1)) 2 user@PxeCtrlSys:~$ echo $((2*3)) 6 # 计算完成后，给变量赋值 user@PxeCtrlSys:~$ i=5 user@PxeCtrlSys:~$ ((i=i*2)) user@PxeCtrlSys:~$ echo $i 10 user@PxeCtrlSys:~$ ((i*=2)) # 简写，等效于 ((i=i*2)) user@PxeCtrlSys:~$ echo $i 20 # 复杂运算，结果赋值给变量a，变量在括号内 user@PxeCtrlSys:~$ ((a=2-5*2/4+2**2)) user@PxeCtrlSys:~$ echo $a 4 # 运算结果赋值给变量b，变量b在括号外，需要使用$ user@PxeCtrlSys:~$ b=$((2-5*2/4+2**2)) user@PxeCtrlSys:~$ echo $b 4 # 直接输出表达式的值，$符号不能去掉 user@PxeCtrlSys:~$ echo $((2-5*2/4+2**2)) 4 # 利用公式计算1-100的和 user@PxeCtrlSys:~$ echo $((100*(100+1)/2)) 5050 ``` #### 逻辑运算 ```bash # 结果为真，输出1，1表示真 user@PxeCtrlSys:~$ echo $((3<5)) 1 user@PxeCtrlSys:~$ echo $((3>5)) 0 user@PxeCtrlSys:~$ echo $((3==2+1)) 1 # 多条件成立 user@PxeCtrlSys:~$ if ((8>6&&5==2+3)) > then > echo yes > fi yes ``` #### (())进行自增++和自减--运算 ```bash user@PxeCtrlSys:~$ a=10 # ++在后面，先输出a的值，在自增 user@PxeCtrlSys:~$ echo $((a++)) 10 user@PxeCtrlSys:~$ echo $a 11 # --在后面，先输出a的值，再自减 user@PxeCtrlSys:~$ echo $((a--)) 11 user@PxeCtrlSys:~$ echo $a 10 # --在前面，先自减，再输出a的值 user@PxeCtrlSys:~$ echo $((--a)) 9 user@PxeCtrlSys:~$ echo $a 9 # ++在前面，先自增，再输出a的值 user@PxeCtrlSys:~$ echo $((++a)) 10 user@PxeCtrlSys:~$ echo $a 10 ``` #### 多个表达式计算 ```bash # 先计算第一个表达式，再计算第二个表达式 user@PxeCtrlSys:~$ ((a=3*2, b=a+6)) user@PxeCtrlSys:~$ echo $a $b 6 12 # 以最后一个表达式的结果作为整个(())命令的执行结果 user@PxeCtrlSys:~$ c=$((1+2, a+b)) user@PxeCtrlSys:~$ echo $c 18 ``` ### Shell let：对整数进行数学运算 和双小括号 `(( ))` 一样，`let` 命令也只能进行整数运算，不能对小数（浮点数）或者字符串进行运算。 语法格式 **`let 表达式`**、**`let "表达式"`**、**`let '表达式'`**，都等价于 `((表达式))`。 当表达式中含有 Shell 特殊字符（例如 `|`）时，需要用双引号`" "`或者单引号`' '`将表达式包围起来。 和 `(( ))` 类似，`let` 命令也支持一次性计算多个表达式，并且以最后一个表达式的值作为整个 `let` 命令的执行结果。但是，对于多个表达式之间的分隔符，`let` 和 `(( ))` 是有区别的： - `let` 命令以空格来分隔多个表达式； - `(( ))` 以逗号`,`来分隔多个表达式。 ```bash user@PxeCtrlSys:~$ i=2 user@PxeCtrlSys:~$ let i+=3 user@PxeCtrlSys:~$ echo $i 5 ``` `let i+=3`等价于`((i+=3))`，但后者效率更高。 `let`后面可以跟多个表达式，用空格分隔 ```bash user@PxeCtrlSys:~$ a=3 user@PxeCtrlSys:~$ let b=3**2 c=a+b user@PxeCtrlSys:~$ echo $a $b 3 9 user@PxeCtrlSys:~$ echo $c 12 ``` ### Shell $[]：对整数进行数学运算 和 `(())`、`let` 命令类似，`$[]` 也只能进行整数运算。语法为 **`$[表达式]`** `$[]` 会对`表达式`进行计算，并取得计算结果。如果`表达式`中包含了变量，那么你可以加`$`，也可以不加。 ```bash # 直接输出结果 user@PxeCtrlSys:~$ echo $[2*3] 6 user@PxeCtrlSys:~$ echo $[(2+3)/3] 1 user@PxeCtrlSys:~$ echo $[(2+3)%3] 2 user@PxeCtrlSys:~$ a=6 # 将结果赋值给变量 user@PxeCtrlSys:~$ b=$[a*2] user@PxeCtrlSys:~$ echo $b 12 user@PxeCtrlSys:~$ echo $[a+b] 18 # 变量前加$对结果没有影响 user@PxeCtrlSys:~$ echo $[$a+$b] 18 ``` ### Shell declare -i：将变量声明为整数 默认情况下，Shell每一个变量的值都是一个字符串，即使给变量赋值一个数字，它也是字符串。 使用 `declare` 命令的`-i`选项可以将一个变量声明为整数类型，这样在进行数学计算时就不会作为字符串处理了。 ```bash #!/bin/bash echo 定义之前，直接求两个数的和 m=2 n=3 echo $m+$n echo 求和后赋值给一个变量 ret=$m+$n echo $ret echo -e "\n声明变量为整数" declare -i m n ret m=2 n=3 echo 直接输出声明后的求和 echo $m+$n ret=$m+$n echo 求和后赋值变量 echo $ret # 运行结果 user@PxeCtrlSys:~$ ./test.sh 定义之前，直接求两个数的和 2+3 求和后赋值给一个变量 2+3 声明变量为整数 直接输出声明后的求和 2+3 求和后赋值变量 5 ``` 除了将 `m`、`n` 定义为整数，还必须将 `ret` 定义为整数，如果不这样做，在执行`ret=$m+$n`时，Shell 依然会将 `m`、`n` 视为字符串。 此外，也不能写类似`echo $m+$n`这样的语句，这种情况下 `m`、`n` 也会被视为字符串。 总之，除了将参与运算的变量定义为整数，还得将承载结果的变量定义为整数，而且只能用整数类型的变量来承载运算结果，不能直接使用 echo 输出。 和 `(())`、`let`、`$[]` 不同，`declare -i`的功能非常有限，仅支持最基本的数学运算（加减乘除和取余），不支持逻辑运算（比较运算、与运算、或运算、非运算），所以在实际开发中很少使用。 ## 关系运算符 关系运算符**只支持数字**，不支持字符串，除非字符串的值是数字 | 运算符 | 说明（例如a=2、b=3） | 举例 | | ----- | --------------------------------------------------------- | ---- | | -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。 | ```bash #!/bin/bash a=2 b=3 if [ $a -eq $b ] then echo "a 大于 b" else echo "a 小于 b" fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh a 小于 b ``` ## 布尔运算符 | 运算符 | 说明（例如a=2、b=3） | 举例 | | ----- | ----------------------------------------------- | ------------- | | ! | 非运算，表达式为 true 则返回 false，否则返回 true。 | \[ ! false \] 返回 true。 | | -o | 或运算，有一个表达式为 true 则返回 true。 | \[ $a -lt 20 -o $b -gt 100 \] 返回 true。 | | -a | 与运算，两个表达式都为 true 才返回 true。 | \[ $a -lt 20 -a $b -gt 100 \] 返回 false。 | ```bash 2 小于 5 或 3 大于 100 : 返回 true #!/bin/bash a=2 b=3 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 # 运行结果 user@PxeCtrlSys:~$ ./test.sh 2 != 3 : a 不等于 b 2 小于 100 且 3 大于 15 : 返回 false 2 小于 100 或 3 大于 100 : 返回 true 2 小于 5 或 3 大于 100 : 返回 true ``` ## 逻辑运算符 | 运算符 | 说明 | 举例 | | ----- | --------- | ------------------------------------------- | | `&&` | 逻辑的 AND | `[[ $a -lt 100 && $b -gt 100 ]]` 返回 false | | `||` | 逻辑的OR | `[[ $a -lt 100 || $b -gt 100 ]]` 返回 true | ```bash #!/bin/bash a=2 b=3 if [[ $a -lt 5 && $b -gt 2 ]] then echo "返回true" else echo "返回false" fi if [[ $a -ge 2 || $b -le 3 ]] then echo "返回true" else echo "返回false" fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh 返回true 返回true ``` ## 字符串运算符 | 运算符 | 说明 | 举例 | | ----- | ------------------------------------- | ----------------------- | | = | 检测两个字符串是否相等，相等返回 true。 | \[ $a = $b \] 返回 false。 | | != | 检测两个字符串是否相等，不相等返回 true。 | \[ $a != $b \] 返回 true。 | | -z | 检测字符串长度是否为0，为0返回 true。 | \[ -z $a \] 返回 false。 | | -n | 检测字符串长度是否为0，不为0返回 true。 | \[ -n "$a" \] 返回 true。 | | $ | 检测字符串是否为空，不为空返回 true。 | \[ $a \] 返回 true。 | ```bash #!/bin/bash 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 # 运行结果 user@PxeCtrlSys:~$ ./test.sh abc = efg: a 不等于 b abc != efg : a 不等于 b -z abc : 字符串长度不为 0 -n abc : 字符串长度不为 0 abc : 字符串不为空 ``` ## 文件测试运算符 文件测试运算符用于检测Unix文件的各种属性 | 操作符 | 说明 | 举例 | | --- | --- | --- | | -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。 | 变量 file 表示文件"/home/user/test.sh"，它的大小为100字节，具有 rwx 权限。下面的代码，将检测该文件的各种属性： ```python #!/bin/bash file="/home/user/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 if [ -e $file ] then echo "文件存在" else echo "文件不存在" fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh 文件可读 文件可写 文件可执行 文件为普通文件 文件不是个目录 文件不为空 文件存在 ``` # Shell内建(内置)命令 由 Bash 自身提供的命令，而不是文件系统中的某个可执行文件。 用于进入或者切换目录的 cd 命令，虽然我们一直在使用它，但如果不加以注意很难意识到它与普通命令的性质是不一样的：该命令并不是某个外部文件，只要在 Shell 中你就一定可以运行这个命令。 可以使用 `type` 来确定一个命令是否是内建命令： ```bash user@PxeCtrlSys:~$ type cd cd is a shell builtin # 内建命令 user@PxeCtrlSys:~$ type ls ls is aliased to 'ls --color=auto' user@PxeCtrlSys:~$ type ssh ssh is /usr/bin/ssh # 外部命令 ``` 通常来说，内建命令会比外部命令执行得更快，执行外部命令时不但会触发磁盘 I/O，还需要 fork 出一个单独的进程来执行，执行完成后再退出。而执行内建命令相当于调用当前 Shell 进程的一个函数。 | <br> | <br> | <br> | <br> | <br> | <br> | <br> | | ------- | ------- | ------ | ------- | -------- | -------- | -------- | | bash | : | . | \[ | alias | bg | bind | | break | builtin | cd | command | compgen | complete | continue | | declare | dirs | disown | echo | enable | eval | exec | | exit | export | fc | fg | getopts | hash | help | | history | jobs | kill | let | local | logout | popd | | printf | pushd | pwd | read | readonly | return | set | | shift | shopt | source | suspend | test | times | trap | | type | typeset | ulimit | umask | unalias | unset | wait | # Shell alias：给命令创建别名 `alias` 用来给命令创建一个别名。 ## 查看alias所有别名 若直接输入该命令且不带任何参数，则列出当前 Shell 环境中使用了哪些别名。 ```bash user@PxeCtrlSys:~$ alias alias ls='ls --color=auto' ``` 终于知道我的腾讯云debian上`ls`命令没有颜色区分了 ```bash # 没有为ls创建别名 root@StarMeow-Svr:~# alias root@StarMeow-Svr:~# alias ls='ls --color=auto' root@StarMeow-Svr:~# ls # 这儿的文件和文件夹就有颜色区分了 ``` 使用 `alias` 当然也可以自定义别名，比如说一般的关机命令是`shutdown-h now`，写起来比较长，这时可以重新定义一个关机命令，以后就方便多了。使用 alias 定义的别名命令也是支持 Tab 键补全的，如下所示： ```bash alias myShutdown='shutdown -h now' ``` 注意，这样定义别名只能在当前 Shell 环境中有效，换句话说，重新登录后这个别名就消失了。 ## 永久生效alias别名 为了确保永远生效，可以将该别名手动写入到用户主目录中的`.bashrc`文件。 ```bash root@StarMeow-Svr:~# vim /root/.bashrc # 将下方代码取消被注释 export LS_OPTIONS='--color=auto' eval "`dircolors`" alias ls='ls $LS_OPTIONS' alias ll='ls $LS_OPTIONS -l' alias l='ls $LS_OPTIONS -lA' # 修改完后使其生效 root@StarMeow-Svr:~# source ~/.bashrc root@StarMeow-Svr:~# ls # 这儿的文件和文件夹就有颜色区分了 root@StarMeow-Svr:~# alias alias l='ls $LS_OPTIONS -lA' alias ll='ls $LS_OPTIONS -l' alias ls='ls $LS_OPTIONS' ``` ## 删除alias别名 使用 `unalias` 内建命令可以删除当前 Shell 环境中的别名。`unalias` 有两种使用方法： - 第一种用法是在命令后跟上某个命令的别名，用于删除指定的别名。 - 第二种用法是在命令后接`-a`参数，删除当前 Shell 环境中所有的别名。 同样，这两种方法都是在当前 Shell 环境中生效的。要想永久删除在`.bashrc`文件中定义的别名，只能进入该文件手动删除。 ```bash # 例如已经通过alias查到如下别名ls user@PxeCtrlSys:~$ alias alias ls='ls --color=auto' # 使用unalias ls就可以删除当前环境的别名 user@PxeCtrlSys:~$ unalias ls ``` # Shell echo：输出字符串 用于字符串输出`echo string` ## 显示普通字符串 ```bash echo "It is a string1" ``` 这里的双引号可以完全省略 ```bash echo It is a string2 ``` ## 显示转义字符 ```bash #!/bin/bash echo "\"It is a string1\"" echo \"It is a string2\" # 运行结果 user@PxeCtrlSys:~$ ./test.sh "It is a string1" "It is a string2" ``` 默认情况下，`echo` 不会解析以反斜杠`\`开头的转义字符。比如，`\n`表示换行，`echo` 默认会将它作为普通字符对待。 ```bash echo "hello \nworld" # 运行结果 hello \nworld echo -e "hello \nworld" # 运行结果 hello world ``` 同样双引号都是可以省略的 ## 显示变量 `read`命令从标准输入中读取一行，并把输入行的每个字段的值指定给shell变量 ```bash #!/bin/bash read name echo "You entered $name" # 运行结果 user@PxeCtrlSys:~$ ./test.sh 66 You entered 66 ``` ## 显示换行：-e参数和\n ```bash #!/bin/bash echo -e "this is first line \n" echo "next" # 运行结果 user@PxeCtrlSys:~$ ./test.sh this is first line next ``` 输出中`-e`表示开启转义，`\n`表示换行 ## 显示不换行：-e参数和\c或-n参数 ```bash #!/bin/bash echo -e "this is first line \c" echo "next" # 运行结果 user@PxeCtrlSys:~$ ./test.sh this is first line next ``` `-e`开启转义，`\c`表示不换行 ```bash echo -n "this is first line" echo -n "next" # 运行结果 this is first linenext ``` ## 输出结果重定向到文件 ```bash #!/bin/bash echo -e "this is first line" > file.ts # 运行结果 user@PxeCtrlSys:~$ ./test.sh user@PxeCtrlSys:~$ ls file.ts software test.sh user@PxeCtrlSys:~$ cat file.ts this is first line ``` ## 原样输出，不转义，不取变量 直接使用单引号即可 ```bash #!/bin/bash name='lr' echo '$name"\' # 运行结果 user@PxeCtrlSys:~$ ./test.sh $name"\ ``` ## 显示命令执行结果 使用反引号，而不是单引号，可以执行Linux的命令 ```bash #!/bin/bash echo `date` # 运行结果 user@PxeCtrlSys:~$ ./test.sh Tue Mar 5 10:41:55 CST 2019 ``` # Shell exit：退出Shell命令 exit 是一个 Shell 内置命令，用来退出当前Shell： - 如果在终端中直接运行 `exit` 命令，会退出当前登录的 Shell，并关闭终端； - 如果在Shell中出现 `exit` 命令，会停止执行后边的所有代码，立即退出 Shell 脚本。 `exit` 命令可以接受的参数是一个状态值 `n`，代表退出时的状态。如果不指定，默认状态值是 0。 ```bash #!/bin/bash echo "exit命令前输出" exit 9 echo "exit命令后输出" # 运行结果 user@PxeCtrlSys:~$ ./test.sh exit命令前输出 # 也就是说exit后面的语句已经不会执行了 # 紧接着用 $? 来获取test.sh的退出状态 user@PxeCtrlSys:~$ echo $? 9 ``` # Shell ulimit：显示并设置进程资源速度 系统的可用资源是有限的，如果不限制用户和进程对系统资源的使用，则很容易陷入资源耗尽的地步，而使用 ulimit 命令可以控制进程对可用资源的访问（ulimit 是一个 Shell 内置命令）。 默认情况下 Linux 系统的各个资源都做了软硬限制，其中硬限制的作用是控制软限制（换言之，软限制不能高于硬限制）。使用`ulimit -a`可以查看当前系统的软限制，使用命令`ulimit -a –H`可查看系统的硬限制。 ## ulimit -a查看软限制 ```bash user@PxeCtrlSys:~$ ulimit -a core file size (blocks, -c) 0 # core文件大小，单位是block，默认为0 data seg size (kbytes, -d) unlimited # 数据段大小，单位是kbyte，默认不做限制 scheduling priority (-e) 0 # 调度优先级，默认为0 file size (blocks, -f) unlimited # 创建文件的大小，单位是block，默认不做限制 pending signals (-i) 15596 # 挂起的信号数量，默认是8192 max locked memory (kbytes, -l) 64 # 最大锁定内存的值，单位是kbyte，默认是32 max memory size (kbytes, -m) unlimited # 最大可用的常驻内存值，单位是kbyte，默认不做限制 open files (-n) 65536 # 最大打开的文件数，默认是1024 pipe size (512 bytes, -p) 8 # 管道最大缓冲区的值 POSIX message queues (bytes, -q) 819200 # 消息队列的最大值，单位是byte real-time priority (-r) 0 # 程序的实时性优先级，默认为0 stack size (kbytes, -s) 8192 # 栈大小，单位是kbyte cpu time (seconds, -t) unlimited # 最大cpu占用时间，默认不做限制 max user processes (-u) 15596 # 用户最大进程数，默认是8192 virtual memory (kbytes, -v) unlimited # 最大虚拟内存，单位是kbyte，默认不做限制 file locks (-x) unlimited # 文件锁，默认不做限制 ``` 每一行中都包含了相应的改变该项设置的参数，以最大可以打开的文件数为例（`open files` 默认是 1024），想要增大至 4096 则按照如下命令设置（可参照此方法调整其他参数）。 ```bash # -n参数是设置最大文件打开数 # 下面命令会同时设置硬限制和软限制 user@PxeCtrlSys:~$ ulimit -n 65536 # 使用-S参数单独设置软限制 user@PxeCtrlSys:~$ ulimit -S -n 65536 # 使用-H参数单独设置硬限制 user@PxeCtrlSys:~$ ulimit -H -n 65536 ``` ## limits.conf 配置文件 使用 `ulimit` 直接调整参数，只会在当前运行时生效，一旦系统重启，所有调整过的参数就会变回系统默认值。所以建议将所有的改动放在 `ulimit` 的系统配置文件中。 ```bash user@PxeCtrlSys:~$ cat /etc/security/limits.conf # /etc/security/limits.conf #该文件是ulimit的配置文件，任何对系统的ulimit的修改都应写入该文件 #Each line describes a limit for a user in the form: #配置应该写成西面格式，即每个配置占用1行，每行4列 #<domain> <type> <item> <value> # #Where: #<domain>取值如下：一个用户名、一个组名，组名前面用@符号、通配符*、通配符% #<domain> can be: # - a user name # - a group name, with @group syntax # - the wildcard *, for default entry # - the wildcard %, can be also used with %group syntax, # for maxlogin limit # - NOTE: group and wildcard limits are not applied to root. # To apply a limit to the root user, <domain> must be # the literal username root. # #<type>有两个可用值：soft用于设置软限制、hard用于设置硬限制 #<type> can have the two values: # - "soft" for enforcing the soft limits # - "hard" for enforcing hard limits # #<item> can be one of the following: # - core - limits the core file size (KB) # - data - max data size (KB) # - fsize - maximum filesize (KB) # - memlock - max locked-in-memory address space (KB) # - nofile - max number of open files # - rss - max resident set size (KB) # - stack - max stack size (KB) # - cpu - max CPU time (MIN) # - nproc - max number of processes # - as - address space limit (KB) # - maxlogins - max number of logins for this user # - maxsyslogins - max number of logins on the system # - priority - the priority to run user process with # - locks - max number of file locks the user can hold # - sigpending - max number of pending signals # - msgqueue - max memory used by POSIX message queues (bytes) # - nice - max nice priority allowed to raise to values: [-20, 19] # - rtprio - max realtime priority # - chroot - change root to directory (Debian-specific) # #<domain> <type> <item> <value> # #以下是使用样例 #* soft core 0 #root hard core 100000 #* hard rss 10000 #@student hard nproc 20 #@faculty soft nproc 20 #@faculty hard nproc 50 #ftp hard nproc 0 #ftp - chroot /ftp #@student - maxlogins 4 # End of file ``` # Shell printf命令 模仿C语言的`printf()`程序，printf的脚本比echo移植性好。 `printf`使用引用文本或空格分隔的参数，外面可以在`printf`中使用格式化字符串，还可以制定字符串的宽度，左右对齐方式等。默认`printf`不会像`echo`自动添加换行符，可以手动添加`\n` 命令语法：`printf format-string [arguments...]` - `format-string`为格式控制字符串 - `arguments`参数列表 ```bash user@PxeCtrlSys:~$ echo "123" 123 user@PxeCtrlSys:~$ printf "123" 123user@PxeCtrlSys:~$ printf "123\n" 123 ``` 格式化输出 ```bash #!/bin/bash printf "%-10s %-8s %-4s\n" 姓名 性别 体重 printf "%-10s %-8s %-4.2f\n" 郭静 男 40 # 运行结果 user@PxeCtrlSys:~$ ./test.sh 姓名 性别 体重 郭静 男 40.00 ``` `%s`、`%c`、`%d`、`%f`都是格式化替代符 `%-10s`指一个宽度为10个字符（`-`表示左对齐，没有该符号就是右对齐），任何字符都会被显示在10个字符宽的字符内。如果不足则以空格填充，超出也会将内容全部显示出来。 `%-4.2f`指格式化为小数，`.2`指保留两位小数。 **%d %s %c %f** 格式替代符详解: - **d: Decimal 十进制整数** ：对应位置参数必须是十进制整数，否则报错！ - **s: String 字符串** ：对应位置参数必须是字符串或者字符型，否则报错！ - **c: Char 字符** ：对应位置参数必须是字符串或者字符型，否则报错！ - **f: Float 浮点** ： 对应位置参数必须是数字型，否则报错！ ```bash #!/bin/bash #!/bin/bash # 格式化字符串为双引号 printf "%d %s\n" 1 "abc" # 格式化字符串为单引号，效果和双引号一致 printf '%d %s\n' 1 'abc' # 没有引号也可以输出，但要求参数只能是一个的情况 printf %s abc echo # 使用这个是为了输出换行 # 格式中只指定了一个参数，但多出的参数仍然会被按照该格式输出，格式化字符串被重用 printf %s abc "def" echo printf "\s\n" qwe "zxc" # 参数按照格式化指定个数进行分组输出，而不够的将输出空值 printf "%s %s %s\n" a b c d e f g # 如果没有参数，那么 %s 用空值代替，%d用0代替 printf "%s 和 %d\n" # 运行结果 user@PxeCtrlSys:~$ ./test.sh 1 abc 1 abc abc abcdef \s a b c d e f g 和 0 ``` ## printf转义序列 | 序列 | 说明 | | ------ | -------------------------------------------------------------- | | \\a | 警告字符，通常为ASCII的BEL字符 | | \\b | 后退 | | \\c | 抑制（不显示）输出结果中任何结尾的换行字符（只在%b格式指示符控制下的参数字符串中有效），而且，任何留在参数里的字符、任何接下来的参数以及任何留在格式字符串中的字符，都被忽略 | | \\f | 换页（formfeed） | | \\n | 换行 | | \\r | 回车（Carriage return） | | \\t | 水平制表符 | | \\v | 垂直制表符 | | \\\ | 一个字面上的反斜杠字符 | | \\ddd | 表示1到3位数八进制值的字符。仅在格式字符串中有效 | | \\0ddd | 表示1到3位的八进制值字符 | ```bash #!/bin/bash printf "<%s>" "a\nb" echo printf "<%b>" "a\nb" echo printf "abc\adef" echo 这儿要换行的 # 运行结果 user@PxeCtrlSys:~$ ./test.sh <a\nb> <a b> abcdef这儿要换行的 ``` # Shell test 命令 Shell中的test用于检查某个条件是否成立，可以进行数值、字符和文件三个方面的测试。 ## 数值测试 | 参数 | 说明 | | --- | ------------ | | -eq | 等于则为真 | | -ne | 不等于则为真 | | -gt | 大于则为真 | | -ge | 大于等于则为真 | | -lt | 小于则为真 | | -le | 小于等于则为真 | ```bash #!/bin/bash num1=100 num2=200 if test $[num1] -eq $[num2] then echo '两个数相等' else echo '两个数不相等' fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh 两个数不相等 #!/bin/bash num1=100 num2=200 # 也可以直接比较两个数的结果 if test $num1 -eq $num2 then echo "相等" else echo "不相等" fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh 不相等 ``` **代码中的`[]`执行基本的算术运算**，如 ```bash #!/bin/bash num1=100 num2=200 # 注意等号两边不能有空格，$[num1+num2]等同于`expr $num1 + $num2` result=$[num1+num2] echo "两个数相加的结果为：$result" # 运行结果 user@PxeCtrlSys:~$ ./test.sh 两个数相加的结果为：300 ``` ## 字符串测试 | 参数 | 说明 | | -------- | --------------------- | | = | 等于则为真 | | != | 不相等则为真 | | -z 字符串 | 字符串的长度为零则为真 | | -n 字符串 | 字符串的长度不为零则为真 | ```bash #!/bin/bash str1='shell' str2='she11' if test $str1 = $str2 then echo "两个字符串相等" else echo "两个字符串不相等" fi if test -n $str1 then echo "字符串的长度不为0" else echo "字符串的长度为0" fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh 两个字符串不相等 字符串的长度不为0 ``` ## 文件测试 | 参数 | 说明 | | -------- | -------------------------------- | | -e 文件名 | 如果文件存在则为真 | | -r 文件名 | 如果文件存在且可读则为真 | | -w 文件名 | 如果文件存在且可写则为真 | | -x 文件名 | 如果文件存在且可执行则为真 | | -s 文件名 | 如果文件存在且至少有一个字符则为真 | | -d 文件名 | 如果文件存在且为目录则为真 | | -f 文件名 | 如果文件存在且为普通文件则为真 | | -c 文件名 | 如果文件存在且为字符型特殊文件则为真 | | -b 文件名 | 如果文件存在且为块特殊文件则为真 | ```bash #!/bin/bash if test -w /home/user/file.ts then echo "文件存在且可写" else echo "文件不存在" fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh 文件存在且可写 ``` ## 与或非逻辑运算test Linux还提供了与`-a`、或`-o`、非`!`三个逻辑操作符用于将测试条件连接起来，优先级为：`!` > `-a` > `-o`。 ```bash #!/bin/bash # file.ts文件存在且可写，以及test.sh存在且可执行时为真 if test -w /home/user/file.ts -a -x /home/user/test.sh then echo "文件都存在，且一个可写，一个可执行" else echo "文件不存在" fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh 文件都存在，且一个可写，一个可执行 ``` # Shell流程控制 在sh/bash里如果else分支没有语句执行，就不要写这个else ## if else `if`语句语法格式 ```bash if condition then command1 command2 ... commandN fi ``` 或者 ```bash if condition; then command1 command2 ... commandN fi ``` 请注意 `condition` 后边的分号`;`，当 `if` 和 `then` 位于同一行的时候，这个分号是必须的，否则会有语法错误。 写成一行（适用于终端命令提示符）： ```bash if [ $(ps -ef | grep -c "ssh") -gt 1 ]; then echo "true"; fi # 在这个系统上运行 user@PxeCtrlSys:~$ ps -ef | grep -c "ssh" 15 ``` `if else` 语法格式 ```bash if condition then command1 command2 ... commandN else command fi ``` Shell 支持任意数目的分支，当分支比较多时，`if else-if else` 语法格式 ```bash if condition1 then command1 elif condition2 then command2 else commandN fi ``` 判断两个变量是否相等 ```bash #!/bin/bash a=10 b=10 if [ $a -eq $b ] then echo "a和b相等" elif [ $a -gt $b ] then echo "a大于b" else echo "a小于b" # -lt fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh a和b相等 ``` 多条件判断 ```bash #!/bin/bash read age if (( $age <= 2 )); then echo "婴儿" elif (( $age >= 3 && $age <= 8 )); then echo "幼儿" elif (( $age >= 9 && $age <= 17 )); then echo "少年" elif (( $age >= 18 && $age <=25 )); then echo "成年" elif (( $age >= 26 && $age <= 40 )); then echo "青年" elif (( $age >= 41 && $age <= 60 )); then echo "中年" else echo "老年" fi ``` ### 与test结合使用 ```bash #!/bin/bash a=$[3*6] b=$[12+3] if test $[a] -eq $[b] then echo "a和b相等" else echo "a和b不相等" fi # 运行结果 user@PxeCtrlSys:~$ ./test.sh a和b不相等 ``` ## for循环 一般格式为 ```bash for var in item1 item2 ... itemN do command1 command2 ... commandN done ``` 写成一行： ```bash for var in item1 item2 ... itemN; do command1; command2; … commandN; done; ``` 例如： ```bash user@PxeCtrlSys:~$ for i in 1 2 3 4; do echo $i; echo $[i*i]; done; 1 1 2 4 3 9 4 16 ``` 当变量在列表里，`for`循环即执行一次所有命令，使用变量名获取列表中的当前取值。命令可为任何有效的shell命令和语句。`in`列表可以包含替换、字符串和文件名。 `in`列表是可选的，如果不使用它，`for`循环使用命令行的位置参数 ```bash #!/bin/bash # 顺序输出当前列表中的数字 for i in 1 2 3 4 5 do echo "循环中输出的值为：$i" done # 顺序输出字符串中的字符 times=0 for str in "顺序输出字符串中的数字" do echo 输出 $[time+1] 次 echo $str done # 运行结果 user@PxeCtrlSys:~$ ./test.sh 循环中输出的值为：1 循环中输出的值为：2 循环中输出的值为：3 循环中输出的值为：4 循环中输出的值为：5 输出 1 次 顺序输出字符串中的数字 ``` 如果是循环字符串，那么它并不是按照字符串中每一个字符输出，而是当作一个整体，循环整个串一次 ## while语句---条件满足循环 `while`循环用于不断执行一系列命令，也用于从输入文件中读取数据；命令通常为测试条件，格式为： ```bash while condition do command done ``` 使用w`hile`循环，当不满足条件时，就跳出循环 ```bash #!/bin/bash num=1 while(( $num<=5 )) do echo $num let "num++" # 直接使用：let num++ 也是可以的 done # 运行结果 user@PxeCtrlSys:~$ ./test.sh 1 2 3 4 5 ``` 上方用了Bash的`let`命令，它用于执行一个或多个表达式，变量计算中不需要加上`$`来表示变量。 `while`循环可用于读取键盘输入 ```bash #!/bin/bash echo "按下<Ctrl-D>退出" echo -n "输入你所想的编程语言：" while read Code do echo "$Code 是一门流行语言" done # 运行结果 user@PxeCtrlSys:~$ ./test.sh 按下<Ctrl-D>退出 输入你所想的编程语言：python python 是一门流行语言 shell shell 是一门流行语言 ``` ## 无限循环 语法格式 ```bash while : do command done ``` 或者 ```bash while true do command done ``` 或者 ```bash for (( ; ; )) do command done ``` ## until循环---条件不满足循环 `until`循环执行一系列命令，知道条件为`true`时停止。 `until`循环与`while`循环再处理方式上刚好相反。 一般`while`循环优于`until`循环，但在某些极少情况`until`更有用。 语法格式 ```bash until condition do command done ``` condition一般为条件表达式，如果返回值为false，则继续执行循环体内的语句，否则跳出循环。**表达式为true跳出循环** ```bash #!/bin/bash a=0 # a小等于10取反，就表示a大等于10，比如3<10为false继续循环 # 由于是先+1再判断，当输出了a=9，+1后，就变成10，满足了10=10为true，就退出循环 until [ ! $a -lt 10 ] do echo $a a=`expr $a + 1` done # 运行结果 user@PxeCtrlSys:~$ ./test.sh 0 1 2 3 4 5 6 7 8 9 ``` ## case多选择语句 可以用`case`语句匹配一个值与一个模式，如果匹配成功，则执行相匹配的命令。语法格式 ```bash case 值 in 模式1) command1 command2 ... commandN ;; 模式2） command1 command2 ... commandN ;; esac ``` `case`工作方式如上。取值后面必须为单词`in`，每一模式必须以右括号`)`结束。取值可以为变量或常熟。匹配发现取值复核某一模式后，其间所有命令开始执行直到`;;`。 取值将检测匹配每一个模式。一旦模式匹配，则执行完该匹配模式相应命令后不再继续其他模式。如果无一匹配模式，使用星号`*`捕获该值，再执行后面的命令。 ```bash #!/bin/bash echo "输入1到5之间的数字：" echo 你输入的数字为： read num case $num in 1) echo '你输入了1' ;; 2) echo 你输入了2 ;; 3) echo "你输入了3";; 4) echo "你输入了4" ;; 5) echo 你输入了5 ;; *) echo "你输入的数字不在该区间" ;; esac # 运行结果 user@PxeCtrlSys:~$ ./test.sh 输入1到5之间的数字： 你输入的数字为： 1 你输入了1 user@PxeCtrlSys:~$ ./test.sh 输入1到5之间的数字： 你输入的数字为： 2 你输入了2 user@PxeCtrlSys:~$ ./test.sh 输入1到5之间的数字： 你输入的数字为： 3 你输入了3 user@PxeCtrlSys:~$ ./test.sh 输入1到5之间的数字： 你输入的数字为： 4 你输入了4 user@PxeCtrlSys:~$ ./test.sh 输入1到5之间的数字： 你输入的数字为： 5 你输入了5 user@PxeCtrlSys:~$ ./test.sh 输入1到5之间的数字： 你输入的数字为： 6 你输入的数字不在该区间 ``` ## 跳出循环 未达到循环结束条件时强制跳出循环 ### break `break`命令允许跳出所有循环（终止执行后面的所有循环）。 ```bash #!/bin/bash while : # 无限循环 do echo -n "输入1到5之间的数字：" read num case $num in 1|2|3|4|5) echo "你输入的数字为：$num" ;; *) echo '你数的数字不在该区间，跳出循环' break;; esac done # 运行结果 user@PxeCtrlSys:~$ ./test.sh 输入1到5之间的数字：3 你输入的数字为：3 输入1到5之间的数字：6 你数的数字不在该区间，跳出循环 ``` ### continue 当执行到`continue`语句是，不会跳出循环，而是之后的语句不会继续执行 ```bash #!/bin/bash while : # 无限循环 do echo -n "输入1到5之间的数字：" read num case $num in 1|2|3|4|5) echo "你输入的数字为：$num" ;; *) echo '你数的数字不在该区间' continue echo "continue之后的不会再执行" ;; esac done # 运行结果 user@PxeCtrlSys:~$ ./test.sh 输入1到5之间的数字：3 你输入的数字为：3 输入1到5之间的数字：6 你数的数字不在该区间 输入1到5之间的数字：2 你输入的数字为：2 输入1到5之间的数字：^C ``` ### esac `case`的语法需要一个`esac`（就是`case`反过来）作为结束标记，每个`case`分支用右圆括号，用两个分号表示`break`。 # Shell输入/输出重定向 大多数Unix系统命令是从终端接受输入并将产生的输出发送回终端。一个命令通常从一个叫标准输入的地方读取，默认情况下，这恰好是终端。同样，一个命令通常将其输出写入到标准输出，默认情况下，也恰好时终端。 | 命令 | 说明 | | --------------- | ---------------------------------------------- | | command > file | 将输出重定向到 file。 | | command < file | 将输入重定向到 file。 | | command >> file | 将输出以追加的方式重定向到 file。 | | n > file | 将文件描述符为 n 的文件重定向到 file。 | | n >> file | 将文件描述符为 n 的文件以追加的方式重定向到 file。 | | n >& m | 将输出文件 m 和 n 合并。 | | n <& m | 将输入文件 m 和 n 合并。 | | << tag | 将开始标记 tag 和结束标记 tag 之间的内容作为输入。 | > 需要注意的是文件描述符 0 通常是标准输入（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）。 ## 输出重定向 重定向一般通过在命令间插入特定的符号来实现，类似于`command > file`，这个命令的意思就是将命令`command`的输出内容存入`file`，且`file`中已经存在的内容将被新内容替代。如果要将新内容添加到文件末尾，需要使用`>>`操作符。 ```bash user@PxeCtrlSys:~$ who > users user@PxeCtrlSys:~$ cat users user pts/0 2019-03-11 09:04 (192.168.96.16) user pts/1 2019-03-11 09:04 (192.168.96.16) ``` ### > 重定向覆盖 使用`>`并不会在终端显示内容，而是将`who`的输出保存到`users`这个文件中了。 ```bash user@PxeCtrlSys:~$ ls / > users user@PxeCtrlSys:~$ cat users bin boot dev etc home initrd.img lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var vmlinuz ``` 也就是说使用`>`如果再次重定向到同样的文件，该文件内容则会被覆盖。 ### >> 重定向追加 如果不希望覆盖，则使用`>>`追加方式。 ```bash user@PxeCtrlSys:~$ who >> users user@PxeCtrlSys:~$ cat users bin boot dev etc home initrd.img lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var vmlinuz user pts/0 2019-03-11 09:04 (192.168.96.16) user pts/1 2019-03-11 09:04 (192.168.96.16) ``` ## 输入重定向 和输出重定向类似，也可以从文件获取输入，语法为`command < file`，这样，本来需要从键盘获取输入的命令就会转移到从文件中读取内容。 ```bash user@PxeCtrlSys:~$ cat users user pts/0 2019-03-11 09:04 (192.168.96.16) user pts/1 2019-03-11 09:04 (192.168.96.16) # 获取文件的行数 user@PxeCtrlSys:~$ wc -l users 2 users # 输入重定向到文件，获取行数 user@PxeCtrlSys:~$ wc -l < users 2 ``` 结果不同：第一个例子，会输出文件名；第二个不会，因为它仅仅知道从标准输入读取内容。 ```bash command < infile > outfile ``` 同时替换输入和输出，执行command，从文件infile读取内容，然后将输出写入到outfile中。 ## 重定向深入讲解 一般情况下，每个 Unix/Linux 命令运行时都会打开三个文件： - 标准输入文件(stdin)：`stdin`的文件描述符为0，Unix程序默认从`stdin`读取数据。 - 标准输出文件(stdout)：`stdout` 的文件描述符为1，Unix程序默认向`stdout`输出数据。 - 标准错误文件(stderr)：`stderr`的文件描述符为2，Unix程序会向`stderr`流中写入错误信息。 默认情况下，`command > file` 将 `stdout` 重定向到 `file`，`command < file` 将`stdin` 重定向到 `file`。 ### stderr重定向到file 如果希望 `stderr` 重定向到 `file`，可以这样写： ```bash command 2 > file ``` ### stderr追加到file 如果希望 `stderr` 追加到 `file` 文件末尾，可以这样写： ```bash command 2 >> file ``` `2` 表示标准错误文件(stderr)。 ### stdout和stderr合并重定向到file 如果希望将 `stdout` 和 `stderr` 合并后重定向到 `file`，可以这样写： ```bash command > file 2>&1 或者 command >> file 2>&1 ``` ### stdin和stdout都重定向 如果希望对 `stdin` 和 `stdout` 都重定向，可以这样写（`command` 命令将 `stdin` 重定向到 `file1`，将 `stdout` 重定向到 `file2`。）： ```bash command < file1 > file2 ``` ## Here Document Here Document 是 Shell 中的一种特殊的重定向方式，用来将输入重定向到一个交互式 Shell 脚本或程序。 ```bash command << delimiter document delimiter ``` 它的作用是将两个 `delimiter` 之间的内容(document) 作为输入传递给 `command`。 delimiter：定界符、分隔符、分界符 - 结尾的`delimiter` 一定要顶格写，前面不能有任何字符，后面也不能有任何字符，包括空格和 tab 缩进。 - 开始的`delimiter`前后的空格会被忽略掉。 ```bash user@PxeCtrlSys:~$ wc -l << EOF shell python EOF # 输入完回车就在下方显示结果 2 ``` 将分隔符之间的文本显示出来 ```bash user@PxeCtrlSys:~$ cat << EOF > shell > python > EOF # 回车后就会输入下方结果 shell python ``` ## /dev/null 文件 如果希望执行某个命令，但又不希望在屏幕上显示输出结果，那么可以将输出重定向到 /`dev/null`： ```bash command > /dev/null ``` `/dev/null` 是一个特殊的文件，写入到它的内容都会被丢弃；如果尝试从该文件读取内容，那么什么也读不到。但是 `/dev/null` 文件非常有用，将命令的输出重定向到它，会起到"禁止输出"的效果。 如果希望屏蔽 `stdout` 和 `stderr`，可以这样写： ```bash command > /dev/null 2>&1 ``` > 注意：0 是标准输入（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）。 # Shell文件包含 Shell 也可以包含外部脚本。这样可以很方便的封装一些公用的代码作为一个独立的文件。 Shell 文件包含的语法格式如下： ```bash . filename # 注意点号(.)和文件名中间有一空格 或 source filename ``` 创建两个 shell 脚本文件。 test1.sh 代码如下 ```bash user@PxeCtrlSys:~$ vim test1.sh user@PxeCtrlSys:~$ cat test1.sh a=2 b=3 ``` test2.sh 代码如下 ```bash user@PxeCtrlSys:~$ vim test2.sh user@PxeCtrlSys:~$ cat test2.sh #!/bin/bash # 使用 . 号来引用test1.sh文件 . ./test1.sh # 或者使用下方的代码 # source ./test1.sh echo "从test1.sh引入的a的值为：$a，b的值为：$b" ``` 为 test2.sh 添加执行权限，运行结果 ```bash user@PxeCtrlSys:~$ chmod +x test2.sh user@PxeCtrlSys:~$ ./test2.sh 从test1.sh引入的a的值为：2，b的值为：3 ``` > 被包含的文件 test1.sh 不需要可执行权限。 参考学习两篇文章 http://www.runoob.com/linux/linux-shell.html http://c.biancheng.net/shell/

明人不说暗话 领红包就是支持！！！ 来都来了，再到页面底部看下呗~ ↓ ↓ ↓

本文地址： http://blog.starmeow.cn/detail/7ef605fc8dba5425d6965fbd4c8fbe1f/

很赞哦！ (0)