Shell语法 on Linux邪修

Shell脚本基础语法

Mon, 01 Jan 0001 00:00:00 +0000

Shell脚本基础语法#

Shell脚本是Linux系统中非常强大的工具，它可以帮助我们自动化各种任务。本教程将从最基础的语法开始，逐步介绍Shell脚本的使用方法。

什么是Shell脚本#

Shell脚本是一个包含一系列命令的文本文件，这些命令可以被Shell解释器执行。在Linux系统中，最常用的Shell是Bash（Bourne Again Shell）。

第一个Shell脚本#

创建脚本文件#

# 创建一个名为hello.sh的脚本文件
touch hello.sh

编写脚本内容#

#!/bin/bash
# 这是一个注释

echo "Hello, World!"

使脚本可执行#

chmod +x hello.sh

执行脚本#

# 方法1：直接执行
./hello.sh

# 方法2：使用bash命令执行
bash hello.sh

Shell脚本的基本结构#

一个完整的Shell脚本通常包含以下部分：

shebang行：指定脚本的解释器
注释：说明脚本的功能
命令：要执行的命令
变量：存储数据
控制结构：条件判断、循环等
函数：封装可重用的代码

注释#

注释以#开头，用于说明脚本的功能，不会被执行。

#!/bin/bash
# 这是一个单行注释

# 这是一个
# 多行注释

echo "Hello, World!" # 行尾注释

命令执行#

在Shell脚本中，你可以执行任何在终端中可以执行的命令。

#!/bin/bash

# 执行ls命令
ls -la

# 执行pwd命令
pwd

# 执行date命令
date

输出#

使用echo命令输出文本。

#!/bin/bash

# 输出简单文本
echo "Hello, World!"

# 输出变量
greeting="Hello"
echo $greeting

# 输出带引号的文本
echo "The value is: $greeting"

# 禁用变量展开
echo 'The value is: $greeting'

# 输出多行文本
echo "Line 1
Line 2
Line 3"

输入#

使用read命令读取用户输入。

Shell脚本变量

Mon, 01 Jan 0001 00:00:00 +0000

Shell脚本变量#

变量是Shell脚本中用于存储数据的容器。本教程将介绍Shell脚本中变量的定义、使用和操作方法。

变量的定义#

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

#!/bin/bash

# 定义变量
name="John"
age=30
pi=3.14159

# 输出变量
echo "Name: $name"
echo "Age: $age"
echo "Pi: $pi"

变量命名规则#

变量名只能包含字母、数字和下划线
变量名不能以数字开头
变量名区分大小写
变量名最好使用有意义的名称

变量的使用#

基本使用#

使用$符号引用变量的值。

#!/bin/bash

# 定义变量
fruit="apple"

# 使用变量
echo "I like $fruit"

# 变量作为命令参数
echo "The length of '$fruit' is ${#fruit}"

花括号的使用#

当变量名与其他字符连在一起时，使用花括号{}来明确变量的边界。

#!/bin/bash

# 定义变量
name="Tom"

# 错误的用法（会将name1当作一个新变量）
echo "Hello $name1"

# 正确的用法
echo "Hello ${name}1"

变量的赋值#

直接赋值#

#!/bin/bash

# 直接赋值
variable="value"

命令替换#

