shell 编程简记

1. 环境变量

环境变量是指操作系统中记录一些配置信息的变量，这些变量在不同的程序之间共享，可以被操作系统或者 shell 脚本读取和修改。

环境变量也可以类比为各个语言中的全局变量，其作用域是全局的，所有的代码段或者说作用域都可以直接访问到这个变量。

1.1 查看环境变量

查看你环境变量的命令是 printenv 或 env 。

env # 查看全部环境变量,只有这一种方式
printenv # 查看全部环境变量
printenv [变量名] # 查看指定环境变量的值

比如

SHELL=/bin/bash
ROS_VERSION=2
SESSION_MANAGER=local/ruby:@/tmp/.ICE-unix/1804,unix/ruby:/tmp/.ICE-unix/1804
QT_ACCESSIBILITY=1
COLORTERM=truecolor
XDG_CONFIG_DIRS=/etc/xdg/xdg-ubuntu:/etc/xdg
XDG_MENU_PREFIX=gnome-
GNOME_DESKTOP_SESSION_ID=this-is-deprecated
GTK_IM_MODULE=fcitx
PKG_CONFIG_PATH=:/usr/local/lib/pkgconfig
ROS_PYTHON_VERSION=3
LANGUAGE=zh_CN:zh:en_US:en
QT4_IM_MODULE=fcitx
MANDATORY_PATH=/usr/share/gconf/ubuntu.mandatory.path
LC_ADDRESS=zh_CN.UTF-8
GNOME_SHELL_SESSION_MODE=ubuntu
LC_NAME=zh_CN.UTF-8
SSH_AUTH_SOCK=/run/user/1000/keyring/ssh
XMODIFIERS=@im=fcitx
DESKTOP_SESSION=ubuntu
PATH=/opt/ros/foxy/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/usr/local/cuda-11.8/bin
 

上面就是使用 printenv 命令查看到的环境变量。可以看出其中指定了很多系统重要的变量，如SHELL表明了bash所在的路径，因此我们可以直接访问到bash而不用指定路径。而DESKTOP_SESSION则表明当前的发行版是Ubuntu。

1.2 设置环境变量

设置环境变量的命令是 export 。
在设置环境变量前，先明确shell中的变量如何书写。

ENV=value # 等号左边为变量名，右边为变量值

这样就在shell中声明了一个变量。注意在一个shell中声明的变量，只对当前shell有效，不会影响其他shell。此时该变量只是普通的临时变量，不会被保存到环境变量中。

查看shell中的变量可以使用 echo 命令，echo可以将变量或者常量的值输出到终端。

echo "test echo"
test echo

因此也可以用来查看变量的值。

echo $ENV # 查看变量值
# 注意变量前要加$来取出其值

使用export来将变量导出为环境变量

export ENV # 将变量导出为环境变量
 
# 或者直接在export命令中指定变量名和值
export ENV=value

这样就可以在其他程序中使用该变量了。已经导出的环境变量可以直接全局赋值更改

ENV=new_value # 全局变量赋值

但是需要注意的是，对于使用命令行export导出的环境变量仅对该次会话生效，当关闭终端或者重新登录后，环境变量就会失效。如果想永久生效，需要修改系统配置文件。

1.3 修改配置文件来设置环境变量

在linux系统启动时，会自动按序读取一些配置文件并从中执行相应的shell命令。因此，我们只需要在这些配置文件中添加export命令，即可设置永久的环境变量。

在ubuntu(不同发行版有所不同)下，比较常用的有如下几个配置文件：

• /etc/profile.d目录下的.sh文件和~/.bashrc 文件 对用户的shell进行初始化和环境变量设置
• ._{/.bash_profile.d目录下的文件和}./bash_login 文件用于个别用户的shell环境初始化 用户登录时会读取内容

因此我们可以在这些文件中添加export命令来设置环境变量。

这里在选择在/etc/profile.d/目录下新建一个文件，叫做source_env.sh，并添加如下内容：

然后保存退出，执行

source /etc/profile.d/source_env.sh
# 这样可以直接生效，不需要重启系统

接着使用env或者printenv命令查看环境变量，就可以看到我们刚才设置的环境变量。

可以看到环境变量MYTEST已经被设置成功，并且可以被其他程序使用。

推荐使用新建文件的方式来添加自己的环境变量，这样可以避免对系统的其他部分造成影响，更加美观以及方便管理。

1.4 常用环境变量

对于比较常用的环境变量，这里给出一个，PATH环境变量

我们使用printenv查看PATH环境变量的值

printenv PATH
/usr/local/bin:/usr/local/sbin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/usr/local/cuda-11.8/bin

可以看到其中是一串以冒号分隔的目录路径，这些目录包含了一些系统命令的可执行文件路径，如ls、cd等常用命令，正是由于这些路径被记录在PATH环境变量中，我们才可以直接在命令行中使用这些命令。

可以使用witch + 空格 + 命令名 来查看某个命令的具体路径

which ls
/bin/ls

可以看到ls命令的具体路径是/bin/ls，而这个路径正是PATH环境变量中第一个目录/usr/bin中的一个。

因此在使用一些命令时报出command not found错误，可能是因为该命令的路径没有被添加到PATH环境变量中。可以使用locate命令来搜索带有某个关键字的文件路径，然后手动添加到PATH环境变量中。

locate ls # locate会搜索系统中所有文件名包含ls字符串的文件路径
/bin/ls 

然后将该路径添加到PATH环境变量中即可。

1.5 命令的别名

在shell中可以使用alias(翻译过来就是别名)来查看当前目录下所有命令的别名，也可以设置新的别名。

查看当前shell下所有命令的别名

alias

设置新的别名

alias 别名='原命令'

比如

