案例

chanchaw大约 15 分钟linuxcentos

向文件写入内容

下面的脚本是向文件 /usr/local/crontabTask/test1.log 中写入时间，即下面代码EOF上面一行的内容。（脚本中其他地方都不会向文件写入内容，只有这一行会）

#! /bin/bash
time=$(date "+%Y-%m-%d %H:%M:%S")
echo "测试向文件写入内容"
echo "${time}"
cat>>/usr/local/crontabTask/test1.log<<EOF
本次写入时间：${time}
EOF

备份mysql

备份单数据库

将下面代码保存为文件 mysql_single_backup.sh 执行 chmod +x mysql_single_backup.sh 赋予可执行权限，运行后会备份数据库中的所有对象以及其中的数据（包括：视图、存储过程、函数、触发器等）

#!/bin/bash

# MySQL单数据库完整备份测试脚本
# 备份存储过程、视图、函数、触发器等所有对象

# 设置颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# MySQL连接配置
MYSQL_USER=""
MYSQL_PASSWORD=""
MYSQL_HOST="localhost"
MYSQL_PORT="3306"
DATABASE=""

# 显示使用说明
show_usage() {
    echo -e "${GREEN}MySQL单数据库完整备份测试脚本${NC}"
    echo "用法: $0"
    echo "功能: 完整备份单个MySQL数据库（包含所有对象）"
    echo ""
    echo "备份内容:"
    echo "  - 表结构和数据"
    echo "  - 存储过程"
    echo "  - 视图"
    echo "  - 函数"
    echo "  - 触发器"
    echo "  - 事件"
}

# 检查必要命令
check_commands() {
    local commands=("mysql" "mysqldump")
    for cmd in "${commands[@]}"; do
        if ! command -v "$cmd" &> /dev/null; then
            echo -e "${RED}错误: 未找到命令: $cmd${NC}"
            exit 1
        fi
    done
}

# 获取MySQL登录凭据
get_mysql_credentials() {
    echo -e "${BLUE}请输入MySQL连接信息${NC}"

    read -p "MySQL用户名 (默认: root): " input_user
    MYSQL_USER="${input_user:-root}"

    read -s -p "MySQL密码: " MYSQL_PASSWORD
    echo ""

    read -p "MySQL主机 (默认: localhost): " input_host
    MYSQL_HOST="${input_host:-localhost}"

    read -p "MySQL端口 (默认: 3306): " input_port
    MYSQL_PORT="${input_port:-3306}"
}

# 获取要备份的数据库
get_database_name() {
    local mysql_cmd="mysql -h ${MYSQL_HOST} -P ${MYSQL_PORT} -u ${MYSQL_USER} -p${MYSQL_PASSWORD}"

    echo -e "${YELLOW}获取数据库列表...${NC}"
    local databases
    databases=$($mysql_cmd -e "SHOW DATABASES;" 2>/dev/null | grep -Ev "(Database|information_schema|performance_schema|mysql|sys)")

    if [ -z "$databases" ]; then
        echo -e "${RED}未找到可备份的数据库${NC}"
        exit 1
    fi

    echo -e "${GREEN}可用的数据库:${NC}"
    echo "$databases"
    echo ""

    while true; do
        read -p "请输入要备份的数据库名称: " db_name
        if echo "$databases" | grep -q "^${db_name}$"; then
            DATABASE="$db_name"
            break
        else
            echo -e "${RED}数据库 '${db_name}' 不存在或不可访问，请重新输入${NC}"
        fi
    done
}

# 构建mysqldump命令
get_mysqldump_cmd() {
    echo "mysqldump -h ${MYSQL_HOST} -P ${MYSQL_PORT} -u ${MYSQL_USER} -p${MYSQL_PASSWORD}"
}

# 检查MySQL连接
check_mysql_connection() {
    local mysql_cmd="mysql -h ${MYSQL_HOST} -P ${MYSQL_PORT} -u ${MYSQL_USER} -p${MYSQL_PASSWORD}"

    echo -e "${YELLOW}测试MySQL连接...${NC}"
    if ! $mysql_cmd -e "SELECT 1;" >/dev/null 2>&1; then
        echo -e "${RED}✗ 无法连接到MySQL数据库${NC}"
        return 1
    else
        echo -e "${GREEN}✓ MySQL连接成功${NC}"
        return 0
    fi
}

