日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
Node.JavaScript文件系統(tǒng)中目錄的操作

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

專注于為中小企業(yè)提供成都網(wǎng)站設計、成都網(wǎng)站制作服務,電腦端+手機端+微信端的三站合一,更高效的管理,為中小企業(yè)臨武免費做網(wǎng)站提供優(yōu)質(zhì)的服務。我們立足成都，凝聚了一批互聯(lián)網(wǎng)行業(yè)人才，有力地推動了上千余家企業(yè)的穩(wěn)健成長，幫助中小企業(yè)通過網(wǎng)站建設實現(xiàn)規(guī)模擴充和轉(zhuǎn)變。

有一種特殊的二叉樹叫二叉查找樹(BST)，其他的特點是：相對較小的值保存在左節(jié)點中，較大的值保存在右節(jié)點中，因為這個特點使查找的效率特別高。

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

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

中序

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

先序

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

后序

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

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

深度優(yōu)先搜索

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

廣度優(yōu)先搜索

同步創(chuàng)建目錄

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

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

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

 
 
 
 
    
  
  
  
  
  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) //如果路徑存在  不創(chuàng)建目錄 
    9.   
  
  
  
  9.         }catch(e){ 
    10.   
  
  
  
  10.            fs.mkdirSync(currentPath) 
    11.   
  
  
  
  11.         } 
    12.   
  
  
  
  12.      } 
    13.   
  
  
  
  13.  } 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. mkdirSync("a/b/c/d")  //默認創(chuàng)建目錄  必須父級存在 才能創(chuàng)建子級 
    16.

 異步創(chuàng)建目錄

 
 
 
 
    
  
  
  
  
  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{   //如果存在則不創(chuàng)建 
    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("創(chuàng)建完成"); 
    18.   
  
  
  
  18. }) 
    19.

創(chuàng)建目錄

深度刪除目錄(同步)

fs.stat() 方法用于查詢文件信息，可以用于查詢文件的大小、創(chuàng)建時間、權限等相關信息。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)   //返回一個數(shù)組 
    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) //刪除兒子節(jié)點 再將自己刪除 
    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循環(huán)橫向列出所有文件的路徑，然后通過倒敘刪除。

 
 
 
 
    
  
  
  
  
  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.              //讀取文件內(nèi)容 
    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.                     //先取出數(shù)組中的第一個  第一個刪除后  在刪第二個 
    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.              //讀取文件內(nèi)容 
    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.                     //每個人刪除之后就調(diào)用done        
    12.   
  
  
  
  12.                     removeDirParalle(current,done); 
    13.   
  
  
  
  13.                     return current 
    14.   
  
  
  
  14.                  }) 
    15.   
  
  
  
  15.                  //并發(fā)刪除 
    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高性能網(wǎng)絡編程之TCP連接的內(nèi)存使用
  4. Python曾是程序員的“瑞士軍刀”，而如今正被慢慢取代
  5. 全球疫情下的網(wǎng)絡安全：警惕“趁火打劫”的線上攻擊

網(wǎng)站名稱：Node.JavaScript文件系統(tǒng)中目錄的操作
新聞來源：http://m.5511xx.com/article/dpoihsh.html