alias ll='ls -l' # 设置ll命令的别名为ls -l
alias lll = 'ls -alh' # 设置lll命令的别名为ls -alh

这样就可以使用新的别名来代替原命令，如ll命令等价于ls -l，lll命令等价于ls -alh。

但是注意，设置的别名只对当前shell有效，不会影响其他shell。依旧可以将其加入到配置文件中，让其永久生效。

若要移除别名，可以使用unalias命令。

unalias 别名

比如

unalias ll

这样ll命令的别名就被移除了。
若想移除该shell下所有别名，可以使用unalias -a命令。

unalias -a

当然，unalias命令仅在该shell下有效，不会影响其他shell。

2. 输入与输出

linux最核心的思想就是一切皆文件，因此输入输出的控制也是由对应的文件来实现的。

2.1 终端的标准输入输出

在linux中，我们使用终端(terminal)来与计算机进行交互。终端的输入输出可以分为两种：

• 标准输入输出(stdin/stdout)：stdin(标准输入)是指键盘输入，stdout(标准输出)是指终端输出。
• 错误输出(stderr)：stderr(标准错误输出)是指终端输出错误信息。

打开一个终端，执行如下命令：

ls  -l /dev/{stdin,stdout,stderr}
 
lrwxrwxrwx 1 root root 15 6月  19  2024 /dev/stderr -> /proc/self/fd/2
lrwxrwxrwx 1 root root 15 6月  19  2024 /dev/stdin -> /proc/self/fd/0
lrwxrwxrwx 1 root root 15 6月  19  2024 /dev/stdout -> /proc/self/fd/1

可以看到在该终端下的stdin,stdout,stderr软链接到了/proc/self/fd/0,1,2三个文件上。而继续执行如下命令：

ls -l /proc/self/fd
lrwxrwxrwx 1 root root 0 6月  19  2024 /proc/self -> 10810

可以看到/proc/self目录下有一个软链接，指向当前进程的进程号。因此这样就可以知道当前进程的标准输入输出文件号。

2.2 管道

linux中的管道(pipe)是实现进程间通信的一种方式，它允许将一个进程的输出作为另一个进程的输入。

其语法如下：

命令1 | 命令2

其中，命令1的输出会作为命令2的输入。

以上一节的例子为例，我们可以编写一个简单的shell来尝试管道的功能

# in pipe.sh
echo "该进程的进程号为$$"   # echo $$ 输出当前终端的进程号

# in get.sh
read line # read + 变量名 可以从标准输入读取内容并赋值给变量
echo "读取到的行是：$line"

编写完这两个shell文件后赋予执行权限

chmod +x pipe.sh get.sh

然后运行

./pipe.sh |./get.sh

可以看到终端输出

该进程的进程号为10810

在使用管道符时，linux会隐式的创建一个临时的管道文件用来存储命令的输出，此时标准输出会软链到管道文件上，而标准输入则会软链到管道文件中读取内容。

当然，我们也可以显式的创建管道文件,称为具名管道

mkfifo  管道名 # 创建一个管道文件

这个管道文件是进程间通用的，可以被多个进程共享来读取。

可以使用cat命令或者echo >> 来读取和写入管道文件。

2.3 文件重定向

我们再理清2.1节中的一些概念。

• 对于每个终端，会有属于自己的进程号，并将其的输入输出以及错误输出文件号记录在/proc/self目录下。
• 而对于每个进程，其输入输出以及错误输出文件号被分配为0, 1, 2三个文件。
• 在不加更改的情况下，0, 1, 2都会软链到/dev/stdin, /dev/stdout, /dev/stderr三个文件上，来实现终端上的。

而linux中文件的重定向可以理解为可以不将0, 1, 2描述符链接到标准的输入输出{stdin,stdout,stderr}三兄弟，而是将其连接到其他位置上。

linux中的重定向简单的分为种

• 输出重定向，包含输出和错误输出
• 输入重定向

2.3.1 输出重定向

输出重定向分为两种：

• 覆盖输出(覆盖掉原来的内容)
• 追加输出(在原来的内容后面追加)

命令 > 文件名  # 覆盖输出
命令 >> 文件名 # 追加输出

比如123.txt文件内容为123

cat 123.txt > 456.txt
cat 456.txt
123
cat 123.txt > 456.txt
cat 456.txt
123
cat 123.txt >> 456.txt
cat 456.txt
123
123

cat命令可以读取文件内容，并将其标准输出到终端，此时文件符1软链至stdout

1->stdout

但是此时我们使用重定向符号，改变了文件符1的定向，在运行时相当于

1->456.txt

运行后文件符1重新软链到stdout。这就是输出重定向。

2.3.X 错误输出重定向

有时我们并不期望命令或可执行文件的标准输出，而是希望检测其运行状态，获取其退出时的错误输出，因此需要将错误输出重定向到文件。

错误输出重定向的语法如下：

命令 2> 文件名
命令 2>> 文件名 # 追加错误输出
# 也就是在标准输出符后面加上2，表示将错误输出重定向到文件

同时shell支持将错误输出与标准输出一同重定向到同一个文件，语法如下：

命令 &> 文件名

2.3.2 输入重定向

输入重定向也有两种

• 覆盖输入(覆盖掉原来的内容)
• 从标准输入读取内容，直到遇到结束符

命令 < 文件名  # 覆盖输入
命令 << 结束符 # 从标准输入读取内容，直到遇到结束符

给出一个shell文件 read.sh

read line
echo "读取到的行是：$line"

前面说过，read命令旨在从终端的标准输入中读取内容，并将其赋值给变量。

赋予read.sh权限后，运行如下命令

chmod +x read.sh
read.sh < 123.txt
读取到的行是：123

可以看到，read命令读取了123.txt文件的内容，并将其赋值给变量line。

