Linux 当中 Shell 编程(超级详细快速入门上手到熟悉)

Linux 当中 Shell 编程(超级详细快速入门上手到熟悉)

@[toc]

---

1. Shell 编程概述

Shell被翻译为“壳”。在Linux内核外面包了一个壳。

Shell是一种用于与操作系统进行交互的命令行解释器。它是一种脚本语言，可以通过编写一系列的命令和脚本来执行操作系统的功能和任务。

我们在终端中编写的命令都是Shell命令。例如：ls、grep......等。

Shell 是一个命令行解释器，它为用户提供了一个向 Linux 内核发送请求以便运行程序的界面系统级程序，用户可以用 Shell 来启动、挂起、停止甚至是编写一些程序。看一个示意图

Linux系统结构：

Linux操作系统是一种开放源代码的类UNIX操作系统，它的结构分为内核、Shell和应用程序三个层次。

1. 内核层

内核是Linux系统的核心部分，它负责管理系统各种硬件设备、文件系统、内存管理和进程管理等核心任务。Linux内核设计了良好的模块化结构，可以动态地加载和卸载内核模块，这使得内核可以兼容各种不同的硬件设备和外围设备。

1. Shell层

Shell是Linux系统的命令行解释器，它负责将用户输入的命令解释并执行。Linux系统上有多种Shell，其中最常用的是Bash Shell。Bash Shell 提供了各种丰富的功能和处理能力，如通配符、重定向、管道、变量等等。

1. 应用层

应用层是Linux系统上的各种应用程序和服务，包括文本编辑器、图形界面、Web服务器、邮件服务器、数据库服务器等。在Linux系统中，应用程序通常以开放源代码方式呈现，用户可以自由学习和使用，也可以根据需求自己编写、修改或扩展。

为什么要学习 Shell 编程

1. Linux 运维工程师在进行服务器集群管理时，需要编写 Shell 程序来进行服务器管理。
2. 对于 Java EE 和 Python 程序员来说，工作的需要，你的上级会要求你编写一些 Shell 脚本进行程序或者是服务器的维护，比如：编写一个定时备份数据库的脚本。
3. 对于大数据程序员来说，需要编写 Shell 程序来管理集群。

Shell 脚本的执行方式

脚本格式要求：

1. 脚本编写的最最最开头要 以#!/bin/bash 开头
2. 该Shell 编写的脚本需要有可执行权限 。

2. 编写第一个 Shell 脚本

需求说明：创建一个 Shell 脚本，输出 hello world!

vim hello.sh

#!/bin/bash
echo "hello world"
                  

执行 shell 脚本

[root@localhost shcode]# ./hello.sh

[root@localhost shcode]# chmod u+x hello.sh  # 为 hello.sh 文件添加上可执行权限

有了可执行权限，执行该 hello.sh Shell 脚本。

[root@localhost shcode]# ./hello.sh

3. Shell 注释

单行注释是一行文本，它以井号（#）开头，从该字符开始一直延伸到该行的结束。在此行内，任何内容都会被 Shell 解释器忽略：

# 这是一行注释
echo "Hello, World!"  # 这是一行带有注释的代码

Shell 脚本也支持多行注释，这种注释也被称为块注释。块注释在脚本中可以用于分组一系列代码，或将一段代码置于未被执行的状态。在 Bash Shell 中，块注释通常使用以下语法：

: '
这里是注释内容。
可以是多行，直到下面一行的单独引号为止。
'

下面是一个示例，说明这种块注释的使用方法：

#!/bin/bash

: '
这是一个多行注释块。
我们将在这里添加一些注释，并将一些代码放在这里，以防它们被执行。

echo "Hello, World!"
'

echo "这行是被执行的。"

在此示例中，我们使用了一个多行注释块，该块包含我们想要添加的注释和未被执行的代码。通过使用这种方式添加注释，我们可以让脚本更具可读性。

注意：第一行代码的作用是告知系统采用bash解释器执行以下代码。可以省略，如果省略会默认使用当前会话的shell解释器。

4. Shell 脚本的常用执行方式

方式 1(输入脚本的绝对路径或相对路径)：

