Linux Shell脚本编程#

什么是Shell脚本？#

Shell脚本是一种包含一系列Shell命令的文本文件，它可以自动执行这些命令，实现自动化任务。Shell脚本是Linux系统中自动化管理和任务处理的重要工具。

常用的Shell#

Bash (Bourne Again Shell)：最常用的Shell，是大多数Linux发行版的默认Shell
sh (Bourne Shell)：最早的Shell，是其他Shell的基础
csh (C Shell)：语法类似C语言的Shell
tcsh：csh的增强版
zsh：功能强大的Shell，兼容Bash
ksh (Korn Shell)：兼容Bash和csh的Shell

Shell脚本的基本结构#

脚本的第一行#

Shell脚本的第一行通常是shebang（#!），指定执行脚本的Shell。

1
#!/bin/bash  # 使用Bash执行脚本
2
#!/bin/sh    # 使用sh执行脚本
3
#!/usr/bin/env bash  # 更灵活的方式，使用环境中的bash

注释#

在Shell脚本中，使用#开始的行是注释，不会被执行。

1
#!/bin/bash
2

3
# 这是一个注释
4
# 下面的命令会创建一个目录
5
mkdir -p test

脚本的执行权限#

需要为Shell脚本添加执行权限才能执行。

1
# 添加执行权限
2
chmod +x script.sh
3

4
# 执行脚本
5
./script.sh

变量#

变量的定义和使用#

在Shell脚本中，变量的定义不需要类型声明，直接赋值即可。

1
#!/bin/bash
2

3
# 定义变量
4
name="World"
5
age=18
6

7
# 使用变量
8
echo "Hello, $name!"
9
echo "Your age is $age."
10

11
# 变量名的大括号包围（推荐）
12
echo "Hello, ${name}!"
13
echo "Your age is ${age}."
14

15
# 修改变量值
16
age=20
17
echo "Your new age is $age."

环境变量#

环境变量是系统预定义的变量，通常使用大写字母表示。

1
#!/bin/bash
2

3
# 显示环境变量
4
echo "Home directory: $HOME"
5
echo "Current user: $USER"
6
echo "Path: $PATH"
7
echo "Shell: $SHELL"
8
echo "Current directory: $PWD"
9

10
# 设置环境变量
11
export MY_VAR="Hello"
12
echo "My variable: $MY_VAR"

特殊变量#

Shell中有一些特殊变量，用于获取命令行参数、退出状态等。

1
#!/bin/bash
2

3
# 显示脚本名称
4
echo "Script name: $0"
5

6
# 显示命令行参数
7
echo "Number of arguments: $#"
8
echo "All arguments: $@"
9
echo "All arguments (as single string): $*"
10
echo "First argument: $1"
11
echo "Second argument: $2"
12

13
# 显示最后一个命令的退出状态
14
echo "Exit status: $?"
15

16
# 显示当前进程ID
17
echo "Process ID: $$"
18

19
# 显示后台最后一个进程的ID
20
echo "Last background process ID: $!"

变量的读取#

使用read命令从标准输入读取变量值。

1
#!/bin/bash
2

3
# 读取变量
4
read -p "Enter your name: " name
5
echo "Hello, $name!"
6

7
# 读取多个变量
8
read -p "Enter your name and age: " name age
9
echo "Hello, $name! Your age is $age."
10

11
# 隐藏输入（用于密码）
12
read -s -p "Enter your password: " password
13
echo "\nPassword entered."

运算符#

算术运算符#

Shell中的算术运算需要使用$((...))或expr命令。

1
#!/bin/bash
2

3
# 使用$((...))进行算术运算
4
x=5
5
y=3
6
echo "x + y = $((x + y))"
7
echo "x - y = $((x - y))"
8
echo "x * y = $((x * y))"
9
echo "x / y = $((x / y))"
10
echo "x % y = $((x % y))"
11
echo "x ** y = $((x ** y))"  # 幂运算
12

13
# 自增和自减
14
x=5
15
echo "x = $x"
16
echo "x++ = $((x++))"
17
echo "x = $x"
18
echo "++x = $((++x))"
19
echo "x = $x"
20

