Python/JS/Go/Java同步学习(第五十八篇)四语言“文件目录创建和删除“对照表: 雷影“老板“要求员工休息日野外实战训练团建风暴（附源码/截图/参数表/避坑指南）
🤝 免骂声明：
- 本文
文件目录创建和删除操作经本蜀黎实战整理，旨在提供快速参考指南📝- 因各语言版本迭代及不同系统
环境差异，偶尔可能出现整理不全面之处，实属正常✅- 理性讨论欢迎，无凭据攻击将依据平台规则处理，并可能触发内容自动备份传播机制🙏！
- 若遇具体问题，请带图评论区留言，本蜀黎必拔码相助🤝
此篇为"白帽"选手文件底层操作基础，无不良引导，代码切勿直接在生产环境中使用
- 文章中引用了
医药GSP，GMP仓储行业管理规范隐喻，这也是我以前每天执行的标准SOP，跨界学习的兄弟们可参考。
※ 温馨提示
- 若本内容
不慎触及某些利益，请理性沟通，但删稿免谈，内容去留仅由平台规则决定。 - 若是学生/自学党，欢迎白嫖，记得转发给和你一样在这条路上同行的伙伴——🔁
- 知识不该被垄断，而该成为照亮彼此前行的灯。
🛡️ 【技术剧情免责声明】
⚠️ 剧情设定说明
-
本文中的职场冲突情节，均为行业技术实践的
戏剧化隐喻 -
所有角色立场设计，旨在对比不同技术方案的适用场景
-
无任何现实指向性，亦
不倡导对立思维
🌿 技术交流初心
-
旨在通过场景化演绎，
降低技术理解门槛 -
遵循「以代码服人，以逻辑辨真」的极客精神
-
鼓励理性探讨，反对任何形式的技术偏见
💡 阅读建议
-
请重点关注技术实现路径的多样性
-
建议将剧情视为技术选型的「压力测试沙盒」
-
欢迎在评论区分享您的技术解决方案
🌿【虎山CTO·药材使用警示】
- 🍀是药
三分毒，代码亦如方！ - ❌文中所涉药材均为技术隐喻，严禁实际配伍使用。
- 🙏真实用药请遵医嘱，乱用者——
- 系统崩坏事小，气血逆流事大！⚠️
📚 系列文章预告：
- 近期内容将聚焦编程基础构建，以
「原创知识矩阵」形式系统梳理核心概念。每篇如连续剧集般环环相扣，建议按顺序学习——知识点一锅端，疗效更持久！🔥
🏗️ 目录的创建与删除：从“木叶忍者学校的场地管理”到“中药药柜的层级构建”
🔥 【场景还原：木叶村的训练场地管理】
💥 三代目火影（看着混乱的忍者学校场地）
- 「今日教学主题：忍者场地管理！连
mkdir和makedirs都分不清的下忍——直接送去妙木山当三年场地清理蛙！」
🍜 鸣人（看着一堆乱七八糟的训练器材）
- 「佐助！为什么要有这么多创建目录的方法？
mkdir、makedirs、createDirectories...我的影分身都记混了！」
🌸 小樱（快速翻阅《场地管理手册》）
- 「鸣人，目录管理就像忍者的阵营布置——
mkdir是搭建单个帐篷，makedirs是建立完整的营地体系，删除就是撤营！」
🕶️ 卡卡西（从《亲热天堂》中抬头）
- 「只会战斗不会布阵的忍者，在野外任务中连基本生存都做不到。记住：真正的精英，能在任何环境中建立根据地。」
🧘 【扎马步·目录管理心法要诀】
💡 目录三重境界：
第一重：基础认知
- 单目录创建 → 如“搭建单兵帐篷”🥇
- 嵌套目录创建 → 如“建立营地防御体系”🥈
- 目录删除的严谨性 → 如“撤营时的安全检查”🥉
第二重：实战应用
- 权限与所有权设置 → 如“营地的准入权限”🥇
- 递归操作的安全性 → 如“营地体系的稳定性”🥈
- 错误处理的完备性 → 如“布阵失败的回退方案”🥉
第三重：深度掌握
- 跨平台兼容性 → 如“不同地形的适应能力”🥇
- 原子操作与事务性 → 如“无缝切换营地”🥈
- 性能优化与资源管理 → 如“高效的后勤保障”🥉
🏔️ 【四语言目录管理奥义】
🐍 Python → 写轮眼·细腻分层
特点：三味药各有妙用，如"老中医的药柜分格术"
import os
# 场景一：单层药柜创建（如存放单味药材）
os.mkdir("解表药材区") # 创建单层药柜
print("✅ 单层药柜创建完成")
# 场景二：多层药柜体系（如完整的中药房）
os.makedirs("中药房/解表区/辛温解表/麻黄类") # 递归创建
print("✅ 多层药柜体系构建完成")
# 场景三：药柜清理（撤柜要谨慎！）
os.rmdir("过期药材区") # 只能删除空目录
os.removedirs("临时药方/测试方剂") # 递归删除空目录链
# 中医映射：
# os.mkdir → 单味药格（如"当归专柜"）
# os.makedirs → 整套药柜（如"补气药区域"）
# os.rmdir → 清空单柜（必须空柜才能撤）
# os.removedirs → 撤除空柜链（如撤除整个"试验药方区"）
核心心法：
os.mkdir()：创建单个目录，父目录必须存在 🎯os.makedirs()：递归创建，自动创建中间目录 🌳os.rmdir()：删除空目录，非空会报错 🗑️os.removedirs()：递归删除空目录链 🔄- 适合：脚本自动化、文件整理、批量建站 📁
☕ Java → 白眼·严谨标准
特点：Files.createDirectories()统一接口，如"御医院的标准化药房管理"
import java.nio.file.*;
public class DirectoryManager {
public static void main(String[] args) throws Exception {
// 标准药房构建（严格按照GSP规范）
Path singleShelf = Paths.get("饮片库/根茎类");
Path nestedShelf = Paths.get("中成药库/内科用药/扶正剂/补气类");
// 创建单层药架
Files.createDirectory(singleShelf);
System.out.println("✅ 单层药架创建完成");
// 创建多层药架体系
Files.createDirectories(nestedShelf);
System.out.println("✅ 多层药架体系构建完成");
// 药架安全检查与撤除
if (Files.isDirectory(singleShelf)) {
try {
Files.delete(singleShelf); // 必须为空
System.out.println("✅ 空药架安全撤除");
} catch (DirectoryNotEmptyException e) {
System.out.println("⚠️ 药架非空，请先清空药材");
}
}
// 中医映射：
// Files.createDirectory → 单味药专柜
// Files.createDirectories → 整套药房体系
// Files.delete → 谨慎撤柜（强类型安全检查）
}
}
核心心法：
Files.createDirectory()：创建单层目录 ⚙️Files.createDirectories()：递归创建多层目录 🏗️Files.delete()：删除目录/文件（非空会抛异常） 🚨- 适合：企业系统、医疗系统、需要严格权限管理的场景 💼
⚡ Go → 体术·直击要害
特点：os.MkdirAll()一力降十会，如"游医的便携药箱管理"
package main
import (
"fmt"
"os"
)
func main() {
// 简单直接创建药箱结构
err := os.Mkdir("简易药箱", 0755) // 0755是权限
if err != nil {
fmt.Println("药箱已存在或创建失败:", err)
} else {
fmt.Println("✅ 简易药箱创建完成")
}
// 递归创建多层药箱结构
err = os.MkdirAll("专业药箱/外用/膏药/活血化瘀", 0755)
if err != nil {
fmt.Println("创建失败:", err)
} else {
fmt.Println("✅ 多层药箱结构构建完成")
}
// 删除药箱（Go的特点：简单但需谨慎）
err = os.Remove("简易药箱") // 必须为空
if err != nil {
fmt.Println("删除失败（可能非空）:", err)
}
// 中医映射：
// os.Mkdir → 搭建单层药架
// os.MkdirAll → 构建完整药房
// os.Remove → 撤除空药架（一力承担）
}
核心心法：
os.Mkdir()：创建单目录，父目录必须存在 ⚡os.MkdirAll()：递归创建，类似makedirs🏔️os.Remove()：删除文件或空目录 🗑️- 错误处理显式而直接 💪
- 适合：CLI工具、系统工具、需要简洁代码的场景 🛠️
🟨 JavaScript → 幻术·异步灵活
特点：fs.mkdir()支持Promise异步，如"炼丹师的时空药房"
const fs = require('fs').promises;
const path = require('path');
async function manageHerbalStore() {
try {
// 异步创建单层药架
await fs.mkdir('炼丹房');
console.log('✅ 炼丹房创建完成');
// 异步递归创建多层药架
await fs.mkdir('丹方库/补益类/气血双补/八珍汤系', { recursive: true });
console.log('✅ 丹方库多层结构构建完成');
// 异步删除空药架
await fs.rmdir('临时试验架');
console.log('✅ 空药架已撤除');
// 批量异步操作（多炉同时炼丹）
const shelves = ['药材架', '器具架', '丹炉区'];
for (const shelf of shelves) {
await fs.mkdir(path.join('炼丹房', shelf), { recursive: true });
console.log(`✅ ${shelf} 准备就绪`);
}
} catch (error) {
if (error.code === 'EEXIST') {
console.log('⚠️ 药房或药架已存在');
} else if (error.code === 'ENOTEMPTY') {
console.log('⚠️ 药架非空，无法撤除');
} else {
console.error('管理失败:', error);
}
}
}
// 中医映射：
// fs.mkdir → 单炉炼丹准备
// recursive: true → 多炉并行炼丹
// fs.rmdir → 清理丹炉（必须冷却且空炉）
核心心法：
fs.mkdir()：创建目录，可选recursive参数 📜fs.rmdir()：删除空目录 🗑️- Promise版本支持优雅的异步流程 ⏳
- 适合：Node.js服务、Web应用、需要异步操作的场景 🌐
📊 四语言目录操作对比表
| 特性 | Python | Java | Go | JavaScript |
|---|---|---|---|---|
| 创建单目录 | os.mkdir() |
Files.createDirectory() |
os.Mkdir() |
fs.mkdir() |
| 递归创建 | os.makedirs() |
Files.createDirectories() |
os.MkdirAll() |
fs.mkdir(recursive:true) |
| 删除空目录 | os.rmdir() |
Files.delete() |
os.Remove() |
fs.rmdir() |
| 递归删除空目录链 | os.removedirs() |
❌ 需自定义 | ❌ 需自定义 | ❌ 需自定义 |
| 权限参数 | mode参数 |
FileAttribute |
perm参数 |
mode参数 |
| 错误处理 | 异常机制 | 异常机制 | 返回值+错误 | 回调/Promise |
| 中医映射 | 药柜分格术 | 标准化药房 | 便携药箱 | 时空炼丹房 |
| 核心优势 | 功能细分明确 | 类型安全严谨 | 简洁高效 | 异步友好 |
| 适用场景 | 脚本/自动化 | 企业系统 | 系统工具 | Web服务 |
⚠️ 【避坑指南·药房建设预警】
🐍 Python：药柜管理需谨慎
# 💥 坑点1：删除非空目录会报错
try:
os.rmdir("非空药柜") # 如果里面有药材，会报OSError
except OSError as e:
# ✅ 正道：使用shutil.rmtree或先清空
import shutil
shutil.rmtree("非空药柜") # 强制删除，慎用！
# 💥 坑点2：Windows上的权限问题
try:
os.mkdir("C:/系统药房") # 可能需要管理员权限
except PermissionError:
print("⚠️ 需要管理员权限创建系统目录")
# 💥 坑点3：相对路径的歧义
os.mkdir("药房/子柜") # 如果"药房"不存在，会报错！
# ✅ 正道：
os.makedirs("药房/子柜", exist_ok=True) # 自动创建父目录
☕ Java：类型安全双刃剑
// 💥 坑点1：安全检查过于严格
Path path = Paths.get("药方存档");
try {
Files.delete(path); // 如果目录非空，抛DirectoryNotEmptyException
} catch (DirectoryNotEmptyException e) {
// ✅ 正道：先递归删除内容
deleteDirectoryRecursively(path);
}
// 💥 坑点2：符号链接处理
Path link = Paths.get("快捷药房");
Files.createDirectory(link); // 创建的是实际目录，不是链接
// ✅ 正道：明确创建符号链接
Files.createSymbolicLink(link, Paths.get("实际药房"));
⚡ Go：简洁但需手动
// 💥 坑点1：错误信息不够详细
err := os.Remove("药柜")
if err != nil {
// 仅返回"directory not empty"，不知道具体原因
// ✅ 正道：自定义错误处理
if strings.Contains(err.Error(), "not empty") {
fmt.Println("请先清空药柜中的药材")
}
}
// 💥 坑点2：跨平台权限差异
err := os.Mkdir("药房", 0777) // 在Windows上权限意义不同
// ✅ 正道：使用更兼容的权限
err := os.Mkdir("药房", 0755) // 所有者读写执行，其他只读执行
🟨 JavaScript：异步的陷阱
// 💥 坑点1：回调地狱（旧版API）
fs.mkdir('药房', (err1) => {
if (err1) return;
fs.mkdir('药房/子柜', (err2) => {
if (err2) return;
// 更多嵌套...
});
});
// ✅ 正道：使用async/await
async function 安全建药房() {
await fs.mkdir('药房', { recursive: true });
await fs.mkdir('药房/子柜', { recursive: true });
}
// 💥 坑点2：Windows路径分隔符
const path = '药房\\子柜'; // Windows风格
// ✅ 正道：使用path模块
const safePath = path.join('药房', '子柜'); // 跨平台安全
以下是本蜀黎整理
源码和截图⏬
1.Python源码⏬
import os
import shutil
# ==================== 财务密室模块 ====================
# os.mkdir("小金库") # 新建财务秘密基地 🔐
# os.rmdir("作废账目") # 单层作废凭证 🗑️
# os.removedirs("财务存在漏洞/历史") # 堵住财务漏洞 🌱
def create_single_directory(dir_path):
try:
os.mkdir(dir_path)
print(f"✅ 成功创建单层目录: {dir_path}")
except FileExistsError:
print(f"⚠️ 目录已存在: {dir_path}")
except Exception as e:
print(f"❌ 创建单层目录失败 {dir_path}: {e}")
def create_nested_directories(dir_path):
try:
os.makedirs(dir_path, exist_ok=True) # 推荐加上 exist_ok=True 更安全
print(f"✅ 成功创建嵌套目录: {dir_path}")
except Exception as e:
print(f"❌ 创建嵌套目录失败 {dir_path}: {e}")
def remove_empty_directory(dir_path):
try:
os.rmdir(dir_path)
print(f"✅ 成功删除空目录: {dir_path}")
except FileNotFoundError:
print(f"⚠️ 目录不存在: {dir_path}")
except OSError as e:
print(f"❌ 无法删除（非空或被占用）: {dir_path} → {e}")
except Exception as e:
print(f"❌ 删除目录出错: {e}")
def remove_nested_empty_dirs(dir_path):
try:
os.removedirs(dir_path)
print(f"✅ 成功递归删除空目录链: {dir_path}")
except Exception as e:
print(f"❌ 递归删除失败: {e}")
# ==================== 演示流程 ====================
if __name__ == "__main__":
print("🔧 开始目录操作演示...\n")
# 1. 创建单层目录
single = "./file/single_dir58"
create_single_directory(single)
# 2. 创建嵌套目录
nested = "./file/nested_dir58/a/b/c"
create_nested_directories(nested)
# # 3. 删除最深层的空目录（递归向上删，直到非空）
# remove_nested_empty_dirs("./file/nested/a/b/c") # 实际会删除 c → b → a（如果都空）
#
# # 4. 删除之前创建的单层目录
# remove_empty_directory(single)
# 5. 演示：删除非空目录（会失败）
non_empty = "./file/non_empty58"
os.makedirs(non_empty, exist_ok=True)
with open(os.path.join(non_empty, "file.txt"), "w") as f:
f.write("test")
print("\n➡️ 尝试删除非空目录（应失败）:")
remove_empty_directory(non_empty)
print("\n🎉 演示结束。")
2.Nodejs源码⏬
const fs = require('fs');
const path = require('path');
// ==================== 中药密阁模块 ====================
// 创建炼丹密室 // 老君的隐形药房 🏺
// 移除失败丹方 // 单层清理药渣 🧹
// 彻底销毁药渣 // 防止配方泄露 🌿
// ⚠️虎山老药师：残留目录会招来丹劫
// 创建单个目录
function createSingleDirectory(dirPath) {
try {
fs.mkdirSync(dirPath);
console.log(`成功创建目录: ${dirPath}`);
} catch (err) {
if (err.code === 'EEXIST') {
console.log(`目录已存在: ${dirPath}`);
} else {
console.log(`创建目录 ${dirPath} 时出错: ${err.message}`);
}
}
}
// 创建嵌套目录
function createNestedDirectories(dirPath) {
try {
fs.mkdirSync(dirPath, { recursive: true });
console.log(`成功创建嵌套目录: ${dirPath}`);
} catch (err) {
if (err.code === 'EEXIST') {
console.log(`目录已存在: ${dirPath}`);
} else {
console.log(`创建嵌套目录 ${dirPath} 时出错: ${err.message}`);
}
}
}
// 删除单个空目录
function removeSingleDirectory(dirPath) {
try {
fs.rmdirSync(dirPath);
console.log(`成功删除目录: ${dirPath}`);
} catch (err) {
if (err.code === 'ENOENT') {
console.log(`目录不存在: ${dirPath}`);
} else if (err.code === 'ENOTEMPTY') {
console.log(`删除目录 ${dirPath} 时出错(可能不是空目录): ${err.message}`);
} else {
console.log(`删除目录 ${dirPath} 时出错: ${err.message}`);
}
}
}
// 递归删除空目录 (Node.js没有完全等效的方法)
function removeNestedDirectories(dirPath) {
try {
// Node.js没有完全等效于os.removedirs的方法
// 这是一个模拟实现，实际上会尝试删除指定路径，但不会递归删除父目录
fs.rmdirSync(dirPath);
console.log(`成功删除目录: ${dirPath} (注意: 这不是完全等效于os.removedirs的实现)`);
} catch (err) {
if (err.code === 'ENOENT') {
console.log(`目录不存在: ${dirPath}`);
} else if (err.code === 'ENOTEMPTY') {
console.log(`删除目录 ${dirPath} 时出错(可能不是空目录): ${err.message}`);
} else {
console.log(`删除目录 ${dirPath} 时出错: ${err.message}`);
}
}
}
// 测试目录操作
function testDirectoryOperations() {
// 定义测试用的目录路径 相对路径显式写法
const singleDir = "./file/test_single_dir58";
const nestedDir = "./file/test_nested_dir58/sub_dir1/sub_dir2";
console.log("===== 开始测试目录操作 =====");
// 测试创建单个目录
console.log("\n[测试1] 创建单个目录:");
createSingleDirectory(singleDir);
// 测试创建已存在的目录
console.log("\n[测试2] 尝试创建已存在的目录:");
createSingleDirectory(singleDir);
// 测试创建嵌套目录
console.log("\n[测试3] 创建嵌套目录:");
createNestedDirectories(nestedDir);
// 测试创建已存在的嵌套目录
console.log("\n[测试4] 尝试创建已存在的嵌套目录:");
createNestedDirectories(nestedDir);
// 测试删除单个空目录
console.log("\n[测试5] 删除单个空目录:");
removeSingleDirectory(singleDir);
// 测试删除不存在的目录
console.log("\n[测试6] 尝试删除不存在的目录:");
removeSingleDirectory("non_existent_dir58");
// 重新创建嵌套目录以便测试删除
console.log("\n重新创建嵌套目录以便测试删除:");
createNestedDirectories(nestedDir);
// 测试递归删除空目录
console.log("\n[测试7] 递归删除空目录:");
// 注意: Node.js没有完全等效的方法，这里只是模拟
try {
// 实际上需要手动递归删除目录内容
function deleteFolderRecursive(folderPath) {
if (fs.existsSync(folderPath)) {
fs.readdirSync(folderPath).forEach((file) => {
const curPath = path.join(folderPath, file);
if (fs.lstatSync(curPath).isDirectory()) {
deleteFolderRecursive(curPath);
} else {
fs.unlinkSync(curPath);
}
});
fs.rmdirSync(folderPath);
}
}
deleteFolderRecursive(nestedDir);
console.log(`成功递归删除目录: ${nestedDir} (使用自定义实现)`);
} catch (err) {
console.log(`递归删除目录 ${nestedDir} 时出错: ${err.message}`);
}
// 测试删除不存在的嵌套目录
console.log("\n[测试8] 尝试递归删除不存在的目录:");
removeNestedDirectories("non_existent_dir58/sub_dir");
// 测试删除非空目录(应该失败)
console.log("\n[测试9] 尝试删除非空目录(应该失败):");
// 先创建一个非空目录
const nonEmptyDir = "test_non_empty_dir58";
fs.mkdirSync(nonEmptyDir);
// 在目录中创建一个文件
fs.writeFileSync(path.join(nonEmptyDir, "test_file58.txt"), "测试文件");
// 尝试删除非空目录
removeSingleDirectory(nonEmptyDir); // 应该失败
// 使用fs-extra来清理非空目录(需要安装: npm install fs-extra)
console.log("\n[清理] 使用fs-extra删除非空目录:");
try {
// 注意: 这里为了演示，实际上需要安装fs-extra模块
// 在实际代码中，你需要先安装: npm install fs-extra
// 然后使用: const fsExtra = require('fs-extra');
// fsExtra.removeSync(nonEmptyDir);
// 由于我们无法假设用户安装了fs-extra，这里使用自定义实现
deleteFolderRecursive(nonEmptyDir);
console.log(`已删除非空目录: ${nonEmptyDir} (使用自定义实现)`);
} catch (err) {
console.log(`删除非空目录 ${nonEmptyDir} 时出错: ${err.message}`);
}
console.log("\n===== 目录操作测试完成 =====");
}
// 运行测试
testDirectoryOperations();
3.Go源码⏬
package main
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
)
// ==================== 仓储密室模块 ====================
// 新建特殊仓位 // 仓库猫的VIP包厢 📦
// 删除问题货架 // 单层下架次品 🚮
// 清空过期库存 // 立体式报废处理 💥
// ⚠️冷溪物流：目录残留会引来药监GSP检查
// 创建单个目录
func createSingleDirectory(dirPath string) {
err := os.Mkdir(dirPath, 0777) // 0777是权限模式
if err != nil {
if os.IsExist(err) {
fmt.Printf("目录已存在: %s\n", dirPath)
} else {
fmt.Printf("创建目录 %s 时出错: %v\n", dirPath, err)
}
} else {
fmt.Printf("成功创建目录: %s\n", dirPath)
}
}
// 创建嵌套目录
func createNestedDirectories(dirPath string) {
err := os.MkdirAll(dirPath, 0777) // MkdirAll类似于os.makedirs
if err != nil {
if os.IsExist(err) {
fmt.Printf("目录已存在: %s\n", dirPath)
} else {
fmt.Printf("创建嵌套目录 %s 时出错: %v\n", dirPath, err)
}
} else {
fmt.Printf("成功创建嵌套目录: %s\n", dirPath)
}
}
// 删除单个空目录
func removeSingleDirectory(dirPath string) {
err := os.Remove(dirPath) // 注意: 在Go中，Remove可以删除文件或空目录
if err != nil {
if os.IsNotExist(err) {
fmt.Printf("目录不存在: %s\n", dirPath)
} else if isDirNotEmptyError(err) {
fmt.Printf("删除目录 %s 时出错(可能不是空目录): %v\n", dirPath, err)
} else {
fmt.Printf("删除目录 %s 时出错: %v\n", dirPath, err)
}
} else {
fmt.Printf("成功删除目录: %s\n", dirPath)
}
}
// 判断错误是否是因为目录不为空
func isDirNotEmptyError(err error) bool {
// 在Go中，os.Remove对非空目录会返回"directory not empty"错误
// 但直接比较错误字符串不太优雅，这里简化处理
return err != nil && os.IsNotExist(err) == false
}
// 递归删除空目录 (Go没有完全等效的方法)
func removeNestedDirectories(dirPath string) {
err := os.Remove(dirPath)
if err != nil {
if os.IsNotExist(err) {
fmt.Printf("目录不存在: %s\n", dirPath)
} else if isDirNotEmptyError(err) {
fmt.Printf("删除目录 %s 时出错(可能不是空目录): %v\n", dirPath, err)
} else {
fmt.Printf("删除目录 %s 时出错: %v\n", dirPath, err)
}
} else {
fmt.Printf("成功删除目录: %s (注意: 这不是完全等效于os.removedirs的实现)\n", dirPath)
}
}
// 递归删除目录的辅助函数 (用于测试清理)
func deleteDirectoryRecursively(dirPath string) error {
return filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if !info.IsDir() {
return os.Remove(path)
}
return nil
})
}
// 实际的递归删除实现
func deleteDirectoryRecursively2(dirPath string) error {
// 先读取目录内容
files, err := ioutil.ReadDir(dirPath)
if err != nil {
return err
}
// 删除所有文件和子目录
for _, file := range files {
fullPath := filepath.Join(dirPath, file.Name())
if file.IsDir() {
err = deleteDirectoryRecursively2(fullPath)
if err != nil {
return err
}
} else {
err = os.Remove(fullPath)
if err != nil {
return err
}
}
}
// 删除空目录
return os.Remove(dirPath)
}
// 测试目录操作
func testDirectoryOperations() {
// 定义测试用的目录路径 相对路径根路径写法
singleDir := "GO/file/test_single_dir58"
nestedDir := "GO/file/test_nested_dir58/sub_dir1/sub_dir2"
fmt.Println("===== 开始测试目录操作 =====")
// 测试创建单个目录
fmt.Println("\n[测试1] 创建单个目录:")
createSingleDirectory(singleDir)
// 测试创建已存在的目录
fmt.Println("\n[测试2] 尝试创建已存在的目录:")
createSingleDirectory(singleDir)
// 测试创建嵌套目录
fmt.Println("\n[测试3] 创建嵌套目录:")
createNestedDirectories(nestedDir)
// 测试创建已存在的嵌套目录
fmt.Println("\n[测试4] 尝试创建已存在的嵌套目录:")
createNestedDirectories(nestedDir)
// 测试删除单个空目录
fmt.Println("\n[测试5] 删除单个空目录:")
removeSingleDirectory(singleDir)
// 测试删除不存在的目录
fmt.Println("\n[测试6] 尝试删除不存在的目录:")
removeSingleDirectory("non_existent_dir")
// 重新创建嵌套目录以便测试删除
fmt.Println("\n重新创建嵌套目录以便测试删除:")
createNestedDirectories(nestedDir)
// 测试递归删除空目录
fmt.Println("\n[测试7] 递归删除空目录:")
// 注意: Go没有完全等效的方法，这里使用自定义实现
err := deleteDirectoryRecursively2(nestedDir)
if err != nil {
fmt.Printf("递归删除目录 %s 时出错: %v\n", nestedDir, err)
} else {
fmt.Printf("成功递归删除目录: %s (使用自定义实现)\n", nestedDir)
}
// 测试删除不存在的嵌套目录
fmt.Println("\n[测试8] 尝试递归删除不存在的目录:")
removeNestedDirectories("non_existent_dir58/sub_dir")
// 测试删除非空目录(应该失败)
fmt.Println("\n[测试9] 尝试删除非空目录(应该失败):")
// 先创建一个非空目录
nonEmptyDir := "test_non_empty_dir58"
err = os.Mkdir(nonEmptyDir, 0777)
if err != nil {
fmt.Printf("准备测试非空目录时出错: %v\n", err)
return
}
// 在目录中创建一个文件
filePath := filepath.Join(nonEmptyDir, "test_file58.txt")
err = ioutil.WriteFile(filePath, []byte("测试文件"), 0644)
if err != nil {
fmt.Printf("创建测试文件时出错: %v\n", err)
return
}
// 尝试删除非空目录
removeSingleDirectory(nonEmptyDir) // 应该失败
// 使用自定义实现清理非空目录
fmt.Println("\n[清理] 使用自定义实现删除非空目录:")
err = deleteDirectoryRecursively2(nonEmptyDir)
if err != nil {
fmt.Printf("删除非空目录 %s 时出错: %v\n", nonEmptyDir, err)
} else {
fmt.Printf("已删除非空目录: %s (使用自定义实现)\n", nonEmptyDir)
}
fmt.Println("\n===== 目录操作测试完成 =====")
}
func main() {
// 运行测试
testDirectoryOperations()
}
4.Java源码⏬
import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
// ==================== ERP密室模块 ====================
// ("上传通道") 创建系统秘密通道 🚪
// ("bug漏洞") 删除表层bug 🐛
// ("危险/历史") 深度清理bug 🧨
// ⚠️ERP老兵_冷溪虎山：目录残留会导致数据泄密
class main58 {
// 创建单个目录
public static void createSingleDirectory(String dirPath) {
Path path = Paths.get(dirPath);
try {
Files.createDirectory(path);
System.out.println("成功创建目录: " + dirPath);
} catch (FileAlreadyExistsException e) {
System.out.println("目录已存在: " + dirPath);
} catch (IOException e) {
System.out.println("创建目录 " + dirPath + " 时出错: " + e.getMessage());
}
}
// 创建嵌套目录
public static void createNestedDirectories(String dirPath) {
Path path = Paths.get(dirPath);
try {
Files.createDirectories(path); // 类似于os.makedirs
System.out.println("成功创建嵌套目录: " + dirPath);
} catch (FileAlreadyExistsException e) {
System.out.println("目录已存在: " + dirPath);
} catch (IOException e) {
System.out.println("创建嵌套目录 " + dirPath + " 时出错: " + e.getMessage());
}
}
// 删除单个空目录
public static void removeSingleDirectory(String dirPath) {
Path path = Paths.get(dirPath);
try {
Files.delete(path);
System.out.println("成功删除目录: " + dirPath);
} catch (NoSuchFileException e) {
System.out.println("目录不存在: " + dirPath);
} catch (DirectoryNotEmptyException e) {
System.out.println("删除目录 " + dirPath + " 时出错(可能不是空目录): " + e.getMessage());
} catch (IOException e) {
System.out.println("删除目录 " + dirPath + " 时出错: " + e.getMessage());
}
}
// 递归删除空目录 (Java没有完全等效的方法)
public static void removeNestedDirectories(String dirPath) {
Path path = Paths.get(dirPath);
try {
// Java没有完全等效于os.removedirs的方法
// 这是一个模拟实现，实际上会尝试删除指定路径
Files.delete(path);
System.out.println("成功删除目录: " + dirPath + " (注意: 这不是完全等效于os.removedirs的实现)");
} catch (NoSuchFileException e) {
System.out.println("目录不存在: " + dirPath);
} catch (DirectoryNotEmptyException e) {
System.out.println("删除目录 " + dirPath + " 时出错(可能不是空目录): " + e.getMessage());
} catch (IOException e) {
System.out.println("删除目录 " + dirPath + " 时出错: " + e.getMessage());
}
}
// 递归删除目录的辅助方法 (用于测试清理)
private static void deleteDirectoryRecursively(Path path) throws IOException {
if (Files.exists(path)) {
Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
Files.delete(file);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
Files.delete(dir);
return FileVisitResult.CONTINUE;
}
});
}
}
// 测试目录操作
public static void testDirectoryOperations() {
// 定义测试用的目录路径 相对路径根路径写法
String singleDir = "4java/file/test_single_dir58";
String nestedDir = "4java/file/test_nested_dir58/sub_dir1/sub_dir2";
System.out.println("===== 开始测试目录操作 =====");
// 测试创建单个目录
System.out.println("\n[测试1] 创建单个目录:");
createSingleDirectory(singleDir);
// 测试创建已存在的目录
System.out.println("\n[测试2] 尝试创建已存在的目录:");
createSingleDirectory(singleDir);
// 测试创建嵌套目录
System.out.println("\n[测试3] 创建嵌套目录:");
createNestedDirectories(nestedDir);
// 测试创建已存在的嵌套目录
System.out.println("\n[测试4] 尝试创建已存在的嵌套目录:");
createNestedDirectories(nestedDir);
// 测试删除单个空目录
System.out.println("\n[测试5] 删除单个空目录:");
removeSingleDirectory(singleDir);
// 测试删除不存在的目录
System.out.println("\n[测试6] 尝试删除不存在的目录:");
removeSingleDirectory("non_existent_dir58");
// 重新创建嵌套目录以便测试删除
System.out.println("\n重新创建嵌套目录以便测试删除:");
createNestedDirectories(nestedDir);
// 测试递归删除空目录
System.out.println("\n[测试7] 递归删除空目录:");
// 注意: Java没有完全等效的方法，这里使用自定义实现
try {
deleteDirectoryRecursively(Paths.get(nestedDir));
System.out.println("成功递归删除目录: " + nestedDir + " (使用自定义实现)");
} catch (IOException e) {
System.out.println("递归删除目录 " + nestedDir + " 时出错: " + e.getMessage());
}
// 测试删除不存在的嵌套目录
System.out.println("\n[测试8] 尝试递归删除不存在的目录:");
removeNestedDirectories("non_existent_dir58/sub_dir");
// 测试删除非空目录(应该失败)
System.out.println("\n[测试9] 尝试删除非空目录(应该失败):");
// 先创建一个非空目录
String nonEmptyDir = "test_non_empty_dir58";
try {
Files.createDirectory(Paths.get(nonEmptyDir));
// 在目录中创建一个文件
Files.write(Paths.get(nonEmptyDir, "test_file58.txt"), "测试文件".getBytes());
// 尝试删除非空目录
removeSingleDirectory(nonEmptyDir); // 应该失败
} catch (IOException e) {
System.out.println("准备测试非空目录时出错: " + e.getMessage());
}
// 使用自定义实现清理非空目录
System.out.println("\n[清理] 使用自定义实现删除非空目录:");
try {
deleteDirectoryRecursively(Paths.get(nonEmptyDir));
System.out.println("已删除非空目录: " + nonEmptyDir + " (使用自定义实现)");
} catch (IOException e) {
System.out.println("删除非空目录 " + nonEmptyDir + " 时出错: " + e.getMessage());
}
System.out.println("\n===== 目录操作测试完成 =====");
}
public static void main(String[] args) {
// 运行测试
testDirectoryOperations();
}
}
源码分享结束⏫
🌈 【剧情结尾：木叶忍者学校的场地考核】
🌸 小樱（完美布置了训练场地体系）
- 「鸣人你看！Python的目录管理像老中医的药柜分格，Java的
FilesAPI像御医院的标准化管理，Go的简洁操作像游医的便携药箱，JS的异步创建像炼丹师的时空术！我们现在能建立任何复杂的训练场地了！」
🍜 鸣人（成功搭建了多层忍术训练场）
- 「哈哈哈！原来
mkdir就是搭个帐篷，makedirs就是建整个营地，删除就是安全撤营！不同的语言就像不同的建筑流派！佐助——来比谁先建好十层训练塔！」
🎭 佐助（写轮眼分析场地结构完整性）
- 「哼...吊车尾的，等你能在创建目录时保持所有符号链接和硬链接的完整性再说大话吧。」
📙 卡卡西（合上《亲热天堂》，露出欣慰表情）
- 「嗯...总算掌握场地管理的基础心法了。记住：
mkdir如单味药格，makedirs如整套药柜，删除如谨慎撤柜——建易拆难，皆有章法。下周教你们目录监控和权限管理的进阶应用...」
🐯 虎山CTO箴言：
- 目录管理如中药配伍——单格可建，整柜可构，层级可深。掌握目录术，就掌握了数据世界的"空间构建之道"！
- 心法口诀：创建如
搭药架，递归如建药房，删除如撤空柜，权限如守药方。虚实之间，自成天地。
🔖虎山CTO三道护体符
因果符：
- 🚀我每被恶意举报一次，就加更一篇干货——感谢黑粉为我提供创作燃料。
镜像符：
- 📌若遭攻击（检测到行业焦虑值上升），建议某些机构停止这种“DDoS攻击”，将资源用于提升自身课程服务的“带宽”与“质量”。
重生符：
- 💪本人是经历过生死重启的野生程序猿，系统兼容性极强——你们那点小打小闹，连个 warning 都触发不了。
⚠️ 免责声明（附因果律警告）
本代码已注入中医玄学能量，请谨慎使用：
- ✅ 允许白嫖，但白漂不点赞可能导致：
- 下次面试官恰好问到这个算法
- 键盘自动打出
//这里感谢冷溪虎山CTO - 奶茶精准洒在刚写好的代码上
- ✅ 允许商用转发，但商用不注明出处可能触发：
- 系统类型混乱自动转型
- 数据库莫名存储"君臣佐使"字段
- ✅ 允许吐槽，但吐槽不带改进建议可能引发：
- 终生与老板N连鞭相爱相杀
🚀 现在立即行动：
- 点赞 → 吸收本篇算法精华+怪蜀黎脑洞思维
- 收藏 → 避免日后求医无门
- 关注 → 接收更多「中医+代码」脑洞
- 评论区留言 → 领取你的专属「算法药方」
⚠️ 友情提示：
- 本文内容过于硬核，建议点赞收藏转发三连，避免小编
心情波动导致文章神秘消失！ - 毕竟小编今天可能爱答不理，明天可能高攀不起——
- 但你的收藏夹，永远是你最稳的知识备份！
🐶💻 （小声说：关我小黑屋？不存在的,备份早已同步GitHub/公众号/网盘！）
前1-57篇请移步至"PY-JS-GO-JAVA基础进阶学习系列"合集中阅读
浙公网安备 33010602011771号