Node.JavaScript文件系统中目录的操作

 谈到对目录的操作，需要涉及到对目录遍历，其实目录也是我们可以把它看成一颗树。树是一种非线性的数据结构，被用来存储具有层级关系的数据，还被用来存储有序列表，其中有一种特殊的树：二叉树。

专注于为中小企业提供成都网站设计、成都网站制作服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业临武免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了上千余家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

有一种特殊的二叉树叫二叉查找树(BST)，其他的特点是：相对较小的值保存在左节点中，较大的值保存在右节点中，因为这个特点使查找的效率特别高。

遍历二叉查找树有三种方式:中序，先序和后序

中序:按照节点上的键值，已升序访问树中所有节点，先访问左子树，在访问根节点，最后访问右子树。

中序

先序:先访问根节点，然后以同样方式访问左子树和右子树

先序

后序:先访问叶子节点，从左子树到右子树，再到根节点

后序

还有两种搜索方法：深度优先搜索和广度优先搜索

深度优先搜索时从一条路径的起始顶点开始一直到最后一个顶点，然后回溯，继续追溯下一条路径，直到到达最后的顶点，如此往复，知道没有路径为止。

深度优先搜索

广度优先搜索是从第一个顶点开始，首先检查最靠近第一个顶点的一层，再逐渐向下移动到离起始顶点最远的一层。

广度优先搜索

同步创建目录

_fs.accessSync_是fs.access的同步方法用于检查文件是否存在，检查是否对文件是否有读写权限，当操作成功时返回值和异步方法执行成功相同，但操作失败时会抛出异常。

_fs.mkdirSync_是同步创建目录

话不多说，我们直接上代码

 
 
 
 
    
  
  
  
  
  1. let fs = require("fs"); 
    2.   
  
  
  
  2. let path = require("path") 
    3.   
  
  
  
  3. function mkdirSync(paths){ 
    4.   
  
  
  
  4.     let arr = paths.split("/"); 
    5.   
  
  
  
  5.     for(let i=0;i  
  
  
  
  6.      let currentPath = arr.slice(0,i+1).join("/"); 
    7.   
  
  
  
  7.         try{  
    8.   
  
  
  
  8.          fs.accessSync(currentPath) //如果路径存在  不创建目录 
    9.   
  
  
  
  9.         }catch(e){ 
    10.   
  
  
  
  10.            fs.mkdirSync(currentPath) 
    11.   
  
  
  
  11.         } 
    12.   
  
  
  
  12.      } 
    13.   
  
  
  
  13.  } 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. mkdirSync("a/b/c/d")  //默认创建目录  必须父级存在 才能创建子级 
    16.

 异步创建目录

 
 
 
 
    
  
  
  
  
  1. function mkdir(paths,cb){ 
    2.   
  
  
  
  2.     let arr = paths.split("/"); 
    3.   
  
  
  
  3.     function next(index){ 
    4.   
  
  
  
  4.        if(index>=arr.length) return cb(); 
    5.   
  
  
  
  5.        let currentPath = arr.slice(0,index+1).join("/"); 
    6.   
  
  
  
  6.        fs.access(currentPath,(err)=>{ 
    7.   
  
  
  
  7.           if(err){  
    8.   
  
  
  
  8.               fs.mkdir(currentPath,()=>next(index+1)) 
    9.   
  
  
  
  9.           }else{   //如果存在则不创建 
    10.   
  
  
  
  10.               next(index+1) 
    11.   
  
  
  
  11.           } 
    12.   
  
  
  
  12.        }) 
    13.   
  
  
  
  13.     } 
    14.   
  
  
  
  14.     next(0) 
    15.   
  
  
  
  15. } 
    16.   
  
  
  
  16. mkdir("a/b/c/d/e",(err)=>{ 
    17.   
  
  
  
  17.    console.log("创建完成"); 
    18.   
  
  
  
  18. }) 
    19.

创建目录

深度删除目录(同步)

fs.stat() 方法用于查询文件信息，可以用于查询文件的大小、创建时间、权限等相关信息。fs.stat() 是异步方法，还有一个同步方法 fs.statSync(path)返回一个对象