21
# 使用let命令
22
let x=10
23
echo "x = $x"
24
let x=x+5
25
echo "x = $x"

比较运算符#

比较运算符用于比较数值或字符串。

1
#!/bin/bash
2

3
# 数值比较
4
x=5
5
y=10
6

7
if [ $x -eq $y ]; then
8
    echo "x equals y"
9
elif [ $x -ne $y ]; then
10
    echo "x not equals y"
11
elif [ $x -lt $y ]; then
12
    echo "x less than y"
13
elif [ $x -le $y ]; then
14
    echo "x less than or equal to y"
15
elif [ $x -gt $y ]; then
16
    echo "x greater than y"
17
elif [ $x -ge $y ]; then
18
    echo "x greater than or equal to y"
19
fi
20

21
# 字符串比较
22
str1="hello"
23
str2="world"
24

25
if [ "$str1" = "$str2" ]; then
26
    echo "str1 equals str2"
27
elif [ "$str1" != "$str2" ]; then
28
    echo "str1 not equals str2"
29
elif [ -z "$str1" ]; then
30
    echo "str1 is empty"
31
elif [ -n "$str1" ]; then
32
    echo "str1 is not empty"
33
elif [ "$str1"  "$str2" ]; then
34
    echo "str1 less than str2"
35
elif [ "$str1"  "$str2" ]; then
36
    echo "str1 greater than str2"
37
fi

逻辑运算符#

逻辑运算符用于组合多个条件。

1
#!/bin/bash
2

3
# 逻辑与 (&&)
4
x=5
5
if [ $x -gt 0 ] && [ $x -lt 10 ]; then
6
    echo "x is between 0 and 10"
7
fi
8

9
# 逻辑或 (||)
10
x=15
11
if [ $x -lt 0 ] || [ $x -gt 10 ]; then
12
    echo "x is less than 0 or greater than 10"
13
fi
14

15
# 逻辑非 (!)
16
x=5
17
if ! [ $x -gt 10 ]; then
18
    echo "x is not greater than 10"
19
fi
20

21
# 使用双括号的逻辑运算
22
x=5
23
if (( $x > 0 && $x < 10 )); then
24
    echo "x is between 0 and 10"
25
fi

文件测试运算符#

文件测试运算符用于测试文件的属性。

1
#!/bin/bash
2

3
file="test.txt"
4

5
# 测试文件是否存在
6
if [ -e "$file" ]; then
7
    echo "File exists"
8
else
9
    echo "File does not exist"
10
fi
11

12
# 测试是否为普通文件
13
if [ -f "$file" ]; then
14
    echo "Is a regular file"
15
fi
16

17
# 测试是否为目录
18
if [ -d "$file" ]; then
19
    echo "Is a directory"
20
fi
21

22
# 测试是否有读取权限
23
if [ -r "$file" ]; then
24
    echo "Has read permission"
25
fi
26

27
# 测试是否有写入权限
28
if [ -w "$file" ]; then
29
    echo "Has write permission"
30
fi
31

32
# 测试是否有执行权限
33
if [ -x "$file" ]; then
34
    echo "Has execute permission"
35
fi
36

37
# 测试文件是否为空
38
if [ -s "$file" ]; then
39
    echo "File is not empty"
40
else
41
    echo "File is empty"
42
fi

控制流#

if语句#

if语句用于条件判断。

1
#!/bin/bash
2

3
# 基本if语句
4
x=5
5
if [ $x -gt 0 ]; then
6
    echo "x is positive"
7
fi
8

9
# if-else语句
10
x=-5
11
if [ $x -gt 0 ]; then
12
    echo "x is positive"
13
else
14
    echo "x is not positive"
15
fi
16

17
# if-elif-else语句
18
x=0
19
if [ $x -gt 0 ]; then
20
    echo "x is positive"
21
elif [ $x -lt 0 ]; then
22
    echo "x is negative"
23
else
24
    echo "x is zero"
25
fi
26

27
# 使用双括号的if语句
28
x=5
29
if (( $x > 0 )); then
30
    echo "x is positive"
31
fi
32

33
# 使用中括号的if语句（更灵活）
34
x=5
35
if [[ $x > 0 && $x < 10 ]]; then
36
    echo "x is between 0 and 10"
