批量删除超出限制的文件脚本

本文目录导读：

1. Linux/Unix Shell 脚本
2. Windows PowerShell 脚本
3. Python 脚本（跨平台）
4. 带安全机制的高级脚本
5. 使用说明

Linux/Unix Shell 脚本

删除超过指定大小限制的文件

#!/bin/bash
# 删除超过指定大小的文件
# 用法: ./delete_oversized.sh /path/to/directory 100M
TARGET_DIR="${1:-.}"  # 默认为当前目录
SIZE_LIMIT="${2:-100M}"  # 默认为100MB
if [ ! -d "$TARGET_DIR" ]; then
    echo "错误: 目录 $TARGET_DIR 不存在"
    exit 1
fi
echo "将删除目录 $TARGET_DIR 中超过 $SIZE_LIMIT 的文件"
echo "文件列表:"
# 找出并显示超过限制的文件
find "$TARGET_DIR" -type f -size +"$SIZE_LIMIT" -exec ls -lh {} \;
# 确认删除
read -p "确认删除以上文件? (y/n): " confirm
if [[ $confirm == [yY] ]]; then
    find "$TARGET_DIR" -type f -size +"$SIZE_LIMIT" -delete
    echo "删除完成"
else
    echo "操作取消"
fi

删除指定天数之前的文件

#!/bin/bash
# 删除指定天数之前的文件
# 用法: ./delete_old_files.sh /path/to/directory 7
TARGET_DIR="${1:-.}"
DAYS="${2:-7}"
FILE_PATTERN="${3:-*}"  # 可选文件模式，如 "*.log"
echo "将删除目录 $TARGET_DIR 中 $DAYS 天前的文件"
find "$TARGET_DIR" -type f -name "$FILE_PATTERN" -mtime +$DAYS -exec ls -lh {} \;
read -p "确认删除? (y/n): " confirm
if [[ $confirm == [yY] ]]; then
    find "$TARGET_DIR" -type f -name "$FILE_PATTERN" -mtime +$DAYS -delete
    echo "删除完成"
fi

Windows PowerShell 脚本

删除超过指定大小限制的文件

# delete_oversized.ps1
param(
    [string]$Directory = ".",
    [string]$SizeLimit = "100MB"
)
# 转换为字节
$limitBytes = [long]($SizeLimit -replace 'MB','' -replace 'GB','' )
if ($SizeLimit -match 'GB') { $limitBytes *= 1GB }
elseif ($SizeLimit -match 'MB') { $limitBytes *= 1MB }
elseif ($SizeLimit -match 'KB') { $limitBytes *= 1KB }
Write-Host "将删除 $Directory 中超过 $SizeLimit 的文件" -ForegroundColor Yellow
# 查找文件
$files = Get-ChildItem -Path $Directory -File | Where-Object { $_.Length -gt $limitBytes }
if ($files.Count -eq 0) {
    Write-Host "没有找到超过限制的文件" -ForegroundColor Green
    exit
}
# 显示文件列表
$files | ForEach-Object {
    Write-Host "$($_.FullName) - $([math]::Round($_.Length/1MB, 2)) MB"
}
# 确认删除
$confirm = Read-Host "确认删除以上文件? (y/n)"
if ($confirm -eq 'y') {
    $files | Remove-Item -Force
    Write-Host "删除完成" -ForegroundColor Green
} else {
    Write-Host "操作取消" -ForegroundColor Yellow
}

Python 脚本（跨平台）

#!/usr/bin/env python3
# delete_oversized.py
import os
import sys
import argparse
from pathlib import Path
def convert_size(size_str):
    """将大小字符串转换为字节"""
    size_map = {
        'b': 1,
        'kb': 1024,
        'mb': 1024**2,
        'gb': 1024**3,
        'tb': 1024**4
    }
    try:
        num = float(size_str[:-2].strip())
        unit = size_str[-2:].lower()
        return int(num * size_map[unit])
    except:
        try:
            num = float(size_str[:-1].strip())
            unit = size_str[-1].lower()
            return int(num * size_map[unit + 'b'] if unit != 'b' else num)
        except:
            return None
def delete_oversized_files(directory, size_limit, min_age=None, dry_run=True):
    """删除超过大小限制的文件"""
    directory_path = Path(directory)
    if not directory_path.exists():
        print(f"错误: 目录 {directory} 不存在")
        return
    limit_bytes = convert_size(size_limit)
    if not limit_bytes:
        print(f"错误: 无法解析大小 {size_limit}")
        return
    deleted_list = []
    for file_path in directory_path.rglob('*'):
        if not file_path.is_file():
            continue
        try:
            size = file_path.stat().st_size
            mtime = file_path.stat().st_mtime
            if size > limit_bytes:
                deleted_list.append(file_path)
                print(f"发现大文件: {file_path} - {size / (1024*1024):.2f} MB")
        except:
            continue
    if not deleted_list:
        print("没有找到超过限制的文件")
        return
    print(f"\n共找到 {len(deleted_list)} 个超过限制的文件")
    if dry_run:
        print("试运行模式，未实际删除")
        return
    confirm = input("确认删除这些文件? (y/n): ")
    if confirm.lower() == 'y':
        for file_path in deleted_list:
            try:
                file_path.unlink()
                print(f"已删除: {file_path}")
            except Exception as e:
                print(f"删除失败: {file_path} - {e}")
        print("删除完成")
    else:
        print("操作取消")
