在线精品人妻一区二区,调教av中文字幕在线,经典另类一二三页

1. fs模塊

在Node.js中，使用fs模塊來實現(xiàn)所有有關(guān)文件及目錄的創(chuàng)建、寫入及刪除操作。
在fs模塊中，所有的方法都分為同步和異步兩種實現(xiàn)。
具有sync后綴的方法為同步方法，不具有sync后綴的方法為異步方法。

2. 整體讀取文件

2.1 異步讀取

fs.readFile(path[, options], callback)

options
- encoding
- flag flag 默認 = 'r'

2.2 同步讀取

fs.readFileSync(path[, options])

3. 寫入文件

3.1 異步寫入

fs.writeFile(file, data[, options], callback)

options
- encoding
- flag flag 默認 = 'w'
- mode 讀寫權(quán)限，默認為0666

    let fs = require('fs');
    fs.writeFile('./1.txt',Date.now()+'\n',{flag:'a'},function(){
      console.log('ok');
    });

3.2 同步寫入

fs.writeFileSync(file, data[, options])

3.3 追加文件

fs.appendFile(file, data[, options], callback)

fs.appendFile('./1.txt',Date.now()+'\n',function(){
  console.log('ok');
})

3.4 拷貝文件

function copy(src,target){
  fs.readFile(src,function(err,data){
    fs.writeFile(target,data);
  })
}

4. 從指定位置處開始讀取文件

4.1 打開文件

fs.open(filename,flags,[mode],callback);

FileDescriptor 是文件描述符

FileDescriptor 可以被用來表示文件

in -- 標準輸入(鍵盤)的描述符

out -- 標準輸出(屏幕)的描述符

err -- 標準錯誤輸出(屏幕)的描述符

fs.open('./1,txt','r',0600,function(err,fd){});

4.2 讀取文件

fs.read(fd, buffer, offset, length, position, callback((err, bytesRead, buffer)))

//張熙沐楓
const fs=require('fs');
const path=require('path');
fs.open(path.join(__dirname,'1.txt'),'r',0o666,function (err,fd) {
    console.log(err);
    let buf = Buffer.alloc(6);
     fs.read(fd,buf,0,6,3,function(err, bytesRead, buffer){
       console.log(bytesRead);//6
       console.log(buffer===buf);//true
       console.log(buf.toString());//峰培
     })
})

4.3 寫入文件

fs.write(fd, buffer[, offset[, length[, position]]], callback)

const fs=require('fs');
const path=require('path');
fs.open(path.join(__dirname,'1.txt'),'w',0o666,function (err,fd) {
    console.log(err);
    let buf=Buffer.from('張熙沐楓');
     fs.write(fd,buf,3,6,0,function(err, bytesWritten, buffer){
       console.log(bytesWritten);//6
       console.log(buffer===buf);//true
       console.log(buf.toString());//張熙沐楓
     })
})

4.4 同步磁盤緩存

fs.fsync(fd,[callback]);

4.5 關(guān)閉文件

fs.close(fd,[callback]);

let buf = Buffer.from('張熙沐楓');
fs.open('./2.txt', 'w', function (err, fd) {
  fs.write(fd, buf, 3, 6, 0, function (err, written, buffer) {
    console.log(written);
    fs.fsync(fd, function (err) {
      fs.close(fd, function (err) {
          console.log('寫入完畢!')
        }
      );
    });
  })
});

4.6 拷貝文件

let BUFFER_SIZE=1;
const path=require('path');
const fs=require('fs');
function copy(src,dest,callback) {
    let buf=Buffer.alloc(BUFFER_SIZE);
    fs.open(src,'r',(err,readFd)=>{
        fs.open(dest,'w',(err,writeFd) => {
            !function read() {
                fs.read(readFd,buf,0,BUFFER_SIZE,null,(err,bytesRead) => {
                    bytesRead&&fs.write(writeFd,buf,0,bytesRead,read);
                });
            }()
        })
    });
}
copy(path.join(__dirname,'1.txt'),path.join(__dirname,'2.txt'),()=>console.log('ok'));

