Shell编程基础入门

古城微笑少年丶 2023-02-26 04:19 53阅读 0赞

## **【1】什么是Shell** ##

### ① shell定义 ###

**下面是从[百度百科][Link 1]摘取的定义。**

> 在计算机科学中，Shell俗称壳（用来区别于核），是指“为使用者提供操作界面”的软件（命令解析器）。它类似于DOS下的command.com和后来的cmd.exe。它接收用户命令，然后调用相应的应用程序。  
> 同时它又是一种程序设计语言。作为命令语言，它交互式解释和执行用户输入的命令或者自动地解释和执行预先设定好的一连串的命令；作为程序设计语言，它定义了各种变量和参数，并提供了许多在高级语言中才具有的控制结构，包括循环和分支。

**从《Linux CommanLine》中摘取的释义：**

> 一说到命令行，我们真正指的是shell。shell 就是一个程序，它接受从键盘输入的命令，然后把命令传递给操作系统去执行。几乎所有的Linux 发行版都提供一个名为bash 的来自GNU项目的shell 程序。“bash”是“Bourne Again SHell”的首字母缩写，所指的是这样一个事实，bash 是最初Unix 上由Steve Bourne 写成shell 程序sh 的增强版。

**在Linux/Unix中示意图如下(橘黄色的是内核)：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70_pic_center]

### ② shell的分类 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">shell类别</th> 
   <th align="left">易学性</th> 
   <th align="left">可移植性</th> 
   <th align="left">编辑性</th> 
   <th align="left">快捷性</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Bourne shell (sh)</td> 
   <td align="left">容易</td> 
   <td align="left">好</td> 
   <td align="left">较差</td> 
   <td align="left">较差</td> 
  </tr> 
  <tr> 
   <td align="left">Korn shell ( ksh)</td> 
   <td align="left">较难</td> 
   <td align="left">较好</td> 
   <td align="left">好</td> 
   <td align="left">较好</td> 
  </tr> 
  <tr> 
   <td align="left">Bourne Again shell ( bash)</td> 
   <td align="left">难</td> 
   <td align="left">较好</td> 
   <td align="left">好</td> 
   <td align="left">好</td> 
  </tr> 
  <tr> 
   <td align="left">POSIX shell ( psh)</td> 
   <td align="left">较难</td> 
   <td align="left">好</td> 
   <td align="left">好</td> 
   <td align="left">较好</td> 
  </tr> 
  <tr> 
   <td align="left">C shell ( csh)</td> 
   <td align="left">较难</td> 
   <td align="left">差</td> 
   <td align="left">较好</td> 
   <td align="left">较好</td> 
  </tr> 
  <tr> 
   <td align="left">TENEX/TOPS C shell ( tcsh)</td> 
   <td align="left">难</td> 
   <td align="left">差</td> 
   <td align="left">好</td> 
   <td align="left">好</td> 
  </tr> 
 </tbody> 
</table>

Shell的两种主要语法类型有Bourne和C，这两种语法彼此不兼容。Bourne家族主要包括`sh、ksh、Bash、psh、zsh`；C家族主要包括：`csh、tcsh` （Bash和zsh在不同程度上支持csh 的语法）。

我们可以通过/etc/shells文件来查询Linux支持的Shell。命令如下：`vim /etc/shells`

/bin/sh
    /bin/bash
    /usr/bin/sh
    /usr/bin/bash
    /bin/tcsh
    /bin/csh

### ③ shell脚本执行的两种方式 ###

编写一个测试脚本hello.sh:

echo "this is test"

Shell脚本写好了，那么这个脚本该如何运行呢？在Linux中脚本的执行主要有这样两种种方法：

*  赋予执行权限，直接运行

这种方法是最常用的Shell脚本运行方法，也最为直接简单。就是赋予执行权限之后，直接运行。当然运行时可以使用绝对路径，也可以使用相对路径运行。命令如下：

#赋予执行权限
    [root@localhost sh]# chmod 755 hello.sh
    #使用绝对路径运行
    [root@localhost sh]# /root/sh/hello.sh
    this is test
    #使用相对路径运行
    [root@localhost sh]# ./hello.sh

*  通过Bash调用执行脚本

这种方法也非常简单，命令如下：

[root@localhost sh]# bash hello.sh
    this is test

脚本中通常可以看到第一行有如下所示，这是定义该脚本为/bin/bash这种shell。也是Linux下默认的shell。

#! /bin/bash
    //...

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

## **【2】Bash的基本功能** ##

### ① 命令别名 ###

查询命令别名：`alias`:

[root@bogon init.d]# alias
    alias cp='cp -i'
    alias egrep='egrep --color=auto'
    alias fgrep='fgrep --color=auto'
    alias grep='grep --color=auto'
    alias l.='ls -d .* --color=auto'
    alias ll='ls -l --color=auto'
    alias ls='ls --color=auto'
    alias mv='mv -i'
    alias rm='rm -i'
    alias which='alias | /usr/bin/which --tty-only --read-alias --show-dot --show-tilde'

如上所示，当我们平时使用rm命令时，其自动给我们附加了`-i`参数。

设定命令别名：`alias 别名='原命令'`

[root@bogon init.d]# alias vi='vim'
    #定义vim命令的别名是vi

**`既然我们说别名的优先级比命令高，那么命令执行时具体的顺序是什么呢？`** 命令执行时的顺序是这样的：