# 检查数据库对象
check_database_objects() {
    local mysql_cmd="mysql -h ${MYSQL_HOST} -P ${MYSQL_PORT} -u ${MYSQL_USER} -p${MYSQL_PASSWORD}"

    echo -e "${BLUE}检查数据库 ${DATABASE} 中的对象...${NC}"

    # 检查表
    local table_count
    table_count=$($mysql_cmd -D "$DATABASE" -e "SHOW TABLES;" 2>/dev/null | wc -l)
    echo -e "表: $((table_count - 1)) 个"

    # 检查存储过程
    local procedure_count
    procedure_count=$($mysql_cmd -D "$DATABASE" -e "SHOW PROCEDURE STATUS WHERE Db = '${DATABASE}';" 2>/dev/null | wc -l)
    echo -e "存储过程: $((procedure_count - 1)) 个"

    # 检查函数
    local function_count
    function_count=$($mysql_cmd -D "$DATABASE" -e "SHOW FUNCTION STATUS WHERE Db = '${DATABASE}';" 2>/dev/null | wc -l)
    echo -e "函数: $((function_count - 1)) 个"

    # 检查视图
    local view_count
    view_count=$($mysql_cmd -D "$DATABASE" -e "SHOW FULL TABLES WHERE Table_type = 'VIEW';" 2>/dev/null | wc -l)
    echo -e "视图: $((view_count - 1)) 个"

    # 检查触发器
    local trigger_count
    trigger_count=$($mysql_cmd -D "$DATABASE" -e "SHOW TRIGGERS;" 2>/dev/null | wc -l)
    echo -e "触发器: $((trigger_count - 1)) 个"

    # 检查事件
    local event_count
    event_count=$($mysql_cmd -D "$DATABASE" -e "SHOW EVENTS;" 2>/dev/null | wc -l)
    echo -e "事件: $((event_count - 1)) 个"
}

# 完整备份数据库
backup_database_complete() {
    local backup_file="$1"
    local mysqldump_cmd
    mysqldump_cmd=$(get_mysqldump_cmd)

    echo -e "${YELLOW}开始完整备份数据库: ${DATABASE}${NC}"

    # 使用完整的mysqldump参数备份所有对象
    $mysqldump_cmd \
        --databases "$DATABASE" \
        --routines \
        --triggers \
        --events \
        --skip-lock-tables \
        --single-transaction \
        --complete-insert \
        --extended-insert \
        --hex-blob \
        --add-drop-database \
        --add-drop-table \
        --add-drop-trigger \
        --result-file="$backup_file" 2>/dev/null

    local exit_code=$?

    if [ $exit_code -eq 0 ] && [ -s "$backup_file" ]; then
        echo -e "${GREEN}✓ 数据库 ${DATABASE} 完整备份成功${NC}"
        echo -e "${GREEN}备份文件: ${backup_file} ($(du -h "${backup_file}" | cut -f1))${NC}"
        return 0
    else
        echo -e "${RED}✗ 数据库 ${DATABASE} 备份失败${NC}"
        return 1
    fi
}

# 验证备份文件内容
verify_backup_content() {
    local backup_file="$1"

    echo -e "${YELLOW}验证备份文件内容...${NC}"

    if [ ! -f "$backup_file" ]; then
        echo -e "${RED}备份文件不存在${NC}"
        return 1
    fi

    if [ ! -s "$backup_file" ]; then
        echo -e "${RED}备份文件为空${NC}"
        return 1
    fi

    # 检查备份文件中是否包含关键对象
    local has_tables=0
    local has_routines=0
    local has_triggers=0
    local has_events=0

    if grep -q "CREATE TABLE" "$backup_file"; then
        has_tables=1
        echo -e "✓ 包含表结构"
    fi

    if grep -q "CREATE.*PROCEDURE\|CREATE.*FUNCTION" "$backup_file"; then
        has_routines=1
        echo -e "✓ 包含存储过程/函数"
    fi

    if grep -q "CREATE.*TRIGGER" "$backup_file"; then
        has_triggers=1
        echo -e "✓ 包含触发器"
    fi

    if grep -q "CREATE.*EVENT" "$backup_file"; then
        has_events=1
        echo -e "✓ 包含事件"
    fi

    if grep -q "INSERT INTO" "$backup_file"; then
        echo -e "✓ 包含数据"
    fi

    echo -e "${GREEN}备份文件验证完成${NC}"
    return 0
}