与输出重定向类似，输入重定向会改变文件符0的定向。
在重定向前，文件符0软链至stdin

0->stdin

在重定向后，文件符0重新软链至123.txt

0->123.txt

因此，read命令不再从stdin中读取内容，而是从123.txt文件中读取内容。

还有一种用法就是从标准输入读取内容直到遇到结束符，并将其作为命令的输入。

cat << 结束符 # 从标准输入读取内容直到遇到结束符

比如

cat << EOF
hello 
1
2
EOF
# 读取结束
# 输出到终端
hello 
1
2

借助此种方法可以有这样的作用

cat << EOF > 123.txt

首先我们将输入重定向到直到遇到EOF才结束输入，然后将输出重定向到123.txt文件，这样就实现了检测关键字结束输入并将输入保存到指定文件。

错误输出重定向的语法用到的时候再去搜吧。

补充一个管道与输入重定向的错误区分。

# 假设存在a.txt且为空
 
echo "hello" >> a.txt
# 将echo的输出重定向到a.txt文件，并追加到文件末尾
 
echo "hello" | a.txt
# 管道运算符允许一个命令的输出作为另一个命令的输入，但是a.txt并没有接受输入的属性或语句，因此会报错
 
# 可以这样写
echo "hello" | cat >> a.txt

最后提一嘴，输入输出的重定向指的是将命令的标准输入输出重定向到文件，是命令与文件间的操作，因此不存在命令间的重定向，想要实现两个命令间的通信请使用管道。

2.3.3 命令展开

命令展开是指将命令的输出作为参数传递给其他命令的一种方式。

其中常用的展开有下面几种

• 通配符展开

ls * # 实际上是将*展开为当前目录的所有文件名作为参数传递给ls命令
ls ~ # 实际上是将～展开为家目录的绝对路径作为参数传递给ls命令
# echo命令使用*会打印当前目录的所有文件，使用～会打印家目录的绝对路径

• 算数表达式展开，$((表达式))

echo $((3+5)) # 输出8

• 变量展开，$变量名

name="Ruby"
echo $name # 输出Ruby
# 变量的访问实际上也是一种展开

• 花括号展开，{字符1,字符2,字符3,...}

echo {a,b,c} # 输出a b c
 
# 使用花括号+字符串
echo alpha_{a,b,c}.txt # 输出alpha_a.txt alpha_b.txt alpha_c.txt
# 可以这样使用
touch alpha_{a,b,c}.txt # 创建三个文件,alpha_a.txt alpha_b.txt alpha_c.txt
 
# 同时花括号支持范围展开
echo {1..10} # 输出1 2 3 4 5 6 7 8 9 10
echo {A..Z}  # 输出A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
# 实际上是在{字符1..字符2}的范围内使用Ascill码进行范围展开
 
# 结合这个用法可以批量创建连续文件
touch 2024-{1..12}.txt
# 创建了2024-1到2024-12的12个文件

• 命令展开

echo `ls *`
echo `cat 123.txt`
# or 
echo $(ls *)
echo $(cat 123.txt)
# 这种方法会将命令的输出展开为字符串，因此可以赋值操作
result=$(ls *) #or result=`ls *`
echo $result

• 引号内展开

在shell中，单引号括起来的字符串相当于python中的原始字符串，只会原样输出引号内的字符，不会进行任何格式化操作。而使用双引号括起来的字符串则会进行变量展开、命令展开、算数表达式展开等操作。

name="Ruby"
echo 'Hello, $name!' # 输出Hello, $name!
echo "Hello, $name!" # 输出Hello, Ruby!
echo "`ls /root/a.txt`" 
# or echo $(ls /root/a.txt)
# 输出/root/a.txt
# 在双引号中可以使用\对特殊字符进行转义
echo "Hello, \$name!" # 输出Hello, $name!

注意，无论单双引号，都不支持通配符以及花括号展开。因此类似于echo "ls *"会输出ls *而不是打印当前目录的所有文件。

3. shell脚本编程

3.1 一个简单的shell脚本

如前面所见，shell脚本的扩展名一般设为.sh，即便不加此扩展名也可以执行，但是约定使用.sh来标识该本件为一个shell脚本文件。

几乎所有在命令行中能执行的shell命令都可以在shell脚本中使用。

给出一个简单的shell脚本，test.sh

脚本的第一行一般使用固定格式#!bin/bash即#！加脚本解释器的绝对路径来指定使用哪个解释器来执行脚本。

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

然后赋予执行权限并执行

chmod +x test.sh
# 这里有两种执行shell脚本的方法
 
# 1. 直接执行
./test.sh
 
# 2. 指定解释器执行
bash test.sh
 
# 输出
Hello,World!

第一种方法中，会根据脚本第一行指定的解释器来对脚本进行解释执行，而第二种方法则是无论指定解释器为何，都将使用bash解释器来执行脚本。

3.2 变量

shell中的变量和python感觉差不多。

变量的定义为

# 变量名=变量值， 如
 
name="RubyRose" 
# 变量名的规范与大多语言相同
# 注意变量名与变量值间的等于号不能有空格

通常使用全大写的变量来表示一个常量，如

PI=3.141592653589793

想要使用echo输出变量值到终端，只需在变量名前加$符号

echo $name
# 若不加$,echo会默认将所有输入作为字符串输出
 
echo name
# 输出name

同时可以直接对变量名重新赋值来更改其值

name="Ruby"

对于变量有几个关键字

# readonly用来指定一个变量是只读不可改的，仅在声明时赋一次值
readonly name
name="else" # 这里会报错，因为name已经被声明为只读不可改
 
# unset用来删除一个变量,或者说来重置一个变量，变量的值会变为空
unset name
echo $name # 输出为空

