shell语法基本教程

末蓝、 2022-11-19 15:58 236阅读 0赞

平凡也就两个字: 懒和惰;  
成功也就两个字: 苦和勤;  
优秀也就两个字: 你和我。  
跟着我从0学习JAVA、spring全家桶和linux运维等知识，带你从懵懂少年走向人生巅峰，迎娶白富美！  
关注微信公众号【 **IT特靠谱** 】，每天都会分享技术心得~

# shell语法基本教程 #

# 1 shell简介 #

Shell 是一种脚本语言。

任何代码最终都要被“翻译”成二进制的形式才能在计算机中执行。有的编程语言，如 C/C++、Pascal、Go语言、汇编等，必须在程序运行之前将所有代码都翻译成二进制形式，也就是生成可执行文件，用户拿到的是最终生成的可执行文件，看不到源码。这个过程叫做编译，这样的编程语言叫做编译型语言，完成编译过程的软件叫做编译器。而有的编程语言，如 Shell、JavaScript、Python、PHP等，需要一边执行一边翻译，不会生成任何可执行文件，用户必须拿到源码才能运行程序。程序运行后会即时翻译，翻译完一部分执行一部分，不用等到所有代码都翻译完。这个过程叫做解释，这样的编程语言叫做解释型语言或者脚本语言，完成解释过程的软件叫做解释器。  
  
编译型语言的优点是执行速度快、对硬件要求低、保密性好，适合开发操作系统、大型应用程序、数据库等。脚本语言的优点是使用灵活、部署容易、跨平台性好，非常适合Web开发以及小工具的制作。Shell 就是一种脚本语言，我们编写完源码后不用编译，直接运行源码即可。

Linux 是一个开源的操作系统，由分布在世界各地的多个组织机构或个人共同开发完成，每个组织结构或个人负责一部分功能，最后组合在一起，就构成了今天的 Linux。例如：

（1）Linux 内核最初由芬兰黑客 Linus Torvalds 开发，后来他组建了团队，Linux 内核由这个团队维护。

（2）GNU 组织开发了很多核心软件和基础库，例如 GCC 编译器、C语言标准库、文本编辑器 Emacs、进程管理软件、Shell 以及 GNOME 桌面环境等。

（3）VIM 编辑器由荷兰人 Bram Moolenaar 开发。

Windows、Mac OS、Android 等操作系统不一样，它们都由一家公司开发，所有的核心软件和基础库都由一家公司做决定，容易形成统一的标准，一般不会开发多款功能类似的软件。而 Linux 不一样，它是“万国牌”，由多个组织机构开发，不同的组织机构为了发展自己的 Linux 分支可能会开发出功能类似的软件，它们各有优缺点，用户可以自由选择。Shell 就是这样的一款软件，不同的组织机构开发了不同的 Shell，它们各有所长，有的占用资源少，有的支持高级编程功能，有的兼容性好，有的重视用户体验，Shell 既是一种脚本编程语言，也是一个连接内核和用户的软件。

Shell 虽然没有 C/C++、Java、Python 等强大，但也支持了基本的编程元素，例如：

（1）if...else 选择结构，switch...case 开关语句，for、while、until 循环；

（2）变量、数组、字符串、注释、加减乘除、逻辑运算等概念；

（3）函数，包括用户自定义的函数和内置函数（例如 printf、export、eval 等）。

# 2 几种常见shell #

常见的shell有：sh、bash、csh、tcsh、ash

## 2.1 查看linux系统支持的shell ##

Shell 是一个程序，一般都是放在`/bin`或者`/user/bin`目录下，当前 Linux 系统可用的 Shell 都记录在`/etc/shells`文件中。`/etc/shells`是一个纯文本文件，你可以在图形界面下打开它，也可以使用 cat 命令查看它。

![20210105161907793.png][]

在现代的 Linux 上，sh 已经被 bash 代替，`/bin/sh`往往是指向`/bin/bash`的符号链接。如果你希望查看当前 Linux 的默认Shell，那么可以输出 SHELL 环境变量（如下图），输出结果表明默认的 Shell 是 bash：

![20210105170646228.png][]

## 2.2 常见shell简介 ##

### 2.2.1 sh ###

sh 的全称是 Bourne shell，由 AT&T 公司的 Steve Bourne开发，为了纪念他，就用他的名字命名了。sh 是 UNIX 上的标准 shell，很多 UNIX 版本都配有 sh。sh 是第一个流行的 Shell。

### 2.2.2 bash ###

bash shell 是 Linux 的默认 shell，本教程也基于 bash 编写。bash 由 GNU 组织开发，保持了对 sh shell 的兼容性（意味着，针对 sh 编写的 Shell 代码可以不加修改地在 bash 中运行），是各种 Linux 发行版默认配置的 shell。