思路是：一个分支上先删除儿子再删除自己，然后到另一个分支上删除儿子再删除自己。

 
 
 
 
    
  
  
  
  
  1. function removeSync(dir){ 
    2.   
  
  
  
  2.    let statObj = fs.statSync(dir) 
    3.   
  
  
  
  3.    if(statObj.isDirectory()){ 
    4.   
  
  
  
  4.       let dirs = fs.readdirSync(dir)   //返回一个数组 
    5.   
  
  
  
  5.     //   console.log(dirs); 
    6.   
  
  
  
  6.      for(let i = 0;i  
  
  
  
  7.         //把路径进行包装 
    8.   
  
  
  
  8.          let current =path.join(dir,dirs[i]) 
    9.   
  
  
  
  9.          removeSync(current) //删除儿子节点 再将自己删除 
    10.   
  
  
  
  10.      } 
    11.   
  
  
  
  11.      fs.rmdirSync(dir)  //删除自己 
    12.   
  
  
  
  12.    }else{ 
    13.   
  
  
  
  13.        //文件就删除 
    14.   
  
  
  
  14.        fs.unlinkSync(dir) 
    15.   
  
  
  
  15.    } 
    16.   
  
  
  
  16. } 
    17.   
  
  
  
  17. removeSync("a") 
    18.

 广度删除目录(同步)

思路：通过while循环横向列出所有文件的路径，然后通过倒叙删除。

 
 
 
 
    
  
  
  
  
  1. while(current = arr[index++]){ 
    2.   
  
  
  
  2.     let statObj = fs.statSync(current); 
    3.   
  
  
  
  3.     if(statObj.isDirectory()){ 
    4.   
  
  
  
  4.         let dirs =fs.readdirSync(current); 
    5.   
  
  
  
  5.         dirs = dirs.map(d=>path.join(current,d)); //当前儿子的文件夹路径 
    6.   
  
  
  
  6.         arr = [...arr,...dirs] 
    7.   
  
  
  
  7.     } 
    8.   
  
  
  
  8.  } 
    9.

结果：[ 'a', 'a\b', 'a\b\c', 'a\b\c\d' ]

 
 
 
 
    
  
  
  
  
  1. function wideSync(dir){ 
    2.   
  
  
  
  2.    let arr = [dir]; 
    3.   
  
  
  
  3.    let index = 0; 
    4.   
  
  
  
  4.    let current; //读取的当前项目 
    5.   
  
  
  
  5.    while(current = arr[index++]){ 
    6.   
  
  
  
  6.       let statObj = fs.statSync(current); 
    7.   
  
  
  
  7.       if(statObj.isDirectory()){ 
    8.   
  
  
  
  8.           let dirs =fs.readdirSync(current); 
    9.   
  
  
  
  9.           dirs = dirs.map(d=>path.join(current,d)); //当前儿子的文件夹路径 
    10.   
  
  
  
  10.           arr = [...arr,...dirs] 
    11.   
  
  
  
  11.       } 
    12.   
  
  
  
  12.    } 
    13.   
  
  
  
  13.    //倒叙删除 
    14.   
  
  
  
  14.    for(let i = arr.length-1;i>=0;i--){ 
    15.   
  
  
  
  15.        let current = arr[i] 
    16.   
  
  
  
  16.        let statObj = fs.statSync(current); 
    17.   
  
  
  
  17.        if(statObj.isDirectory()){ 
    18.   
  
  
  
  18.            fs.rmdirSync(current) 
    19.   
  
  
  
  19.        }else{ 
    20.   
  
  
  
  20.            fs.unlinkSync(current) 
    21.   
  
  
  
  21.        } 
    22.   
  
  
  
  22.    } 
    23.   
  
  
  
  23. } 
    24.   
  
  
  
  24. wideSync("a") 
    25.