说明：首先要赋予 hello.sh 脚本的+x 可执行权限， 再执行脚本。

比如 ./hello.sh(当前路径下) 或者使用绝对路径 /root/shcode/hello.sh 方式 2(sh+脚本)：

说明：不用赋予脚本+x 权限，直接执行即可。

比如 sh hello.sh , 也可以使用绝对路径

[root@localhost shcode]# sh hello.sh 
hello world
[root@localhost shcode]# pwd
/home/linux/Study/Demo/shcode
[root@localhost shcode]# sh /home/linux/Study/Demo/shcode/hello.sh 
hello world
[root@localhost shcode]# 

5. Shell 的变量

1. Linux Shell 中的变量分为，系统变量和用户自定义变量。
2. 系统变量：$HOME、$PWD、$SHELL、$USER 等等，比如： echo $HOME 等等。
3. 显示当前 shell 中所有变量：set

5.1 shell 变量的定义

基本语法：

1. 定义变量：变量名=值 (注意：中间不要有空格)

2. 撤销变量：unset 变量
3. 声明静态变量：readonly 变量，注意：不能 unset

快速入门：

案例 1：定义变量 A

#!/bin/bash
#案例1: 定义变量A
A=100
#输出变量需要加上$
echo A $A
echo "A = $A"

[root@localhost shcode]# vim var.sh
[root@localhost shcode]# chmod u+x var.sh 
[root@localhost shcode]# ./var.sh 
A 100
A = 100

案例 2：撤销变量 A

#!/bin/bash
#案例1: 定义变量A
A=100
#输出变量需要加上$
echo A $A
echo "A = $A"
#案例2:撤销变量A
unset A
echo "A=$A"

案例 3：声明静态的变量 B=2，不能 unset

#!/bin/bash
#案例1: 定义变量A
A=100
#输出变量需要加上$
echo A $A
echo "A = $A"
#案例2:撤销变量A
unset A
echo "A=$A"
#案例3: 声明静态的变量B=2,不能unset
readonly B=2
echo "B=$B"
unset B

5.2 Shell 变量的定义

定义变量的规则：

1. 变量名称可以由字母、数字和下划线组成，但是不能以数字开头。5A=200(×)
2. 等号两侧不能有空格
3. 变量名称一般习惯为大写， 这是一个规范，我们遵守即可。

将命令的返回值赋给变量：

A=`date` 反引号，运行里面的命令，并把结果返回给变量 A。注意是反问号。
=$(date) 等价于反引号

#!/bin/bash
#案例1: 定义变量A
A=100
#输出变量需要加上$
echo A $A
echo "A = $A"
#案例2:撤销变量A
unset A
echo "A=$A"
#案例3: 声明静态的变量B=2,不能unset
readonly B=2
echo "B=$B"
#unset B
# 将指令返回的结果赋给变量
C=`date`
D=$(date)
echo "C=$C"
echo "D=$D"
# 使用环境变量 TOMCAT_HOME
echo "tomcat_home=$TOMCAT_HOME"

5.3 设置环境变量

基本语法：

1. export 变量名=变量值 （功能描述：将 shell 变量输出为环境变量/全局变量)

2. source 配置文件 （功能描述：让修改后的配置信息立即生效）

3. echo $变量名 （功能描述：查询环境变量的值）

4. 示意

在/etc/profile 文件中定义 TOMCAT_HOME 环境变量

查看环境变量 TOMCAT_HOME 的值

在另外一个 shell 程序中使用 TOMCAT_HOME 注意：在输出 TOMCAT_HOME 环境变量前，需要让其生效

shell 脚本的多行注释：

#unset B
# 将指令返回的结果赋给变量
:<<!
C=`date`
D=$(date)
echo "C=$C"
echo "D=$D"
!
# 使用环境变量 TOMCAT_HOME
echo "tomcat_home=$TOMCAT_HOME"
~                                 

5.4 位置参数变量(就是参数变量)

当我们执行一个 shell 脚本时，如果希望获取到命令行的参数信息，就可以使用到位置参数变量 比如 ： ./myshell.sh 100 200 , 这个就是一个执行 shell 的命令行，可以在 myshell 脚本中获取到参数信息