值得注意的是，在赋值时，不加引号也会默认值为字符串值

alpha=rose
# 等价于
alpha="rose"

也就是说，shell中默认的变量类型为字符串。

3.3 字符串操作

在shell的打印输出(echo)中，会遇到一些格式化字符串的需求

name=Ruby
 
# 1. 字符串拼接，使用双引号
echo "Hello, $name!"
# 输出Hello, Ruby!
 
# 有时会有这样的需求
echo "Hello, $nameBBB"
# 此时变量名与字符串重合，而我们并没有定义nameBBB变量，输出空。
# 因此可以使用{}包裹变量名来解决这个问题
echo "Hello, ${name}BBB"
 
 
# 2. 原始字符串，使用单引号
echo 'Hello, $name!'
# 输出Hello, $name!,相当于python中的r"name"
 
# 3. 获取字符串长度
echo ${#name}
# 输出4

3.4 变量类型指定

shell中变量类型有三种

3.2节中已经讲过，shell中的变量默认为字符串类型，也就是说在不使用关键字指定的前提下，无法进行数值运算。

num1=10
num2=20
sum=$num1+$num2
echo $sum 
# 输出字符串10+20

因此在声明一些变量时，可以使用delcare关键字来指定变量的类型。

使用时的语法如下

declare [+/-] [变换属性] 变量名
 
# - 表示为变量增加属性
# + 表示为变量删除属性
# 变换属性有如下几种
 
# -i 整型
# -l 小写字母
# -u 大写字母
# -a 数组类型
# -A 关联数组类型(HashMap)
# -x 环境变量
# -r 只读变量
# -g 全局变量，shell中不加指定也默认为全局变量
# -p 显示变量类型

一些演示例子如下

1. 声明整型变量

declare -i num=10
declare -i num_=20
declare -i sum=$num+$num_
echo $sum # 输出30

值得一提的是，shell会将赋值尽量的转换到赋值对象所需要的类型，因此对于一个已经声明的整型变量，允许如下操作。

declare -i num
str1=10
str2=20 # 记得吗，str1和str2默认为字符串
num=$str1+$str2
echo $num # 输出30

同理也有

declare -i num=10
declare -i num_=10
str=$num+$num_ # str默认字符串，因此整型转换到字符串进行字符串拼接
echo $str # 输出10+10

2. 声明大小写字母变量

declare -l Lowname=RUBY
declare -u Upname=ruby
echo $Lowname # 输出ruby
echo $Upname # 输出RUBY

shell会将赋值的字符串根据变量声明时的属性来仅保留大写或者小写

3. 声明数组以及关联数组

数组也是shell中的一种基本类型,其可以使用declare -a来声明，亦可以直接声明，访问其元素与正常数组类似。

# 元素用小括号包裹，用空格分隔
declare -a arr=(1 2 3 4 5)
# or
arr=(1 2 3 4 5)
# or 直接声明
arr[0]=1 # 这里直接声明了一个数组，只有一个元素1
 
 
# 访问元素
echo $arr # 数组名指向第一个元素，输出1
echo ${arr[2]} # 输出1
echo ${arr[@]} or echo ${arr[*]} # 输出1 2 3 4 5
 
# 数组长度
echo ${#arr[@]} # 输出5,语法与输出字符串长度类似
 
# 添加元素
arr[5]=6 # 直接从最后一个元素的后面的索引赋值即可添加
echo ${arr[*]} # 输出1 2 3 4 5 6
# or
arr+=(6 7 8) # 也可以使用+=来添加元素或者一段数组
echo ${arr[*]} # 输出1 2 3 4 5 6 6 7 8
 
# 数组拼接
arr1=(1 2 3)
arr2=(4 5 6)
arr3=(${arr1[*]} ${arr2[*]}) # 注意有空格
echo ${arr3[*]} # 输出1 2 3 4 5 6
 

关于关联数组，shell中没有直接的声明方式，需要使用declare -A来声明，其用法与python中的Dict类似,赋值时以[键]=值的方式进行。

# 元素用小括号包裹，用空格分隔
declare -A arr=([id1]=11 [id2]=12 [id3]=13)
# or
declare -A arr
arr[id1]=11
arr[id2]=12
arr[id3]=13
# 即关联数组支持声明后直接使用键值对来添加元素，对于已经存在的键，会覆盖原值，对于不存在的键，会新增键值对。
 
# 访问元素
echo ${arr[id1]} # 输出11
echo ${arr[@]} or echo ${arr[*]} # 输出11 12 13，即只会输出值
 
# 想要遍历输出关联数组的键，可以加`!`
echo ${!arr[*]} # 输出id1 id2 id3
 
# 关联数组长度
echo ${#arr[@]} # 输出3

4. 声明环境变量

declare -x MYENV=123
echo $MYENV # 输出123
printenv MYENV # 输出123，说明确实导出到了环境变量

5. 声明只读变量

declare -r name=ruby
# 等价于 readonly name=ruby
name=else # 报错，不可修改

6. 显示变量类型

declare -p [...变量名] # 输出变量类型，可跟多个变量名

可以通过组合使用这些关键字来声明各种变量类型。

declare -ai arr=(1 2 3)
# or
declare -a -i arr=(1 2 3)
# 声明一个整型数组arr
arr[0]+=1
echo ${arr[0]} # 输出2

上述的声明后的变量可以使用+[属性]来取消其属性。

declare -l Lowname
Lowname=RUBY
echo $Lowname # 输出ruby
declare +l Lowname # 取消小写字母属性
Lowname=BIG
echo $Lowname # 输出BIG,属性失效

但是注意，+r选项并不能取消变量的只读属性，对一个只读变量使用+r选项会报错。

也可以使用typeset命令来声明变量类型，其语法与declare基本一致。

3.4.X 算数运算

因为shell中变量类型默认为字符串，因此无法直接进行数值运算。

a=10
b=20
sum=$a+$b
echo $sum # 输出字符串10+20,而非30

shell中提供了一些命令来进行数值运算。

在此之前，简单了解一下内建命令与外部命令的区别。

• 内建命令是在编译时与shell一起编译生成可执行文件的命令，自身已集成在shell内部，不需要访问外部的可执行文件来执行。
• 外部命令则是指需要调用外部可执行文件来执行的命令，如ls、cp、mv等。

可以通过type命令来查看某个命令是否为内建命令，而且使用which命令来查看内建命令时，一般找不到其路径，因为已经集成在shell内部。

type mv
mv 是 /usr/bin/mv # 说明mv是外部命令
which mv
/usr/bin/mv
 
type cd
cd 是 shell 内建
which cd 
# 输出空，内建命令找不到路径

下面开始介绍常用的算数运算命令。

1. 括号实现

# 使用$((...))来包裹算数表达式
result=$((10+20))
echo $result # 输出30
 
#or 
num1=10
num2=20
result=$(($num1*$num2))
echo $result # 输出200
 
 
#支持整数加(+),减(-),乘(*),除(/),乘方(**),取模(%)运算
 
#也支持位运算如左移(<<)、右移(>>)、按位与(&)、按位或(|)、按位异或(^)、逻辑非(~)

仅可以实现整数运算，非整除会截断为整数。

2. expr命令

# expr命令可以进行算数运算，其语法如下
expr [数] [运算符] [数]
 
# 其中数字和运算符各作为参数传入，需要用空格分隔。
 
# such as
expr 10 + 20 # 输出30
expr 10 / 20 # 输出0，因为除法运算结果为浮点数
expr 5 * 2   # 报错，因为*号是shell中的特殊字符,可以使用转义字符\来表示
expr 5 \* 2  # 输出10，因为\*表示*号本身
 
# 也可以赋值给变量
sum = $(expr 10 + 20)
# or
sun = `expr 10 + 20`
echo $sum # 输出30
 
# 注意，expr实现的运算仅有+-*/%
 

3. bc命令
   在终端中输入bc

bc

会出现以下

可以看出bc是linux中的一个可执行程序，用来进行算术运算。
其中支持加(+)减(-)乘(*)除(/)乘方(^)以及取非(!)运算。
但是仅可以执行表达式，不能直接赋值给变量。

1+2
3
5^2
25
!0
1
!5
0
quit # 输入quit退出bc

上面的方法仅支持整数运算。想要进行浮点数运算，可以使用-l选项来实现。

bc -l

然后就可以使用浮点数运算了。

6 / 4
1.50000000000000000000
quit
# 小数位有点多，可以直接在bc中使用scale命令来指定小数位数，直接截断，非四舍五入
bc -l
2/3
.666666666666666666666
scale=2 # 指定小数位数为2
2/3
.66
quit

在浮点数运算模式下bc提供了一些函数计算

s(x) 计算 sin(x)，以下x皆为弧度表示
c(x) 计算 cos(x)
a(x) 计算arctangent(x)
l(x) 计算ln(x)
e(x) 计算e的x次方，其中e为自然底数
x^y 计算x的y次方
sqrt(x) 计算根号下x
# 直接传入即可

可以看见bc执行后默认由标准输入读取表达式然后将结果到标准输出，因此可以使用管道向其输入表达式。

echo '1+2' | bc # 输出3
echo '6/4' | bc -l # 输出1.5000000000
# 多条命令使用分号;隔开
echo '1+2;2/3' | bc -l
3.0000000000
.66666666666
 
# 使用这个方法可以指定小数位数
echo 'scale=2;2/3' | bc -l
.66
 
# 在使用一些重定向就可以实现使用bc赋值
echo '1+2' | bc >> a.txt
# 将bc的输出重定向到a.txt文件末尾
 
# 也可以将bc的输出赋值给变量
result=$(echo '1+2' | bc)
# or 
result=`echo '1+2' | bc`

可以看到使用$([命令/命令表达式])or` [表达式] `的方法来将命令的输出赋值给变量。

4. let
   let命令一般与赋值操作结合实现数值运算。

# 使用let来进行数值运算
num1=10
num2=20
let sum=$num1+$num2
echo $sum # 输出30
# let 支持省略$来进行数值运算,则上述等同
let sum=num1+num2
echo $sum # 输出30

let支持加(+)减(-)乘(*)除(/)乘方(**)取模(%)运算
不支持位运算。
支持+=，-=等类似运算，支持自增自减运算。

num=0
let num++ # 自增
echo $num # 输出1
let num-- # 自减
echo $num # 输出0
let num+=10 # 加法赋值
echo $num # 输出10

# 对于并非使用let声明的变量，也可以使用let来进行数值运算
num=10
let num+=10
echo $num # 输出20
 
# 对于非数字的变量，let默认其值为0
alpha="b"
let alpha++ # 自增
echo $alpha # 输出1
alpha="b"
let alpha+=10
echo $alpha # 输出10
 

3.5 命令状态及其状态运算

3.5.1 命令状态码

在shell中，每条命令执行完毕后，都会返回一个退出状态(exit status)码,用来表示命令执行成功与否。其取值范围为0-255，0表示成功，非0表示失败，因此在使用退出状态码时大部分时间仅需要关注0与非0即可。

当执行完命令后，可以通过echo $?来打印出上一条命令的退出状态码。

ls a.txt # a.txt存在
echo $? # 输出0
 
ls b.txt # b.txt不存在
echo $? # 输出1

注意的是，与大多数语言不同，shell中表示成功的退出状态码为0(true)，表示失败的退出状态码为非0(false)。

在编写shell脚本时，执行脚本后的退出状态码默认为脚本最后一个语句的退出状态码。

#!/bin/bash
ls a.txt
ls b.txt

此脚本执行后，如果b.txt不存在，则退出状态码为1，否则为0。

当然，我们也可以通过exit命令来指定退出状态码。

#!/bin/bash
ls a.txt    
exit 0 # 表示成功

这样不论a.txt是否存在，脚本都会返回0作为退出状态码。0可以换成其他数字。

需要注意的是，exit后的语句不会执行，脚本执行到exit即结束。

3.5.2 test测试命令

test命令是一个用于条件判断的命令，其语法如下

test [表达式] -[选项] [表达式]
# or
test -[选项] [表达式]

其中选项有如下(真的很多)

# 数值比较，左边相对于右边
 
-eq	    #等于则为真(equal)
-ne	    #不等于则为真(not equal)
-gt	    #大于则为真(greater than)
-ge	    #大于等于则为真(greater than or equal)
-lt	    #小于则为真(less than)
-le	    #小于等于则为真(less than or equal)
# such as
test 10 -eq 10 # 该语句的状态码为0

# 字符串比较，左边在右边中出现则为真
 
=	    #等于则为真
!=	    #不相等则为真
-z 字符串 	#字符串的长度为零则为真
-n 字符串 	#字符串的长度不为零则为真
# such as
test "abc" = "abc" # 该语句的状态码为0
name=Ruby
test -z "$name" # 该语句的状态码为0，因为name的长度为3
test -n "$name" # 该语句的状态码为0，因为name的长度不为0
# 这里建议将字符串用双引号括起来，防止空变量名的情况发生。
如
test -n $non # 由于non变量为空，相当于test -z ，而该语句的状态码为0,因此本该输出0，实际输出1。

# 文件测试，文件测试命令用于测试文件是否存在、是否可读、是否可写、是否可执行等。
-e 文件名	#如果文件存在则为真
-r 文件名	#如果文件存在且可读则为真
-w 文件名	#如果文件存在且可写则为真
-x 文件名	#如果文件存在且可执行则为真
-s 文件名	#如果文件存在且至少有一个字符则为真
-d 文件名	#如果文件存在且为目录则为真
-f 文件名	#如果文件存在且为普通文件则为真
-c 文件名	#如果文件存在且为字符型特殊文件则为真
-b 文件名	#如果文件存在且为块特殊文件则为真
# such as
# 假设a.txt存在且可读
test -e a.txt # 该语句的状态码为0，因为a.txt存在
test -r a.txt # 该语句的状态码为0，因为a.txt存在且可读

上述这些选项前可以将！作为参数传入来对其逻辑取反，即本来

test ! -e a.txt # 此时若a.txt存在，则该语句的状态码为1，否则为0
#等价与[ ! -e a.txt ]
test "abc" != "abc" # 状态码为1，因为"abc"等于"abc"，只有不相等时才为真，状态吗为0。

这些选项之后用到再来查阅即可，太多了不可能一下记住。

当然shell提供了一种关于test更简单的写法

[ [表达式] -[选项] [表达式] ]
# or
[ -[选项] [表达式] ]
# 注意中括号与语句间均有一个空格
# such as
[ "abs" = "abs" ]
[ -z "$name" ]

3.5.3 逻辑运算符

与C++以及Python等语言类似，shell提供了一些逻辑运算符来进行条件判断，包括逻辑与(&&)、逻辑或(||)以及逻辑非(!)。

在了解shell中的逻辑运算符前，先了解两个shell中的内建命令true和false。

true # 该命令的退出状态码恒为0
false # 该命令的退出状态码恒为非0

1. 逻辑与

[表达式] && [表达式]
# or
[ [表达式] -a [表达式] ] # -a = and

该运算符用于判断两个表达式是否都为真，如果两个表达式的退出状态码都为0，则返回退出状态码为0,否则返回退出状态码为1，相应的，也会有逻辑短路的现象。

[ "abc" = "def" -a touch yes.txt ]
# 等价与 [ "abc" = "def" ] && touch yes.txt
 
# 显然字符串abc不等于def，因此无论后面是什么，都会返回1，同时后面的表达式也不会被执行，因此不会创建yes.txt文件。

2. 逻辑或

[表达式] || [表达式]
# or
[ [表达式] -o [表达式] ] # -o = or

该运算符用于判断两个表达式是否至少有一个为真，如果两个表达式的退出状态码有一个为0，则返回退出状态码为0,否则返回退出状态码为1，相应的，也会有逻辑短路的现象。

[ "abc" = "abc" -o touch yes.txt ]
# 等价与 [ "abc" = "abc" ] || touch yes.txt
# 显然字符串abc等于abc，无论后面是什么，都会返回0，因此后面的表达式touch yes.txt不会被执行，不会创建yes.txt文件。  

3. 逻辑非

! [表达式]
# or
[ ! [表达式] ]
[ [表达式] ！ -[选项] [表达式]]

该运算符用于对表达式取反，如果表达式的退出状态码为0，则返回退出状态码为1,否则返回退出状态码为0。

[! -e a.txt ]
# 等价与 -e a.txt 为假，即a.txt不存在，则返回0，否则返回1。
！ls a.txr
# 若a.txt存在，则返回1，否则返回0。
[ "abc" != "abc" ]
# 显然abc等于abc，!=不成立，因此返回1。

通过上述的逻辑运算符，我们可以写出一些复杂的条件判断语句，应用其短路特性达到if-else的效果。

[ -e a.txt ] && rm a.txt
# 若a.txt存在，则删除a.txt，否则什么都不做。
 
[ ! -e a.txt ] && touch a.txt
# 若a.txt不存在，则创建a.txt，否则什么都不做。

在考虑这几个运算符间的优先级时，直接用小括号最省脑子。

3.6 条件语句

3.6.1 if-else语句

shell中提供if-else来实现条件语句，当条件为真(退出状态码为0)时执行if块中的命令，否则执行else块中的命令。
其语法如下
最简单的if-else语句如下

if [条件]
then
    # 条件为真时执行的代码
fi  # 结束if语句
 
# shell中可以使用;来在一行分割命令，那么上面可以这样写
if [条件]; then echo "条件为真"; fi

带有else的if-else语句如下

if [条件]
then
    # 条件判断1为真时执行的代码
else
    # 条件判断1为假时执行的代码
fi # 结束if语句

或者带有elif的if-else语句如下

if [条件1]
then
    # 条件判断1为真时执行的代码
elif [条件2]
then
    # 条件判断2为真时执行的代码
else
    # 条件判断1和2都为假时执行的代码
fi # 结束if语句

多层嵌套的if-else使用缩进区分

if [条件1]
then
    if [条件2]
    then
        # 条件判断2为真时执行的代码
    fi
else
    if [条件3]
    then
        # 条件判断3为真时执行的代码
    fi
fi # 结束if语句

注意这里的条件为条件块，即使用如下

if [ 5 -gt 3 ]
    echo "5大于3"
else
    echo "5不大于3"
fi
# 可以组合逻辑运算符
num=10
if [ $num -gt 3 -a $num -lt 15 ]
    echo "num大于3且小于15"
else
    echo "num不大于3或大于15"
fi
上面等价与
if [ $num -gt 3 ] && [ $num -lt 15 ]
    echo "num大于3且小于15"
else
    echo "num不大于3或大于15"
fi

对于一些复杂的条件判断，可以使用逻辑运算符的短路特性来简化代码，这里就不举例子了。

3.6.2 case语句

case语句类似与C++中的switch语句，用于多分支条件判断。

case 变量 in
值1)
    # 变量等于值1时执行的代码
    ;;
值2)    
    # 变量等于值2时执行的代码
    ;;
*)
    # 变量不等于值1或2时执行的代码