# 主备份函数
main_backup() {
    local timestamp
    timestamp=$(date +%Y%m%d_%H%M%S)
    local backup_file="${DATABASE}_complete_backup_${timestamp}.sql"

    echo -e "${GREEN}开始MySQL单数据库完整备份测试${NC}"
    echo "========================================"

    # 检查必要命令
    check_commands

    # 获取MySQL凭据
    get_mysql_credentials

    # 检查MySQL连接
    if ! check_mysql_connection; then
        echo -e "${RED}数据库连接失败，请重新运行脚本并检查凭据${NC}"
        exit 1
    fi

    # 获取要备份的数据库
    get_database_name

    # 检查数据库对象
    check_database_objects

    echo ""
    echo -e "${BLUE}备份配置:${NC}"
    echo "  数据库: $DATABASE"
    echo "  备份文件: $backup_file"
    echo "  包含: 表结构, 数据, 存储过程, 函数, 视图, 触发器, 事件"
    echo ""

    # 确认备份
    read -p "是否开始备份? (y/N): " confirm
    case "$confirm" in
        [yY]|[yY][eE][sS])
            echo "开始备份..."
            ;;
        *)
            echo -e "${YELLOW}备份已取消${NC}"
            exit 0
            ;;
    esac

    # 执行备份
    if backup_database_complete "$backup_file"; then
        echo ""
        echo -e "${GREEN}备份成功完成!${NC}"

        # 验证备份内容
        echo ""
        verify_backup_content "$backup_file"

        echo ""
        echo -e "${GREEN}您可以检查备份文件内容:${NC}"
        echo "  less $backup_file"
        echo ""
        echo -e "${GREEN}或者查看文件头信息:${NC}"
        echo "  head -50 $backup_file"

    else
        echo -e "${RED}备份失败${NC}"
        exit 1
    fi
}

# 主程序
main() {
    echo -e "${GREEN}========================================${NC}"
    echo -e "${GREEN}  MySQL单数据库完整备份测试工具${NC}"
    echo -e "${GREEN}========================================${NC}"
    echo ""

    main_backup
}

# 脚本入口
if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
    show_usage
else
    main
fi

批量备份

批量备份当前服务器上的所有数据库，将下面文件保存为 mysql_backup.sh 后执行 chmod +x mysql_backup.sh 赋予可执行权限，已验证可用。

#!/bin/bash

# MySQL数据库批量完整备份脚本
# 备份所有数据库，包含存储过程、视图、函数、触发器等所有对象

# 设置颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# MySQL连接配置
MYSQL_USER=""
MYSQL_PASSWORD=""
MYSQL_HOST="localhost"
MYSQL_PORT="3306"

# 检查必要命令是否存在
check_commands() {
    local commands=("mysql" "mysqldump" "zip" "systemctl")
    for cmd in "${commands[@]}"; do
        if ! command -v "$cmd" &> /dev/null; then
            echo -e "${RED}错误: 未找到命令: $cmd${NC}"
            exit 1
        fi
    done
}

# 获取MySQL登录凭据
get_mysql_credentials() {
    echo -e "${BLUE}请输入MySQL连接信息${NC}"

    read -p "MySQL用户名 (默认: root): " input_user
    MYSQL_USER="${input_user:-root}"

    read -s -p "MySQL密码: " MYSQL_PASSWORD
    echo ""

    read -p "MySQL主机 (默认: localhost): " input_host
    MYSQL_HOST="${input_host:-localhost}"

    read -p "MySQL端口 (默认: 3306): " input_port
    MYSQL_PORT="${input_port:-3306}"
}

