[[351532]]

 談到對(duì)目錄的操作，需要涉及到對(duì)目錄遍歷，其實(shí)目錄也是我們可以把它看成一顆樹。樹是一種非線性的數(shù)據(jù)結(jié)構(gòu)，被用來存儲(chǔ)具有層級(jí)關(guān)系的數(shù)據(jù)，還被用來存儲(chǔ)有序列表，其中有一種特殊的樹：二叉樹。

有一種特殊的二叉樹叫二叉查找樹(BST)，其他的特點(diǎn)是：相對(duì)較小的值保存在左節(jié)點(diǎn)中，較大的值保存在右節(jié)點(diǎn)中，因?yàn)檫@個(gè)特點(diǎn)使查找的效率特別高。

遍歷二叉查找樹有三種方式:中序，先序和后序

中序:按照節(jié)點(diǎn)上的鍵值，已升序訪問樹中所有節(jié)點(diǎn)，先訪問左子樹，在訪問根節(jié)點(diǎn)，最后訪問右子樹。

中序

先序:先訪問根節(jié)點(diǎn)，然后以同樣方式訪問左子樹和右子樹

先序

后序:先訪問葉子節(jié)點(diǎn)，從左子樹到右子樹，再到根節(jié)點(diǎn)

后序 

還有兩種搜索方法：深度優(yōu)先搜索和廣度優(yōu)先搜索

深度優(yōu)先搜索時(shí)從一條路徑的起始頂點(diǎn)開始一直到最后一個(gè)頂點(diǎn)，然后回溯，繼續(xù)追溯下一條路徑，直到到達(dá)最后的頂點(diǎn)，如此往復(fù)，知道沒有路徑為止。

深度優(yōu)先搜索

廣度優(yōu)先搜索是從第一個(gè)頂點(diǎn)開始，首先檢查最靠近第一個(gè)頂點(diǎn)的一層，再逐漸向下移動(dòng)到離起始頂點(diǎn)最遠(yuǎn)的一層。

廣度優(yōu)先搜索 

同步創(chuàng)建目錄

_fs.accessSync_是fs.access的同步方法用于檢查文件是否存在，檢查是否對(duì)文件是否有讀寫權(quán)限，當(dāng)操作成功時(shí)返回值和異步方法執(zhí)行成功相同，但操作失敗時(shí)會(huì)拋出異常。

_fs.mkdirSync_是同步創(chuàng)建目錄

話不多說，我們直接上代碼

let fs = require("fs"); 
let path = require("path") 
function mkdirSync(paths){ 
    let arr = paths.split("/"); 
    for(let i=0;i<arr.length;i++){ 
     let currentPath = arr.slice(0,i+1).join("/"); 
        try{  
         fs.accessSync(currentPath) //如果路徑存在  不創(chuàng)建目錄 
        }catch(e){ 
           fs.mkdirSync(currentPath) 
        } 
     } 
 } 
 
mkdirSync("a/b/c/d")  //默認(rèn)創(chuàng)建目錄  必須父級(jí)存在 才能創(chuàng)建子級(jí) 

 異步創(chuàng)建目錄

function mkdir(paths,cb){ 
    let arr = paths.split("/"); 
    function next(index){ 
       if(index>=arr.length) return cb(); 
       let currentPath = arr.slice(0,index+1).join("/"); 
       fs.access(currentPath,(err)=>{ 
          if(err){  
              fs.mkdir(currentPath,()=>next(index+1)) 
          }else{   //如果存在則不創(chuàng)建 
              next(index+1) 
          } 
       }) 
    } 
    next(0) 
} 
mkdir("a/b/c/d/e",(err)=>{ 
   console.log("創(chuàng)建完成"); 
}) 

創(chuàng)建目錄 

深度刪除目錄(同步)

fs.stat() 方法用于查詢文件信息，可以用于查詢文件的大小、創(chuàng)建時(shí)間、權(quán)限等相關(guān)信息。fs.stat() 是異步方法，還有一個(gè)同步方法 fs.statSync(path)返回一個(gè)對(duì)象