5 目錄操作

5.1 創(chuàng)建目錄

fs.mkdir(path[, mode], callback)

要求父目錄必須存在

5.2 判斷一個文件是否有權(quán)限訪問

fs.access(path[, mode], callback)

fs.access('/etc/passwd', fs.constants.R_OK | fs.constants.W_OK, (err) => {
  console.log(err ? 'no access!' : 'can read/write');
});

5.3 讀取目錄下所有的文件

fs.readdir(path[, options], callback)

5.4 查看文件目錄信息

fs.stat(path, callback)

stats.isFile()
stats.isDirectory()
atime(Access Time)上次被讀取的時間。
ctime(State Change Time)：屬性或內(nèi)容上次被修改的時間。
mtime(Modified time)：檔案的內(nèi)容上次被修改的時間。

5.5 移動文件或目錄

fs.rename(oldPath, newPath, callback)

5.6 刪除文件

fs.unlink(path, callback)

5.7 截斷文件

fs.ftruncate(fd[, len], callback)

const fd = fs.openSync('temp.txt', 'r+');
// 截斷文件至前4個字節(jié)
fs.ftruncate(fd, 4, (err) => {
  console.log(fs.readFileSync('temp.txt', 'utf8'));
});

5.8 監(jiān)視文件或目錄

fs.watchFile(filename[, options], listener)

let fs = require('fs');
fs.watchFile('1.txt', (curr, prev) => {
  //parse() 方法可解析一個日期時間字符串，并返回 1970/1/1 午夜距離該日期時間的毫秒數(shù)。
  if(Date.parse(prev.ctime)==0){
    console.log('創(chuàng)建');
  }else if(Date.parse(curr.ctime)==0){
    console.log('刪除');
  }else if(Date.parse(prev.ctime) != Date.parse(curr.ctime)){
    console.log('修改');
  }
});

6 遞歸創(chuàng)建目錄

6.1 同步創(chuàng)建目錄

let fs=require('fs');
let path=require('path');
function makepSync(dir) {
    let parts=dir.split(path.sep);
    for (let i=1;i<=parts.length;i++){
        let parent=parts.slice(0,i).join(path.sep);
        try {
            fs.accessSync(parent);
        } catch (error) {
            fs.mkdirSync(parent);
        }

    }
}

6.2 異步創(chuàng)建目錄

function makepAsync(dir,callback) {
    let parts=dir.split(path.sep);
    let i=1;
    function next() {
        if (i>parts.length)
            return callback&&callback();    
        let parent=parts.slice(0,i++).join(path.sep);
        fs.access(parent,err => {
            if (err) {
                fs.mkdir(parent,next);
            } else {
                next();
            }
        });
    }
    next();
}

6.3 Async+Await創(chuàng)建目錄

async function mkdir(parent) {
    return new Promise((resolve,reject) => {
        fs.mkdir(parent,err => {
            if (err) reject(err);
            else resolve();
        });
    });
}

async function access(parent) {
    return new Promise((resolve,reject) => {
        fs.access(parent,err => {
            if (err) reject(err);
            else resolve();
        });
    });
}
async function makepPromise(dir,callback) {
    let parts=dir.split(path.sep);
    for (let i=1;i<=parts.length;i++){
        let parent=parts.slice(0,i).join(path.sep);
        try {
            await access(parent);
        }catch(err) {
            await mkdir(parent);
        }

    }
}

7. 遞歸刪除目錄

7.1 同步刪除目錄(深度優(yōu)先)

let fs=require('fs');
let path=require('path')
function rmSync(dir) {
    try {
        let stat = fs.statSync(dir);
        if (stat.isFile()) {
            fs.unlinkSync(dir);
        } else {
            let files=fs.readdirSync(dir);
            files
                .map(file => path.join(dir,file))
                .forEach(item=>rmSync(item));
            fs.rmdirSync(dir);
        }
    } catch (e) {
        console.log('刪除失敗!');
    }
}
rmSync(path.join(__dirname,'a'));