esac

即对于每种模式，我们使用值)来充当类型case,然后使用;;来表示该模式结束。由于shell中没有default关键字，因此使用通配符*来匹配所有其他情况,最后使用esac来结束case语句。

很有意思的是，if-else和case语句的结束符都是其反写，即fi和esac。

这里提一嘴，shell中的匹配与正则表达式几乎一致。

case语句也支持使用|来用一种模式匹配多个情况。

read -p "请输入数字：" num # read的-p选项用于提示用户输入
case $num in
1|2|3)
    echo "你输入的数字是1、2、3中的一个"
    ;;
4|5|6)
    echo "你输入的数字是4、5、6中的一个"
    ;;
*)
    echo "你输入的数字不是1、2、3、4、5、6中的任何一个"
esac

同时可以使用正则表达式来匹配

read -p "请输入：：" str
case $str in
[0-9]*)
    echo "你输入的是数字"
    ;;
[a-zA-Z]*)
    echo "你输入的是字母"
    ;;
*)
    echo "你输入的不是数字也不是字母"
esac

3.7 循环语句

3.7.1 for循环

shell中提供了两种for的写法，一种是类似python的迭代for，一种是类似C语言条件for。

迭代for的语法如下

for 变量 in 值1 值2 值3...
do
   # 循环体
