一、学习内容

1. Shell脚本

   1. shell中的变量

      1. shell中变量的定义

         1. shell中的变量是没有数据类型的，，默认是字符串

         2. shell中的变量默认是全局变量

         3. 格式

            1. 变量名 错误，计算机认为变量名是一个指令

            2. 变量名= 正确，定义变量 ，值为空

            3. 变量名=值 正确，定义变量并赋值

            4. 注意变量名：符合命名规范

      2. shell中变量的定义以及初始化

         1. 注意：=号的左右两端不允许有空格

         2. 格式

            1. 变量名=初始值

            2. 变量名='初始值'

            3. 变量名="初始值"

            4. 初始化的值不能有空格

               1. var = hello 错误

            5. 初始化的值有空格

               1. var=hello world 错误 var='hello world' 正确

            6. 使用变量进行初始化

               1.     a=hello
                      b=world
                      var=a  ---->var的值是a 而不是hello
                      var=$a --->var的值是hello
                      var=${a}
                      var=$a $b    错误
                      var='$a $b'  等价于  var的值是$a $b 不可以展开变量的值
                      var="$a $b"  hello world  可以展开变量的值

      3. shell中变量值的引用

         1. 引用变量的值

            1. 格式1

               1. $变量名

            2. 格式2

               1. ${变量名}

      4. 位置变量

         1. 位置变量：类似于C语言中的argc和argv, 接受终端输入的字符串 多用于函数传参

      5. 预定义变量

         1. 概念：系统已经定义好的变量，直接使用即可

         2. $* 终端输入的所有字符串，不包括文件名，它们中间使用空格隔开

         3. $# 输入字符串的个数

         4. $@ 终端输入的所有字符串，不包括文件名，它们中间使用空格隔开

         5. $? 接收上一个指令的状态 0成功指令 非0失败

         6. $$ 获取当前终端的进程号

      6. 命令置换

         1. 概念：把一个指令的输出赋值给变量

         2. 格式

            1. 变量名=$(指令)

            2. 变量名=`指令`

      7. shell的特殊符号

         1. readonly 只读

            1. 格式： readonly 变量名=初始值 不可变

         2. unset 取消变量，不可以取消只读类型的变量

            1. 格式： unset 变量名

         3. local 局部变量

            1. 格式： local 变量名=初始值

   2. shell中的输入输出

      1. 输出 echo

         1. 格式

            1. 输出字符串

               1. echo 字符串

               2. echo '字符串'

               3. echo "字符串"

            2. 使用echo输出变量

               1.  a=100
                     b=200
                     echo a=$a b=$b    ----->a=100 b=200
                     echo 'a=$a b=$b'  ----->a=$a b=$b
                     echo "a=$a b=$b"  ----->a=100 b=200

      2. 输入 read

         1. 输入一个或者多个变量

            1. read 变量名1 变量名2 ... 多个数据的输入使用空格或者tab隔开，使用enter结束

         2. read -p "提示语句" 变量名

            1. read -p "please input .." a

         3. read -n 个数 变量 输入多少个 自动结束

            1. read -n 3 a

         4. read -t 秒数 几秒不输入自动结束

         5. read -s 变量 加密输入

         6. read -a 数组名

   3. shell的字符串

      1. 默认shell中的变量初始化的值就是字符串 2.var=hello 【shell中的字符串就是个普通变量，不是字符数组】

         1. 计算字符串的长度

            1. 格式： ${#变量}

         2. 字符串连接

            1. a=hello b=world a=$a$b --->字符串的连接

         3. 字符串剪切

            1. 从左往右（从前往后），截取从0开始计算到后面的所有字符串

               1. 格式1：${变量名:n} 从左往右，0开始。从n截取到最后

               2. 格式2：${变量名:n:m} 从左往右，0开始。从n截取m个

            2. 从右往左，截取从1开始

               1. 格式1：${变量名:0-n} 从右往左，1开始。从n截取到最后

               2. 格式2：${变量名:0-n:m} 从右往左，1开始。从n截m个

            3. 使用 # ## % %% 截取字符串 string 表示分隔符

               1. 格式1: ${变量名#*string}

                  1. str=www.baidu.com a=${str#*.} 一个#表示，从左往右，截取第一个以.分隔符后面的所有字符串 baidu.com

               2. 格式2: ${变量名##*string}

                  1. str=www.baidu.com b=${str##*.} 两个个#表示，从左往右，截取最后一个以.分隔符后面的所有字符串 com

               3. 格式3: ${变量名%string*}

                  1. str=www.baidu.com c=${str%.*} 一个%表示，从右往左，截取第一个以.分隔符的前面所有的字符串 www.baidu

               4. 格式4: ${变量名%%string*}

                  1. str=www.baidu.com d=${str%%.*}两个%表示，从右往左，截取最后一个以.分隔符的前面所有的字符串 www

   4. shell中的数组

      1. shell中只有一维数组，不存在二维数组、三维。。数组 2.shell中数组里的元素都是字符串

         1. 数组的定义以及初始化

            1. 数组的标志：在初始化时需要使用()赋值

               1. 定义数组并初始化

                  1. arr=(1 2 3 4 5) ---->而不是{} arr=([0]=1 [1]=2 [2]=3 [3]=4 [4]=5)

                  2. shell中的数组支持稀疏数组，

                  3. 单个初始化 ，不需要定义数组

                  4. 数组追加初始化

                  5. 数组的拼接

                     1. c=(${a[*]} ${b[*]}) c=(${a[@]} ${b[@]})

         2. 数组的引用 （元素的值）

            1. ${arr[index]} 单个元素的引用 数组的元素值 必须使用${}

            2. ${arr[*]} 引用数组中所有的元素

            3. ${arr[@]} 引用数组中所有的元素

            4. ${#arr[index]} 单个元素的字符个数

            5. ${#arr[*]} 数组的元素个数

            6. ${#arr[@]} 数组的元素个数

   5. shell的运算符

      1. 1.shell不擅长算术运算，擅长对字符串和文件的相关操作 2.shell中的运算符 (()) ---->算术、关系、逻辑、条件 $[] ---->算术、关系、逻辑、条件 let ---->算术、关系、逻辑、条件 expr ---->算术、逻辑、字符串、关系

         1. (())

            1. 功能： 对整数做运算、算术、关系、条件、逻辑 (()) 是运算符 不是指令

               1. 格式

                  1. ((变量=表达式))

                  2. 变量=$((表达式))

               2. 注意事项

                  1. 空格可有可无

                  2. 使用变量的值时，$可有可无

                  3. (()) 可以实现任意复杂的表达式：算术、关系、逻辑、条件

                  4. 可以实现自增或自减的运算

                  5. 可以实现幂运算

         2. $[]

            1. 功能：对整数做运算，算术、关系、条件、逻辑 $[] 是运算符 不是指令

               1. 格式

                  1. 变量=$[表达式]

               2. 注意事项

                  1. 空格可有可无

                  2. 使用变量的值时，$可有可无

                  3. $[] 可以实现任意复杂的表达式：算术、关系、逻辑、条件

                  4. 可以实现自增或自减的运算

                  5. 可以实现幂运算

         3. let

            1. 功能：对整数做运算，算术、关系、条件、逻辑 let是一个指令

               1. 格式

                  1. let 变量=表达式 let c=a+b 不可以写空格

                  2. let "变量=表达式"

               2. 注意事项

                  1. 空格可有可无

                  2. 使用变量的值时， $可有可无

                  3. let 可以实现任意复杂的表达式：算术、关系、逻辑、条件

                  4. 可以实现自增或自减的运算

                  5. 可以实现幂运算

         4. expr

            1. expr是一个指令 expr必须空格

               1. 格式

                  1. expr 表达式

                  2. 引用格式

                     1. 变量=`expr 表达式`

                     2. 变量=$(expr 表达式)

               2. 注意事项

                  1. 空格必须存在

                  2. 使用变量时，$必须存在，建议添加""

                  3. expr可以实现算术、关系、逻辑、字符串 关系可能出错，需要添加转义字符 eg: \> \!=

                  4. 不可以实现自增或自减运算

                  5. 不可以实现幂运算

               3. 逻辑运算

                  1. 逻辑或

                     1. ARG1 | ARG2

                        1. 如果ARG1为真(不为0 空)， ARG2为真， 返回的结果是ARG1
                           如果ARG1为真(不为0 空)， ARG2假， 返回的结果是ARG1
                           如果ARG1为假， ARG2为真(不为0 空)， 返回的结果是ARG2
                           如果ARG1为假， ARG2假， 返回的结果是0

                  2. 逻辑与

                     1. ARG1 & ARG2

                        1. 如果ARG1为真(不为0 空)， ARG2为真， 返回的结果是ARG1
                           如果ARG1为真(不为0 空)， ARG2为假， 返回的结果是0
                           如果ARG1为假， ARG2为真， 返回的结果是0 如果ARG1为假， ARG2假， 返回的结果是0

               4. 关系运算

                  1. 如果条件成立则返回1，否则返回0

                     1. ARG1 < ARG2

                     2. ARG1 <= ARG2

                     3. ARG1 = ARG2

                     4. ARG1 != ARG2

                     5. ARG1 >= ARG2

                     6. ARG1 > ARG2

               5. 算术运算

                  1. ARG1 + ARG2

                  2. ARG1 - ARG2

                  3. ARG1 * ARG2

                  4. ARG1 / ARG2

                  5. ARG1 % ARG2

               6. 字符串运算

                  1. 匹配字符串，返回匹配字符的个数

                     1. match STRING REGEXP

                        1.  eg:
                                       str=hello
                                       str1=he
                                       value=`expr match $str $str1` ------>2

                  2. 实现字符串截取 从第一个位置开始第几个 截取多少个

                     1. substr STRING POS LENGTH

                        1. eg:
                                      str=www.hqyj.com
                                      格式：value=`expr substr $str 5 4`   ----->hqyj 

                  3. 获取字符在字符串中出现的位置从1开始，失败返回0

                     1. index STRING CHARS

                        1.  eg:
                                   char=e
                                   str=hello
                                   格式： value=`expr index $str $char`    -----返回的位置是2           

                  4. 计算字符串长度

                     1. length STRING

                        1. eg:
                                   str=www.hqyj.com    ${#str}
                                   格式： value=`expr length $str`  ------>12

   6. shell的选择结构

      1. 单、双、多分支

         1. 单分支选择结构

            1. if 表达式
                   then
                       sell语句
                   fi
                   执行过程：如果表达式为真，则执行shell语句，否则跳过

         2. 双分支选择结构

            1. if 表达式
                   then
                      sell语句1
                   else
                      sell语句2
                   fi
                   执行过程：如果表达式为真，则执行shell语句1，否则执行shell语句2

         3. 多分支选择结构

            1.   if 表达式1
                   then
                       sell语句1
                   elif 表达式2
                   then
                       sell语句2
                   .....
                   else
                       sell语句n
                   fi
                   执行过程：如果  表达式1为真，则执行shell语句1,结束多分支。如果表达式1为假，则执行表达式2，
                   如果表达式2为真，则执行shell语句2，结束多分支。如果为假向下继续

      2. test指令

         1. 1】test是一个指令,必须加空格
            2】test使用变量的值时，必须加$,使用变量时建议加" "
            3】test指令等价于[]

            1. 格式

               1.   if test 表达式
                      then
                          shell语句
                      fi

               2.  if [ 表达式 ]    ---->因为[]等价于test，而test是一个指令，指令必须有空格
                    then
                          shell语句
                    fi  

            2. test 的关系运算 e: = g: > l: < -eq:== -ge: >= -gt: > -le:<= -lt:< -ne:!=

               1. 判断整数INTEGER1和INTEGER2是否相等

                  1. INTEGER1 -ge INTEGER2

               2. 判断整数INTEGER1大于INTEGER2

                  1. INTEGER1 -gt INTEGER2

               3. 判断整数INTEGER1小于等于INTEGER2

                  1. INTEGER1 -le INTEGER2

               4. 判断整数INTEGER1小于INTEGER2

                  1. INTEGER1 -lt INTEGER2

               5. 判断整数INTEGER1不等于INTEGER2

                  1. INTEGER1 -ne INTEGER2

            3. test的逻辑运算

               1. 格式

                  1. [ 表达式1 -a 表达式2 ]

                  2. [ 表达式1 ] && [ 表达式2 ]

               2. 判断表达式为真

                  1. ( EXPRESSION )

                     1. 判断a不等于0
                        if(a!=0) if [ $a ]

               3. 判断表达式为假

                  1. ! EXPRESSION

                     1. 判断a等于0
                        if(a==0) if [ !$a ]

               4. 逻辑与：遇假则假，全真为真

                  1. EXPRESSION1 -a EXPRESSION2

                     1. if(ch>='0'&&ch<='9')
                                   if [ $ch -ge '0' -a $ch -le '9' ]                     
                                   if [ $ch -ge '0' ] && [ $ch -le '9' ] 

               5. 逻辑或：全假为假，遇真则真

                  1. EXPRESSION1 -o EXPRESSION2

2. 脑图

二、作业

1、分支结构结合test指令完成一下编程

1>判断闰年

代码解答：

#!/bin/bash


read -p "请输入一个年份：" year
if [ $((year%4)) -eq 0 -a $((year%100)) -ne 0 -o $((year%400)) -eq 0 ]
then
	echo yes
else
	echo no
fi

成果展现：

2>输入一个数判断是否为偶数

代码解答：

#!/bin/bash


read -p "请输入一个数字：" a
if [ $((a%2)) -eq 0 ]
then
	echo yes
fi

成果展现：

 

3>使用test指令实现等级判断 90--100A 60--89B 0-59C 其他错误

代码解答：

#!/bin/bash

read -p "请输入成绩：" score

if [ $score -ge 90 ] && [ $score -le 100 ]; then
    echo A
elif [ $score -ge 60 ] && [ $score -lt 90 ]; then
    echo B
elif [ $score -ge 0 ] && [ $score -lt 60 ]; then
    echo C
else
    echo "输入错误，请输入0到100之间的成绩"
fi

成果展现：

三、总结

学习内容概述

1. Shell脚本基础：

基本语法：

包括脚本的编写格式、注释的使用、变量的定义与使用。

基本命令：

常用的Shell命令如`echo`、`read`、`test`等，以及如何进行字符串操作、文件操作。

2. 条件控制：

if-else语句：

如何在Shell中使用`if`语句进行条件判断，包括单条件、多条件判断，`test`命令的使用。

case语句：

多条件判断的简化形式，处理多个匹配模式的情况。

3. 循环结构：

for循环：用于遍历列表或数组。

while和until循环：基于条件的循环执行，了解它们的不同应用场景。

循环控制语句：

`break`和`continue`的用法，控制循环的执行。

学习难点

1. 字符串和文件处理：

Shell脚本中处理字符串和文件时需要熟练使用各种命令，如`cut`、`sed`、`awk`等，这些命令的用法灵活多样，初学时容易混淆。

2. 条件判断与运算：

Shell脚本中的条件判断与其他编程语言有一定差异，特别是在数值运算和字符串比较时，`test`命令的符号使用容易引起困惑。

3. 输入输出重定向：

处理多个文件和命令的输入输出时，需要注意重定向符号的正确使用，避免数据丢失或格式错误。

注意事项

1. 脚本执行权限：

编写完成后，务必为脚本赋予执行权限（使用`chmod +x`），否则无法直接运行脚本。

2. 变量命名和作用域：

Shell脚本中变量的命名和作用域需要注意，全局变量和局部变量的管理不当可能导致数据冲突或不可预期的结果。

3. 调试脚本：

编写复杂的脚本时，建议在每个关键步骤进行输出，或者使用`set -x`进行逐步调试，方便查找逻辑问题。

4. 参数传递和返回值：

编写函数时要清楚如何传递参数，并了解返回值的局限性（只能返回整数），需要通过全局变量或回显来处理复杂数据。

 未来学习重点

1. 文件与文本处理工具：

深入学习`sed`、`awk`、`grep`等命令，掌握它们在数据过滤、格式化和分析中的强大功能。

2. Shell脚本中的高级编程：

学习如何通过Shell脚本自动化管理系统任务，例如定时任务的创建、日志文件的分析、批量文件处理等。

3. 与其他工具的结合：

探索Shell脚本与其他编程工具的结合，如Python、Perl，用于编写更复杂的系统管理脚本或自动化工具。

4. 性能优化：

随着脚本复杂度的增加，研究如何提高脚本执行效率，包括命令优化、减少不必要的资源消耗等。