尽管如此，bash 和 sh 还是有一些不同之处：

（1）bash 扩展了一些命令和参数；

（2）bash 并不完全和 sh 兼容，它们有些行为并不一致，但在大多数企业运维的情况下区别不大，特殊场景可以使用 bash 代替 sh。

### 2.2.3 csh ###

sh 之后另一个广为流传的 shell 是由柏克莱大学的 Bill Joy 设计的，这个 shell 的语法有点类似C语言，所以才得名为 C shell ，简称为 csh。Bill Joy 是一个风云人物，他创立了 BSD 操作系统（BSD 是 UNIX 的一个重要分支，后人在此基础上发展出了很多现代的操作系统，最著名的有 FreeBSD、OpenBSD 和 NetBSD，就连 Mac OS X 在很大程度上也基于BSD），开发了 vi 编辑器，还是 Sun 公司的创始人之一。

### 2.2.4 tcsh ###

tcsh 是 csh 的增强版，加入了命令补全功能，提供了更加强大的语法支持。

### 2.2.5 ash ###

一个简单的轻量级的 Shell，占用资源少，适合运行于低内存环境，与bash shell 完全兼容。

# 3 第一个Shell脚本 #

## 3.1 新建脚本文件 ##

linux系统中创建一个名为first.sh的文件，扩展名为sh（sh代表shell），扩展名并不影响脚本执行，见名知意就好，如果你用php写shell 脚本，扩展名就用php好了。然后打开文本编辑器（vim），输入如下内容：

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

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

## 3.2 给脚本文件添加可执行权限 ##

输入命令：chmod +x ./first.sh ，使脚本具有执行权限。

![20210105173748571.png][]

## 3.3 执行脚本 ##

输入命令：./first.sh ，执行脚本。通过这种方式运行bash脚本，第一行一定要写对，好让系统查找到正确的解释器。这里的"系统"，其实就是shell这个应用程序，既然这个系统就是指shell，那么一个使用/bin/sh作为解释器的脚本是不是可以省去第一行呢？是的。

![20210105174104705.png][]

注意，一定要写成./first.sh，而不是first.sh。运行其它二进制的程序也一样，直接写first.sh，linux系统会去PATH里寻找有没有叫first.sh的，而只有/bin, /sbin, /usr/bin，/usr/sbin等在PATH里，你的当前目录通常不在PATH里，所以写成first.sh是会找不到命令的，要用./first.sh告诉系统说，就在当前目录找。

# 4 变量 #

变量用来存放各种数据。脚本语言在定义变量时通常不需要指明类型，直接赋值就可以，Shell 变量也遵循这个规则。在 Bash shell 中，每一个变量的值都是字符串，无论你给变量赋值时有没有使用引号，值都会以字符串的形式存储。这意味着，Bash shell 在默认情况下不会区分变量类型，即使你将整数和小数赋值给变量，它们也会被视为字符串，这一点和大部分的编程语言不同。当然，如果有必要，你也可以使用 declare 关键字显式定义变量的类型，但在一般情况下没有这个需求，Shell 开发者在编写代码时自行注意值的类型即可。

## 4.1 定义变量 ##

Shell 变量的命名规范和大部分编程语言都一样：

（1）变量名由数字、字母、下划线组成；

（2）必须以字母或者下划线开头；

（3）不能使用 Shell 里的关键字（通过 help 命令可以查看保留关键字）。

Shell 支持以下三种定义变量的方式。注意：赋值号的周围不能有空格！，这可能和你熟悉的大部分编程语言都不一样。

name=value
    name='value'
    name="value"

name是变量名，value 是赋给变量的值。如果 value 不包含任何空白符（例如空格、Tab缩进等），那么可以不使用引号；如果 value 包含了空白符，那么就必须使用引号包围起来。使用单引号和使用双引号也是有区别的，稍后我们会详细说明

示例：

![20210105175226236.png][]

## 4.2 使用变量 ##

使用一个定义过的变量，只要在变量名前面加美元符号`$`即可，如：

echo $name
    echo ${name}
    echo "我是${name},今年${age}岁了.我是一个${label}的帅哥!"

变量名外面的花括号`{ }`是可选的，加不加都行，加花括号是为了帮助解释器识别变量的边界。推荐给所有变量加上花括号`{ }`，这是个良好的编程习惯。

比如下面这种情况：

![20210105181308275.png][]

执行结果：

![20210105181516626.png][]