>  *  第一顺位执行用绝对路径或相对路径执行的命令。
>  *  第二顺位执行别名。
>  *  第三顺位执行Bash的内部命令。
>  *  第四顺位执行按照`$PATH`环境变量定义的目录查找顺序找到的第一个命令。

为了让这个别名永久生效，可以把别名写入环境变量配置文件“`~/.bashrc`”。命令如下：

[root@localhost ~]# vi /root/.bashrc
    source /root/.bashrc
    #使配置文件的环境变量生效而不用重新登录

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

### ② Bash常用快捷键 ###

<table> 
 <thead> 
  <tr> 
   <th align="center">快捷键</th> 
   <th align="left">作 用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">ctrl+A</td> 
   <td align="left">把光标移动到命令行开头。如果我们输入的命令过长，想要把光标移动到命令行开头时使用。</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+E</td> 
   <td align="left">把光标移动到命令行结尾。</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+C</td> 
   <td align="left">强制终止当前的命令。</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+L</td> 
   <td align="left">清屏，相当于clear命令。</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+U</td> 
   <td align="left">删除或剪切光标之前的命令。我输入了一行很长的命令，不用使用退格键一个一个字符的删除，使用这个快捷键会更加方便</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+K</td> 
   <td align="left">删除或剪切光标之后的内容。</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+Y</td> 
   <td align="left">粘贴ctrl+U或ctrl+K剪切的内容。</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+R</td> 
   <td align="left">在历史命令中搜索，按下ctrl+R之后，就会出现搜索界面，只要输入搜索内容，就会从历史命令中搜索。</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+D</td> 
   <td align="left">退出当前终端</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+Z</td> 
   <td align="left">暂停，并放入后台</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+S</td> 
   <td align="left">暂停屏幕输出</td> 
  </tr> 
  <tr> 
   <td align="center">ctrl+Q</td> 
   <td align="left">恢复屏幕输出</td> 
  </tr> 
 </tbody> 
</table>

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

### ③ 输入输出重定向 ###

**3.1 Bash的标准输入输出**

<table> 
 <thead> 
  <tr> 
   <th>设备</th> 
   <th>设备文件名</th> 
   <th>文件描述符</th> 
   <th>类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>键盘</td> 
   <td>/dev/stdin</td> 
   <td>0</td> 
   <td>标准输入</td> 
  </tr> 
  <tr> 
   <td>显示器</td> 
   <td>/dev/stdout</td> 
   <td>1</td> 
   <td>标准输出</td> 
  </tr> 
  <tr> 
   <td>显示器</td> 
   <td>/dev/stderr</td> 
   <td>2</td> 
   <td>标准错误输出</td> 
  </tr> 
 </tbody> 
</table>

**3.2 输出重定向**

<table> 
 <thead> 
  <tr> 
   <th>类 型</th> 
   <th>符 号</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>标准输出重定向</code></td> 
   <td>命令 &gt; 文件</td> 
   <td>以覆盖的方式，把命令的正确输出输出到指定的文件或设备当中。</td> 
  </tr> 
  <tr> 
   <td>标准输出重定向</td> 
   <td>命令 &gt;&gt; 文件</td> 
   <td>以追加的方式，把命令的正确输出输出到指定的文件或设备当中。</td> 
  </tr> 
  <tr> 
   <td><code>标准错误输出重定向</code></td> 
   <td>错误命令 2&gt;文件</td> 
   <td>以覆盖的方式，把命令的错误输出输出到指定的文件或设备当中。</td> 
  </tr> 
  <tr> 
   <td>标准错误输出重定向</td> 
   <td>错误命令 2&gt;&gt;文件</td> 
   <td>以追加的方式，把命令的错误输出输出到指定的文件或设备当中。</td> 
  </tr> 
  <tr> 
   <td><code>正确输出和错误输出同时保存</code></td> 
   <td>命令 &gt; 文件 2&gt;&amp;1</td> 
   <td>以覆盖的方式，把正确输出和错误输出都保存到同一个文件当中。</td> 
  </tr> 
  <tr> 
   <td>正确输出和错误输出同时保存</td> 
   <td>命令 &gt;&gt; 文件 2&gt;&amp;1</td> 
   <td>以追加的方式，把正确输出和错误输出都保存到同一个文件当中。</td> 
  </tr> 
  <tr> 
   <td>正确输出和错误输出同时保存</td> 
   <td>命令 &amp;&gt;文件</td> 
   <td>以覆盖的方式，把正确输出和错误输出都保存到同一个文件当中。</td> 
  </tr> 
  <tr> 
   <td>正确输出和错误输出同时保存</td> 
   <td>命令 &amp;&gt;&gt;文件</td> 
   <td>以追加的方式，把正确输出和错误输出都保存到同一个文件当中。</td> 
  </tr> 
  <tr> 
   <td>正确输出和错误输出同时保存</td> 
   <td>命令&gt;&gt;文件1 2&gt;&gt;文件2</td> 
   <td>把正确的输出追加到文件1中，把错误的输出追加到文件2中。</td> 
  </tr> 
 </tbody> 
</table>

`命令 >> 文件 2>&1`可以解释为：把命令正确输出保存到文件中，错误输出保存到正确输出里。

如果错误输出不想保存到文件，可以使用如下命令：`命令>>文件 2>>/dev/null` 就会丢弃错误输出。

**3.3 输入重定向**

输入重定向即改变默认从键盘输入，而从某个文件进行读取，通常是`<`号。如下以wc命令实例说明。

语法格式：

wc [选项] [文件名]