使用反引号`或$()将命令的输出赋值给变量。

Shell脚本输入输出

Mon, 01 Jan 0001 00:00:00 +0000

Shell脚本输入输出#

在Shell脚本中，输入输出（I/O）操作是与用户交互和处理数据的基础。本教程将详细介绍Shell中的各种I/O操作，从基础的echo命令到复杂的重定向和管道操作。

入门#

基本输出 - echo命令#

echo命令是Shell中最基本的输出命令，用于在终端显示文本。

# 显示简单文本
echo "Hello, World!"

# 显示变量值
name="John"
echo "Hello, $name!"

# 显示转义字符
echo "Line 1\nLine 2"
echo "Tabbed\tText"

基本输入 - read命令#

read命令用于从用户输入中读取数据并存储到变量中。

# 基本读取
read name
echo "Hello, $name!"

# 带提示信息的读取
read -p "请输入您的名字: " name
echo "欢迎您, $name!"

# 读取多个值
read -p "请输入您的名字和年龄: " name age
echo "$name, 您今年$age岁。"

中级#

输出格式化#

printf命令#

printf命令提供了更强大的格式化输出能力，类似于C语言中的printf函数。

# 基本格式化
printf "Hello, %s!\n" "World"

# 多个参数
printf "姓名: %s, 年龄: %d\n" "John" 30

# 格式化选项
printf "数字: %5d\n" 123 # 右对齐，宽度5
printf "浮点数: %.2f\n" 3.14159 # 保留2位小数
printf "字符串: %-10s结束\n" "测试" # 左对齐，宽度10

输入控制#

# 静默输入（密码）
read -s -p "请输入密码: " password
echo "\n密码已设置"

# 限制输入时间
if read -t 5 -p "请在5秒内输入: " input; then
 echo "您输入了: $input"
else
 echo "\n输入超时"
fi

# 限制输入字符数
read -n 3 -p "请输入3个字符: " input
echo "\n您输入了: $input"

高级#

重定向操作#

标准输出重定向#

# 覆盖重定向
echo "Hello" > output.txt

# 追加重定向
echo "World" >> output.txt

标准错误重定向#

# 重定向标准错误
command 2> error.txt

# 同时重定向标准输出和标准错误
command > output.txt 2>&1

# 重定向到黑洞（丢弃输出）
command > /dev/null 2>&1

输入重定向#

# 从文件读取输入
cat < input.txt

# Here文档
cat << EOF
这是一个Here文档
可以包含多行文本
EOF

# Here字符串
grep "pattern" <<< "This is a test string"

管道操作#

管道（|）用于将一个命令的输出作为另一个命令的输入。

Shell脚本条件判断

Mon, 01 Jan 0001 00:00:00 +0000

Shell脚本条件判断#

条件判断是Shell脚本中实现逻辑控制的核心机制，允许脚本根据不同的条件执行不同的命令。本教程将详细介绍Shell中的各种条件判断语句，从基础的if语句到复杂的逻辑组合。

入门#

基本if语句#

if语句是Shell中最基本的条件判断结构，用于根据条件的真假执行不同的命令。

# 基本if语句
if [ condition ]; then
 # 条件为真时执行的命令
fi

# 示例：检查文件是否存在
if [ -f "file.txt" ]; then
 echo "文件存在"
fi

# if-else语句
if [ -f "file.txt" ]; then
 echo "文件存在"
else
 echo "文件不存在"
fi

# if-elif-else语句
if [ $USER = "root" ]; then
 echo "您是root用户"
elif [ $USER = "admin" ]; then
 echo "您是admin用户"
else
 echo "您是普通用户"
fi

测试命令#

Shell中的测试命令用于检查条件是否成立，有两种形式：[ condition ]和test condition。

# 测试文件状态
[ -f "file.txt" ] # 检查是否为普通文件
[ -d "dir" ] # 检查是否为目录
[ -e "path" ] # 检查路径是否存在
[ -s "file.txt" ] # 检查文件是否非空

# 测试字符串
[ -z "string" ] # 检查字符串是否为空
[ -n "string" ] # 检查字符串是否非空
[ "$a" = "$b" ] # 检查字符串是否相等
[ "$a" != "$b" ] # 检查字符串是否不相等

# 测试数字
[ $a -eq $b ] # 检查数字是否相等
[ $a -ne $b ] # 检查数字是否不相等
[ $a -lt $b ] # 检查a是否小于b
[ $a -le $b ] # 检查a是否小于等于b
[ $a -gt $b ] # 检查a是否大于b
[ $a -ge $b ] # 检查a是否大于等于b

中级#

高级测试操作#

逻辑运算符#

# 逻辑与 -a 或 &&
if [ -f "file.txt" -a -r "file.txt" ]; then
 echo "文件存在且可读"
fi

# 使用&&的另一种形式
if [ -f "file.txt" ] && [ -r "file.txt" ]; then
 echo "文件存在且可读"
fi

# 逻辑或 -o 或 ||
if [ -f "file1.txt" -o -f "file2.txt" ]; then
 echo "至少有一个文件存在"
fi

# 逻辑非 !
if [ ! -f "file.txt" ]; then
 echo "文件不存在"
fi

双括号语法#

(( ))语法用于算术运算和比较，支持C风格的语法。

Shell脚本循环结构

Mon, 01 Jan 0001 00:00:00 +0000

Shell脚本循环结构#

循环结构是Shell脚本中处理重复任务的核心机制，允许脚本根据条件重复执行一系列命令。本教程将详细介绍Shell中的各种循环结构，从基础的for循环到复杂的嵌套循环和循环控制。

入门#

基本for循环#

for循环是Shell中最常用的循环结构之一，用于遍历列表中的元素。

# 基本for循环
for variable in item1 item2 item3; do
 # 执行命令
 echo $variable
done

# 示例：遍历数字
for i in 1 2 3 4 5; do
 echo "数字: $i"
done

# 示例：遍历字符串
for fruit in apple banana cherry; do
 echo "水果: $fruit"
done

# 示例：遍历命令输出
for file in $(ls *.txt); do
 echo "文件: $file"
done

基本while循环#

while循环会在条件为真时重复执行命令，直到条件变为假。

# 基本while循环
while [ condition ]; do
 # 执行命令
done

# 示例：计数器循环
count=1
while [ $count -le 5 ]; do
 echo "计数: $count"
 count=$((count + 1))
done

# 示例：读取文件内容
while read line; do
 echo "行: $line"
done < file.txt

# 示例：无限循环
while true; do
 echo "按Ctrl+C退出"
 sleep 1
done

中级#

高级for循环#

C风格for循环#

# C风格for循环
for ((i=1; i<=5; i++)); do
 echo "数字: $i"
done

# 带步长的循环
for ((i=1; i<=10; i+=2)); do
 echo "奇数: $i"
done

# 反向循环
for ((i=5; i>=1; i--)); do
 echo "倒计时: $i"
done

通配符和序列#

# 使用通配符
for file in *.txt; do
 echo "文本文件: $file"
done

# 使用序列表达式
for i in {1..5}; do
 echo "数字: $i"
done

# 带步长的序列
for i in {1..10..2}; do
 echo "奇数: $i"
done

# 字母序列
for letter in {a..e}; do
 echo "字母: $letter"
done

until循环#

until循环与while循环相反，会在条件为假时重复执行命令，直到条件变为真。

Shell脚本函数

Mon, 01 Jan 0001 00:00:00 +0000

Shell脚本函数#

函数是Shell脚本中组织代码、提高复用性和可维护性的重要机制。本教程将详细介绍Shell中的函数定义、参数传递、返回值处理、作用域管理等内容，从基础的函数定义到高级的函数库和模块化设计。

入门#

基本函数定义#

在Shell中，函数可以通过两种方式定义：使用function关键字或直接定义函数名。

# 使用function关键字定义函数
function hello {
 echo "Hello, World!"
}

# 直接定义函数名
hello() {
 echo "Hello, World!"
}

# 调用函数
hello

# 带参数的函数
greet() {
 echo "Hello, $1!"
}

# 调用带参数的函数
greet "John"

函数参数#

Shell函数通过位置参数（$1, $2, 等）接收参数，与脚本参数类似。

# 带多个参数的函数
add() {
 echo "参数1: $1"
 echo "参数2: $2"
 sum=$(( $1 + $2 ))
 echo "和: $sum"
}

# 调用带多个参数的函数
add 10 20

# 处理任意数量的参数
sum_all() {
 local sum=0
 for num in "$@"; do
 sum=$(( sum + num ))
 done
 echo "总和: $sum"
}

# 调用带任意数量参数的函数
sum_all 1 2 3 4 5

函数返回值#

Shell函数通过return语句返回退出状态码（0-255），或通过输出返回数据。

Shell脚本命令集成

Mon, 01 Jan 0001 00:00:00 +0000

Shell脚本命令集成#

命令集成是Shell脚本的核心能力之一，它允许脚本组合和利用各种Linux命令的功能，实现复杂的任务自动化。本教程将详细介绍Shell中的命令集成技术，从基础的命令替换到高级的管道和xargs操作。

入门#

命令替换#

命令替换允许将一个命令的输出作为另一个命令的参数或变量值，有两种语法：`command` 和 $(command)。

# 使用反引号进行命令替换
date=`date`
echo "当前日期: $date"

# 使用$()进行命令替换（推荐，更清晰）
date=$(date)
echo "当前日期: $date"

# 在参数中使用命令替换
echo "当前目录包含 $(ls -l | wc -l) 个文件"

# 嵌套命令替换
files=$(ls -l $(pwd))
echo "当前目录文件: $files"

基本管道操作#

管道（|）用于将一个命令的标准输出作为另一个命令的标准输入，是Shell中最强大的功能之一。

# 基本管道
ls -la | grep "txt"

# 多个管道组合
ps aux | grep "bash" | wc -l

# 管道与重定向结合
ls -la | grep "txt" > text_files.txt

# 常见管道组合
# 查找包含特定文本的文件
grep "pattern" *.txt

# 统计文件行数
cat file.txt | wc -l

# 排序并去重
sort file.txt | uniq

命令执行#

在Shell脚本中，可以直接执行任何Linux命令，并通过$?获取其退出状态码。

Shell脚本错误处理

Mon, 01 Jan 0001 00:00:00 +0000

Shell脚本错误处理#

错误处理是Shell脚本开发中的重要组成部分，良好的错误处理可以提高脚本的健壮性和可维护性。本教程将详细介绍Shell中的各种错误处理技术，从基础的退出状态码检查到高级的调试和错误恢复策略。

入门#

基本错误检查#

在Shell中，每个命令执行后都会返回一个退出状态码（0-255），其中0表示成功，非0表示失败。

# 检查命令执行结果
ls -la
if [ $? -eq 0 ]; then
 echo "命令执行成功"
else
 echo "命令执行失败"
fi

# 直接在if语句中检查
if ls -la; then
 echo "命令执行成功"
else
 echo "命令执行失败"
fi

# 使用逻辑运算符
ls -la && echo "成功" || echo "失败"

简单错误处理#

# 检查文件是否存在
if [ ! -f "file.txt" ]; then
 echo "错误: 文件不存在"
 exit 1
fi

# 检查目录是否存在
if [ ! -d "dir" ]; then
 echo "错误: 目录不存在"
 exit 1
fi

# 检查参数是否提供
if [ $# -eq 0 ]; then
 echo "错误: 请提供参数"
 exit 1
fi

基本调试技巧#

# 使用 -x 选项启用调试模式
# 在脚本开头添加
#!/bin/bash -x

# 或者在执行时指定
bash -x script.sh

# 使用 -v 选项显示脚本内容
bash -v script.sh

# 使用 -n 选项检查语法错误
bash -n script.sh

中级#

错误捕获和处理#

set 命令#

set命令可以控制Shell的行为，包括错误处理模式。

Shell脚本高级技巧

Mon, 01 Jan 0001 00:00:00 +0000

Shell脚本高级技巧#

Shell脚本是Linux系统管理和自动化的强大工具，掌握高级技巧可以让您编写更加高效、灵活和强大的脚本。本教程将详细介绍Shell脚本中的各种高级技巧，从正则表达式到进程管理，从数组操作到信号处理。

入门#

正则表达式基础#

正则表达式是用于匹配字符串模式的强大工具，在Shell脚本中广泛应用于文本处理。

# 基本正则表达式
# 匹配包含"test"的行
grep "test" file.txt

# 匹配以"test"开头的行
grep "^test" file.txt

# 匹配以"test"结尾的行
grep "test$" file.txt

# 匹配包含数字的行
grep "[0-9]" file.txt

# 匹配包含字母的行
grep "[a-zA-Z]" file.txt

# 匹配包含单词"test"的行（边界匹配）
grep "\\<test\\>" file.txt

数组基础#

数组是Shell中存储多个值的变量类型，支持索引数组和关联数组。

# 索引数组定义
fruits=(apple banana cherry date)

# 访问数组元素
echo "第一个元素: ${fruits[0]}"
echo "第二个元素: ${fruits[1]}"

# 访问所有元素
echo "所有元素: ${fruits[@]}"
echo "所有元素: ${fruits[*]}"

# 获取数组长度
echo "数组长度: ${#fruits[@]}"

# 修改数组元素
fruits[2]="grape"
echo "修改后: ${fruits[@]}"

# 添加元素
fruits+=(elderberry)
echo "添加后: ${fruits[@]}"

进程管理基础#

# 查看当前进程
ps

# 查看所有进程
ps aux

# 查看特定进程
ps aux | grep "bash"

# 终止进程
kill PID

# 强制终止进程
kill -9 PID

# 后台执行命令
command &

# 查看后台进程
jobs

# 将后台进程调回前台
fg %1

# 暂停进程
Ctrl+Z

# 继续执行暂停的进程
bg %1

中级#

高级正则表达式#

扩展正则表达式#

# 使用扩展正则表达式（-E选项）
# 匹配"test"或"exam"
grep -E "test|exam" file.txt

# 匹配重复字符
grep -E "a{2,3}" file.txt # 匹配2-3个连续的a

# 匹配分组
grep -E "(test){2}" file.txt # 匹配"testtest"

# 匹配可选字符
grep -E "colou?r" file.txt # 匹配"color"或"colour"

# 匹配单词边界
grep -E "\\btest\\b" file.txt # 匹配单词"test"

正则表达式工具#

# sed命令使用正则表达式
# 替换文本
sed 's/old/new/g' file.txt

# 替换并直接修改文件
sed -i 's/old/new/g' file.txt

# awk命令使用正则表达式
# 按模式匹配行
awk '/test/ {print}' file.txt

# 按模式分割字段
awk -F'[0-9]+' '{print $1}' file.txt

# 正则表达式匹配测试
grep -q "pattern" file.txt && echo "匹配" || echo "不匹配"

高级数组操作#

关联数组#

# 定义关联数组
declare -A colors

# 添加元素
colors["red"]="#FF0000"
colors["green"]="#00FF00"
colors["blue"]="#0000FF"

# 访问元素
echo "红色: ${colors["red"]}"
echo "绿色: ${colors[green]}"

# 遍历关联数组
for color in "${!colors[@]}"; do
 echo "$color: ${colors[$color]}"
done

# 获取关联数组长度
echo "数组长度: ${#colors[@]}"

数组操作#

# 数组切片
numbers=(1 2 3 4 5 6 7 8 9 10)
echo "前3个元素: ${numbers[@]:0:3}" # 从索引0开始，取3个元素
echo "从索引2开始: ${numbers[@]:2}" # 从索引2开始，取所有元素

# 数组排序
sorted=($(echo "${numbers[@]}" | tr ' ' '\n' | sort -n))
echo "排序后: ${sorted[@]}"

# 数组去重
unique=($(echo "${numbers[@]}" | tr ' ' '\n' | uniq))
echo "去重后: ${unique[@]}"

# 数组交集
array1=(1 2 3 4 5)
array2=(3 4 5 6 7)
intersection=($(comm -12 <(echo "${array1[@]}" | tr ' ' '\n' | sort) <(echo "${array2[@]}" | tr ' ' '\n' | sort)))
echo "交集: ${intersection[@]}"

# 数组差集
difference=($(comm -23 <(echo "${array1[@]}" | tr ' ' '\n' | sort) <(echo "${array2[@]}" | tr ' ' '\n' | sort)))
echo "差集: ${difference[@]}"

信号处理#

# 基本信号处理
trap 'echo "收到SIGINT信号"' SIGINT

echo "按Ctrl+C测试信号处理"
sleep 10

# 多个信号处理
trap 'echo "收到信号"' SIGINT SIGTERM

# 忽略信号
trap '' SIGINT

echo "按Ctrl+C不会终止脚本"
sleep 10

# 恢复默认信号处理
trap - SIGINT

echo "按Ctrl+C会终止脚本"
sleep 10

# 退出时执行清理
trap 'echo "执行清理"; rm -f temp.txt' EXIT

echo "创建临时文件"
touch temp.txt
sleep 5

高级#

进程控制#

进程创建和管理#

# 创建子进程
(child_process) {
 echo "子进程PID: $$"
 echo "父进程PID: $PPID"
 sleep 2
 echo "子进程完成"
}

child_process &
parent_pid=$$
echo "父进程PID: $parent_pid"
wait

echo "父进程完成"

# 进程替换
# 同时执行多个命令并捕获输出
paste <(ls *.txt) <(wc -l *.txt | grep -v total)

# 进程间通信
# 使用管道
echo "Hello" | (read msg; echo "收到: $msg")

# 使用命名管道
mkfifo mypipe

echo "写入命名管道" > mypipe &
echo "从命名管道读取: $(cat mypipe)"
rm mypipe

进程监控#

# 监控进程状态
watch -n 1 "ps aux | grep 'python'"

# 监控系统负载
watch -n 1 "uptime"

# 监控磁盘I/O
iotop

# 监控网络连接
netstat -tuln

# 监控进程资源使用
top -p PID

# 进程跟踪
strace command

高级文本处理#

awk 高级用法#

# awk 基本用法
# 打印文件的第一列
awk '{print $1}' file.txt

# 打印包含"test"的行的第一列
awk '/test/ {print $1}' file.txt

# 使用变量
awk '{sum += $1} END {print sum}' file.txt

# 使用自定义分隔符
awk -F"," '{print $1}' csv_file.txt

# 条件判断
awk '$1 > 10 {print $0}' file.txt

# 循环
awk '{
 for (i=1; i<=NF; i++) {
 print "字段" i ":" $i
 }
}' file.txt

# 数组
awk '{
 count[$1]++
} END {
 for (word in count) {
 print word ":" count[word]
 }
}' file.txt

sed 高级用法#

# sed 基本用法
# 替换第一处匹配
sed 's/old/new/' file.txt

# 替换所有匹配
sed 's/old/new/g' file.txt

# 替换第n处匹配
sed 's/old/new/2' file.txt

# 使用不同分隔符
sed 's|old|new|g' file.txt

# 删除空行
sed '/^$/d' file.txt

# 删除包含"test"的行
sed '/test/d' file.txt

# 在指定行后插入文本
sed '/test/a new line' file.txt

# 在指定行前插入文本
sed '/test/i new line' file.txt

# 替换指定行范围
sed '1,5s/old/new/g' file.txt

系统编程#

文件描述符操作#

# 基本文件描述符
# 0: 标准输入
# 1: 标准输出
# 2: 标准错误

# 重定向标准输出和标准错误
command > output.txt 2>&1

# 自定义文件描述符
# 创建文件描述符3指向文件
exec 3> output.txt
echo "通过文件描述符3输出" >&3
exec 3>&-

# 读写文件描述符
exec 4<> data.txt
echo "写入数据" >&4
seek 0 4
cat <&4
exec 4>&-

# 复制文件描述符
exec 5>&1
echo "输出到标准输出" >&5
exec 5>&-

环境变量#

# 查看环境变量
env

# 查看特定环境变量
echo $HOME
echo $PATH

# 设置环境变量
export MY_VAR="value"
echo $MY_VAR

# 临时修改环境变量
PATH=/usr/local/bin:$PATH command

# 移除环境变量
unset MY_VAR

# 环境变量持久化
# 在~/.bashrc或~/.bash_profile中添加
export MY_VAR="value"

# 加载环境变量
source ~/.bashrc

大师#

高级脚本设计#

模块化脚本#

# 模块定义
# utils.sh

#!/bin/bash

# 日志函数
log() {
 echo "[$(date '+%Y-%m-%d %H:%M:%S')] $@"
}

# 文件检查函数
check_file() {
 local file=$1
 [ -f "$file" ] && [ -r "$file" ]
}

# 导出函数
export -f log
export -f check_file

# 主脚本

#!/bin/bash

# 导入模块
source utils.sh

# 使用模块函数
log "开始执行脚本"

if check_file "data.txt"; then
 log "数据文件存在"
else
 log "数据文件不存在"
fi

log "脚本执行完成"

配置管理#

# 配置文件
# config.sh

#!/bin/bash

# 默认配置
CONFIG_DIR="/etc/myapp"
LOG_FILE="/var/log/myapp.log"
DEBUG=false

# 加载用户配置
if [ -f "~/.myapp/config.sh" ]; then
 source "~/.myapp/config.sh"
fi

# 命令行参数覆盖
while getopts "d:l:v" opt; do
 case $opt in
 d)
 CONFIG_DIR=$OPTARG
 ;;
 l)
 LOG_FILE=$OPTARG
 ;;
 v)
 DEBUG=true
 ;;
 esac
done

# 主脚本

#!/bin/bash

# 加载配置
source config.sh

# 使用配置
echo "配置目录: $CONFIG_DIR"
echo "日志文件: $LOG_FILE"
echo "调试模式: $DEBUG"

性能优化#

脚本性能优化#

# 减少命令执行次数
# 不好的做法
for file in *.txt; do
 wc -l "$file"
done

# 好的做法
wc -l *.txt

# 减少文件I/O
# 不好的做法
for i in {1..1000}; do
 echo "$i" >> output.txt
done

# 好的做法
{
 for i in {1..1000}; do
 echo "$i"
 done
} > output.txt

# 减少子shell
# 不好的做法
for i in $(seq 1 1000); do
 echo $i
done

# 好的做法
for i in {1..1000}; do
 echo $i
done

# 使用更快的命令
# 不好的做法
ps aux | grep "bash" | wc -l

# 好的做法
pgrep -c "bash"

# 并行执行
# 不好的做法
for file in *.txt; do
 process_file "$file"
done

# 好的做法
find . -name "*.txt" | xargs -P 4 -I {} process_file "{}"

内存管理#

# 减少内存使用
# 处理大文件时使用流式处理
# 不好的做法
content=$(cat large_file.txt)
process "$content"

# 好的做法
cat large_file.txt | process

# 释放变量
large_variable="big content"
# 使用变量
unset large_variable

# 限制命令内存使用
ulimit -m 1024000 # 限制为1GB
memory_intensive_command

# 监控内存使用
while true; do
 mem_usage=$(ps -o rss= -p $$)
 echo "当前内存使用: $mem_usage KB"
 sleep 1
done

安全编程#

安全实践#

# 输入验证
validate_input() {
 local input=$1
 # 只允许字母和数字
 if [[ ! "$input" =~ ^[a-zA-Z0-9]+$ ]]; then
 echo "错误: 输入包含非法字符"
 return 1
 fi
 return 0
}

# 命令注入防护
safe_exec() {
 local cmd=$1
 # 检查命令是否安全
 if [[ "$cmd" =~ [;&|<>] ]]; then
 echo "错误: 命令包含非法字符"
 return 1
 fi
 eval "$cmd"
}

# 路径遍历防护
safe_path() {
 local path=$1
 # 解析绝对路径
 real_path=$(realpath "$path")
 # 检查是否在允许的目录内
 if [[ ! "$real_path" =~ ^/allowed/dir ]]; then
 echo "错误: 路径超出允许范围"
 return 1
 fi
 echo "$real_path"
}

# 权限检查
check_permissions() {
 if [ $(id -u) -ne 0 ]; then
 echo "错误: 需要root权限"
 return 1
 fi
 return 0
}

加密和哈希#

# 生成随机密码
openssl rand -base64 12

# 加密文件
openssl enc -aes-256-cbc -salt -in plaintext.txt -out encrypted.txt

# 解密文件
openssl enc -d -aes-256-cbc -in encrypted.txt -out decrypted.txt

# 生成文件哈希
md5sum file.txt
sha256sum file.txt

# 密码哈希
echo "password" | sha256sum

# 验证哈希
if [ "$(echo "password" | sha256sum)" = "expected_hash" ]; then
 echo "密码正确"
else
 echo "密码错误"
fi

无敌#

高级系统集成#

网络编程#

# 基本网络操作
# 检查网络连接
ping -c 1 google.com

# 检查端口
nc -z google.com 80

# 简单HTTP请求
curl http://example.com

# 下载文件
wget http://example.com/file.txt

# 创建简单的HTTP服务器
python3 -m http.server 8080

# 网络套接字
# 使用nc创建服务器
nc -l 8080

# 使用nc连接服务器
nc localhost 8080

# 传输文件
# 接收端
nc -l 8080 > received_file.txt

# 发送端
nc localhost 8080 < send_file.txt

数据库操作#

# SQLite操作
# 创建数据库
sqlite3 mydb.db "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT);"

# 插入数据
sqlite3 mydb.db "INSERT INTO users (name, email) VALUES ('John', 'john@example.com');"

# 查询数据
sqlite3 mydb.db "SELECT * FROM users;"

# MySQL/MariaDB操作
# 连接数据库
mysql -u user -p database

# 执行SQL命令
mysql -u user -p database -e "SELECT * FROM users;"

# PostgreSQL操作
# 连接数据库
psql -U user -d database

# 执行SQL命令
psql -U user -d database -c "SELECT * FROM users;"

高级工具集成#

Git 集成#

# Git 基本操作
git status
git add .
git commit -m "提交消息"
git push

# Git 分支
git branch
git checkout branch_name
git merge branch_name

# Git 日志
git log
git log --oneline

# Git 标签
git tag v1.0
git push --tags

# Git 钩子
# .git/hooks/pre-commit

#!/bin/bash

# 运行测试
echo "运行测试..."
if ! ./run_tests.sh; then
 echo "测试失败，取消提交"
 exit 1
fi

echo "测试通过，继续提交"
exit 0

Docker 集成#

# Docker 基本操作
docker ps
docker images
docker run -it ubuntu bash

# Docker 构建
docker build -t myapp .

# Docker 运行
docker run -d -p 8080:80 myapp

# Docker Compose
docker-compose up -d
docker-compose down

# Docker 脚本
# docker_deploy.sh

#!/bin/bash

# 构建镜像
docker build -t myapp:$(date +%Y%m%d) .

# 停止旧容器
docker stop myapp || true
docker rm myapp || true

# 运行新容器
docker run -d --name myapp -p 8080:80 myapp:$(date +%Y%m%d)

echo "部署完成"

实用脚本示例#

系统管理工具#

#!/bin/bash

# 系统管理工具

# 显示系统信息
show_system_info() {
 echo "===== 系统信息 ====="
uname -a
echo ""

 echo "===== 硬件信息 ====="
lscpu
echo ""

 echo "===== 内存信息 ====="
free -h
echo ""

 echo "===== 磁盘信息 ====="
df -h
echo ""

 echo "===== 网络信息 ====="
ip addr
echo ""
}

# 服务管理
manage_service() {
 local action=$1
 local service=$2
 
 case $action in
 start)
 sudo systemctl start "$service"
 ;;
 stop)
 sudo systemctl stop "$service"
 ;;
 restart)
 sudo systemctl restart "$service"
 ;;
 status)
 sudo systemctl status "$service"
 ;;
 *)
 echo "无效操作: $action"
 return 1
 ;;
 esac
}

# 系统监控
monitor_system() {
 local interval=5
 local count=10
 
 for ((i=1; i<=count; i++)); do
 clear
 echo "===== 系统监控 (第$i/$count次) ====="
 
 echo "CPU使用:"
top -bn1 | grep "Cpu(s)"
 
 echo "\n内存使用:"
 free -h
 
 echo "\n磁盘I/O:"
iostat
 
 echo "\n网络流量:"
 netstat -i
 
 if [ $i -lt $count ]; then
 sleep $interval
 fi
 done
}

# 主菜单
show_menu() {
 echo "===== 系统管理工具 ====="
 echo "1. 显示系统信息"
 echo "2. 管理服务"
 echo "3. 系统监控"
 echo "4. 退出"
 echo "===================="
}

# 主循环
while true; do
 show_menu
 read -p "请选择: " choice
 
 case $choice in
 1)
 show_system_info
 ;;
 2)
 read -p "输入操作(start/stop/restart/status): " action
 read -p "输入服务名: " service
 manage_service "$action" "$service"
 ;;
 3)
 monitor_system
 ;;
 4)
 echo "再见!"
 exit 0
 ;;
 *)
 echo "无效选择"
 ;;
 esac
 
 echo "按Enter键继续..."
 read
done

数据处理工具#

#!/bin/bash

# 数据处理工具

# CSV文件处理
process_csv() {
 local file=$1
 
 echo "===== CSV文件处理 ====="
 echo "文件: $file"
 echo "行数: $(wc -l < "$file")"
 echo ""
 
 # 显示前5行
 echo "前5行:"
 head -5 "$file"
 echo ""
 
 # 统计列数
 columns=$(head -1 "$file" | tr ',' '\n' | wc -l)
 echo "列数: $columns"
 echo ""
 
 # 显示列名
 echo "列名:"
 head -1 "$file" | tr ',' '\n' | nl
 echo ""
 
 # 按列排序
 read -p "输入排序列号: " sort_col
 echo "按列$sort_col排序:"
 sort -t',' -k"$sort_col" "$file" | head -10
}

# 日志分析
analyze_log() {
 local file=$1
 
 echo "===== 日志分析 ====="
 echo "文件: $file"
 echo "行数: $(wc -l < "$file")"
 echo ""
 
 # 统计错误数
 error_count=$(grep -c "ERROR" "$file")
 echo "错误数: $error_count"
 echo ""
 
 # 统计警告数
 warning_count=$(grep -c "WARNING" "$file")
 echo "警告数: $warning_count"
 echo ""
 
 # 显示最近的错误
 echo "最近的错误:"
 grep "ERROR" "$file" | tail -10
 echo ""
 
 # 显示最近的警告
 echo "最近的警告:"
 grep "WARNING" "$file" | tail -10
}

# 文本转换
convert_text() {
 local file=$1
 local operation=$2
 
 case $operation in
 upper)
 echo "转换为大写:"
 tr '[:lower:]' '[:upper:]' < "$file" | head -10
 ;;
 lower)
 echo "转换为小写:"
 tr '[:upper:]' '[:lower:]' < "$file" | head -10
 ;;
 title)
 echo "转换为标题格式:"
 sed 's/\b\(\w\)/\U\1/g' < "$file" | head -10
 ;;
 reverse)
 echo "反转每行:"
 rev < "$file" | head -10
 ;;
 *)
 echo "无效操作"
 ;;
 esac
}

# 主菜单
show_menu() {
 echo "===== 数据处理工具 ====="
 echo "1. CSV文件处理"
 echo "2. 日志分析"
 echo "3. 文本转换"
 echo "4. 退出"
 echo "===================="
}

# 主循环
while true; do
 show_menu
 read -p "请选择: " choice
 
 case $choice in
 1)
 read -p "输入CSV文件路径: " csv_file
 if [ -f "$csv_file" ]; then
 process_csv "$csv_file"
 else
 echo "文件不存在"
 fi
 ;;
 2)
 read -p "输入日志文件路径: " log_file
 if [ -f "$log_file" ]; then
 analyze_log "$log_file"
 else
 echo "文件不存在"
 fi
 ;;
 3)
 read -p "输入文本文件路径: " text_file
 if [ -f "$text_file" ]; then
 echo "1. 转换为大写"
 echo "2. 转换为小写"
 echo "3. 转换为标题格式"
 echo "4. 反转每行"
 read -p "请选择操作: " op_choice
 
 case $op_choice in
 1)
 convert_text "$text_file" upper
 ;;
 2)
 convert_text "$text_file" lower
 ;;
 3)
 convert_text "$text_file" title
 ;;
 4)
 convert_text "$text_file" reverse
 ;;
 *)
 echo "无效选择"
 ;;
 esac
 else
 echo "文件不存在"
 fi
 ;;
 4)
 echo "再见!"
 exit 0
 ;;
 *)
 echo "无效选择"
 ;;
 esac
 
 echo "按Enter键继续..."
 read
done

总结#

Shell脚本高级技巧是提升脚本编写能力的关键，通过掌握正则表达式、数组操作、进程管理、信号处理等高级技术，您可以编写更加高效、灵活和强大的Shell脚本。从简单的文本处理到复杂的系统管理，Shell脚本都能胜任。