如果不给 skill 变量加花括号，写成`echo "I am good at $skillScript"`，解释器就会把 $skillScript 当成一个变量（其值为空），代码执行结果就不是我们期望的样子了

## 4.3 修改变量的值 ##

已定义的变量，可以被重新赋值。第二次对变量赋值时不能在变量名前加`$`，只有在使用变量时才能加`$`。

![20210105181904809.png][]

![20210105182159401.png][]

## 4.4 删除变量 ##

使用 unset 命令可以删除变量。语法：unset variable\_name。变量被删除后不能再次使用，unset 命令不能删除只读变量。

![20210105193611152.png][]

执行脚本，输出name变量值为空。

![20210105193557989.png][]

# 5 特殊变量 #

变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。

<table>  
 <strong>特殊变量列表</strong>  
 <tbody> 
  <tr> 
   <th>变量</th> 
   <th>含义</th> 
  </tr> 
  <tr> 
   <td>$0</td> 
   <td>当前脚本的文件名</td> 
  </tr> 
  <tr> 
   <td>$n</td> 
   <td>传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个参数是$1，第二个参数是$2。</td> 
  </tr> 
  <tr> 
   <td>$#</td> 
   <td>传递给脚本或函数的参数个数。</td> 
  </tr> 
  <tr> 
   <td>$*</td> 
   <td>传递给脚本或函数的所有参数。</td> 
  </tr> 
  <tr> 
   <td>$@</td> 
   <td>传递给脚本或函数的所有参数。被双引号(" ")包含时，与 $* 稍有不同，下面将会讲到。</td> 
  </tr> 
  <tr> 
   <td>$?</td> 
   <td>上个命令的退出状态，或函数的返回值。</td> 
  </tr> 
  <tr> 
   <td>$$</td> 
   <td>当前Shell进程ID。对于 Shell 脚本，就是这些脚本所在的进程ID。</td> 
  </tr> 
 </tbody> 
</table>

运行脚本时传递给脚本的参数称为命令行参数。命令行参数用 $n 表示，例如，$1 表示第一个参数，$2 表示第二个参数......。示例如下：

#! /bin/bash
    echo "脚本文件名为:$0"
    echo "命令行第1个参数为:$1"
    echo "命令行第2个参数为:$2"
    echo "命令行第3个参数为:$3"
    echo "命令行参数个数为:$#"
    echo "命令行全部参数为:$*"
    echo "命令行全部参数为:$@"

执行结果为：

![20210106173304816.png][]

# 6 运算符 #

## 6.1 算数运算符 ##

Bash 支持很多运算符，包括算数运算符、关系运算符、布尔运算符、字符串运算符和文件测试运算符。  
  
原生bash不支持简单的数学运算，但是可以通过其他命令来实现，例如 awk 和 expr，expr 最常用。expr 是一款表达式计算工具，使用它能完成表达式的求值操作。

<table>  
 <strong>算术运算符列表（变量a值为10，变量b值为20）</strong>  
 <tbody> 
  <tr> 
   <th style="width:105px;">运算符</th> 
   <th style="width:377px;">说明</th> 
   <th style="width:414px;">举例</th> 
  </tr> 
  <tr> 
   <td style="width:105px;">+</td> 
   <td style="width:377px;">加法</td> 
   <td style="width:414px;">`expr $a + $b` 结果为&nbsp;30。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">-</td> 
   <td style="width:377px;">减法</td> 
   <td style="width:414px;">`expr $a - $b` 结果为 -10。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">*</td> 
   <td style="width:377px;">乘法</td> 
   <td style="width:414px;">`expr $a \* $b` 结果为 &nbsp;200。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">/</td> 
   <td style="width:377px;">除法</td> 
   <td style="width:414px;">`expr $b / $a` 结果为&nbsp;2。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">%</td> 
   <td style="width:377px;">取余</td> 
   <td style="width:414px;">`expr $b % $a` 结果为&nbsp;0。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">=</td> 
   <td style="width:377px;">赋值</td> 
   <td style="width:414px;">a=$b 将把变量 b 的值赋给 a。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">==</td> 
   <td style="width:377px;">相等。用于比较两个数字，相同则返回 true。</td> 
   <td style="width:414px;">[ $a == $b ] 返回&nbsp;false。</td> 
  </tr> 
  <tr> 
   <td style="width:105px;">!=</td> 
   <td style="width:377px;">不相等。用于比较两个数字，不相同则返回 true。</td> 
   <td style="width:414px;">[ $a != $b ] 返回 true。</td> 
  </tr> 
 </tbody> 
</table>

注意1：条件表达式要放在方括号之间，并且要有空格，例如 \[$a==$b\] 是错误的，必须写成 \[ $a == $b \]。