选项：

-c 统计字节数
    -w 统计单词数
    -l 统计行数

#具体实例如下
    [root@bogon init.d]# wc -l abc
    15 abc
    [root@bogon init.d]# wc < abc
     15  27 199
    [root@bogon init.d]# wc abc
     15  27 199 abc

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

### ④ 多命令顺序执行 ###

<table> 
 <thead> 
  <tr> 
   <th>多命令执行符</th> 
   <th>格式</th> 
   <th>作 用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>；</code></td> 
   <td>命令1 ；命令2</td> 
   <td>多个命令顺序执行，命令之间没有任何逻辑联系</td> 
  </tr> 
  <tr> 
   <td><code>&amp;&amp;</code></td> 
   <td>命令1 &amp;&amp; 命令2</td> 
   <td>当命令1正确执行（<code>$?=0</code>），则命令2才会执行<br>当命令1执行不正确（<code>$?≠0</code>），则命令2不会执行</td> 
  </tr> 
  <tr> 
   <td><code>||</code></td> 
   <td><code>命令1 || 命令2</code></td> 
   <td>当命令1 执行不正确（<code>$?≠0</code>），则命令2才会执行<br>当命令1正确执行（<code>$?=0</code>），则命令2不会执行</td> 
  </tr> 
 </tbody> 
</table>

### ⑤ Bash中的特殊符号 ###

**5.1 通配符**

<table> 
 <thead> 
  <tr> 
   <th>通配符</th> 
   <th align="left">作 用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>?</code></td> 
   <td align="left">匹配一个任意字符</td> 
  </tr> 
  <tr> 
   <td><code>*</code></td> 
   <td align="left">匹配0个或任意多个任意字符，也就是可以匹配任何内容</td> 
  </tr> 
  <tr> 
   <td><code>[]</code></td> 
   <td align="left">匹配中括号中任意一个字符。例如：[abc]代表一定匹配一个字符，或者是a，或者是b，或者是c。</td> 
  </tr> 
  <tr> 
   <td><code>[-]</code></td> 
   <td align="left">匹配中括号中任意一个字符，-代表一个范围。例如：[a-z]代表匹配一个小写字母。</td> 
  </tr> 
  <tr> 
   <td><code>[^]</code></td> 
   <td align="left">逻辑非，表示匹配不是中括号内的一个字符。例如：[^0-9]代表匹配一个不是数字的字符。</td> 
  </tr> 
 </tbody> 
</table>

[root@localhost tmp]# ls *
    012 0abc abc abcd
    #“*”代表所有的文件
    
    [root@localhost tmp]# ls ?abc
    0abc
    #“?”匹配任意一个字符，所以会匹配0abc
    #但是不能匹配abc，因为“?”不能匹配空
    
    [root@localhost tmp]# ls [0-9]*
    012 0abc
    #匹配任何以数字开头的文件
    
    [root@localhost tmp]# ls [^0-9]*
    abc abcd
    #匹配不已数字开头的文件

**5.2 其他特殊符号**

<table> 
 <thead> 
  <tr> 
   <th>符 号</th> 
   <th align="left">作 用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>''</code></td> 
   <td align="left">单引号。在单引号中所有的特殊符号，如“$”和“`”(反引号)都没有特殊含义。</td> 
  </tr> 
  <tr> 
   <td><code>""</code></td> 
   <td align="left">双引号。在双引号中特殊符号都没有特殊含义，但是“$”、“`”和“\”是例外，拥有“调用变量的值”、“引用命令”和“转义符”的特殊含义。</td> 
  </tr> 
  <tr> 
   <td>``</td> 
   <td align="left">反引号。反引号括起来的内容是系统命令，在Bash中会先执行它。和<code>$()</code>作用一样，不过推荐使用$()，因为反引号非常容易看错。</td> 
  </tr> 
  <tr> 
   <td>$()</td> 
   <td align="left">和反引号作用一样，用来引用系统命令。</td> 
  </tr> 
  <tr> 
   <td>()</td> 
   <td align="left">用于一串命令执行时，()中的命令会在子Shell中运行</td> 
  </tr> 
  <tr> 
   <td>{}</td> 
   <td align="left">用于一串命令执行时，{}中的命令会在当前Shell中执行。也可以用于变量变形与替换。</td> 
  </tr> 
  <tr> 
   <td>[]</td> 
   <td align="left">用于变量的测试。</td> 
  </tr> 
  <tr> 
   <td>#</td> 
   <td align="left">在Shell脚本中，#开头的行代表注释。</td> 
  </tr> 
  <tr> 
   <td>$</td> 
   <td align="left">用于调用变量的值，如需要调用变量name的值时，需要用$name的方式得到变量的值。</td> 
  </tr> 
  <tr> 
   <td>\</td> 
   <td align="left">转义符，跟在\之后的特殊符号将失去特殊含义，变为普通字符。如<code>\$</code>将输出<code>“$”</code>符号，而不当做是变量引用。</td> 
  </tr> 
 </tbody> 
</table>

#定义变量
    [root@bogon dev]# name=jane
    #输出变量值
    [root@bogon dev]# echo $name
    jane
    
    #先执行date命令结果赋值给a
    [root@bogon dev]# a=$(date)
    [root@bogon dev]# echo $a
    Tue Jul 14 16:08:45 CST 2020
    
    #输出命令组合的返回结果：某个应用程序的进程ID
    [root@bogon dev]# echo $(ps -ef|grep yihuiyuan|awk 'NR==1{printf $2 "\n"}')
    13099
    
    
    #使用反引号
    [root@bogon dev]# a=`date`
    [root@bogon dev]# echo $a
    Tue Jul 14 16:10:36 CST 2020