深度删除目录(串行异步)

 
 
 
 
    
  
  
  
  
  1. function rmdirSeries(dir,callback){ 
    2.   
  
  
  
  2.     fs.stat(dir,(err,statObj)=>{ 
    3.   
  
  
  
  3.         if(statObj.isDirectory()){ 
    4.   
  
  
  
  4.              //读取文件内容 
    5.   
  
  
  
  5.              fs.readdir(dir,(err,dirs)=>{ 
    6.   
  
  
  
  6.                  dirs = dirs.map(d=>path.join(dir,d)) 
    7.   
  
  
  
  7.                  function next(index){ 
    8.   
  
  
  
  8.                     if(index == dirs.length) return fs.rmdir(dir,callback) 
    9.   
  
  
  
  9.                     //先取出数组中的第一个  第一个删除后  在删第二个 
    10.   
  
  
  
  10.                     rmdirSeries(dirs[index],()=>next(index+1)) 
    11.   
  
  
  
  11.                  } 
    12.   
  
  
  
  12.                  next(0) 
    13.   
  
  
  
  13.              }) 
    14.   
  
  
  
  14.         }else{ 
    15.   
  
  
  
  15.             fs.unlink(dir,callback) 
    16.   
  
  
  
  16.         } 
    17.   
  
  
  
  17.     }) 
    18.   
  
  
  
  18. } 
    19.   
  
  
  
  19. rmdirSeries("a",()=>{ 
    20.   
  
  
  
  20.     console.log("删除成功"); 
    21.   
  
  
  
  21. }) 
    22.

深度删除目录(并行异步)

 
 
 
 
    
  
  
  
  
  1. function removeDirParalle(dir,callback){ 
    2.   
  
  
  
  2.     fs.stat(dir,(err,statObj)=>{ 
    3.   
  
  
  
  3.         if(statObj.isDirectory()){ 
    4.   
  
  
  
  4.              //读取文件内容 
    5.   
  
  
  
  5.              fs.readdir(dir,(err,dirs)=>{ 
    6.   
  
  
  
  6.                  if(dirs.length == 0){ 
    7.   
  
  
  
  7.                     return fs.rmdir(dir,callback) 
    8.   
  
  
  
  8.                  } 
    9.   
  
  
  
  9.                  dirs = dirs.map(d=>{ 
    10.   
  
  
  
  10.                     let current = path.join(dir,d); 
    11.   
  
  
  
  11.                     //每个人删除之后就调用done        
    12.   
  
  
  
  12.                     removeDirParalle(current,done); 
    13.   
  
  
  
  13.                     return current 
    14.   
  
  
  
  14.                  }) 
    15.   
  
  
  
  15.                  //并发删除 
    16.   
  
  
  
  16.                  let index = 0; 
    17.   
  
  
  
  17.                  function done(){ 
    18.   
  
  
  
  18.                      if(++index == dirs.length){ 
    19.   
  
  
  
  19.                         fs.rmdir(dir,callback) 
    20.   
  
  
  
  20.                      } 
    21.   
  
  
  
  21.                  } 
    22.   
  
  
  
  22.              }) 
    23.   
  
  
  
  23.         }else{ 
    24.   
  
  
  
  24.             fs.unlink(dir,callback) 
    25.   
  
  
  
  25.         } 
    26.   
  
  
  
  26.     }) 
    27.   
  
  
  
  27. } 
    28.   
  
  
  
  28. removeDirParalle("a",()=>{ 
    29.   
  
  
  
  29.     console.log("删除成功"); 
    30.   
  
  
  
  30. }) 
    31.

 【编辑推荐】

  1. TIOBE 11月榜单：Python挤掉了Java！
  2. React Concurrent Mode三连：是什么/为什么/怎么做
  3. Linux高性能网络编程之TCP连接的内存使用
  4. Python曾是程序员的“瑞士军刀”，而如今正被慢慢取代
  5. 全球疫情下的网络安全：警惕“趁火打劫”的线上攻击

当前文章：Node.JavaScript文件系统中目录的操作
标题来源：http://www.csdahua.cn/qtweb/news11/401261.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

定制开发知识

行业网站建设

腾讯免备案主机　　 　手机网站制作设计　　 　资阳发电机　　 　成都微商城开发　　 　短视频拍摄　　 　关键词优化　　 　温江网站建设　　 　贵州义龙电信机房　　 　主机租用　　 　彭山网站制作　　 　沃尔沃电机组维修　　 　遂宁网站建设　　 　主机托管　　 　江油网站建设　　 　简阳网站建设　　 　西部信息机房　　 　西云主机托管　　 　成都企业网站设计　　 　营销网站定位　　 　全网营销