def main():
    parser = argparse.ArgumentParser(description='批量删除超出限制的文件')
    parser.add_argument('directory', help='目标目录')
    parser.add_argument('-s', '--size', default='100MB', help='大小限制 (如: 100MB, 1GB, 500KB)')
    parser.add_argument('--dry-run', action='store_true', help='试运行模式')
    parser.add_argument('--delete', action='store_true', help='实际删除（默认只显示）')
    args = parser.parse_args()
    delete_oversized_files(args.directory, args.size, dry_run=not args.delete)
if __name__ == "__main__":
    main()

带安全机制的高级脚本

#!/usr/bin/env python3
# safe_cleanup.py
import os
import hashlib
import json
from pathlib import Path
from datetime import datetime
class SafeCleanup:
    def __init__(self, base_dir):
        self.base_dir = Path(base_dir)
        self.log_file = self.base_dir / "cleanup_log.json"
    def calculate_hash(self, file_path):
        """计算文件哈希"""
        sha256_hash = hashlib.sha256()
        with open(file_path, "rb") as f:
            for byte_block in iter(lambda: f.read(4096), b""):
                sha256_hash.update(byte_block)
        return sha256_hash.hexdigest()
    def safe_delete(self, file_path, backup=True):
        """安全删除文件"""
        if backup:
            # 创建备份副本
            backup_dir = self.base_dir / "trash_backup"
            backup_dir.mkdir(exist_ok=True)
            backup_path = backup_dir / file_path.name
            try:
                # 重命名而不是直接删除
                if backup_path.exists():
                    backup_path = backup_dir / f"{file_path.name}_{datetime.now():%Y%m%d_%H%M%S}"
                file_path.rename(backup_path)
                print(f"已移动到回收站: {file_path} -> {backup_path}")
                return backup_path
            except Exception as e:
                print(f"备份失败: {e}")
                return None
        else:
            file_path.unlink()
            print(f"已永久删除: {file_path}")
            return file_path
    def cleanup_oversized(self, size_limit_mb, file_patterns=None, dry_run=True):
        """清理超出大小限制的文件"""
        limit_bytes = size_limit_mb * 1024 * 1024
        all_files = []
        # 根据文件模式筛选
        if file_patterns:
            for pattern in file_patterns:
                all_files.extend(list(self.base_dir.rglob(pattern)))
        else:
            all_files = list(self.base_dir.rglob('*'))
        # 筛选超过限制的文件
        oversized = []
        for file_path in all_files:
            if file_path.is_file() and file_path.stat().st_size > limit_bytes:
                oversized.append(file_path)
        if not oversized:
            print("没有找到超过限制的文件")
            return
        print(f"找到 {len(oversized)} 个超过 {size_limit_mb}MB 的文件:")
        delete_list = []
        for file_path in oversized:
            size_mb = file_path.stat().st_size / (1024 * 1024)
            print(f"  {file_path} - {size_mb:.2f}MB")
            delete_list.append(file_path)
        if dry_run:
            print("\n[试运行模式] 未实际删除文件")
            return
        confirm = input(f"确认删除这 {len(delete_list)} 个文件? (y/n): ")
        if confirm.lower() == 'y':
            result = []
            for file_path in delete_list:
                backup_path = self.safe_delete(file_path, backup=True)
                result.append({
                    'original': str(file_path),
                    'backup': str(backup_path) if backup_path else None,
                    'size_mb': file_path.stat().st_size / (1024 * 1024),
                    'deleted_at': datetime.now().isoformat()
                })
            # 保存日志
            self.save_log(result)
            print(f"删除完成，已备份到 trash_backup 目录")
    def save_log(self, entries):
        """保存删除日志"""
        try:
            if self.log_file.exists():
                data = json.loads(self.log_file.read_text())
            else:
                data = []
            data.extend(entries)
            self.log_file.write_text(json.dumps(data, indent=2))
        except Exception as e:
            print(f"保存日志失败: {e}")
if __name__ == "__main__":
    cleanup = SafeCleanup(Path("."))
    cleanup.cleanup_oversized(size_limit_mb=100, file_patterns=['*.log', '*.tmp'], dry_run=True)

使用说明

基本使用方法：

Shell (Linux/Mac):

# 添加执行权限
chmod +x delete_oversized.sh
# 运行
./delete_oversized.sh /path/to/directory 50MB

PowerShell (Windows):

# 运行
.\delete_oversized.ps1 -Directory "C:\path\to\dir" -SizeLimit "100MB"

Python (跨平台):

# 试运行模式（推荐先用这个）
python delete_oversized.py /path/to/directory --dry-run
# 实际删除
python delete_oversized.py /path/to/directory --delete --size 50MB

安全建议：

1. 始终先试运行（--dry-run），确认要删除的文件
2. 启用备份功能，以防误删
3. 使用日志记录，方便追踪
4. 设置合理的限制条件，避免删除重要文件
5. 定期清理而不是一次性大批量删除

这些脚本都包含了确认机制，确保您在删除前能够复查一遍,选择最适合您工作环境的版本使用。