# 构建MySQL连接命令
get_mysql_cmd() {
    echo "mysql -h ${MYSQL_HOST} -P ${MYSQL_PORT} -u ${MYSQL_USER} -p${MYSQL_PASSWORD}"
}

# 构建mysqldump连接命令
get_mysqldump_cmd() {
    echo "mysqldump -h ${MYSQL_HOST} -P ${MYSQL_PORT} -u ${MYSQL_USER} -p${MYSQL_PASSWORD}"
}

# 检查MySQL服务状态
check_mysql_service() {
    echo -e "${YELLOW}检查MySQL服务状态...${NC}"

    if [ "$MYSQL_HOST" = "localhost" ] || [ "$MYSQL_HOST" = "127.0.0.1" ]; then
        if systemctl is-active --quiet mysqld; then
            echo -e "${GREEN}✓ MySQL服务正在运行${NC}"
        elif systemctl is-active --quiet mariadb; then
            echo -e "${GREEN}✓ MariaDB服务正在运行${NC}"
        else
            echo -e "${YELLOW}⚠ 未检测到本地MySQL服务，继续尝试连接...${NC}"
        fi
    fi
}

# 检查MySQL连接
check_mysql_connection() {
    echo -e "${YELLOW}测试MySQL连接...${NC}"
    local mysql_cmd
    mysql_cmd=$(get_mysql_cmd)

    if ! $mysql_cmd -e "SELECT 1;" >/dev/null 2>&1; then
        echo -e "${RED}✗ 无法连接到MySQL数据库${NC}"
        echo -e "${RED}请检查以下信息：${NC}"
        echo "  - 用户名和密码是否正确"
        echo "  - 主机和端口是否可达"
        echo "  - 用户是否有足够的权限"
        echo "  - MySQL服务是否正在运行"
        return 1
    else
        echo -e "${GREEN}✓ MySQL连接成功${NC}"
        return 0
    fi
}

# 获取所有数据库列表
get_database_list() {
    local mysql_cmd
    mysql_cmd=$(get_mysql_cmd)

    $mysql_cmd -e "SHOW DATABASES;" | grep -Ev "(Database|information_schema|performance_schema|mysql|sys)"
}

# 检查数据库对象统计
get_database_objects_count() {
    local db_name=$1
    local mysql_cmd
    mysql_cmd=$(get_mysql_cmd)

    echo -n "表:$($mysql_cmd -D "$db_name" -e "SHOW TABLES;" 2>/dev/null | wc -l | awk '{print $1-1}') "
    echo -n "视图:$($mysql_cmd -D "$db_name" -e "SHOW FULL TABLES WHERE Table_type = 'VIEW';" 2>/dev/null | wc -l | awk '{print $1-1}') "
    echo -n "过程:$($mysql_cmd -D "$db_name" -e "SHOW PROCEDURE STATUS WHERE Db = '${db_name}';" 2>/dev/null | wc -l | awk '{print $1-1}') "
    echo -n "函数:$($mysql_cmd -D "$db_name" -e "SHOW FUNCTION STATUS WHERE Db = '${db_name}';" 2>/dev/null | wc -l | awk '{print $1-1}') "
    echo -n "触发器:$($mysql_cmd -D "$db_name" -e "SHOW TRIGGERS;" 2>/dev/null | wc -l | awk '{print $1-1}') "
    echo -n "事件:$($mysql_cmd -D "$db_name" -e "SHOW EVENTS;" 2>/dev/null | wc -l | awk '{print $1-1}')"
}