**5.3 小括号()与大括号\{\}**

如果是用于一串命令的执行，那么小括号和大括号的主要区别在于：

*  ()执行一串命令时，需要重新开一个子shell进行执行
 *  \{\}执行一串命令时，是在当前shell执行；
 *  ()和\{\}都是把一串的命令放在括号里面，并且命令之间用;号隔开；
 *  ()最后一个命令可以不用分号；
 *  \{\}最后一个命令要用分号；
 *  \{\}的第一个命令和左括号之间必须要有一个空格；
 *  ()里的各命令不必和括号有空格；
 *  ()和\{\}括号里面的某个命令的重定向只影响该命令，但括号外的重定向则影响到括号里的所有命令。

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

## **【3】Bash的变量** ##

### ① Bash中的变量 ###

在定义变量时，有一些规则需要遵守：

*  变量名称可以由字母、数字和下划线组成，但是不能以数字开头。如果变量名是“2name”则是错误的。
 *  在Bash中，变量的默认类型都是字符串型，如果要进行数值运算，则必修指定变量类型为数值型。
 *  变量用等号连接值，等号左右两侧不能有空格。
 *  变量的值如果有空格，需要使用单引号或双引号包括。如：“test=“hello world!””。其中双引号括起来的内容`“$”、“\”和反引号`都拥有特殊含义，而单引号括起来的内容都是普通字符。
 *  在变量的值中，可以使用`“\”`转义符。
 *  如果需要增加变量的值，那么可以进行变量值的叠加。不过变量需要用`双引号`包含`"$变量名"`或用`${变量名}`包含变量名
 *  如果是把命令的结果作为变量值赋予变量，则需要使用反引号或`$()`包含命令
 *  环境变量名建议大写，便于区分

变量叠加实例如下：

[root@localhost ~]# test=123
    [root@localhost ~]# test="$test"456
    [root@localhost ~]# echo $test
    123456
    #叠加变量test，变量值变成了123456
    [root@localhost ~]# test=${test}789
    [root@localhost ~]# echo $test
    123456789
    #再叠加变量test，变量值编程了123456789

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

### ② 变量的分类 ###

*  用户自定义变量：这种变量是最常见的变量，由用户自由定义变量名和变量的值。
 *  环境变量：这种变量中主要保存的是和系统操作环境相关的数据，比如当前登录用户，用户的家目录，命令的提示符等。环境变量的变量名可以自由定义，但是一般对系统起作用的环境变量的变量名是系统预先设定好的。
 *  位置参数变量：这种变量主要是用来向脚本当中传递参数或数据的，变量名不能自定义，变量作用是固定的。
 *  预定义变量：是Bash中已经定义好的变量，变量名不能自定义，变量作用也是固定的。

**2.1 变量查看**

语法格式：`set 选项`，直接使用set命令，会查询系统中所有的变量，包含用户自定义变量和环境变量。  
选项：

-u： 如果设定此选项，调用未声明变量时会报错（默认无任何提示）
    -x: 如果设定此选项，在命令执行之前，会把命令先输出一次

set -u可以用来测试变量是否存在。变量值为空与变量是否存在是两个概念。

[root@bogon shell]# set -u
    [root@bogon shell]# echo $y
    -bash: y: unbound variable

**2.2 变量删除**

语法格式：`unset 变量名`

#定义变量
    [root@bogon dev]# name=jane
    #输出值
    [root@bogon dev]# echo $name
    jane
    #删除变量
    [root@bogon dev]# unset name
    [root@bogon dev]# echo $name
    
    #这里为空，表示变量已经不存在

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

### ③ 环境变量 ###

**3.1 设置环境变量**

#使用export声明的变量即是环境变量
    export age="18"

**3.2 环境变量的查询和删除**

env命令和set命令的区别是，set命令可以查看所有变量，而env命令只能查看环境变量。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70]  
常见变量说明：

BASH=/bin/bash 	#Bash的位置
    BASH_VERSINFO=([0]="4" [1]="1" [2]="2" [3]="1" [4]="release"
    [5]="i386-redhat-linux-gnu") 	#Bash版本
    BASH_VERSION='4.1.2(1)-release' 	#bash的版本
    COLORS=/etc/DIR_COLORS 	#颜色记录文件
    HISTFILE=/root/.bash_history 	#历史命令保存文件
    HISTFILESIZE=1000 	#在文件当中记录的历史命令最大条数
    HISTSIZE=1000 	#在缓存中记录的历史命令最大条数
    LANG=zh_CN.UTF-8 	#语系环境
    MACHTYPE=i386-redhat-linux-gnu 	#软件类型是i386兼容类型
    MAILCHECK=60 	#每60秒去扫描新邮件
    PPID=2166 	#父shell的PID。我们当前Shell是一个子shell
    PS1='[\u@\h \W]\$ ' 	#命令提示符
    PS2='> ' 	#如果命令一行没有输入完成，第二行命令的提示符
    UID=0 	#当前用户的UID

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

### ④ PATH变量 ###

PATH是系统查找命令的路径。 PATH变量的值是用`“：”`分割的路径，这些路径就是系统查找命令的路径。也就是说当我们输入了一个程序名，如果没有写入路径，系统就会到PATH变量定义的路径中去寻找，是否有可以执行的程序。如果找到则执行，否则会报“命令没有发现”的错误。

