node学习-fs

一.文件的创建与删除 mkdir/rmdir

1.fs.mkdir(path[, mode], callback) - 创建一个文件夹，对应的异步方法为mkdirSync

    如下：创建了一个名为"a"的文件夹：

let fs = require('fs');
fs.mkdir('a',function(err){
    console.log(err);
});

    注：需要注意的是这里的文件夹创建不可用于多级文件夹创建，即当前创建的文件夹的父文件夹必须存在，否则会报错，如果希望进行多级文件夹创建，可进行如下操作：

let fs = require('fs');
let path = require('path');

function makep(url,callback){
    let urlAry = url.split('/');
    let index = 0;
    function make(p){
        // 中止条件判断
        if (urlAry.length < index+1) return;
        // 判断当前文件夹是否存在，如果不存在则创建，如果存在那么创建下一级文件夹
        if (!fs.existsSync(p)){
            fs.mkdir(p,function(err){
                if (err) return callback(err);
                // path.join(...urlAry.slice(0,index+1))当前所需要创建的文件夹路径拼接
                index++;
                make(path.join(...urlAry.slice(0,index+1)));
            });
        }else{
            index++;
            make(path.join(...urlAry.slice(0,index+1)));
        }
    }
    make(urlAry[0]);
}

makep('a/b/c/d',function(err){
    console.log(err)
});

2.fs.rmdir(path, callback) - 删除一个文件夹，对应的同步方法为rmdirSync

    如下:删除一个空的a文件夹

let fs = require('fs');

fs.rmdir('a',(err)=>{
    console.log(err);
});

    希望 需要删除当前文件夹及当前文件夹下的所有子文件夹和文件，则可以使用下面方法

let fs = require('fs');

function removeAllDir(url){
    let stats = fs.statSync(url);
    if (stats.isFile()){
        fs.unlinkSync(url);
        return;
    }
    let files = fs.readdirSync(url);
    if (!files.length){
        fs.rmdirSync(url);
        return;
    }
    files.forEach((file)=>{
        removeAllDir(url+'/'+file);
    });
    fs.rmdirSync(url);
}

removeAllDir('a');

二.文件信息的获取

fs.stat(path,callback) - 对应的同步方法是statSync

    如下获取路径为a的文件信息，并判断它是否是一个文件夹

let fs = require('fs');

fs.stat('a',(err,stats)=>{
  if (err) return console.log(err);
    console.log(stats);
     console.log(stats.idDirectory());
});


stats的值打印如下：
Stats {
  dev: 351163,
  mode: 16822,
  nlink: 1,
  uid: 0,
  gid: 0,
  rdev: 0,
  blksize: undefined,
  ino: 18858823439650600,
  size: 0,
  blocks: undefined,
  atimeMs: 1524552984823.592,
  mtimeMs: 1524552984823.592,
  ctimeMs: 1524552984823.592,
  birthtimeMs: 1524535520681.1023,
  atime: 2018-04-24T06:56:24.824Z,
  mtime: 2018-04-24T06:56:24.824Z,
  ctime: 2018-04-24T06:56:24.824Z,
  birthtime: 2018-04-24T02:05:20.681Z
}

stats上的方法如下：
stats.isFile()
stats.isDirectory()
stats.isBlockDevice()
stats.isCharacterDevice()
stats.isSymbolicLink() (仅对 fs.lstat() 有效)
stats.isFIFO()
stats.isSocket()

三.目录内容读取readdir

fs.readdir(path[, options], callback) -   读取一个目录的内容，对应的同步方法为readdirSync

     - path：读取的路径

     - options：可以通过encoding，指定编码方式，默认为“utf8”

     - callback(err,files)：err为错误参数，files为一个数组对象，包含该目录下的第一级文件夹与文件的名字，注并非路径

    如下：读取a目录下的内容

let fs = require('fs');

fs.readdir('a',(err,files)=>{
    if (err) return console.log(err);
    console.log(files);//[ '2.txt', 'b', 'c' ]
});

    文件夹目录结构如下：

    

如果期望获取当前文件夹下的所有文件夹及文件，可使用如下代码：

let fs = require('fs');
let path = require('path');

function getAllFile(url){
    let founderAry = [];
    function find(p){
        let files = fs.readdirSync(p);
        if (files.length){
            files.forEach((file)=>{
                founderAry.push(path.resolve(p+'/'+file));
                let stats = fs.statSync(p+'/'+file);
                if (stats.isDirectory()){
                    find(p+'/'+file)
                }
            })
        }
    }
    find(url);
    return founderAry;
}

getAllFile('a');

四.文件的读写及内容追加

1. fs.readFile(path[, options], callback) - 读取对应文件中的内容，同步方法为readFileSync

let fs = require('fs');

fs.readFile('a/2.txt','utf8',(err,data)=>{
    if(err) return console.log(err);
    console.log(data);//This is text;
});

fs.readFile('a/2.txt',{'encoding':'utf8','flags':'r'},(err,data)=>{
    if(err) return console.log(err);
    console.log(data);//This is text;
});

2. fs.writeFile(file, data[, options], callback) - 像对应的文件中写入内容，对应的同步方法为 fs.writeFileSync

     - 注：这里的写入会覆盖文件中原来的内容，如果当前文件不存在，则会自动创建