37
fi

case语句#

case语句用于多分支条件判断，类似于其他语言的switch语句。

1
#!/bin/bash
2

3
# 基本case语句
4
read -p "Enter a number (1-3): " num
5

6
case $num in
7
    1)
8
        echo "You entered one."
9
        ;;
10
    2)
11
        echo "You entered two."
12
        ;;
13
    3)
14
        echo "You entered three."
15
        ;;
16
    *)
17
        echo "Invalid input."
18
        ;;
19
esac
20

21
# 使用模式匹配
22
read -p "Enter a string: " str
23

24
case $str in
25
    [a-z]*)
26
        echo "Starts with lowercase letter"
27
        ;;
28
    [A-Z]*)
29
        echo "Starts with uppercase letter"
30
        ;;
31
    [0-9]*)
32
        echo "Starts with number"
33
        ;;
34
    *)
35
        echo "Starts with other character"
36
        ;;
37
esac

for循环#

for循环用于遍历列表中的元素。

1
#!/bin/bash
2

3
# 遍历数字列表
4
for i in 1 2 3 4 5; do
5
    echo "Number: $i"
6
done
7

8
# 遍历字符串列表
9
for fruit in apple banana cherry date; do
10
    echo "Fruit: $fruit"
11
done
12

13
# 使用seq生成数字序列
14
for i in $(seq 1 5); do
15
    echo "Number: $i"
16
done
17

18
# 使用{start..end}生成序列（Bash 4+）
19
for i in {1..5}; do
20
    echo "Number: $i"
21
done
22

23
# 使用C风格的for循环
24
for ((i=1; i<=5; i++)); do
25
    echo "Number: $i"
26
done
27

28
# 遍历目录中的文件
29
for file in *.txt; do
30
    echo "File: $file"
31
done
32

33
# 遍历命令行参数
34
for arg in "$@"; do
35
    echo "Argument: $arg"
36
done

while循环#

while循环用于在条件为真时重复执行命令。

1
#!/bin/bash
2

3
# 基本while循环
4
count=1
5
while [ $count -le 5 ]; do
6
    echo "Count: $count"
7
    count=$((count + 1))
8
done
9

10
# 使用C风格的while循环
11
count=1
12
while (( $count <= 5 )); do
13
    echo "Count: $count"
14
    count=$((count + 1))
15
done
16

17
# 无限循环（使用Ctrl+C退出）
18
# while true; do
19
#     echo "Hello"
20
#     sleep 1
21
# done
22

23
# 从文件读取行
24
while read line; do
25
    echo "Line: $line"
26
done < file.txt
27

28
# 读取标准输入
29
# echo "Enter lines (Ctrl+D to end):"
30
# while read line; do
31
#     echo "You entered: $line"
32
# done

until循环#

until循环用于在条件为假时重复执行命令，与while循环相反。

1
#!/bin/bash
2

3
# 基本until循环
4
count=1
5
until [ $count -gt 5 ]; do
6
    echo "Count: $count"
7
    count=$((count + 1))
8
done
9

10
# 使用C风格的until循环
11
count=1
12
until (( $count > 5 )); do
13
    echo "Count: $count"
14
    count=$((count + 1))
15
done

break和continue#

break：跳出当前循环
continue：跳过当前循环的剩余部分，开始下一次循环

1
#!/bin/bash
2

3
# 使用break
4
for i in 1 2 3 4 5; do
5
    if [ $i -eq 3 ]; then
6
        break
7
    fi
8
    echo "Number: $i"
9
done
10

11
# 使用continue
12
for i in 1 2 3 4 5; do
13
    if [ $i -eq 3 ]; then
14
        continue
15
    fi
16
    echo "Number: $i"
17
done

函数#

函数的定义和调用#

1
#!/bin/bash
2

3
# 定义函数
4
greet() {
5
    echo "Hello, $1!"
6
}
7

8
# 调用函数
9
greet "World"
10
greet "Alice"
11

12
# 带返回值的函数
13
add() {
14
    local sum=$(( $1 + $2 ))
15
    echo $sum
16
}
17