如果我们把自己的脚本拷贝到PATH变量定义的路径中，我们自己写的脚本也可以不输入路径而直接运行。当然也可以选择修改PATH变量的值，而不是把程序脚本复制到/bin/目录中

#查看PATH值
    [root@bogon dev]# echo $PATH
    /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin
    #修改PATH值
    [root@bogon dev]# PATH="$PATH":/root/sh
    #查看修改后的PATH值
    [root@bogon dev]# echo $PATH
    /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/root/sh

当然我们这样定义的PATH变量只是临时生效，一旦重启或注销就会消失，如果想要永久生效，需要写入环境变量配置文件。

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

### ⑤ 位置参数变量 ###

<table> 
 <thead> 
  <tr> 
   <th>位置参数变量</th> 
   <th align="left">作 用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>$n</code></td> 
   <td align="left">n为数字，<code>$0</code>代表命令本身，<code>$1-$9</code>代表第一到第九个参数，十以上的参数需要用大括号包含，如<code>${10}</code>.</td> 
  </tr> 
  <tr> 
   <td><code>$*</code></td> 
   <td align="left">这个变量代表命令行中所有的参数，<code>$*</code>把所有的参数看成一个整体</td> 
  </tr> 
  <tr> 
   <td><code>$@</code></td> 
   <td align="left">这个变量也代表命令行中所有的参数，不过<code>$@</code>把每个参数区分对待</td> 
  </tr> 
  <tr> 
   <td><code>$#</code></td> 
   <td align="left">这个变量代表命令行中所有参数的个数</td> 
  </tr> 
 </tbody> 
</table>

**5.1 `$n`参数实例count.sh**

[root@bogon shell]# vim count.sh
    #!/bin/bash
    num1=$1
    #给num1变量赋值是第一个参数
    num2=$2
    #给num2变量赋值是第二个参数
    sum=$(( num1 + num2))
    #变量sum的和是num1加num2
    echo $sum
    #打印变量sum的值

> 需要告诉shell是数字变量进行相加，所以需要用到`$(())`，注意非`$()`

测试count.sh:

[root@bogon shell]# ./count.sh 11 22
    33

**5.2 参数实例parameter.sh**

#!/bin/bash
    echo "A total of $# parameters"
    #使用$#代表所有参数的个数
    echo "The parameters is: $*"
    #使用$*代表所有的参数
    echo "The parameters is: $@"
    #使用$@也代表所有参数

parameter.sh测试实例：

[root@bogon shell]# ./parameter.sh 11 22 33
    A total of 3 parameters
    The parameters is: 11 22 33
    The parameters is: 11 22 33

那么`“$*”和“$@”`有区别吗？还是有区别的，`$*`会把接收的所有参数当成一个整体对待，而`$@`则会区分对待接收到的所有参数。

**5.3 参数实例parameter2.sh**

[root@localhost sh]# vi parameter2.sh
    #!/bin/bash
    for i in "$*"
    #定义for循环，in后面有几个值，for会循环多少次，注意“$*”要用双引号括起来
    #每次循环会把in后面的值赋予变量i
    #Shell把$*中的所有参数看成是一个整体，所以这个for循环只会循环一次
    do
    echo "The parameters is: $i"
    #打印变量$i的值
    done
    
    x=1
    #定义变量x的值为1
    for y in "$@"
    #同样in后面的有几个值，for循环几次，每次都把值赋予变量y
    #可是Shell中把“$@”中的每个参数都看成是独立的，所以“$@”中有几个参数，就会循环几次
    do
    echo "The parameter$x is: $y"
    #输出变量y的值
    x=$(( $x +1 ))
    #然变量x每次循环都加1，为了输出时看的更清楚
    done

脚本测试如下：

[root@bogon shell]# ./parameter2.sh 11 22 33
    The parameters is: 11 22 33
    The parameter1 is: 11
    The parameter2 is: 22
    The parameter3 is: 33

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

### ⑥ 预定义变量 ###

<table> 
 <thead> 
  <tr> 
   <th>预定义变量</th> 
   <th align="left">作 用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>$？</code></td> 
   <td align="left">最后一次执行的命令的返回状态。如果这个变量的值为0，证明上一个命令正确执行；<br>如果这个变量的值为非0（具体是哪个数，由命令自己来决定），则证明上一个命令执行不正确了。</td> 
  </tr> 
  <tr> 
   <td><code>$$</code></td> 
   <td align="left">当前进程的进程号（PID）</td> 
  </tr> 
  <tr> 
   <td><code>|$!</code></td> 
   <td align="left">后台运行的最后一个进程的进程号（PID）</td> 
  </tr> 
 </tbody> 
</table>

`$?`命令测试如下：

[root@bogon shell]# ls
    count.sh  parameter2.sh  parameter.sh  test1.txt
    [root@bogon shell]# echo $?
    0
    #预定义变量“$?”的值是0，证明上一个命令执行正确
    
    [root@bogon shell]# lks
    bash: lks: command not found...
    [root@bogon shell]# echo $?
    127
    #变量“$?”返回一个非0的值，证明上一个命令没有正确执行
    #至于错误的返回值到底是多少，是在编写ls命令时定义好的，

接下来我们来说明下`“$$”和“$!”`这两个预定义变量