基本语法：

1. $n （功能描述：n 为数字，$0 代表命令本身，$1-$9 代表第一到第九个参数，十以上的参数，十以上的参数需要用大括号包含，如${10}。
2. $* （功能描述：这个变量代表命令行中所有的参数，$* 把所有的参数看成一个整体）。
3. $@ （功能描述：这个变量也代表命令行中所有的参数，不过$@ 把每个参数区分对待）。
4. $#（功能描述：这个变量代表命令行中所有参数的个数）

案例：编写一个 shell 脚本 position.sh ， 在脚本中获取到命令行的各个参数信息。

#!/bin/bash
echo 0=$0 1=$1 2=$2
echo "所有参数(看作一个整体)=$*"
echo "所有参数(独立开)%@"
echo "参数的个数=$#"
~                        

[root@localhost shcode]# chmod u+x position.sh 
[root@localhost shcode]# ./position.sh 100 200
0=./position.sh 1=100 2=200
所有参数(看作一个整体)=100 200
所有参数(独立开)%@
参数的个数=2

5.5 预定义变量

就是 shell 设计者事先已经定义好的变量，可以直接在 shell 脚本中使用

基本语法：

1. $$ （功能描述：当前进程的进程号（PID））
2. $! （功能描述：后台运行的最后一个进程的进程号（PID））
3. $？（功能描述：最后一次执行的命令的返回状态。如果这个变量的值为 0，证明上一个命令正确执行；如果这个变量的值为非 0（具体是哪个数，由命令自己来决定），则证明上一个命令执行不正确了。）

在一个 shell 脚本中简单使用一下预定义变量 preVar.sh

#!bin/bash
echo "当前执行的进程id=$$"
#以后台的方式运行一个脚本,并获取他的进程号
/home/linux/Study/Demo/shcode/hello.sh&
echo "最后一个后台方式运行的进程id=$"
echo "执行的结果是=$?"