# 完整备份单个数据库（包含所有对象）
backup_database_complete() {
    local db_name=$1
    local backup_dir=$2
    local backup_file="${backup_dir}/${db_name}.sql"
    local mysqldump_cmd
    mysqldump_cmd=$(get_mysqldump_cmd)

    echo -e "${YELLOW}正在备份数据库: ${db_name}${NC}"

    # 使用完整的mysqldump参数备份所有对象
    $mysqldump_cmd \
        --databases "$db_name" \
        --routines \
        --triggers \
        --events \
        --skip-lock-tables \
        --single-transaction \
        --complete-insert \
        --extended-insert \
        --hex-blob \
        --add-drop-database \
        --add-drop-table \
        --add-drop-trigger \
        --result-file="$backup_file" 2>/dev/null

    local exit_code=$?

    if [ $exit_code -eq 0 ] && [ -s "$backup_file" ]; then
        # 验证备份文件包含关键内容
        if grep -q "CREATE TABLE\|CREATE.*PROCEDURE\|CREATE.*FUNCTION\|CREATE.*TRIGGER" "$backup_file" 2>/dev/null; then
            echo -e "${GREEN}✓ 数据库 ${db_name} 完整备份成功 ($(du -h "${backup_file}" | cut -f1))${NC}"
            return 0
        else
            echo -e "${YELLOW}⚠ 数据库 ${db_name} 备份文件可能不完整${NC}"
            return 1
        fi
    else
        echo -e "${RED}✗ 数据库 ${db_name} 备份失败${NC}"
        return 1
    fi
}

# 验证备份文件内容
verify_backup_file() {
    local backup_file="$1"
    local db_name="$2"

    if [ ! -f "$backup_file" ] || [ ! -s "$backup_file" ]; then
        echo -e "  ${RED}✗ 备份文件无效${NC}"
        return 1
    fi

    local has_tables=0
    local has_routines=0
    local has_triggers=0

    if grep -q "CREATE TABLE" "$backup_file" 2>/dev/null; then
        has_tables=1
    fi

    if grep -q "CREATE.*PROCEDURE\|CREATE.*FUNCTION" "$backup_file" 2>/dev/null; then
        has_routines=1
    fi

    if grep -q "CREATE.*TRIGGER" "$backup_file" 2>/dev/null; then
        has_triggers=1
    fi

    echo -n "  [表:${has_tables} 过程:${has_routines} 触发器:${has_triggers}]"

    if [ $has_tables -eq 1 ] || [ $has_routines -eq 1 ] || [ $has_triggers -eq 1 ]; then
        echo -e " ${GREEN}✓${NC}"
        return 0
    else
        echo -e " ${RED}✗${NC}"
        return 1
    fi
}