[root@localhost sh]# vi variable.sh
    #!/bin/bash
    echo "The current process is $$"
    #输出当前进程的PID。
    #这个PID就是variable.sh这个脚本执行时，生成的进程的PID
    
    find /root -name hello.sh &
    #使用find命令在root目录下查找hello.sh文件
    #符号&的意思是把命令放入后台执行，工作管理我们在系统管理章节会详细介绍
    echo "The last one Daemon process is $!"
    #输出这个后台执行命令的进程的PID，也就是输出find命令的PID号

variable.sh脚本测试实例如下：

[root@bogon shell]# ./variable.sh
    The current process is 5139
    The last one Daemon process is 5140

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

### ⑦ 接收键盘输入 ###

**语法格式**：`read [选项] [变量名]`

选项：

-p “提示信息”： 在等待read输入时，输出提示信息
    -t 秒数： read命令会一直等待用户输入，使用此选项可以指定等待时间
    -n 字符数： read命令只接受指定的字符数，就会执行
    -s： 隐藏输入的数据，适用于机密信息的输入

变量名：

*  变量名可以自定义，如果不指定变量名，会把输入保存入默认变量REPLY
 *  如果只提供了一个变量名，则整个输入行赋予该变量
 *  如果提供了一个以上的变量名，则输入行分为若干字，一个接一个地赋予各个变量，而命令行上的最后一个变量取得剩余的所有字

测试脚本如下：

[root@bogon shell]# vim read.sh
    
    #!/bin/bash
    read -t 30 -p "Please input your name: " name
    #提示“请输入姓名”并等待30秒，把用户的输入保存入变量name中
    
    echo "Name is $name"
    #看看变量“$name”中是否保存了你的输入
    
    read -s -t 30 -p "Please enter your age: " age
    #提示“请输入年龄”并等待30秒，把用户的输入保存入变量age中
    #年龄是隐私，所以我们用“-s”选项隐藏输入
    echo -e "\n"
    #调整输出格式，如果不输出换行，一会的年龄输出不会换行
    echo "Age is $age"
    
    read -n 1 -t 30 -p "Please select your gender[M/F]: " gender
    #提示“请选择性别”并等待30秒，把用户的输入保存入变量gender
    #使用“-n 1”选项只接收一个输入字符就会执行（都不用输入回车）
    echo -e "\n"
    echo "Sex is $gender"

测试实例如下：

[root@bogon shell]# ./read.sh
    Please input your name: jane
    Name is jane
    Please enter your age:
    
    Age is 18
    Please select your gender[M/F]: M
    
    Sex is M

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

### ⑧ 变量的测试与内容置换 ###

这个主要用来对变量进行测试，如根据X的值间接判断Y的情况。

<table> 
 <thead> 
  <tr> 
   <th>变量置换方式</th> 
   <th>变量y没有设置</th> 
   <th>变量y为空值</th> 
   <th>变量y设置值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>x=${y-新值}</code></td> 
   <td>x=新值</td> 
   <td>x为空</td> 
   <td><code>x=$y</code></td> 
  </tr> 
  <tr> 
   <td><code>x=${y:-新值}</code></td> 
   <td>x=新值</td> 
   <td>x=新值</td> 
   <td><code>x=$y</code></td> 
  </tr> 
  <tr> 
   <td><code>x=${y+新值}</code></td> 
   <td>x为空</td> 
   <td>x=新值</td> 
   <td>x=新值</td> 
  </tr> 
  <tr> 
   <td><code>x=${y:+新值}</code></td> 
   <td>x为空</td> 
   <td>x为空</td> 
   <td>x=新值</td> 
  </tr> 
  <tr> 
   <td><code>x=${y=新值}</code></td> 
   <td>x=新值 y=新值</td> 
   <td>x为空 y值不变</td> 
   <td>x=$y y值不变</td> 
  </tr> 
  <tr> 
   <td><code>x=${y:=新值}</code></td> 
   <td>x=新值 y=新值</td> 
   <td>x=新值 y=新值</td> 
   <td>x=$y y值不变</td> 
  </tr> 
  <tr> 
   <td><code>x=${y?新值}</code></td> 
   <td>新值输出到标准错误输出（就是屏幕）</td> 
   <td>x为空</td> 
   <td>x=$y</td> 
  </tr> 
  <tr> 
   <td><code>x=${y:?新值}</code></td> 
   <td>新值输出到标准错误输出</td> 
   <td>新值输出到标准错误输出</td> 
   <td>x=$y</td> 
  </tr> 
 </tbody> 
</table>

*  如果大括号内没有“：”，则变量y是为空，还是没有设置，处理方法是不同的；
 *  如果大括号内有“：”，则变量y不论是为空，还是没有没有设置，处理方法是一样的。
 *  如果大括号内是“-”或“+”，则在改变变量x值的时候，变量y是不改变的；
 *  如果大括号内是“=”，则在改变变量x值的同时，变量y的值也会改变。
 *  如果大括号内是“？”，则当变量y不存在或为空时，会把“新值”当成报错输出到屏幕上。

测试实例如下：

[root@localhost ~]# unset y
    #删除变量y
    [root@localhost ~]# x=${y-new}
    #进行测试
    [root@localhost ~]# echo $x
    new
    #因为变量y不存在，所以x=new
    [root@localhost ~]# echo $y
    #但是变量y还是不存在的

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

## 【4】 Shell的运算符 ##

进行数值运算，可以采用以下三种方法中的任意一种：

*  使用declare声明变量类型
 *  使用expr或let数值运算工具
 *  使用`“$((运算式))”或“$[运算式]”`方式运算