18
# 使用函数返回值
19
result=$(add 5 3)
20
echo "Sum: $result"
21

22
# 函数中的局部变量
23
count=10
24

25
increment() {
26
    local count=0  # 局部变量，不会影响外部变量
27
    count=$((count + 1))
28
    echo "Local count: $count"
29
}
30

31
increment
32
echo "Global count: $count"
33

34
# 函数库
35
# 可以将常用函数放在一个文件中，然后在其他脚本中source
36
# source functions.sh

函数的参数#

函数可以接收参数，使用$1、$2等获取。

1
#!/bin/bash
2

3
# 函数的参数
4
print_args() {
5
    echo "Number of arguments: $#"
6
    echo "First argument: $1"
7
    echo "Second argument: $2"
8
    echo "All arguments: $@"
9
}
10

11
# 调用函数
12
print_args "Hello" "World"
13

14
# 函数中的特殊变量
15
print_special() {
16
    echo "Function name: $0"
17
    echo "Last command exit status: $?"
18
    echo "Process ID: $$"
19
}
20

21
print_special

输入和输出#

标准输入、输出和错误#

标准输入 (stdin)：文件描述符为0，默认是键盘
标准输出 (stdout)：文件描述符为1，默认是屏幕
标准错误 (stderr)：文件描述符为2，默认是屏幕

重定向#

1
#!/bin/bash
2

3
# 重定向标准输出到文件
4
 echo "Hello, World!" > output.txt
5

6
# 重定向标准输出并追加到文件
7
 echo "Hello again!" >> output.txt
8

9
# 重定向标准错误到文件
10
error_command 2> error.txt
11

12
# 重定向标准输出和错误到文件
13
command &> output.txt
14

15
# 重定向标准输出到标准错误
16
echo "Error message" >&2
17

18
# 从文件读取输入
19
while read line; do
20
    echo "Line: $line"
21
done < input.txt
22

23
# 管道：将一个命令的输出作为另一个命令的输入
24
echo "Hello, World!" | grep "World"
25

26
#  tee命令：同时输出到标准输出和文件
27
echo "Hello, World!" | tee output.txt

数组#

数组的定义和使用#

1
#!/bin/bash
2

3
# 定义数组
4
fruits=('apple' 'banana' 'cherry' 'date')
5

6
# 访问数组元素
7
echo "First fruit: ${fruits[0]}"
8
echo "Second fruit: ${fruits[1]}"
9
echo "Third fruit: ${fruits[2]}"
10
echo "Fourth fruit: ${fruits[3]}"
11

12
# 访问所有元素
13
echo "All fruits: ${fruits[@]}"
14
echo "All fruits: ${fruits[*]}"
15

16
# 数组长度
17
echo "Number of fruits: ${#fruits[@]}"
18

19
# 修改数组元素
20
fruits[2]='grape'
21
echo "Third fruit: ${fruits[2]}"
22

23
# 添加数组元素
24
fruits+=('elderberry')
25
echo "Fifth fruit: ${fruits[4]}"
26
echo "All fruits: ${fruits[@]}"
27

28
# 删除数组元素
29
unset fruits[1]
30
echo "All fruits after deletion: ${fruits[@]}"
31

32
# 遍历数组
33
for fruit in "${fruits[@]}"; do
34
    echo "Fruit: $fruit"
35
done
36

37
# 遍历数组（带索引）
38
for i in "${!fruits[@]}"; do
39
    echo "Fruit $i: ${fruits[$i]}"
40
done

关联数组#

关联数组（也称为哈希表）允许使用字符串作为索引，Bash 4.0+支持。

1
#!/bin/bash
2

3
# 声明关联数组
4
declare -A colors
5

6
# 添加键值对
7
colors["red"]="#ff0000"
8
colors["green"]="#00ff00"
9
colors["blue"]="#0000ff"
10

11
# 访问关联数组元素
12
echo "Red: ${colors[red]}"
13
echo "Green: ${colors[green]}"
14
echo "Blue: ${colors[blue]}"
15

16
# 遍历关联数组的键
17
for color in "${!colors[@]}"; do
18
    echo "Color: $color"
19
done
20