思路是：一個(gè)分支上先刪除兒子再刪除自己，然后到另一個(gè)分支上刪除兒子再刪除自己。

function removeSync(dir){ 
   let statObj = fs.statSync(dir) 
   if(statObj.isDirectory()){ 
      let dirs = fs.readdirSync(dir)   //返回一個(gè)數(shù)組 
    //   console.log(dirs); 
     for(let i = 0;i<dirs.length;i++){ 
        //把路徑進(jìn)行包裝 
         let current =path.join(dir,dirs[i]) 
         removeSync(current) //刪除兒子節(jié)點(diǎn) 再將自己刪除 
     } 
     fs.rmdirSync(dir)  //刪除自己 
   }else{ 
       //文件就刪除 
       fs.unlinkSync(dir) 
   } 
} 
removeSync("a") 

 廣度刪除目錄(同步)

思路：通過while循環(huán)橫向列出所有文件的路徑，然后通過倒敘刪除。

while(current = arr[index++]){ 
    let statObj = fs.statSync(current); 
    if(statObj.isDirectory()){ 
        let dirs =fs.readdirSync(current); 
        dirs = dirs.map(d=>path.join(current,d)); //當(dāng)前兒子的文件夾路徑 
        arr = [...arr,...dirs] 
    } 
 } 

結(jié)果：[ 'a', 'a\b', 'a\b\c', 'a\b\c\d' ]

function wideSync(dir){ 
   let arr = [dir]; 
   let index = 0; 
   let current; //讀取的當(dāng)前項(xiàng)目 
   while(current = arr[index++]){ 
      let statObj = fs.statSync(current); 
      if(statObj.isDirectory()){ 
          let dirs =fs.readdirSync(current); 
          dirs = dirs.map(d=>path.join(current,d)); //當(dāng)前兒子的文件夾路徑 
          arr = [...arr,...dirs] 
      } 
   } 
   //倒敘刪除 
   for(let i = arr.length-1;i>=0;i--){ 
       let current = arr[i] 
       let statObj = fs.statSync(current); 
       if(statObj.isDirectory()){ 
           fs.rmdirSync(current) 
       }else{ 
           fs.unlinkSync(current) 
       } 
   } 
} 
wideSync("a") 

深度刪除目錄(串行異步) 

function rmdirSeries(dir,callback){ 
    fs.stat(dir,(err,statObj)=>{ 
        if(statObj.isDirectory()){ 
             //讀取文件內(nèi)容 
             fs.readdir(dir,(err,dirs)=>{ 
                 dirs = dirs.map(d=>path.join(dir,d)) 
                 function next(index){ 
                    if(index == dirs.length) return fs.rmdir(dir,callback) 
                    //先取出數(shù)組中的第一個(gè)  第一個(gè)刪除后  在刪第二個(gè) 
                    rmdirSeries(dirs[index],()=>next(index+1)) 
                 } 
                 next(0) 
             }) 
        }else{ 
            fs.unlink(dir,callback) 
        } 
    }) 
} 
rmdirSeries("a",()=>{ 
    console.log("刪除成功"); 
}) 

深度刪除目錄(并行異步)

function removeDirParalle(dir,callback){ 
    fs.stat(dir,(err,statObj)=>{ 
        if(statObj.isDirectory()){ 
             //讀取文件內(nèi)容 
             fs.readdir(dir,(err,dirs)=>{ 
                 if(dirs.length == 0){ 
                    return fs.rmdir(dir,callback) 
                 } 
                 dirs = dirs.map(d=>{ 
                    let current = path.join(dir,d); 
                    //每個(gè)人刪除之后就調(diào)用done        
                    removeDirParalle(current,done); 
                    return current 
                 }) 
                 //并發(fā)刪除 
                 let index = 0; 
                 function done(){ 
                     if(++index == dirs.length){ 
                        fs.rmdir(dir,callback) 
                     } 
                 } 
             }) 
        }else{ 
            fs.unlink(dir,callback) 
        } 
    }) 
} 
removeDirParalle("a",()=>{ 
    console.log("刪除成功"); 
}) 

 【編輯推薦】