### ① 使用declare声明变量类型 ###

既然所有变量的默认类型是字符串型，那么只要我们把变量声明为整数型不就可以运算了吗？使用declare命令就可以实现声明变量的类型。命令如下：`declare [+/-][选项] 变量名`

**选项：**

\-： 给变量设定类型属性  
\+： 取消变量的类型属性  
\-a： 将变量声明为数组型  
\-i： 将变量声明为整数型（integer）  
\-r： 将变量声明为只读变量。注意，一旦设置为只读变量，既不能修改变量的值，也不能删除变量，甚至不能通过+r取消只读属性  
\-x： 将变量声明为环境变量  
\-p： 显示指定变量的被声明的类型

**将变量声明为整数类型实例如下：**

#定义变量
    [root@bogon shell]# a=1
    [root@bogon shell]# b=2
    #如下进行遍历值相加
    [root@bogon shell]# declare -i c=a+b
    [root@bogon shell]# echo $c
    3
    #如下进行遍历值相加
    [root@bogon shell]# declare -i d=$a+$b
    [root@bogon shell]# echo $d
    3

**数组变量类型实例如下：**

[root@bogon shell]# name[0]=jane
    [root@bogon shell]# name[1]=lucy
    [root@bogon shell]# name[2]=lily
    [root@bogon shell]# echo $name
    jane
    [root@bogon shell]# echo ${name[*]}
    jane lucy lily

> 在定义变量时采用了“变量名\[下标\]”的格式，这个变量就会被系统认为是数组型。数组的下标是从0开始的，在调用数组值时，需要使用`${数组[下标]}`的方式来读取。输出数组的内容，如果只写数组名，那么只会输出第一个下标变量

**变量属性的查看与修改：**

#将变量声明为环境变量
    [root@bogon shell]# declare -x test
    #查看变量属性
    [root@bogon shell]# declare -p test
    declare -x test="1"
    
    #将变量声明为只读变量
    [root@bogon shell]# declare -r test
    [root@bogon shell]# declare -p test
    declare -rx test="1"
    
    #取消test变量的环境变量属性
    [root@bogon shell]# declare +x test
    [root@bogon shell]# declare -p test
    declare -r test="1"

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

### ② 使用expr或let数值运算工具 ###

**2.1 使用expr命令**

要想进行数值运算的第二种方法是使用expr命令，这种命令就没有declare命令复杂。使用expr命令进行运算时，`要注意“+”号左右两侧必须有空格`，否则运算不执行。命令实例如下：

[root@bogon shell]# a=1
    [root@bogon shell]# b=2
    [root@bogon shell]# c=$(expr $a + $b)
    [root@bogon shell]# echo $c
    3

**2.2 使用let命令**

let命令对格式要求要比expr命令宽松，所以推荐使用let命令进行数值运算。

[root@bogon shell]# a=1
    [root@bogon shell]# b=2
    [root@bogon shell]# let c=$a+$b+1
    [root@bogon shell]# echo $c
    4

### ③ 使用`“$((运算式))”`或`“$[运算式]”`方式运算-推荐 ###

**实例如下：**

[root@bogon shell]# a=1
    [root@bogon shell]# b=2
    [root@bogon shell]# c=$(($a+$b))
    [root@bogon shell]# echo $c
    3
    [root@bogon shell]# d=$[$a+$b]
    [root@bogon shell]# echo $d
    3

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

### ④ Shell常用运算符 ###

运算符优先级表明在每个表达式或子表达式中哪一个运算对象首先被求值，数值越大优先级越高，具有较高优先级级别的运算符先于较低级别的运算符进行求值运算。

<table> 
 <thead> 
  <tr> 
   <th>优先级</th> 
   <th align="left">运算符</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>13</td> 
   <td align="left"><code>-, +</code></td> 
   <td align="left">单目负、单目正</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td align="left"><code>!, ~</code></td> 
   <td align="left">逻辑非、按位取反或补码</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td align="left"><code>* , / , %</code></td> 
   <td align="left">乘、除、取模</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td align="left"><code>+, -</code></td> 
   <td align="left">加、减</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td align="left"><code>&lt;&lt; , &gt;&gt;</code></td> 
   <td align="left">按位左移、按位右移</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td align="left"><code>&lt; =, &gt; =, &lt; , &gt;</code></td> 
   <td align="left">小于或等于、大于或等于、小于、大于</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td align="left"><code>== , !=</code></td> 
   <td align="left">等于、不等于</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td align="left"><code>&amp;</code></td> 
   <td align="left">按位与</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td align="left"><code>^</code></td> 
   <td align="left">按位异或</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td align="left"><code>|</code></td> 
   <td align="left">按位或</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td align="left"><code>&amp;&amp;</code></td> 
   <td align="left">逻辑与</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td align="left"><code>||</code></td> 
   <td align="left">逻辑或</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td align="left"><code>=,+=,-=,*=,/=,%=,&amp;=, ^=, |=, &lt;&lt;=, &gt;&gt;=</code></td> 
   <td align="left">赋值、运算且赋值</td> 
  </tr> 
 </tbody> 
</table>

**四则运算脚本实例：**