[root@localhost shcode]# chmod u+x preVar.sh
[root@localhost shcode]# sh preVar.sh 
当前执行的进程id=9715
最后一个后台方式运行的进程id=$
执行的结果是=0
[root@localhost shcode

6. Shell 运算符

基本语法：

1. “$((运算式))”或“$[运算式]”或者 expr m + n //expression表达式

2. 注意 expr 运算符间要有空格, 如果希望将 expr 的结果赋给某个变量，使用 `` 反引号。

3. expr m - n

4. expr \*, /, % 乘，除，取余 。注意：这里乘法带了一个 /

应用实例 oper.sh

案例 1：计算（2+3）X4 的值

#!bin/bash
#案例 1：计算（2+3）X4 的值
#使用第一种方式:
RES1=$(((2+3)*4))
echo "res1=$RES1"
#使用第二种方式，推荐推荐推荐
RES2=$[(2+3)*4]
echo "res2=$RES2"
#使用第三种方式 expr
TEMP=`expr 2 + 3`
RES4=`expr $TEMP \* 4`
echo "temp=$TEMP"
echo "res4=$RES4"

案例 2：请求出命令行的两个参数[整数]的和 20 50

# 案例 2：请求出命令行的两个参数[整数]的和 20 50
SUM=$[$1+$2]
echo "sum=$SUM"

[root@localhost shcode]# vim oper.sh 
[root@localhost shcode]# sh oper.sh 20 50
res1=20
res2=20
temp=5
res4=20
sum=70
[root@localhost shcode]# 

7. Shell 条件判断

判断语句：

if condition 
then
  command1
  command2
  ...
elif condition2 
then
  command3
  command4
  ...
else
  command5
  command6
  ...
fi

基本语法：

[ condition ]（注意 condition 前后要有空格）
#非空返回 true，可使用$?验证（0 为 true，>1 为 false）

[ rainbowsea ] 返回 true
[ ] 返回 false。注意：[]中括号里面，前后都要有一个空格，一共2个空格。
[ condition ] && echo OK || echo notok 条件满足，执行后面的语句

判断语句：

中括号有两种使用方法：

1. 用于比较操作符：用于比较两个值的大小或者判断两个值是否相等。例如：

• -eq: 判断两个值是否相等（equal to），例如[ $a -eq $b ]
• -ne: 判断两个值是否不相等（not equal to），例如[ $a -ne $b ]
• -lt: 判断左边的值是否小于右边的值（less than），例如[ $a -lt $b ]
• -gt: 判断左边的值是否大于右边的值（greater than），例如[ $a -gt $b ]
• -le: 判断左边的值是否小于等于右边的值（less than or equal to），例如[ $a -le $b ]
• -ge: 判断左边的值是否大于等于右边的值（greater than or equal to），例如[ $a -ge $b ]

在Shell中，比较操作符可以用于中括号[]中，例如:[ $a -eq $b ]。在比较时，要注意两个值之间必须有空格分隔，否则会出现语法错误。

1. 用于测试表达式：用于测试某个表达式是否成立。例如：

• -f: 判断某个文件是否存在并且是一个常规文件（regular file），例如[ -f file.txt ]
• -d: 判断某个文件是否存在并且是一个目录（directory），例如[ -d dir ]
• -z: 判断某个字符串是否为空（zero length），例如[ -z "$str" ]
• -n: 判断某个字符串是否非空（not zero length），例如[ -n "$str" ]
• -e: 判断某个文件或目录是否存在（exist），例如[ -e file.txt ]

3. 按照文件权限进行判断

• -r : 有读的权限
• -w: 有写的权限
• -x: 有执行的权

4. 按照文件类型进行判断

• -f: 文件存在并且是一个常规的文件
• -e: 文件存在
• -d: 文件存在并是一个目录

在Shell中，测试表达式也可以用于中括号[]中，例如:[ -f file.txt ]。在多数Linux发行版中，测试表达式可以用中括号[]或者test命令实现，例如:test -f file.txt等价于[ -f file.txt ]。

需要注意的是，中括号中的空格很重要，空格缺少会导致语法错误。另外，在使用中括号[]时，要注意变量用双引号括起来，避免空值引起的语法错误。

应用实例 案例 1："ok"是否等于"ok" 判断语句：使用 = 案例 2：23 是否大于等于 22 判断语句：使用 -ge 案例 3：/root/shcode/aaa.txt 目录中的文件是否存在 判断语句： 使用 -f 代码如下

#!/bin/bash
#案例1：“ok” 是否等于 "ok"
if [ "ok" = "ok" ]
then
       echo "equal"
fi
#案例2: 23 是否大于等于 22
if [ 23 -ge 22 ]
then
       echo "大于"
fi
#案例3:/root/shcode/aaa.txt 目录中文件是否存在
#判断语句:使用 -f
if [ -f /root/schode/aaa.txt ]
then
       echo "存在"
fi
#看几个案例:
if [ rainbowsea ]
then
       echo "hello rainbowsea"
fi
if [  ]
then
       echo "真"
fi

8. 流程控制

8.1 if 判断

注意事项：[ 条件判断式 ]，中括号和条件判断式之间必须有空

if condition 
then
  command1
  command2
  ...
elif condition2 
then
  command3
  command4
  ...
else
  command5
  command6
  ...
fi

应用实例 ifCase.sh 案例：请编写一个 shell 程序，如果输入的参数，大于等于 60，则输出 "及格了"，如果小于 60,则输出 "不及格"

#案例：请编写一个 shell 程序，如果输入的参数，大于等于 60，则输出 "及格了"，如果小于 60,则输出 "不及格"
if [ $1 -ge 60 ]
then
        echo "及格了"
elif [ $1 -lt 60 ]
then
        echo "不及格"
fi

[root@localhost shcode]# vim ifCase.sh
[root@localhost shcode]# chmod u+x ifCase.sh 
[root@localhost shcode]# sh ifCase.sh 99
及格了

8.2 case 语句

基本语法:

case $变量名 in
"值 1"）
如果变量的值等于值 1，则执行程序 1
;;
"值 2"）
如果变量的值等于值 2，则执行程序 2
;;
…省略其他分支…
*）
如果变量的值都不是以上的值，则执行此程序
;;
esac

应用实例 testCase.sh 案例 1 ：当命令行参数是 1 时，输出 "周一", 是 2 时，就输出"周二"， 其它情况输出 "other"

#/!bin/bash
#案例 1 ：当命令行参数是 1 时，输出 "周一", 是 2 时，就输出"周二"， 其它情况输出 "other"
case $1 in
"1")
echo "周一"
;;
"2")
echo "周二"
;;
*)
echo "other.."
;;
esac