done
# 值1,2,3...也可为可迭代对象或者其他使用空格或者tab分隔的值,亦可以使用一些展开的语法来实现。
 
# such as 
for i in 1 2 5 
do 
   echo $i
done
# 输出1 2 5
 
for i in *
do 
   echo "$i"
done
# 打印当前目录下所有文件名
 
for i in {1..10}
do
   echo $i
done
# 打印1到10

条件for的语法如下

for (( 初始值; 条件; 步进值 ))
do
   # 循环体
done
# 初始值,条件,步进值均为数字,亦可使用一些变量来代替,注意使用双层小括号。
 
# such as 
for ((i=1; i<=10; i++))
do
   echo $i
done
# 输出1 2 3 4 5 6 7 8 9 10

也可以用来访问数组或者关联数组

arr=(1 2 3 4 5)
for val in ${arr[*]}
do
    echo $val
done
# 输出1 2 3 4 5
declare -A assoc_arr
assoc_arr[key1]=value1
assoc_arr[key2]=value2
for key in ${!assoc_arr[@]}
do
    echo $key : ${assoc_arr[$key]}
done
# 输出key1 : value1 key2 : value2

3.7.2 while与until循环

shell中提供了while和until循环，用于循环执行一段代码，直到条件为真或假。

其中while循环和until循环可以认为是两个相反的例子，while循环仅有表达式的退出状态码为0时(即为真或者说执行成功)去执行循环体，而until循环则是表达式的退出状态码为0时(即为真或者说执行成功)退出执行。