#!/bin/bash
    
    read -t 30 -p "please input num1: " num1
    read -t 30 -p "please input num2: " num2
    read -n1 -t 30 -p "please input operato[+-*/]: " oper
    echo -e "\n"
    
    [ "$oper" == "+" ] && echo "$(( $num1 + $num2 ))" && exit
    [ "$oper" == "-" ] && echo "$(( $num1 - $num2 ))" && exit
    [ "$oper" == "*" ] && echo "$(( $num1 * $num2 ))" && exit
    [ "$oper" == "/" ] && echo "$(( $num1 / $num2 ))" && exit
    
    echo "qing shu ru zhengque yunsuanfu "

测试实例如下：

[root@bogon shell]# ./count4.sh
    please input num1: 1
    please input num2: 2
    please input operato[+-*/]: +
    
    3

> 这里第一次用到了中括号\[\]，在这里表示测试判断的意思，首先判断操作符是什么，然后执行后续命令。

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

## **【5】环境变量配置文件** ##

使配置文件生效：

[root@localhost ~]# source 配置文件
    或
    [root@localhost ~]# . 配置文件

### ① 登录时生效的环境变量配置文件 ###

在Linux系统登录时主要生效的环境变量配置文件有以下五个：

*  /etc/profile
 *  /etc/profile.d/\*.sh
 *  ~/.bash\_profile
 *  ~/.bashrc
 *  /etc/bashrc

**环境变量配置文件调用过程：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70 1]  
**1.1 在用户登录过程先调用/etc/profile文件**

在这个环境变量配置文件中会定义这些默认环境变量：

*  USER变量：根据登录的用户，给这个变量赋值（就是让USER变量的值是当前用户）。
 *  LOGNAME变量：根据USER变量的值，给这个变量赋值。
 *  MAIL变量：根据登录的用户，定义用户的邮箱为/var/spool/mail/用户名。
 *  PATH变量：根据登录用户的UID是否为0，判断PATH变量是否包含/sbin、/usr/sbin和/usr/local/sbin这三个系统命令目录。
 *  HOSTNAME变量：主机名，给这个变量赋值。
 *  HISTSIZE变量：定义历史命令的保存条数。
 *  umask：定义umask默认权限。注意/etc/profile文件中的umask权限是在“有用户登录过程（也就是输入了用户名和密码）”时才会生效。
 *  调用`/etc/profile.d/*.sh`文件，也就是调用`/etc/profile.d/`目录下所有以`.sh`结尾的文件。

**1.2 由/etc/profile文件调用`/etc/profile.d/*.sh`文件**

这个目录中所有以.sh结尾的文件都会被/etc/profile文件调用，这里最常用的就是lang.sh文件，而这个文件又会调用/etc/sysconfig/i18n文件。/etc/sysconfig/i18n这个文件眼熟吗？就是默认语系配置文件。

**1.3 由/etc/profile文件调用`~/.bash_profile`文件**

`~/.bash_profile`文件就没有那么复杂了，这个文件主要实现了两个功能：

*  调用了`~/.bashrc`文件。
 *  在PATH变量后面加入了`“:$HOME/bin”`这个目录。那也就是说，如果我们在自己的家目录中建立bin目录，然后把自己的脚本放入`“~/bin”`目录，就可以直接执行脚本，而不用通过目录执行了。

**1.4 由`~/.bash_profile`文件调用`~/.bashrc`文件**

在~/.bashrc文件中主要实现了：

*  定义默认别名
 *  调用/etc/bashrc

**1.5 由`~/.bashrc`调用了`/etc/bashrc`文件**

在/etc/bashrc文件中主要定义了这些内容：

*  PS1变量：也就是用户的提示符，如果我们想要永久修改提示符，就要在这个文件中修改
 *  umask：定义umask默认权限。这个文件中定义的umask是针对“没有登录过程（也就是不需要输入用户名和密码时，比如从一个终端切换到另一个终端，或进入子Shell）”时生效的。如果是“有用户登录过程”，则是/etc/profile文件中的umask生效。
 *  PATH变量：会给PATH变量追加值，当然也是在“没有登录过程”时才生效。
 *  调用`/etc/profile.d/*.sh`文件，这也是在“没有用户登录过程”是才调用。在“有用户登录过程”时，`/etc/profile.d/*.sh`文件已经被`/etc/profile`文件调用过了。

这样这五个环境变量配置文件会被依次调用，那么如果是我们自己定义的环境变量应该放入哪个文件呢？如果你的修改是打算对所有用户生效的，那么可以放入`/etc/profile`环境变量配置文件；如果你的修改只是给自己使用的，那么可以放入`~/.bash_profile或~/.bashrc`这两个配置文件中的任一个。

可是如果我们误删除了这些环境变量，比如删除了`/etc/bashrc`文件，或删除了`~/.bashrc`文件，那么这些文件中配置就会失效（`~/.bashrc文件会调用/etc/bashrc文件`）。那么我们的提示符就会变成：`-bash-4.1#`

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

### ② 注销时生效的环境变量配置文件 ###

在用户退出登录时，只会调用一个环境变量配置文件，就是`~/.bash_logout`。这个文件默认没有写入任何内容，可是如果我们希望再退出登录时执行一些操作，比如清除历史命令，备份某些数据，就可以把命令写入这个文件。

### ③ 其他配置文件 ###

还有一些环节变量配置文件，最常见的就是`~/.bash_history`文件，也就是历史命令保存文件。

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

[Link 1]: https://baike.baidu.com/item/shell/99702?fr=aladdin
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230209/b64add6d4a8c4a4aa29bf1f145148e28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70]: /images/20230209/e52d75e60e3e4f7e8d633c47dc6838c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70 1]: /images/20230209/37225053e8554e74ba13248b660dd440.png