[root@localhost shcode]# vim testCase.sh
[root@localhost shcode]# chmod u+x testCase.sh 
[root@localhost shcode]# sh testCase.sh 
other..
[root@localhost shcode]# sh testCase.sh 2
周二
[root@localhost shcode]# sh testCase.sh 1
周一
[root@localhost shcode]# sh testCase.sh 6
other..

8.3 for 循环

基本语法：

for循环用于遍历指定列表或值的集合，并执行相应的语句块。for循环语法格式如下：

for 变量 in 值 1 值 2 值 3…
do
   程序/代码
done

for var in list
do
  command1
  command2
  ...
done

其中，var是一个临时的变量名，用于存储当前循环的值，list是一个值或者多个带有空格或换行符分隔的值组成的列表。在每一次循环迭代时，var会被list列表中的一个值所替换，直到list中的所有值都被处理完为止。

应用实例 testFor1.sh

案例 1 ：打印命令行输入的参数 [这里可以看出$* 和$@ 的区别]

#!/bin/bash
#案例 1 ：打印命令行输入的参数 [这里可以看出∗和* 和 @ 的区别]
# 注意: $* 是把输入的参数,当做一个整体，所以，只会输出一句
for i in "$*"
do
     echo "num is $1"
done
#使用 $@来获取输入的参数,注意:这时是分别对待，所以有几个参数，就输出几个
echo "===================================================="
for j in "$@"
do
     echo "num is $j"
done

[root@localhost shcode]# vim testFor1.sh 
[root@localhost shcode]# chmod u+x testFor1.sh 
[root@localhost shcode]# sh testFor1.sh 
num is 
====================================================
[root@localhost shcode]# sh testFor1.sh 100 200 300
num is 100
====================================================
num is 100
num is 200
num is 300

基本语法 2：

for (( 初始值;循环控制条件;变量变化 ))
do
   程序/代码
done

应用实例 testFor2.sh 案例 1 ：输入参数，从 1 加到 参数 的值输出显示

#!/bin/bash
#案例 1 ：输入参数，从 1 加到 参数 的值输出显示
for((i=1;i<=$1;i++))
do
#写下你要处理的业务代码
     SUM=$[$SUM+$i]
done
echo "总和SUM=$SUM"