7.2 異步刪除非空目錄(Promise版)

function rmPromise(dir) {
    return new Promise((resolve,reject) => {
        fs.stat(dir,(err,stat) => {
            if (err) return reject(err);
            if (stat.isDirectory()) {
                fs.readdir(dir,(err,files) => {
                    let paths = files.map(file => path.join(dir,file));
                    let promises = paths.map(p=>rmPromise(p));
                    Promise.all(promises).then((() => fs.rmdir(dir,resolve)));
                });
            } else {
                fs.unlink(dir,resolve);
            }
        });
    });
}
rmPromise(path.join(__dirname,'a')).then(() => {
    console.log('刪除成功');
})

7.3 異步串行刪除目錄(深度優(yōu)先)

function rmAsyncSeries(dir,callback) {
    setTimeout(() => {
        fs.stat(dir,(err,stat) => {
            if (err) return callback(err);
            if (stat.isDirectory()) {
                fs.readdir(dir,(err,files) => {
                    let paths = files.map(file => path.join(dir,file));
                    function next(index) {
                        if (index>=files.length) return fs.rmdir(dir,callback);
                        let current=paths[index];
                        rmAsyncSeries(current,()=>next(index+1));
                    }
                    next(0);
                });
            } else {
                fs.unlink(dir,callback);
            }
        })
    },1000);
}

console.time('cost');
rmAsyncSeries(path.join(__dirname,'a'),err => {
     console.timeEnd('cost');
})

7.4 異步并行刪除目錄(深度優(yōu)先)

function rmAsyncParallel(dir,callback) {
    setTimeout(() => {
        fs.stat(dir,(err,stat) => {
            if (err) return callback(err);
            if (stat.isDirectory()) {
                fs.readdir(dir,(err,files) => {
                    let paths=files.map(file => path.join(dir,file));
                    if (paths.length>0) {
                        let i=0;
                        function done() {
                            if (++i == paths.length) {
                                fs.rmdir(dir,callback);
                            }
                        }
                      paths.forEach(p=>rmAsyncParallel(p,done));
                    } else {
                        fs.rmdir(dir,callback);
                    }
                });
            } else {
                fs.unlink(dir,callback);
            }
        })
    },1000);
}
console.time('cost');
rmAsyncParallel(path.join(__dirname,'a'),err => {
     console.timeEnd('cost');
})

7.5 同步刪除目錄(廣度優(yōu)先)

function rmSync(dir){
    let arr=[dir];
    let index=0;
    while (arr[index]) {
        let current=arr[index++];
        let stat=fs.statSync(current);
        if (stat.isDirectory()) {
            let dirs=fs.readdirSync(current);
            arr=[...arr,...dirs.map(d => path.join(current,d))];
        }
    }
    let item;
    while (null != (item = arr.pop())) {
        let stat = fs.statSync(item);
        if (stat.isDirectory()) {
            fs.rmdirSync(item);
        } else {
            fs.unlinkSync(item);
        }
    }
}

7.6 異步刪除目錄(廣度優(yōu)先)

function rmdirWideAsync(dir,callback){
    let dirs=[dir];
    let index=0;
    function rmdir() {
        let current = dirs.pop();
        if (current) {
            fs.stat(current,(err,stat) => {
                if (stat.isDirectory()) {
                    fs.rmdir(current,rmdir);
                } else {
                    fs.unlink(current,rmdir);
                }
            });
        }
    }
    !function next() {
        let current=dirs[index++];
        if (current) {
            fs.stat(current,(err,stat) => {
                if (err) callback(err);
                if (stat.isDirectory()) {
                    fs.readdir(current,(err,files) => {
                        dirs=[...dirs,...files.map(item => path.join(current,item))];
                        next();
                    });
                } else {
                    next();
                }
            });
        } else {
            rmdir();
        }

    }();
}