21
# 遍历关联数组的键值对
22
for color in "${!colors[@]}"; do
23
    echo "$color: ${colors[$color]}"
24
done
25

26
# 关联数组的大小
27
echo "Number of colors: ${#colors[@]}"
28

29
# 删除关联数组元素
30
unset colors[red]
31
echo "Colors after deletion: ${!colors[@]}"
32

33
# 清空关联数组
34
unset colors
35
echo "Number of colors after unset: ${#colors[@]}"

算术运算#

基本算术运算#

1
#!/bin/bash
2

3
# 使用$((...))
4
x=5
5
y=3
6

7
# 加法
8
sum=$((x + y))
9
echo "Sum: $sum"
10

11
# 减法
12
diff=$((x - y))
13
echo "Difference: $diff"
14

15
# 乘法
16
product=$((x * y))
17
echo "Product: $product"
18

19
# 除法
20
quotient=$((x / y))
21
echo "Quotient: $quotient"
22

23
# 取模
24
remainder=$((x % y))
25
echo "Remainder: $remainder"
26

27
# 幂运算
28
power=$((x ** y))
29
echo "Power: $power"
30

31
# 自增和自减
32
x=5
33
echo "Original x: $x"
34
x=$((x + 1))
35
echo "x after increment: $x"
36
x=$((x - 1))
37
echo "x after decrement: $x"
38

39
# 使用let命令
40
x=5
41
let x=x+1
42
echo "x after let increment: $x"
43

44
# 使用expr命令（较旧的方式）
45
x=5
46
y=3
47
sum=$(expr $x + $y)
48
echo "Sum using expr: $sum"

浮点运算#

Shell本身不支持浮点运算，需要使用外部工具如bc。

1
#!/bin/bash
2

3
# 使用bc进行浮点运算
4
x=5
5
y=3
6

7
# 除法
8
division=$(echo "scale=2; $x / $y" | bc)
9
echo "Division: $division"
10

11
# 其他运算
12
square_root=$(echo "scale=2; sqrt($x)" | bc)
13
echo "Square root of $x: $square_root"
14

15
exponential=$(echo "scale=2; e($x)" | bc -l)
16
echo "Exponential of $x: $exponential"
17

18
sine=$(echo "scale=2; s($x)" | bc -l)
19
echo "Sine of $x: $sine"

正则表达式#

grep命令的正则表达式#

1
#!/bin/bash
2

3
# 基本正则表达式
4
# 匹配包含"test"的行
5
echo "Testing 123" | grep "test"
6

7
# 匹配以"test"开头的行
8
echo "testing 123" | grep "^test"
9

10
# 匹配以"123"结尾的行
11
echo "testing 123" | grep "123$"
12

13
# 匹配包含数字的行
14
echo "testing 123" | grep "[0-9]"
15

16
# 匹配包含字母的行
17
echo "testing 123" | grep "[a-zA-Z]"
18

19
# 匹配包含"test"或"exam"的行
20
echo "testing" | grep -E "test|exam"
21

22
# 匹配包含3个数字的行
23
echo "testing 123" | grep "[0-9]{3}"
24

25
# 匹配单词边界
26
echo "testing" | grep "\btest\b"

sed命令的正则表达式#

1
#!/bin/bash
2

3
# 替换文本
4
echo "Hello, World!" | sed 's/World/Shell/'
5

6
# 替换所有匹配
7
echo "Hello, World! World!" | sed 's/World/Shell/g'
8

9
# 使用正则表达式替换
10
echo "Testing 123" | sed 's/[0-9]/X/g'
11

12
# 替换行首
13
echo "Testing 123" | sed 's/^/Prefix: /'
14

15
# 替换行尾
16
echo "Testing 123" | sed 's/$/ :Suffix/'

awk命令的正则表达式#

1
#!/bin/bash
2

3
# 匹配包含"test"的行
4
echo "Testing 123" | awk '/test/ {print $0}'
5

6
# 匹配以"test"开头的行
7
echo "testing 123" | awk '/^test/ {print $0}'
8

9
# 匹配以"123"结尾的行
10
echo "testing 123" | awk '/123$/ {print $0}'
11