# 主备份函数
main_backup() {
    local timestamp
    timestamp=$(date +%Y%m%d_%H%M%S)
    local backup_dir="/tmp/mysql_complete_backup_${timestamp}"
    local zip_file="backupAlldbs_complete_${timestamp}.zip"

    # 创建临时备份目录
    mkdir -p "${backup_dir}"

    echo -e "${GREEN}开始MySQL数据库完整批量备份${NC}"
    echo "========================================"

    # 检查必要命令
    check_commands

    # 获取MySQL凭据
    get_mysql_credentials

    # 检查MySQL连接
    if ! check_mysql_connection; then
        echo -e "${RED}数据库连接失败，请重新运行脚本并检查凭据${NC}"
        exit 1
    fi

    # 获取数据库列表
    echo -e "${YELLOW}获取数据库列表...${NC}"
    local databases
    databases=$(get_database_list)

    if [ -z "$databases" ]; then
        echo -e "${RED}未找到可备份的数据库${NC}"
        rm -rf "${backup_dir}"
        exit 1
    fi

    # 显示数据库列表和对象统计
    echo -e "${GREEN}找到以下数据库:${NC}"
    echo "========================================"
    local total_databases=0
    for db in $databases; do
        ((total_databases++))
        echo -n "- ${db} "
        get_database_objects_count "$db"
        echo ""
    done
    echo "========================================"
    echo -e "${BLUE}总计: ${total_databases} 个数据库${NC}"
    echo ""

    # 确认备份
    read -p "是否继续完整备份所有数据库? (y/N): " confirm_backup
    case "$confirm_backup" in
        [yY]|[yY][eE][sS])
            echo "开始备份..."
            ;;
        *)
            echo -e "${YELLOW}备份已取消${NC}"
            rm -rf "${backup_dir}"
            exit 0
            ;;
    esac

    # 备份每个数据库
    echo ""
    echo -e "${YELLOW}开始备份数据库...${NC}"
    echo "========================================"

    local backup_count=0
    local fail_count=0
    local backup_results=()

    for db in $databases; do
        echo -e "${BLUE}备份: ${db}${NC}"
        if backup_database_complete "$db" "$backup_dir"; then
            ((backup_count++))
            backup_results+=("$db:成功")
            # 验证备份文件
            verify_backup_file "${backup_dir}/${db}.sql" "$db"
        else
            ((fail_count++))
            backup_results+=("$db:失败")
        fi
        echo "----------------------------------------"
    done

    # 显示备份结果摘要
    echo ""
    echo -e "${GREEN}备份完成摘要${NC}"
    echo "========================================"
    for result in "${backup_results[@]}"; do
        local db_name="${result%:*}"
        local status="${result#*:}"
        if [ "$status" = "成功" ]; then
            echo -e "${GREEN}✓ ${db_name}${NC}"
        else
            echo -e "${RED}✗ ${db_name}${NC}"
        fi
    done
    echo "========================================"
    echo -e "${BLUE}备份完成: ${backup_count} 成功, ${fail_count} 失败${NC}"

    if [ $backup_count -eq 0 ]; then
        echo -e "${RED}没有数据库备份成功，退出${NC}"
        rm -rf "${backup_dir}"
        exit 1
    fi

    # 压缩备份文件
    echo ""
    echo -e "${YELLOW}正在压缩备份文件...${NC}"
    if cd "${backup_dir}" && zip -r "${zip_file}" ./*.sql >/dev/null 2>&1; then
        echo -e "${GREEN}✓ 备份文件压缩成功${NC}"
        echo -e "压缩文件: ${zip_file} ($(du -h "${backup_dir}/${zip_file}" | cut -f1))"
    else
        echo -e "${RED}✗ 备份文件压缩失败${NC}"
        rm -rf "${backup_dir}"
        exit 1
    fi

    # 询问用户保存路径
    while true; do
        echo ""
        echo -e "${YELLOW}请输入要保存备份文件的完整路径:${NC}"
        echo -e "示例: /home/username/backups 或 /opt/mysql_backups"
        echo -e "按 Enter 使用当前目录: $(pwd)"
        read -p "保存路径: " target_path

        # 如果为空，使用当前目录
        if [ -z "$target_path" ]; then
            target_path="."
        fi

        # 创建目标目录（如果不存在）
        if ! mkdir -p "$target_path" 2>/dev/null; then
            echo -e "${RED}无法创建目录: $target_path，请检查权限或输入其他路径${NC}"
            continue
        fi

        # 检查目录是否可写
        if [ ! -w "$target_path" ]; then
            echo -e "${RED}目录不可写: $target_path，请检查权限或输入其他路径${NC}"
            continue
        fi

        break
    done

    # 移动备份文件到目标位置
    local final_path="${target_path}/${zip_file}"
    if mv "${backup_dir}/${zip_file}" "$final_path" 2>/dev/null; then
        echo ""
        echo -e "${GREEN}✓ 备份文件已保存到: ${final_path}${NC}"

        # 显示备份文件信息
        echo -e "${YELLOW}备份文件信息:${NC}"
        ls -lh "$final_path"

        # 显示备份内容统计
        echo ""
        echo -e "${YELLOW}备份包含以下数据库:${NC}"
        for result in "${backup_results[@]}"; do
            if [[ "$result" == *":成功" ]]; then
                local db_name="${result%:*}"
                echo -e "  ${GREEN}✓${NC} ${db_name}"
            fi
        done

    else
        echo -e "${RED}✗ 移动备份文件失败${NC}"
        echo -e "${YELLOW}备份文件临时位置: ${backup_dir}/${zip_file}${NC}"
    fi

    # 清理临时文件
    rm -rf "${backup_dir}"
    echo ""
    echo -e "${GREEN}临时文件已清理${NC}"

    echo ""
    echo -e "${GREEN}========================================${NC}"
    echo -e "${GREEN}     数据库完整备份完成!${NC}"
    echo -e "${GREEN}========================================${NC}"
}

# 显示使用说明
show_usage() {
    echo -e "${GREEN}MySQL数据库完整批量备份脚本${NC}"
    echo "用法: $0"
    echo "功能: 完整备份所有MySQL数据库并压缩为zip文件"
    echo ""
    echo "备份内容包含:"
    echo "  - 表结构和数据"
    echo "  - 存储过程和函数"
    echo "  - 视图"
    echo "  - 触发器"
    echo "  - 事件"
    echo ""
    echo "要求:"
    echo "  - MySQL/MariaDB服务可访问"
    echo "  - 有MySQL访问权限"
    echo "  - 有足够的磁盘空间存放备份"
}

# 主程序
main() {
    # 显示欢迎信息
    echo -e "${GREEN}========================================${NC}"
    echo -e "${GREEN}   MySQL数据库完整批量备份工具${NC}"
    echo -e "${GREEN}========================================${NC}"
    echo ""

    # 确认是否继续
    echo -e "${YELLOW}此脚本将完整备份所有MySQL数据库（排除系统数据库）${NC}"
    echo -e "${YELLOW}备份内容包含：表、视图、存储过程、函数、触发器、事件${NC}"
    read -p "是否继续? (y/N): " confirm

    case "$confirm" in
        [yY]|[yY][eE][sS])
            main_backup
            ;;
        *)
            echo -e "${YELLOW}操作已取消${NC}"
            exit 0
            ;;
    esac
}

# 脚本入口
if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
    show_usage
else
    main
fi

删除日志文件

#!/bin/sh
find /sbJarLogs/wxbe/ -mtime +3 -name "*.tmp" -exec rm -rf {} \;
find /sbJarLogs/wxbe/ -mtime +3 -name "*.log.zip" -exec rm -rf {} \;
find /sbJarLogs/wxbe/ -mtime +3 -name "*.log" -exec rm -rf {} \;

读取目录下所有文件

#!/bin/bash
# 采集一个函数
readDir() {
  # 获取传入的目录路径
  local dir=$1
  # 循环指定目录下的所有文件
  local files
  files=$(ls "$dir")
  for file in $files; do
    local path="$dir/$file" #指的是当前遍历文件的完整路径
    # 判断是否是目录，如果是目录则递归遍历，如果是文件则打印该文件的完整路径
    if [ -d "$path" ]; then
      readDir "$path"
    else
      echo "$path"
    fi
  done
}

# 调用函数，传入顶级目录为/root
readDir /usr/local/piclist

读取当前目录下所有文件

#!/bin/bash
# 采集一个函数
readDir() {
  # 获取传入的目录路径
  local dir=$1
  # 循环指定目录下的所有文件
  local files
  files=$(ls "$dir")
  for file in $files; do
    local path="$dir/$file" #指的是当前遍历文件的完整路径
    # 判断是否是目录，如果是目录则递归遍历，如果是文件则打印该文件的完整路径
    if [ -d "$path" ]; then
      readDir "$path"
    else
      echo "$path"
      echo "path:$dir,file:$file"
    fi
  done
}

# 下面的pwd表示本sh文件所在目录。整个批处理文件是读取当前目录下的所有文件，打印出绝对路径+文件名
CRTDIR=$(pwd)
readDir $CRTDIR

获取字符串长度

#!/bin/bash
# str是变量名称
${#str}

数组长度

${#array_name[@]}

读取本地文件并新文件名

#!/bin/bash
# 采集一个函数
readDir() {
  # 获取传入的目录路径
  local dir=$1
  # 循环指定目录下的所有文件
  local files
  files=$(ls "$dir")
  for file in $files; do
    local path="$dir/$file" #指的是当前遍历文件的完整路径
    # 判断是否是目录，如果是目录则递归遍历，如果是文件则打印该文件的完整路径
    if [ -d "$path" ]; then
      readDir "$path"
    else
      #echo "$path"
      #echo "path:$dir,file:$file"

      # 创建新的文件名称
      # 分割文件名
      fileNameArr=(${file//./ })
      # 文件名长度
      lenFileName=${#file}
      # 分割后的文件数组的长度
      lenArr=${#fileNameArr[@]}
      # 最后一个元素，即文件的扩展名
      lastEle=${fileNameArr[lenArr-1]}
      # 文件扩展名长度
      lenExt=${#lastEle}
      # 没有扩展名的纯文件名
      fileNamePure=${file:0:${lenFileName}-${lenExt}-1}
      # 创建的新文件的名称
      newFileName="${fileNamePure}.ff.${lastEle}"
      echo "文件名：${file},纯文件名：${fileNamePure},扩展名：${lastEle}，新文件名：${newFileName}"
    fi
  done
}

# 下面的pwd表示本sh文件所在目录。整个批处理文件是读取当前目录下的所有文件，打印出绝对路径+文件名
CRTDIR=$(pwd)
readDir $CRTDIR

压缩当前目录mp4文件

#!/bin/bash
# 采集一个函数
readDir() {
  # 获取传入的目录路径
  local dir=$1
  echo $(date "+%Y-%m-%d %H:%M:%S") "当前目录：${dir}" >> compress.log
  # 循环指定目录下的所有文件
  local files
  files=$(ls "$dir")
  for file in $files; do
    local path="$dir/$file" #指的是当前遍历文件的完整路径
    # 判断是否是目录，如果是目录则递归遍历，如果是文件则打印该文件的完整路径
    if [ -d "$path" ]; then
      readDir "$path"
    else
      #echo "$path"
      #echo "path:$dir,file:$file"

      # 创建新的文件名称
      # 分割文件名
      fileNameArr=(${file//./ })
      # 文件名长度
      lenFileName=${#file}
      # 分割后的文件数组的长度
      lenArr=${#fileNameArr[@]}
      # 最后一个元素，即文件的扩展名
      lastEle=${fileNameArr[lenArr-1]}
      # 文件扩展名长度
      lenExt=${#lastEle}
      # 没有扩展名的纯文件名
      fileNamePure=${file:0:${lenFileName}-${lenExt}-1}
      # 创建的新文件的名称
      newFileName="${fileNamePure}.ff.${lastEle}"
      #echo "文件名：${file},纯文件名：${fileNamePure},扩展名：${lastEle}，新文件名：${newFileName}"

      # 只处理 mp4 文件
      if [ ${lastEle} == "mp4" ]; then
        echo $(date "+%Y-%m-%d %H:%M:%S") " 开始压缩文件 ${file}" >> compress.log
        ffmpeg -i ${file} -vcodec h264 -s 1280*720 -acodec copy -f mp4 ${newFileName}
        echo $(date "+%Y-%m-%d %H:%M:%S") " 压缩结束，新文件： ${newFileName}" >> compress.log
      else
        echo $(date "+%Y-%m-%d %H:%M:%S") " 只压缩 mp4 文件，当前文件： ${file}" >> compress.log
      fi
    fi
  done
}

function mail(){
  from_name="chanchaw"
  from="chan_chaw@126.com"
  to="409223171@qq.com"

  # 目标收到的邮件中不会显示
  email_title="shell test mail title"
  # 目标收到的邮件中看到的正文内容
  email_content="compress.log"
  # 目标收到的邮件标题
  email_subject="ffmpeg压缩完毕通知"

  echo -e "To: \"${email_title}\" <${to}>\nFrom: \"${from_name}\" <${from}>\nSubject: ${email_subject}\n\n`cat ${email_content}`" | /usr/sbin/sendmail -t
}

CRTDIR=$(pwd)
readDir $CRTDIR
# 压缩完毕后发送邮件
mail

案例

# 向文件写入内容

# 备份mysql

# 删除日志文件

# 读取目录下所有文件

# 读取当前目录下所有文件

# 获取字符串长度

# 数组长度

# 读取本地文件并新文件名

# 压缩当前目录mp4文件