8. 遍歷算法

目錄是一個樹狀結(jié)構(gòu)，在遍歷時一般使用深度優(yōu)先+先序遍歷算法
深度優(yōu)先，意味著到達一個節(jié)點后，首先接著遍歷子節(jié)點而不是鄰居節(jié)點
先序遍歷，意味著首次到達了某節(jié)點就算遍歷完成，而不是最后一次返回某節(jié)點才算數(shù)

因此使用這種遍歷方式時，下邊這棵樹的遍歷順序是A > B > D > E > C > F。

8.1 同步深度優(yōu)先+先序遍歷

function deepSync(dir){
  console.log(dir);
  fs.readdirSync(dir).forEach(file=>{
      let child = path.join(dir,file);
      let stat = fs.statSync(child);
      if(stat.isDirectory()){
          deepSync(child);
      }else{
          console.log(child);
      }
  });
}

### 8.2 異步深度優(yōu)先+先序遍歷  

```js
function deep(dir,callback) {
  console.log(dir);
  fs.readdir(dir,(err,files)=>{
      !function next(index){
          if(index == files.length){
              return callback();
          }
          let child = path.join(dir,files[index]);
          fs.stat(child,(err,stat)=>{
              if(stat.isDirectory()){
                  deep(child,()=>next(index+1));
              }else{
                  console.log(child);
                  next(index+1);
              }
          })
      }(0)
  })
}
```


### 8.3 同步廣度優(yōu)先+先序遍歷   

```js
function wideSync(dir){
  let dirs = [dir];
  while(dirs.length>0){
      let current = dirs.shift();
      console.log(current);
      let stat = fs.statSync(current);
      if(stat.isDirectory()){
          let files = fs.readdirSync(current);
          files.forEach(item=>{
              dirs.push(path.join(current,item));
          });
      }
  }
}
```

8.4 異步廣度優(yōu)先+先序遍歷

// 異步廣度遍歷
function wide(dir, cb) {
    console.log(dir);
    cb && cb()
    fs.readdir(dir, (err, files) => {
        !function next(i){
            if(i>= files.length) return;
            let child = path.join(dir,files[i]);
            fs.stat(child,(err,stat)=>{
                if(stat.isDirectory()){
                    wide(child, () => next(i+1));
                } else {
                    console.log(child);
                    next(i+1);
                }
            })
        }(0);
    })
}
wide(path.join(__dirname,'a'));

8. path模塊

path是node中專門處理路徑的一個核心模塊

path.join 將多個參數(shù)值字符串結(jié)合為一個路徑字符串
path.basename 獲取一個路徑中的文件名
path.extname 獲取一個路徑中的擴展名
path.sep 操作系統(tǒng)提定的文件分隔符
path.delimiter 屬性值為系統(tǒng)指定的環(huán)境變量路徑分隔符
path.normalize 將非標準的路徑字符串轉(zhuǎn)化為標準路徑字符串特點：
- 可以解析 . 和 ..
- 多個杠可以轉(zhuǎn)換成一個杠
- 在windows下反杠會轉(zhuǎn)化成正杠
- 如結(jié)尾以杠結(jié)尾的，則保留斜杠

resolve

以應用程序根目錄為起點
如果參數(shù)是普通字符串，則意思是當前目錄的下級目錄
如果參數(shù)是.. 回到上一級目錄
如果是/開頭表示一個絕對的根路徑

var path = require('path');
var fs = require('fs');
/**

- normalize 將非標準化的路徑轉(zhuǎn)化成標準化的路徑
- 1.解析. 和 ..
- 2.多個斜杠會轉(zhuǎn)成一個斜杠
- 3.window下的斜杠會轉(zhuǎn)成正斜杠
- 4.如果以斜杠會保留
  **/

console.log(path.normalize('./a////b//..\\c//e//..//'));
//  \a\c\