12
# 匹配包含数字的行
13
echo "testing 123" | awk '/[0-9]/ {print $0}'

脚本的调试#

调试选项#

Bash提供了几个调试选项，可以帮助找出脚本中的问题。

1
#!/bin/bash
2

3
# 在脚本开头添加调试选项
4

5
# -x：显示执行的命令和参数
6
# #!/bin/bash -x
7

8
# -v：显示读取的脚本行
9
# #!/bin/bash -v
10

11
# -n：检查语法错误，不执行脚本
12
# #!/bin/bash -n
13

14
# 在脚本中启用/禁用调试
15
set -x  # 启用调试
16
echo "This line will be debugged"
17
set +x  # 禁用调试
18
echo "This line will not be debugged"
19

20
# 其他有用的调试选项
21
set -e  # 遇到错误时退出
22
set -u  # 遇到未定义变量时退出
23
set -o pipefail  # 管道中任何命令失败时退出

常见错误#

1
#!/bin/bash
2

3
# 常见错误示例
4

5
# 1. 变量名和等号之间不能有空格
6
# name = "World"  # 错误
7
name="World"  # 正确
8

9
# 2. 变量使用时需要$符号
10
# echo "Hello, name!"  # 错误
11
echo "Hello, $name!"  # 正确
12

13
# 3. 命令替换使用反引号或$()
14
# current_dir=ls -la  # 错误
15
current_dir=$(ls -la)  # 正确
16

17
# 4. 条件判断中的空格
18
# if [$name == "World"]; then  # 错误
19
if [ "$name" == "World" ]; then  # 正确
20
    echo "Hello, World!"
21
fi
22

23
# 5. 字符串比较使用=或==，数值比较使用-eq等
24
# if [ $name == "World" ]; then  # 正确（字符串比较）
25
# if [ $age == 18 ]; then  # 错误（数值比较）
26
# if [ $age -eq 18 ]; then  # 正确（数值比较）
27

28
# 6. 数组元素的访问
29
# fruits=('apple' 'banana')
30
# echo "First fruit: $fruits[0]"  # 错误
31
# echo "First fruit: ${fruits[0]}"  # 正确
32

33
# 7. 函数调用不需要括号
34
# greet() {
35
#     echo "Hello!"
36
# }
37
# greet()  # 错误
38
# greet  # 正确

实用脚本示例#

备份脚本#

1
#!/bin/bash
2

3
# 备份脚本
4

5
# 备份目录
6
BACKUP_DIR="/backup"
7

8
# 源目录
9
SOURCE_DIRS=("/home" "/etc" "/var/www")
10

11
# 日期格式
12
DATE=$(date +"%Y-%m-%d_%H-%M-%S")
13

14
# 创建备份目录
15
mkdir -p "$BACKUP_DIR"
16

17
# 备份每个目录
18
for dir in "${SOURCE_DIRS[@]}"; do
19
    # 目录名
20
    dir_name=$(basename "$dir")
21

22
    # 备份文件名
23
    backup_file="$BACKUP_DIR/${dir_name}_${DATE}.tar.gz"
24

25
    # 执行备份
26
    echo "Backing up $dir to $backup_file..."
27
    tar -czf "$backup_file" "$dir"
28

29
    # 检查备份是否成功
30
    if [ $? -eq 0 ]; then
31
        echo "Backup of $dir completed successfully!"
32
    else
33
        echo "Backup of $dir failed!"
34
    fi
35
done
36

37
# 清理旧备份（保留最近7天的备份）
38
echo "Cleaning up old backups..."
39
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +7 -delete
40
echo "Old backups cleaned up!"
41

42
echo "Backup script completed!"

监控脚本#

1
#!/bin/bash
2

3
# 监控脚本
4

5
# 监控间隔（秒）
6
INTERVAL=5
7

8
# 监控次数
9
COUNT=10
10

11
# 日志文件
12
LOG_FILE="system_monitor.log"
13

14
# 清空日志文件
15
> "$LOG_FILE"
16

17
# 监控系统状态
18
for ((i=1; i<=COUNT; i++)); do
19
    # 时间戳
20
    timestamp=$(date +"%Y-%m-%d %H:%M:%S")