注意2：乘号(\*)前边必须加反斜杠(\\)才能实现乘法运算；

注意3：表达式和运算符之间要有空格，例如 \`expr $a+$b\` 是不对的，必须写成 \`expr $a + $b\`，这与我们熟悉的大多数编程语言不一样。

注意4：完整的表达式要被 \` \` 包含，注意这个字符不是常用的单引号，在 Esc 键下边。

算数运算符测试示例：

#! /bin/bash
    a=10
    b=20
    val=`expr $a + $b`
    echo "a + b : $val"
    val=`expr $a - $b`
    echo "a - b : $val"
    val=`expr $a \* $b`
    echo "a * b : $val"
    val=`expr $b / $a`
    echo "b / a : $val"
    val=`expr $b % $a`
    echo "b % a : $val"
    if [ $a == $b ]
    then
       echo "a is equal to b"
    fi
    if [ $a != $b ]
    then
       echo "a is not equal to b"
    fi

测试结果：

![20210106180730637.png][]

## 6.2 关系运算符 ##

关系运算符只支持数字，不支持字符串，除非字符串的值是数字。

<table>  
 <strong>关系运算符列表</strong>  
 <tbody> 
  <tr> 
   <th style="width:90px;">运算符</th> 
   <th style="width:405px;">说明</th> 
   <th style="width:211px;">举例</th> 
  </tr> 
  <tr> 
   <td style="width:90px;">-eq</td> 
   <td style="width:405px;">检测两个数是否相等，相等返回 true。</td> 
   <td style="width:211px;">[ $a -eq $b ] 返回&nbsp;true。</td> 
  </tr> 
  <tr> 
   <td style="width:90px;">-ne</td> 
   <td style="width:405px;">检测两个数是否相等，不相等返回 true。</td> 
   <td style="width:211px;">[ $a -ne $b ] 返回 true。</td> 
  </tr> 
  <tr> 
   <td style="width:90px;">-gt</td> 
   <td style="width:405px;">检测左边的数是否大于右边的，如果是，则返回 true。</td> 
   <td style="width:211px;">[ $a -gt $b ] 返回 false。</td> 
  </tr> 
  <tr> 
   <td style="width:90px;">-lt</td> 
   <td style="width:405px;">检测左边的数是否小于右边的，如果是，则返回 true。</td> 
   <td style="width:211px;">[ $a -lt $b ] 返回 true。</td> 
  </tr> 
  <tr> 
   <td style="width:90px;">-ge</td> 
   <td style="width:405px;">检测左边的数是否大等于右边的，如果是，则返回 true。</td> 
   <td style="width:211px;">[ $a -ge $b ] 返回 false。</td> 
  </tr> 
  <tr> 
   <td style="width:90px;">-le</td> 
   <td style="width:405px;">检测左边的数是否小于等于右边的，如果是，则返回 true。</td> 
   <td style="width:211px;">[ $a -le $b ] 返回 true。</td> 
  </tr> 
 </tbody> 
</table>

关系运算符测试示例：

#! /bin/bash
    a=10
    b=20
    if [ $a -eq $b ]
    then
       echo "$a -eq $b : a等于b"
    else
       echo "$a -eq $b: a不等于b"
    fi
    if [ $a -ne $b ]
    then
       echo "$a -ne $b: a不等于b"
    else
       echo "$a -ne $b : a等于b"
    fi
    if [ $a -gt $b ]
    then
       echo "$a -gt $b: a大于b"
    else
       echo "$a -gt $b: a不大于b"
    fi
    if [ $a -lt $b ]
    then
       echo "$a -lt $b: a小于b"
    else
       echo "$a -lt $b: a不小于b"
    fi
    if [ $a -ge $b ]
    then
       echo "$a -ge $b: a大于等于b"
    else
       echo "$a -ge $b: a小于b"
    fi
    if [ $a -le $b ]
    then
       echo "$a -le $b: a小于等于b"
    else
       echo "$a -le $b: a大于b"
    fi

测试结果：

![20210106181915122.png][]

## 6.3 布尔运算符 ##

<table>  
 <strong>布尔运算符列表</strong>  
 <tbody> 
  <tr> 
   <th style="width:76px;">运算符</th> 
   <th style="width:365px;">说明</th> 
   <th style="width:296px;">举例</th> 
  </tr> 
  <tr> 
   <td style="width:76px;">!</td> 
   <td style="width:365px;">非运算，表达式为 true 则返回 false，否则返回 true。</td> 
   <td style="width:296px;">[ ! false ] 返回 true。</td> 
  </tr> 
  <tr> 
   <td style="width:76px;">-o</td> 
   <td style="width:365px;">或运算，有一个表达式为 true 则返回 true。</td> 
   <td style="width:296px;">[ $a -lt 20 -o $b -gt 100 ] 返回&nbsp;true。</td> 
  </tr> 
  <tr> 
   <td style="width:76px;">-a</td> 
   <td style="width:365px;">与运算，两个表达式都为 true 才返回 true。</td> 
   <td style="width:296px;">[ $a -lt 20 -a $b -gt 100 ] 返回&nbsp;false。</td> 
  </tr> 
 </tbody> 
</table>

布尔运算符测试示例：

#! /bin/bash
    a=10
    b=20
    if [ $a != $b ]
    then
       echo "$a != $b : a不等于b"
    else
       echo "$a != $b: a等于b"
    fi
    if [ $a -lt 100 -a $b -gt 15 ]
    then
       echo "$a -lt 100 -a $b -gt 15 : a小于100 且 b大于15"
    else
       echo "$a -lt 100 -a $b -gt 15 : a不小于100 或 b不大于15"
    fi
    if [ $a -lt 100 -o $b -gt 100 ]
    then
       echo "$a -lt 100 -o $b -gt 100 : a小于100 或 b大于100"
    else
       echo "$a -lt 100 -o $b -gt 100 : a不小于100 且 b不大于100"
    fi
    if [ $a -lt 5 -o $b -gt 100 ]
    then
       echo "$a -lt 100 -o $b -gt 100 : a小于5 或 b大于100"
    else
       echo "$a -lt 100 -o $b -gt 100 : a不小于5 且 b不大于100"
    fi

测试结果：

![20210106184614526.png][]

## 6.4 字符串运算符 ##

<table>  
 <strong>字符串运算符列表</strong>  
 <tbody> 
  <tr> 
   <th style="width:84px;">运算符</th> 
   <th style="width:373px;">说明</th> 
   <th style="width:256px;">举例</th> 
  </tr> 
  <tr> 
   <td style="width:84px;">=</td> 
   <td style="width:373px;">检测两个字符串是否相等，相等返回 true。</td> 
   <td style="width:256px;">[ $a = $b ] 返回 false。</td> 
  </tr> 
  <tr> 
   <td style="width:84px;">!=</td> 
   <td style="width:373px;">检测两个字符串是否相等，不相等返回 true。</td> 
   <td style="width:256px;">[ $a != $b ] 返回&nbsp;true。</td> 
  </tr> 
  <tr> 
   <td style="width:84px;">-z</td> 
   <td style="width:373px;">检测字符串长度是否为0，为0返回 true。</td> 
   <td style="width:256px;">[ -z $a ] 返回 false。</td> 
  </tr> 
  <tr> 
   <td style="width:84px;">-n</td> 
   <td style="width:373px;">检测字符串长度是否为0，不为0返回 true。</td> 
   <td style="width:256px;">[ -z $a ] 返回 true。</td> 
  </tr> 
  <tr> 
   <td style="width:84px;">str</td> 
   <td style="width:373px;">检测字符串是否为空，不为空返回 true。</td> 
   <td style="width:256px;">[ $a ] 返回&nbsp;true。</td> 
  </tr> 
 </tbody> 
</table>

字符串运算符测试示例：

#! /bin/bash
    a="abc"
    b="efg"
    if [ $a = $b ]
    then
       echo "$a = $b : 两个字符串相等"
    else
       echo "$a = $b: 两个字符串不相等"
    fi
    if [ $a != $b ]
    then
       echo "$a != $b : 两个字符串不相等"
    else
       echo "$a != $b: 两个字符串相等"
    fi
    if [ -z $a ]
    then
       echo "-z $a : 字符串a的长度为0"
    else
       echo "-z $a : 字符串a的长度不为0"
    fi
    if [ -n $a ]
    then
       echo "-n $a : 字符串a的长度不为0"
    else
       echo "-n $a : 字符串a的长度为0"
    fi
    if [ $a ]
    then
       echo "$a : 字符串a不为空"
    else
       echo "$a : 字符串a为空"
    fi

测试结果：

![20210106185331821.png][]

# 7 注释（\#） #

shell里没有多行注释，只能在需要注释的代码的每一行加一个\#号。

# 8 字符串 #

字符串是shell编程中最常用最有用的数据类型（除了数字和字符串，也没啥其它类型好用了），字符串可以用单引号，也可以用双引号，也可以不用引号。

## 8.1 单引号和双引号的区别 ##

### 8.1.1 单引号 ###

单引号字符串的限制：

（1）单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的；

（2）单引号字符串中不能出现单引号（对单引号使用转义符后也不行）。

单引号字符串示例：

#! /bin/bash
    name='IT特靠谱'
    echo '大家好,我是${name}'

测试结果如下，可见单引号中的变量是无效的！

![20210106190025316.png][]

### 8.1.2 双引号 ###

双引号字符串的优点：

（1）双引号里可以有变量，且能正常解析；

（2）双引号里可以出现转义字符。

双引号字符串示例：

#! /bin/bash
    name='IT特靠谱'
    echo "大家好,我是${name}"

测试结果：

![2021010619032774.png][]

## 8.2 字符串拼接 ##

#! /bin/bash
    txt1="大家好,我叫:"
    txt2="IT特靠谱"
    name="${txt1}${txt2}"
    echo "${name}"

![2021010717364232.png][]

## 8.3 获取字符串长度 ##

#! /bin/bash
    name="大家好,我叫:IT特靠谱"
    echo "${#name}"

![20210107174919966.png][]

## 8.4 截取子字符串 ##

注意：字符串的下标从0开始！

截取下标为1~5的子字符串，示例：

#! /bin/bash
    name="大家好,我叫:IT特靠谱"
    echo "${name}"
    echo "${name:1:5}"

![2021010717534177.png][]

# 9 数组 #

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

## 9.1 定义数组 ##

在Shell中，用括号()来表示数组，数组元素用“空格”符号分割开，数组中的各个元素类型可以不同！

定义数组的一般形式为：array\_name=(value1 value2 value3 ... valuen)，当然还可以单独定义，如下：

array_name[0]=value1
    
    array_name[1]=value2
    
    array_name[2]=value3  .......
    
    Tips：可以不使用连续的下标，而且下标的范围没有限制。

两种定义数组的方式示例：

#! /bin/bash
    arr1=(1 2 "IT特靠谱" true 3.14159)
    arr2[0]=1
    arr2[1]=2
    arr2[3]=true
    arr2[4]=3.14159
    echo "${arr1[4]}"
    echo "${arr2[2]}"
    echo "${arr2[4]}"

测试结果：

![20210107182200113.png][]

## 9.2 拼接数组和给数组追加数据 ##

### 9.2.1 拼接数组 ###

测试示例：

#! /bin/bash
    # 拼接数组
    arr1=(1 "数组1" false 3.14159)
    arr2=(2 "数组2" true 0.0001)
    arr=(${arr1[*]} ${arr2[*]} "lastEle")
    echo "拼接后数组为：${arr[*]}"
    for val in ${arr[*]}
    do
        echo "当前循环的值为：${val}"
    done

测试结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70][]

### 9.2.2 给数组追加数据 ###

实质上与拼接数组没啥差别。只是拼接后的新数组名与原数组名一致，新数组会覆盖原数组值而已！

测试示例：

#! /bin/bash
    # 拼接数组
    arr=(1 "数组1" false 3.14159)
    echo "原数组为：${arr[*]}"
    arr=(${arr[*]} "newEle1" "newEle2")
    echo "拼接后数组为：${arr[*]}"
    for val in ${arr[*]}
    do
        echo "当前循环的值为：${val}"
    done

测试结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70 1][]

## 9.3 获取数组的值 ##

读取数组元素值的一般格式是：$\{array\_name\[index\]\}。index为@ 或 \* 表示获取数组中的所有元素。

#! /bin/bash
    arr1=(1 2 "IT特靠谱" true 3.14159)
    arr2[0]=1
    arr2[1]=2
    arr2[3]=true
    arr2[4]=3.14159
    echo "${arr1[4]}"
    echo "${arr2[2]}"
    echo "${arr2[4]}"
    echo "arr1数组的全部元素为:${arr1[*]}"
    echo "arr1数组的全部元素为:${arr1[@]}"
    echo "arr2数组的全部元素为:${arr2[*]}"
    echo "arr2数组的全部元素为:${arr2[@]}"

![2021010720194298.png][]

## 9.4 获取数组长度 ##

获取数组长度的方法与获取字符串长度的方法相同。

#! /bin/bash
    arr1=(1 2 "IT特靠谱" true 3.14159)
    arr2[0]=1
    arr2[1]=2
    arr2[3]=true
    arr2[4]=3.14159
    echo "arr1数组的全部元素为:${arr1[*]}"
    echo "arr1数组的全部元素为:${arr1[@]}"
    echo "arr2数组的全部元素为:${arr2[*]}"
    echo "arr2数组的全部元素为:${arr2[@]}"
    echo "arr1数组元素个数为:${#arr1[*]}"
    echo "arr1数组元素个数为:${#arr1[@]}"
    echo "arr2数组元素个数为:${#arr2[*]}"
    echo "arr2数组元素个数为:${#arr2[@]}"

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70 2][]

# 10 echo命令 #

echo是Shell的一个内部指令，用于在屏幕上打印出指定的字符串。命令格式：echo arg

#! /bin/bash
    # 显示转义字符
    echo "\"显示双引号转义字符\""
    
    # 显示变量
    name="IT特靠谱"
    echo "有或无大括号显示变量:$name, ${name}"
    year=2021
    echo "变量与其他字符相连时必须使用大括号:${year}abc, $yearabc"
    
    # 原样输出字符串（若需要原样输出字符串（不进行转义或不显示变量值），请使用单引号）
    name="IT特靠谱"
    echo '\"我是${name}\"'
    
    # 显示命令执行结果（反单引号，esc键下面）
    echo `date`

![20210107203822274.png][]

# 11 if..else条件判断 #

if 语句通过关系运算符判断表达式的真假来决定执行哪个分支。Shell 有三种 if ... else 语句：

（1）if then ... fi 语句；

（2）if then ... else ... fi 语句；

（3）if then ... elif then ... else ... fi 语句。

## 11.1 if then ... fi 语句 ##

如果 expression 返回 true，then 后边的语句将会被执行；如果返回 false，不会执行任何语句。最后必须以 fi 来结尾闭合 if，fi 就是 if 倒过来拼写。  
  
注意：expression 和方括号(\[ \])之间必须有空格，否则会有语法错误。

if [ expression ]
    then
       Statement(s) to be executed if expression is true
    fi

## 11.2 if then ... else ... fi 语句 ##

如果 expression 返回 true，那么 then 后边的语句将会被执行；否则，执行 else 后边的语句。

if [ expression ]
    then
       Statement(s) to be executed if expression is true
    else
       Statement(s) to be executed if expression is not true
    fi

## 11.3 if then ... elif then ... else ... fi 语句 ##

哪一个 expression 的值为 true，就执行哪个 expression 后面的语句；如果都为 false，那么不执行任何语句。

if [ expression 1 ]
    then
       Statement(s) to be executed if expression 1 is true
    elif [ expression 2 ]
    then
       Statement(s) to be executed if expression 2 is true
    elif [ expression 3 ]
    then
       Statement(s) to be executed if expression 3 is true
    else
       Statement(s) to be executed if no expression is true
    fi

## 11.4 测试 ##

#! /bin/bash
    a=50
    b=100
    # if  then ... fi 语句
    if [ $a == $b ]
    then
        echo "a等于b"
    fi
    
    # if  then ... else ... fi 语句
    if [ $a == $b ]
    then
        echo "a等于b"
    else
        echo "a不等于b"
    fi
    
    # if  then ... elif  then ... else ... fi 语句
    if [ $a -gt 200 ]
    then
        echo "a > 200"
    elif [ $a -gt 100 ]
    then
        echo "a > 100"
    elif [ $a -gt 50 ]
    then
        echo "a > 50"
    elif [ $a -gt 20 ]
    then
        echo "a > 20"
    else
        echo "a <= 20"
    fi

测试结果：

![20210107210313985.png][]

# 12 for循环 #

for 循环是固定循环，也就是在循环时已经知道需要进行几次循环。有时也把 for 循环称为计数循环。for循环也可以多层嵌套！for 循环的语法有如下2 种。

## 12.1 for循环方式1 ##

语法格式为：

for 变量 in 列表
    do
        command1
        command2
        ...
        commandN
    done

在这种语法中，for 循环的次数取决于 in 后面值的个数（各个数值以空格分隔），有几个值就循环几次，并且每次循环都把值赋予变量。也就是说，假设 in 后面有三个值，for 会循环三次，第一次循环会把值 1 赋予变量，第二次循环会把值 2 赋予变量，以此类推。

## 12.2 for循环方式2 ##

和其他语言中的 for 循环类似，也就是事先决定循环次数的固定循环（通过循环控制条件来决定循环多少次）。

语法格式为：

for ((初始值；循环控制条件；变量变化))
    do
        command1
        command2
        ...
        commandN
    done

在语法二中需要注意以下几点：

（1）初始值：在循环开始时，需要给某个变量赋予初始值，如 i=1。

（2）循环控制条件：用于指定变量循环的次数，如 i<=100，则只要 i 的值小于等于 100，循环就会继续。

（3）变量变化：每次循环之后，变量该如何变化，如 i=i+1，代表每次循环之后，变量的值都加 1。

## 12.3 循环测试 ##

示例代码：

#! /bin/bash
    # 循环列表（列表中数据用空格隔开）
    for var in 1 "IT特靠谱" false 3.14159
    do
        echo "[列表循环1]当前循环元素值为：${var}"
    done
    
    # 列表循环2：列表为变量情况
    list="1 "IT特靠谱" false 3.14159"
    for var in ${list}
    do
        echo "[列表循环2]当前循环元素值为：${var}"
    done
    
    # 数组循环1：元素循环
    arr1=(1 "IT特靠谱" false 3.14159)
    for var in ${arr1[*]}
    do
        echo "[数组循环1]当前循环元素���为：${var}
    done
    
    # 数组循环2：下标循环
    arr2=(1 "IT特靠谱" false 3.14159)
    for (( i=0; i<${#arr2[*]}; i++ ))
    do
        echo "[数组循环2]当前循环元素值为：${arr2[$i]}"
    done

测试结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70 3][]

参考文档：[http://c.biancheng.net/cpp/view/6994.html][http_c.biancheng.net_cpp_view_6994.html]

（1）**商务合作微信号**：M9392W

（2） **购物商城**： **扫码即可进入博主开发的****小程序购物商城****，享超大优惠购物，支持一下博主吧~**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70 4][]

（3） **博主微信公众号**：**IT特靠谱**，学习更多开发实战技巧！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70 5][]

[20210105161907793.png]: /images/20221119/d1f85e2b447a4ccd85944d27d0d6d773.png
[20210105170646228.png]: /images/20221119/d6c21f9848eb4123bccc822a97817635.png
[20210105173748571.png]: /images/20221119/89212bf702f44817aaf547b6de20cb2e.png
[20210105174104705.png]: /images/20221119/ef49986a9d5f43d085aa25e7c40a9b4e.png
[20210105175226236.png]: /images/20221119/c0904e648f1f473da3a07ea14ad1db1f.png
[20210105181308275.png]: /images/20221119/9bb4b6f8c6d740f9ad30cc8223a7a16b.png
[20210105181516626.png]: /images/20221119/3a36dd0f4b8f4c179d0a03c39e6d7d69.png
[20210105181904809.png]: /images/20221119/39539360dfae4f15a3d4602401d12852.png
[20210105182159401.png]: /images/20221119/8569483fd0cb4c97a03c3af6b592b5bf.png
[20210105193611152.png]: /images/20221119/16bb0f63ab75452683f17f8ba2a95e6d.png
[20210105193557989.png]: /images/20221119/ac19ff0cfd854f54a6490fce2c6ae09c.png
[20210106173304816.png]: /images/20221119/0a5778eb17ed4a189eaae22cc38468cd.png
[20210106180730637.png]: /images/20221119/0b295810cd4b4f529469567c7f9b716a.png
[20210106181915122.png]: /images/20221119/9629fdcbc3aa4377bd775b31fe4358e2.png
[20210106184614526.png]: /images/20221119/40c9c24ed2b746b5a10a7e45ea93a429.png
[20210106185331821.png]: /images/20221119/95dbf4e7016040399a945739c38d7cbb.png
[20210106190025316.png]: /images/20221119/51dbae07d74c4a16ad42fb834489d15f.png
[2021010619032774.png]: /images/20221119/06f7f14ae009432a936191e6a7c6f3d8.png
[2021010717364232.png]: /images/20221119/fc9f461dc86c4bdab4bbc3687e440142.png
[20210107174919966.png]: /images/20221119/f8fb749cb1c843fba0f9925cb7cbcf31.png
[2021010717534177.png]: /images/20221119/7b0c3fa95ad546aa994e1e6d57742115.png
[20210107182200113.png]: /images/20221119/07deb496253e4139a4569c449774abaf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70]: /images/20221119/609afeaaa26c410692346ffd984efb77.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70 1]: /images/20221119/15a729a832f4459ba1565dfb35ad32c1.png
[2021010720194298.png]: /images/20221119/020860c89ebf4a4cab8ffde0a72497c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70 2]: /images/20221119/5c3f0474c164446ab9043b1b30d0fb2e.png
[20210107203822274.png]: /images/20221119/59622e4630984cc8a2f48c8f23ab660b.png
[20210107210313985.png]: /images/20221119/4ac5987e9aff416f9699fdce312a99c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70 3]: /images/20221119/ef2680fea20941cb8d3df9e59623791d.png
[http_c.biancheng.net_cpp_view_6994.html]: http://c.biancheng.net/cpp/view/6994.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70 4]: /images/20221119/5fae637adefb42ca9217bcae428ac442.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUX01vc3Q_size_16_color_FFFFFF_t_70 5]: /images/20221119/15f2f73e1de94f32984f6ce80ef1f807.png