//多個參數(shù)字符串合并成一個路徑 字符串
console.log(path.join(__dirname,'a','b'));

/**

- resolve
- 以就用程序為根目錄，做為起點，根據(jù)參數(shù)解析出一個絕對路徑
- 1.以應用程序為根起點
- 2... .
- 1. 普通 字符串代表子目錄
- 1. /代表絕地路徑根目錄
     */
     console.log(path.resolve());//空代表當前的目錄 路徑
     console.log(path.resolve('a','/c'));// /a/b
     // d:\c
     //可以獲取兩個路徑之間的相對關(guān)系
     console.log(path.relative(__dirname,'/a'));
     // a
     //返回指定路徑的所在目錄
     console.log(path.dirname(__filename)); // 9.path
     console.log(path.dirname('./1.path.js'));//  9.path
     //basename 獲取路徑中的文件名
     console.log(path.basename(__filename));
     console.log(path.basename(__filename,'.js'));
     console.log(path.extname(__filename));

console.log(path.sep);//文件分隔符 window \ linux /
console.log(path.win32.sep);
console.log(path.posix.sep);
console.log(path.delimiter);//路徑 分隔符 window ; linux :

9. flags

符號	含義
r	讀文件，文件不存在報錯
r+	讀取并寫入，文件不存在報錯
rs	同步讀取文件并忽略緩存
w	寫入文件，不存在則創(chuàng)建，存在則清空
wx	排它寫入文件
w+	讀取并寫入文件，不存在則創(chuàng)建，存在則清空
wx+	和w+類似，排他方式打開
a	追加寫入
ax	與a類似，排他方式寫入
a+	讀取并追加寫入，不存在則創(chuàng)建
ax+	作用與a+類似，但是以排他方式打開文件

10. 助記

r 讀取
w 寫入
s 同步
+ 增加相反操作
x 排他方式
r+ w+的區(qū)別?
- 當文件不存在時，r+不會創(chuàng)建，而會導致調(diào)用失敗，但w+會創(chuàng)建。
- 如果文件存在，r+不會自動清空文件，但w+會自動把已有文件的內(nèi)容清空。

11. linux權(quán)限

文件類型與權(quán)限	鏈接占用的節(jié)點(i-node)	文件所有者	文件所有者的用戶組	文件大小	文件的創(chuàng)建時間	最近修改時間	文件名稱

authorigy.jpg

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Node進階 ---- fs

1. fs模塊

2. 整體讀取文件

2.1 異步讀取

2.2 同步讀取

3. 寫入文件

3.1 異步寫入

3.2 同步寫入

3.3 追加文件

3.4 拷貝文件

4. 從指定位置處開始讀取文件

4.1 打開文件

4.2 讀取文件

4.3 寫入文件

4.4 同步磁盤緩存

4.5 關(guān)閉文件

4.6 拷貝文件

5 目錄操作

5.1 創(chuàng)建目錄

5.2 判斷一個文件是否有權(quán)限訪問

5.3 讀取目錄下所有的文件

5.4 查看文件目錄信息

5.5 移動文件或目錄

5.6 刪除文件

5.7 截斷文件

5.8 監(jiān)視文件或目錄

6 遞歸創(chuàng)建目錄

6.1 同步創(chuàng)建目錄

6.2 異步創(chuàng)建目錄

6.3 Async+Await創(chuàng)建目錄

7. 遞歸刪除目錄

7.1 同步刪除目錄(深度優(yōu)先)

7.2 異步刪除非空目錄(Promise版)

7.3 異步串行刪除目錄(深度優(yōu)先)

7.4 異步并行刪除目錄(深度優(yōu)先)

7.5 同步刪除目錄(廣度優(yōu)先)

7.6 異步刪除目錄(廣度優(yōu)先)

8. 遍歷算法

8.1 同步深度優(yōu)先+先序遍歷

8.4 異步廣度優(yōu)先+先序遍歷

8. path模塊

9. flags

10. 助記

11. linux權(quán)限

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av