while [ 条件 ]
do
    # 循环体
done
 
until [ 条件 ]
do
    # 循环体
done
 
# such as
let cnt=0
while [ $cnt -le 5 ] # 循环条件为cnt小于等于5
do
    echo $cnt
    let cnt++
done
# 输出0 1 2 3 4 5
 
let cnt=0
until [ $cnt -ge 5 ] # 退出循环条件为cnt大于等于5
do
    echo $cnt
    let cnt++
done
# 输出0 1 2 3 4 5

3.7.3 循环控制语句break与continue

shell提供了向c/c++中类似的break和continue语句，用于控制循环的执行。

break用于跳出当前循环，continue用于跳过当前循环的剩余语句，并开始下一次循环。

let cnt=0
while [ $cnt -le 5]
do 
    echo $cnt
    let cnt++
    if [ $cnt -eq 3 ] # 若cnt等于3
    then
        break # 跳出当前循环
    fi
done
# 输出0 1 2
# 上面的if-else语句可以使用逻辑短路来简化
[ $cnt -eq 3 ] && break
 
# contine用于跳过当前循环的剩余语句，并开始下一次循环
let cnt=0
while [ $cnt -le 5 ]
do
    let cnt++
    [ $cnt -eq 3 ] && continue # 若cnt等于3,则跳过当前循环的剩余语句，并开始下一次循环
    echo $cnt