let fs = require('fs');

fs.writeFile('a/2.txt','dsdasd','utf8',(err)=>{
    if(err) return console.log(err);
});

如下：是通过readFile和writeFile写的一个copy函数：

let fs = require('fs');

function copy(source,target,cb){
    fs.readFile(source,'utf8',(err,data)=>{
        if (err) return console.log(err);
        fs.writeFile(target,data,'utf8',cb);
    })
}
copy('data/1.txt','data/2.txt',(err)=>{
    if (err) return console.log(err);
    console.log('拷贝成功');
});

3.fs.read(fd, buffer, offset, length, position, callback)  - 读取文件中内容写入buffer中，并可以从buffer中读取内容，对应的同步方法为readSync，相对于readFile提供的相比较底层的接口，参数如下：

     - fd： 从fd 指定的文件中读取数据

     - buffer： 是数据将被写入到的 buffer

     - offset： 是 buffer 中开始写入的偏移量

     - length： 是一个整数，指定要读取的字节数

     - position： 指定从文件中开始读取的位置，如果需要从头读取，设置该项为null

     - callback：有三个参数：err（错误参数），bytesRead（字节的读取数），buffer（重写内容后的buffer）

注: 一般情况下不建议使用这种方式来读取文件，因为它要求你手动管理缓冲区和文件指针，尤其是在 你不知道文件大小的时候，这将会是一件很麻烦的事情

用法如下：

let fs = require('fs');

fs.open('data/1.txt','r',(err,fd)=>{
    if (err) return console.log(err);
    let buf = Buffer.alloc(20);
    fs.read(fd,buf,0,10,3,(err,bytesRead,buffer)=>{
        if (err) console.log(err);
        console.log(bytesRead);//10
        console.log(buffer);//<Buffer 34 35 36 37 38 39 30 31 32 33 00 00 00 00 00 00 00 00 00 00>
    })
});

4. 进行文件写入操作，提供相对writeFile较底层的方式，不太常用

fs.write(fd, buffer[, offset[, length[, position]]], callback) -   这种写法将buffer写入文件，同步方法为writeSync

     - fd 文件描述符

     - buffer 需要写入的buffer

     - offset：决定buffer中被写入的部分，buffer的偏移量

     - length：写入字节的长度

     - position：文件开始写入数据的位置的偏移量

fs.write(fd, string[, position[, encoding]], callback) -   这种写法将数据data写入文件

     - fd 文件描述符

     - string 写入的string，如果不是一个string，则该值会被强转换为一个字符串

     - position：文件开始写入数据的位置的偏移量

     - encoding：期望的字符编码

let fs = require('fs');

fs.open('data/1.txt','r+',(err,fd)=>{
    if (err) return console.log(err);
    let buf = Buffer.from('这是写入的文本');
    fs.write(fd,buf,0,buf.length,1,(err,bytesRead,buffer)=>{
        if (err) return console.log(err);
        console.log(bytesRead);//21
        console.log(buf.toString());//这是写入的文本
    })
});

fs.open('data/1.txt','r+',(err,fd)=>{
    if (err) return console.log(err);
    fs.write(fd,'这是写入的文本哦',0,'utf8',(err,bytesRead,buffer)=>{
        if (err) return console.log(err);
  console.log(bytesRead);//24
  console.log(buffer.toString());//这是写入的文本哦      
    })
});

5.fs.appendFile(file, data[, options], callback) - 向对应的文件中追加写入内容，对应的同步方法为 fs. appendFile Sync

     - 如果文件不存在，则会自动创建

fs.appendFile('a/3.txt','111111',(err)=>{
    if(err) return console.log(err);
});

6. fs.createReadStream(path[, options]) - 返回一个新建的 ReadStream对象，option默认参数如下：

const defaults = {
  flags: 'r',
  encoding: null,
  fd: null,
  mode: 0o666,
  autoClose: true, // 
  highWaterMark: 64 * 1024 // 每次可以读取的字节数，默认为64K
};

    实例如下：

let fs = require('fs');

// 每次读取3字节，起始位置为1，结束为止为9
let rs = fs.createReadStream('data/2.txt',{encoding:'utf8',highWaterMark:3,start:1,end:9});
rs.on('data',(data)=>{
    // 读取数据时触发
    console.log(data);
     //234
     //567
     //890

     // 这里使没读取一次都进行暂停，2s之后再进行恢复
rs.pause(); 
setTimeout(()=>{
    rs.resume();
},2000);
});
rs.on('end',()=>{
    // 读取数据时触发
    console.log('文件全部读取完毕');
});
rs.on('close',function(){
    console.log('文件被关闭');
});
rs.on('error',(err)=>{
    // 读取数据时触发
    console.log('文件读取失败');
});

7.fs.createWriteStream(path[, options]) - 返回新建的WriteStream对象

var fs = require('fs');
var rs = fs.createReadStream('data/1.txt');
var ws = fs.createWriteStream('data/2.txt');
rs.on('data',function(data){
    ws.write(data);
});
ws.on('open',function(fd){
    console.log('需要被写入的文件已打开');
});
rs.on('end',function(){
    console.log('共写入'+ws.bytesWritten+'字节数据');
});