21

22
    # 系统负载
23
    load=$(uptime | awk '{print $10, $11, $12}')
24

25
    # 内存使用
26
    memory=$(free -h | grep "Mem:" | awk '{print $3 "/" $2}')
27

28
    # 磁盘使用
29
    disk=$(df -h / | grep "/" | awk '{print $3 "/" $2}')
30

31
    # CPU使用（简化版）
32
    cpu=$(top -bn1 | grep "Cpu(s)" | awk '{print $2 + $4}')
33

34
    # 网络流量
35
    network=$(ifconfig eth0 | grep "RX bytes" | awk '{print $2}' | sed 's/bytes://')
36

37
    # 写入日志
38
    echo "[$timestamp] Load: $load | Memory: $memory | Disk: $disk | CPU: ${cpu}% | Network: $network bytes" >> "$LOG_FILE"
39

40
    # 显示到控制台
41
    echo "[$timestamp] Load: $load | Memory: $memory | Disk: $disk | CPU: ${cpu}% | Network: $network bytes"
42

43
    # 等待
44
    sleep $INTERVAL
45
done
46

47
echo "Monitoring completed! Log saved to $LOG_FILE"

系统信息脚本#

1
#!/bin/bash
2

3
# 系统信息脚本
4

5
echo "===================================="
6
echo "System Information Script"
7
echo "===================================="
8

9
# 主机名
10
echo "Hostname: $(hostname)"
11

12
# 操作系统
13
echo "OS: $(lsb_release -ds)"
14

15
# 内核版本
16
echo "Kernel: $(uname -r)"
17

18
# 架构
19
echo "Architecture: $(uname -m)"
20

21
# 启动时间
22
echo "Uptime: $(uptime -p)"
23

24
# 处理器信息
25
echo "CPU: $(lscpu | grep "Model name" | awk -F":" '{print $2}' | sed 's/^[ \t]*//')"
26
echo "CPU Cores: $(nproc)"
27

28
# 内存信息
29
echo "Memory: $(free -h | grep "Mem:" | awk '{print $3 "/" $2}')"
30

31
# 磁盘信息
32
echo "Disk Usage:"
33
df -h | grep -E "^/dev/"
34

35
# 网络信息
36
echo "Network Interfaces:"
37
ip addr | grep -E "^[0-9]+: " | awk -F":" '{print $2}' | sed 's/^[ \t]*//'
38

39
# 登录用户
40
echo "Logged in Users:"
41
who
42

43
# 运行进程数
44
echo "Running Processes: $(ps aux | wc -l)"
45

46
# 系统负载
47
echo "System Load: $(uptime | awk '{print $10, $11, $12}')"
48

49
echo "===================================="
50
echo "Script completed!"
51
echo "===================================="

总结#

本文介绍了Linux Shell脚本编程的基本概念和技术，包括变量、运算符、控制流、函数、输入输出、数组、算术运算、正则表达式和脚本调试等内容。通过学习这些知识，你可以编写各种自动化脚本，提高工作效率。

Shell脚本是Linux系统管理和自动化任务的强大工具，掌握Shell脚本编程是Linux系统管理员的必备技能。希望本文能够帮助你入门Shell脚本编程，并在实践中不断提高。

练习#

编写一个脚本，输出当前目录下所有文件的名称和大小。
编写一个脚本，计算1到100的和。
编写一个脚本，检查指定文件是否存在，如果存在则显示其权限和大小。
编写一个脚本，接收用户输入的两个数，计算它们的和、差、积、商。
编写一个脚本，遍历当前目录下的所有.txt文件，将其中包含”error”的行输出到error.log文件。
编写一个脚本，创建一个目录结构：test/{dir1,dir2,dir3}。
编写一个脚本，显示系统的CPU使用率、内存使用率和磁盘使用率。
编写一个脚本，备份指定目录到/home/backup目录，备份文件名为目录名加上当前日期。
编写一个脚本，检查系统中是否安装了指定的软件包，如果没有安装则提示用户。
编写一个脚本，使用函数计算两个数的最大公约数。

溪谷回声

记录每一次探索与抵达

Linux Shell脚本编程