done
# 输出0 1 2 4 5

3.8 脚本传参

类似于ls a.txt，ls实际上也是一个可执行程序，我们向其中传入了a.txt作为参数。

在自己编写的shell中，我们可以使用$n来表示传递给脚本或函数的参数，其中n为参数的位置，从0开始。

# t.sh
#!/bin/bash
echo "第一个参数为：$1"
echo "第二个参数为：$2"
echo "第三个参数为：$3"
 
chmod +x t.sh # 使脚本可执行
./t.sh a b c # 执行脚本，并传入参数a,b,c
# 输出
# 第一个参数为：a
# 第二个参数为：b
# 第三个参数为：c

其中还有一些特殊符号

$0 运行脚本时提供的路径
$# 传递给脚本或函数的参数个数
$@ 传递给脚本或函数的所有参数

# t.sh
#!/bin/bash
for i in $@
do
    echo $i
done
# 输出所有参数
./t.sh "hello world" 123
# 输出
# hello 
# world
# 123
# 这是由于hello world虽然是一个参数,但是未加双引号的情况下参数会依据空白字符重新分割。因此需要使用双引号将$@括起来。
 
for i in "$@"
do
    echo $i
done
# 输出所有参数
./t.sh "hello world" 123
# 输出
# hello world
# 123
# "$@"会将每个参数使用双引号括起来，因此不会出现空格被遍历出来。

3.9 函数

shell中提供了函数的概念，可以将一系列命令封装成一个函数，然后在其他地方调用。

函数的写法有三种

# 第一种,使用function关键字来定义函数,同时函数名后面加上()
function 函数名() {
    # 函数体
}
 
# 第二种,省略function关键字,直接使用函数名加()
函数名() {
    # 函数体
}
 
# 第三种,使用关键字function来定义函数,省略函数名后的()
function 函数名{
    # 函数体
}
 
# 这三种写法的花括号都可以另起一行
func()
{
    echo "Hello, World!"
}
 
# 调用函数直接使用函数名即可
func
# 输出
# Hello, World!

shell中的函数也可以传参和使用返回值来传递数据。

其中传参的写法与向脚本传参的形式类似，而非像其他语言中在小括号中先声明参数。

func()
{
    echo "第一个参数为：$1" # 使用$n的形式获取第n个参数
    echo "第二个参数为：$2"
    echo "第三个参数为：$3"
 
    echo "所有参数为：$#" # 使用$#获取参数个数
    for i in "$@" # 使用@或*的形式获取所有参数
    do 
        echo $i 
    done
}

而函数的返回值可以通过return关键字来实现,执行完函数后使用$?来获取函数的退出状态码，即其返回值。

func()
{
    let sum=0
    for num in "$@"
    do
        let sum=sum+num
    done
    return $sum # 返回函数的返回值
}
func {1..5}
echo "函数的返回值为：$?" # 输出函数的返回值
# 输出
# 函数的返回值为：15

但是使用return仅能返回一个int值，因为本质上执行函数就是执行一个封装好的命令，返回实际上是返回了一个退出状态码，范围在0-255之间。因此大于255的返回值会溢出。

由于函数类似于命令，因此可以使用命令的展开来实现任意无限制的返回值。

func()
{
    let sum=0
    for num in "$@"
    do
        let sum=sum+num
    done
    echo "$sum"
}
res=`func {1..100}`
#or
res=$(func {1..100})
echo "函数的返回值为：$res"
# 输出 
# 函数的返回值为：5050

使用这种方法的返回可以不限制返回值的类型。

函数中的变量作用域默认是全局的，可以通过local关键字来声明局部变量。

而使用命令展开获取返回值时，即使不使用local声明，也无法修改和访问函数内部的变量。

3.10 grep命令

grep命令是linux中非常常用的命令，用于在指定文本中查找能够匹配上模式的行。模式可以是字符串，亦可以是正则表达式。匹配时区分大小写。

grep [选项] [模式] [文件]
其中常用的选项有
-i：忽略大小写进行匹配。
-v：反向查找，只打印不匹配的行。
-n：显示匹配行的行号。
-r：递归查找子目录中的文件。
-l：只打印匹配的文件名。
-c：只打印匹配的行数。
-w：匹配整个单词。
-q：静默模式，不打印任何信息。可以通过退出状态来判断是否匹配到。
-B 数字 ：打印匹配行之前的n行
-A 数字 ：打印匹配行之后的n行
-C 数字 ：打印匹配行前后各n行
 
# 当grep匹配到行时，退出状态码为0，否则为1。
# 匹配到多个行时，会将所有匹配的行打印出来。

a.txt
cat1
cat2
cat3
cat4
 
grep "cat" a.txt
# 输出
# cat1
# cat2
# cat3
# cat4
echo "$?" # 输出0
 
grep "dog" a.txt
echo "$?" # 输出1
 
grep -w "cat" a.txt # 匹配整个单词
echo "$?"  # 输出1

使用管道可以结合其他命令的输出来使用grep

cat a.txt | grep "cat"
# 作用与 grep "cat" a.txt 相同,这里使用管道将cat的输出作为grep的输入
 
ls * | grep *.txt
# 找到当前目录下所有以.txt结尾的文件名