[root@localhost shcode]# vim testFor2.sh 
[root@localhost shcode]# chmod u+x testFor2.sh 
[root@localhost shcode]# sh testFor2.sh 
testFor2.sh: line 3: ((: i<=: syntax error: operand expected (error token is "<=")
总和SUM=
[root@localhost shcode]# sh testFor2.sh 100
总和SUM=5050
[root@localhost shcode]# 

8.4 while 循环

基本语法：

while循环用于不断执行语句块，直到满足指定条件为止。while循环语法格式如下：

while [ 条件判断式 ]
do
  command1
  command2
  ...
done

其中，condition是要检查的条件，如果条件为真，则执行do语句块中的命令，执行完后再回到while语句中检查条件是否依然为真，如果条件仍为真，则继续执行命令块，否则跳出循环。

注意：在shell编程中 $((...)) 被称为算术扩展运算符，做数学运算的，并且将运算结果返回。$(...)运算符会将结果直接返回。例如：

• $((j+1))，如果j是5的话，结果就会返回6 （注意，使用这个运算符的时候，括号里面不能有空格）
• $(echo "hello world")，会将"hello world"打印，然后再将"hello world"字符串返回。

注意：while 和 [有空格，条件判断式和 [也有空格]

应用实例 testWhile.sh 案例 1 ：从命令行输入一个数 n，统计从 1+..+ n 的值是多少？

#!/bin/bash
#案例 1 ：从命令行输入一个数 n，统计从 1+..+ n 的值是多少？
#定义一个变量 SUM
SUM=0
i=0
while [ $i -le $1 ]
do
     SUM=$[$SUM+$i]
     #i自增
     i=$[$i+1]
done
echo "SUM=$SUM"

[root@localhost shcode]# vim testWhile.sh 
[root@localhost shcode]# chmod u+x testWhile.sh 
[root@localhost shcode]# sh testWhile.sh 
testWhile.sh: line 6: [: 0: unary operator expected
SUM=0
[root@localhost shcode]# sh testWhile.sh 100
SUM=5050
[root@localhost shcode]# 

8.5 until 循环

until循环用于不断执行语句块，直到满足指定条件为止。和while循环不同的是，直到指定条件为假时才会停止循环。until循环语法格式如下：

until [ 条件判断式 ]  # until后面要有空格
do
  command1
  command2
  ...
done

其中，condition是要检查的条件，如果条件为假，则执行do语句块中的命令，执行完后再回到until语句中检查条件是否依然为假，如果条件仍为假，则继续执行命令块，否则跳出循环。

#!/bin/bash

k=0
until [ $k -ge 5 ]
do
  echo "The value of k is: $k"
  k=$((k+1))
done

8.6 3.3.6. break 和 continue语句

break和continue是控制循环的两个重要关键字。

• break语句用于跳出当前循环块，例如在for循环和while循环中使用该语句时，可以跳出当前循环并停止迭代。break语句可以嵌套在多重循环中，用于跳出内层循环和外层循环，其语法格式如下：

while [ 条件判断式 ]  # while 后面要有空格
do
  command1
  command2
  if condition2 
	then
    break
  fi
  command3
  ...
done

在上述示例中，如果在执行command2时，条件condition2成立，那么会执行break语句，跳出循环块并停止迭代。

• continue语句用于跳过本次循环迭代，直接进入下一次的迭代。在for循环和while循环中使用该语句时，可以用于跳过本次迭代，执行下一次迭代。其语法格式如下：

while condition
do
  command1
  command2
  if condition2
  then
    continue
  fi
  command3
  ...
done

在上述示例中，如果在执行command2时，条件condition2成立，那么会执行continue语句，跳过本次迭代，直接进入下一次迭代。

#!/bin/bash

for l in 1 2 3 4 5
do
  if [ $l -eq 3 ] 
	then
    continue
  fi
  echo "The value of l is: $l"
  if [ $l -eq 4 ] 
	then
    break
  fi
done

9. read 读取控制台输入

基本语法：

read(选项)(参数) 选项： -p： 指定读取值时的提示符； -t： 指定读取值时等待的时间（秒），如果没有在指定的时间内输入，就不再等待了。。 参数 变量：指定读取值的变量名

应用实例 testRead.sh

案例 1：读取控制台输入一个 NUM1 值

案例 2：读取控制台输入一个 NUM2 值，在 10 秒内输入。

#!/bin/bash
#案例 1：读取控制台输入一个 NUM1 值
read -p "请输入一个数NUM1=" NUM1
echo "你输入的NUM1=$NUM1"
#案例 2：读取控制台输入一个 NUM2 值，在 10 秒内输入
read -t 10 -p "输入一个数NUM2=" NUM2
echo "你输入的NUM1=$NUM2"

[root@localhost shcode]# vim testRead.sh 
[root@localhost shcode]# chmod u+x testRead.sh 
[root@localhost shcode]# sh testRead.sh 
请输入一个数NUM1=100
你输入的NUM1=100
输入一个数NUM2=200
你输入的NUM1=200
[root@localhost shcode]# sh testRead.sh 
请输入一个数NUM1=666
你输入的NUM1=666
输入一个数NUM2=你输入的NUM1=
[root@localhost shcode]# vim testRead.sh 

10. Shell 函数

在Shell编程中，函数是一种可重用的代码块，可以提高程序的可读性和可维护性。通过定义一个函数，可以把一段代码封装起来，赋予其一个名称，可以在程序的其他部分反复调用。

Shell脚本中的函数非常灵活，可以使用各种Shell语句和命令来编写，如if语句、for循环、while循环等。

10.1 系统函数

basename 基本语法 功能：返回完整路径最后 / 的部分，常用于获取文件名

basename [pathname] [suffix]
basename [string] [suffix] （功能描述：basename 命令会删掉所有的前缀包括最后一个（‘/’）字符，然后将字符串
显示出来。
选项：
suffix 为后缀，如果 suffix 被指定了，basename 会将 pathname 或 string 中的 suffix 去掉。

应用实例：

案例 1：请返回 /home/aaa/test.txt 的 "test.txt" 部分 basename /home/aaa/test.txt

[root@localhost shcode]#  basename /home/aaa/test.txt
test.txt
[root@localhost shcode]# 

dirname 基本语法：

功能：返回完整路径最后 / 的前面的部分，常用于返回路径部分 dirname 文件绝对路径 （功能描述：从给定的包含绝对路径的文件名中去除文件名（非目录的部分），然后返回剩 下的路径（目录的部分））

应用实例

案例 1：请返回 /home/aaa/test.txt 的 /home/aaa 的dirname /home/aaa/test.txt

[root@localhost shcode]# dirname /home/aaa/test.txt
/home/aaa
[root@localhost shcode]# 

10.2 自定义函数

基本语法：

[ function ] funname[()]
{
    Action;
    [return int;]
}

调用直接写函数名：funname [值]

下面是一个示例函数的定义：

function say_hello() {
  echo "Hello, world!"
}

在上述示例中，我们定义了一个函数名为say_hello，它的执行结果是输出Hello, world!字符串。函数定义的语法格式如下：

function_name() {
    commands
}

使用function关键字来定义函数是可选的。当使用function关键字时，要注意不要加空格，否则会出现语法错误。函数体中可以包含任意数量的命令和语句。

应用实例 案例 1：计算输入两个参数的和(动态的获取)， getSum

#!/bin/bash
#案例 1：计算输入两个参数的和(动态的获取)， getSum
#定义函数: getSum
function getSum() {
       SUM=$[$n1+$n2]
       echo "和是=$SUM"
}
#输入两个值
read -p "请输入一个数n1=" n1
read -p "请输入一个数n2=" n2
#调用自定义函数
getSum $n1 $n2

[root@localhost shcode]# vim testFun.sh
[root@localhost shcode]# chmod u+x testFun.sh 
[root@localhost shcode]# sh testFun.sh 
请输入一个数n1=10
请输入一个数n2=90
和是=100
[root@localhost shcode]# 

11. 实现数据库自动备份

下面是一个用Shell编写的自动备份数据库的脚本，可以根据实际情况进行修改和调整：

#!/bin/bash

# 设置备份目录
backupDir="/home/backup"

# 设置需要备份的数据库名称和用户名、密码
dbUser="root"
dbPass="123456"
dbName="database_name"

# 设置备份文件名，包括日期和时间
backupFile="$backupDir/${dbName}_$(date +%Y%m%d_%H%M%S).sql"

# 执行备份命令
mysqldump -u$dbUser -p$dbPass $dbName > $backupFile

# 压缩备份文件
gzip -f $backupFile

# 删除7天前的备份文件
find $backupDir -mtime +7 -type f -name "${dbName}*.sql.gz" -delete

脚本的实现流程如下：

1. 首先设置备份目录和要备份的数据库的用户名、密码和名称。
2. 然后，设置备份文件名，这里使用了当前日期和时间来命名备份文件。
3. 接下来，使用mysqldump命令备份数据库并将结果重定向到备份文件中。
4. 备份完成后，使用gzip命令将备份文件压缩。
5. 最后，使用find命令删除7天前的备份文件，以避免占用过多磁盘空间。

将这个脚本保存到一个文件中，如backup_db.sh，并添加可执行权限：

chmod +x backup_db.sh

通过编辑crontab文件，可以将这个脚本设置为定期自动运行，比如每天执行一次备份。打开终端，输入：

crontab -e

在文件末尾添加下面的一行：

0 0 * * * /path/to/backup_db.sh

#  20 12 * * * /path/to/backup_db.sh 表示每天12:20会执行一次脚本。

保存并退出crontab文件，这样在每天午夜0点进行自动备份。如果需要调整自动备份的时间，也可以修改crontab文件中的时间字段。

12. 最后：

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”