nodeJs高阶模块--fs

头像
villainhr
    阅读 8 分钟
    7

    请问大家: NodeJs只能做的两件事是什么？
    这也能做,那也能做~
    just joke~
    实际上,所有后台语言都能做的两件事是： 文件操作和网络编程.
    这其实是所有语言的根本。 计算机无外乎就是文件和通信。Linux中,是把一切都当做文件,如果理解了这一点那就无可厚非了.
    所以,这里,我想介绍一下NodeJS中一个重要的模块--fs.
    这里我给大家放一个我的框架图~

    (为什么不是http? 懒~)
    let's start.
    针对于fs,我们切实围绕几个问题来吧~

    1. fs是如何操作文件的？

    2. drain和write到底是什么关系?

    3. fs怎么写出向gulp那样实时监听文件改变的插件？

    关于fs的API,直接参考Nodejs官网. 同样,放上fs的基本架构图:

    (图有点大，大家另外开一个窗口看吧)
    我们围绕这些问题来展开,说明吧.

    fs操作文件的几种方式

    这里,我们针对文件最基本的两种操作进行相关的解释和说明吧--read&&write
    读写文件有哪几种操作方式呢？
    我们先从最简便的开始吧~

    先熟悉API: fs.createReadStream(path[, options]) path就是打开的文件路径,options有点复杂:

    {
  flags: 'r',
  encoding: null,
  fd: null,
  mode: 0o666,
  autoClose: true
}

    实际上我们一般也用不到options,除非你是获取已经打开后的文件.具体描述详见.官网.
    ok~ 现在正式打开一个文件:

    const fs = require('fs');
const read = fs.createReadStream('sam.js',{encoding:'utf8'});
read.on('data',(str)=>{
    console.log(str);
})
read.on('end',()=>{
    console.log('have already opened');
})

    实际上,我们就是利用fs继承的readStream来进行操作的.

    使用open打开文件
    同样上:API:
    fs.open(path, flags[, mode], callback)这个和上面的readStream不同,open打开文件是一个持续状态,相当于会将文件写入到内存当中. 而readStream只是读取文件,当读取完毕时则会自动关闭文件--相当于fs.open+fs.close两者的结合~ 其中flags和mode 就是设置打开文件的权限,以及文件的权限模式(rwx).
    使用open来打开一个文件

    const fs = require('fs');
fs.open('sam.js','r',(err,fd)=>{
    fs.fstat(fd,(err,stat)=>{
        var len = stat.size;  //检测文件长度
        var buf = new Buffer(len);
        fs.read(fd,buf,0,len,0,(err,bw,buf)=>{
            console.log(buf.toString('utf8'));
            fs.close(fd);
        })
    });
});

    使用相关的read/readdir/readFile/readlink
    read方法,使用来读取已经打开后的文件。 他不用用来进行打开文件操作，这点很重要》 那还有其他方法,在读的过程可以直接打开文件吗？
    absolutely~
    这里就拿readFile和readdir举例吧
    API
    fs.readFile(file[, options], callback): file就是文件路径,options可以为object也可以为string. 不过最常用的还是str. 我们直接看demo:

    const fs = require('fs');
fs.readFile('sam.js','utf8',(err,data)=>{
    console.log(`the content is ,${data}`);
})

    另外一个readdir,顾名思义该API就是用来读取文件夹的.实际上,该API也没有什么卵用~
    fs.readdir(path, callback):用来获取文件下所有的文件(包括目录),并且不会进行recursive.并且callback(err,files)中的files只是以数组的形式放回该目录下所有文件的名字
    show u code:

    //用来检查,上层目录中那些是file,那些是dir
const fs = require('fs');
fs.readdir('..', (err,files)=>{
    var path,stat;
    files.map((val)=>{
        path = `../${val}`;
        stat= fs.statSync(path);
        if(stat.isFile()){
            console.log(`file includes ${val}`);
        }else if(stat.isDirectory()){
            console.log(`dir includes ${val}`);
        }
    })
})

    nodejs 打开文件的所有方式就是以上这几种.接下来我们再来看一下,如果写入文件吧~

    写入文件

    同样,先介绍最简单的吧.

    fs.createWriteStream(path[, options]): path就是文件路径.而options和上面的createWriteStream一样比较复杂;

    {
  flags: 'w',
  defaultEncoding: 'utf8',
  fd: null,
  mode: 0o666
}

    实际上,我们只需要写好path就enough了.
    直接看demo吧:

    //用来写入str的操作
const fs = require('fs');
const write = fs.createWriteStream('sam.js');
write.on('drain',()=>{
    write.resume();
});
var writeData = function(){
    var i = 1000;
    while(i--){
        if(!write.write('sam')){
            write.pause();
        }
    }
}
writeData();

    实际上,上面那段代码是最常用的写入文件的写法.drain是代表,写入内存已经清空后,可以继续写入时触发的事件.这就是第二个问题: drain和write到底是什么关系? 这个问题,我们放到后面讲解,这里先继续说一下如何写入内容.

    使用fs.write方法直接写入内容:
    fs.writeAPI其实就有两个:
    fs.write(fd, buffer, offset, length[, position], callback):这一种，是用来直接写入Buffer数据内容的.
    fs.write(fd, data[, position[, encoding]], callback):这一种,是用来写入str数据内容的.
    不过,fs.write()该方法,也是建立在已有文件打开的基础上的.
    直接看一下demo:

    //使用Buffer写入
const fs = require('fs');
fs.open('sam.js','w+',(err,fd)=>{
    var buf = new Buffer("sam",'utf8');
    fs.write(fd,buf,0,buf.length,0,(err,bw,buf)=>{
        fs.close(fd);
    });
})
//直接使用string写入:
const fs = require('fs');
fs.open('sam.js','w+',(err,fd)=>{
    fs.write(fd,'sam','utf8',0,(err,bw,buf)=>{
        fs.close(fd);
    });
})

    通常情况下,我们也不会用来写入Buffer的. 所以,第二种方法就足够了.

    同理,能否直接写入未打开的文件呢？
    当然是可以的,所以这里介绍最后一种方法. 使用writeFile和appendFile来写入数据.

    fs.writeFile(file, data[, options], callback):直接写入指定文件. 写入的内容会直接覆盖掉原始内容.
    fs.appendFile(file, data[, options], callback):真正的用来append file

    //检测文件是否存在,如果存在则增加内容,否则新建文件并写入内容.
const fs = require('fs');
var writeData = function() {
    fs.access('sam.js', (noAccess) => {
        if (noAccess) {
            fs.writeFile('sam.js', 'sam', (err) => {
                if (!err) console.log('writeFile success')
            })
        } else {
            fs.appendFile('sam.js', 'sam', (err) => {
                if (!err) console.log('appendFile success~');
            });
        }
    })
}
writeData()

    大致梳理一下上面说的内容吧:

    drain和stream.write的关联

    首先这两个东西,是底层writeStream提供的. write这个方法不用解释了吧~ 关键drain到底怎么使用~ 这也是官网没说清楚的地方:

    If a stream.write(chunk) call returns false, then the 'drain' event will indicate when it is appropriate to begin writing more data to the stream.

    实际上,我们判断用没用到drain事件的机制,是根据write方法的返回值来进行判断的. 官方也给出一个demo，用来测试drain事件的触发.

    const fs = require('fs');
const writer = fs.createWriteStream('sam.js');
writeOneMillionTimes(writer,'sam','utf8',()=>{});

    没错,这样确实会多次触发drain事件.但是,他到底是什么时候会触发呢？
    根据源码的介绍,write方法在使用时,会内置一个Buffer用来写入数据.我们可以理解该Buffer就是该次写入的最大内存值~ 那到底是多少呢？ 源码:

    var defaultHwm = this.objectMode ? 16 : 16 * 1024;
//即,默认为16KB

    相当于,我们每次写入都会有16KB的空间开着~ 如果写入data已经填满了16KB, 而我们还继续写入就有可能造成 memory leak~ 这就go die了。轻者卡一卡，重则死机都有可能. 那如果按照官网那种写法的话,每次写入一个大文件,都要写入老长老长的函数呢？
    伦家~才不要~
    实际上,我们直接提炼一下,使用stream.once('drain')事件来进行处理.

    if(!stream.write(data))stream.once('drain',()=>{
    stream.write(otherData);
})

    或者当你使用readStream和writeStream用来读写文件时~可以使用

    //试一试读取一个较大的文件,你会发现drain事件也会触发~ 所以我们需要使用pause和resume来暂停流的读取,防止memory leak~
const fs = require('fs');
const read = fs.createReadStream('唱歌的孩子.mp3');
const write = fs.createWriteStream('get.mp3');
read.on('data',(chunk)=>{
    if(!write.write(chunk))read.pause();
});
write.on('drain',()=>{
    console.log('drain');
    read.resume();
})
read.on('end',()=>{
    console.log(`finish`);
})

    如何写出像gulp一样监听文件变化的插件呢？

    首先,我们看一下监听插件的配置:

    gulp.task('sync', function() {
    var files = [
        'app/**/*.html',
        'app/styles/**/*.css',
        'app/img/**/*.png',
        'app/src/**/*.js'
    ];
    browserSync.init(files, {
        server: {
            baseDir: './app'
        }
    });
});

    首先,我们设置了files之后,就可以监听文件,并且开启一个服务~
    而实际上,就是使用Nodejs底层的fs.watch对文件进行监听.我们来使用fs.watch和fs.watchFile来实现文件的监听~
    这里，我们先从简单的watchFile入手~
    根据nitoyon的解释,我们可以得出两个结论

    • fs.watch() uses native API

    • fs.watchFile() periodically executes fs.stat()

    所以,底层上来看,其实fs.watchFile是周期性执行fs.stat的,速度上来看,肯定会慢的. 不多说了，我们看一下demo:

    const fs = require('fs');
fs.watchFile('sam.js', {
    persistent:true,
    interval:3000
}, (cur,prev)=>{
    if(cur.mtime>prev.mtime){
        console.log('change');
        console.log(cur,prev);
    }
})

    这里,主要想谈及一下watchFile中的第二个参数,options中的interval. 这个东西有点傻逼~ 为什么呢？ 因为,他并不是在一定时间内,触发watch,而是在第一次触发后的interval时间内,不会触发watch. 即,他会发生改变的积累~ 在interval时间内改变的内容,只会在最后一次中呈现出来~ 而他的底层其实就是调用fs.stat来完成的.这里，我们使用fs.stat来模仿一遍~

    const fs = require('fs'),
    Event = require('events').EventEmitter,
    event = new Event();


//原始方法getCur
//原始属性prev
var watchFile = function(file,interval,cb){
    var pre,cur;
    var getPrv = function(file){
        var stat = fs.statSync(file);
        return stat;
    }
    var getCur = function(file){
        cur = getPrv(file);
        console.log(cur,pre);
        if(cur.mtime.toString()!==pre.mtime.toString()){
            cb('change');
        }
        pre = cur; //改变初始状态
    }
    var init = (function(){
        pre = getPrv(file); //首先获取pre
        event.on('change',function(){
            getCur(file);
        });
        setInterval(()=>{
            event.emit('change');
        },interval);
    })()
}
watchFile('sam.js',2000,function(eventname){
    console.log(eventname);
})

    上述,完善了一下,在指定时间内,对文件改动进行监听,和fs.watchFile不同.
    ok~ 这个out-of-date的监听方式,我们大致了解了. 接下来我们来看一下,如何使用v0.5.x版本退出的新API:fs.watch. 我们参考官网:

    fs.watch should be used instead of fs.watchFile and fs.unwatchFile when possible.

    为什么呢?
    不为什么. 因为,fs.watch调用的是native API。而fs.watchFile是调用的是fs.stat. 比起来,时间肯定会慢一点.

    那怎么使用fs.watch监听文件呢？
    先看一下API吧:
    fs.watch(filename, options):其实和fs.watchFile没差多少. 不多options里面有一个参数不同:

    { persistent: true, recursive: false }

    即，该API不仅可以监听文件,还可以监听目录.其中recursive表示递归,用来监听目录下的文件。 不过NodeJS如是说:

    The recursive option is only supported on OS X and Windows.

    懂了吧. 不过基本上, 该API的覆盖率也足够了.别告诉我,你用linxu写代码.

    const fs = require('fs');
fs.watch('..',{recursive:true},function(event,filename){
    console.log(`event is ${event} and filename is ${filename}`);
})

    在MAC OX 11完美通过. 每当保存一次,就会触发一次。不过当你修改文件名时,便会触发两次. 一次是,原文件被修改,另一次是新文件被创建.即.

    event is rename and filename is app/sam.html
event is rename and filename is app/index.html

    en~ fs模块的基本内容就介绍到这里吧~ 大家有兴趣可以参考nodeJS官网. 由于nodeJs还年轻,以后的路还很长~ 刚把得~

    fsnode.jsgulpwatchwritestream
    villainhr
    7.8k 声望2.2k 粉丝
    « 上一篇
    细数js模块机制内涵
    下一篇 »
    KOA框架铺垫之generator

    引用和评论

    被 1 篇内容引用
    推荐阅读
    头像
    如何写出一手好的小程序之多端架构篇

    villainhr赞 87阅读 10.6k评论 8

    头像
    阿里云ECS服务器部署Node.js项目全过程详解

    kovli赞 1阅读 9.1k

    头像
    SAP Fiori应用的三种部署方式

    注销赞 1阅读 5.1k

    头像
    安装vmware配置ubuntu linux环境 上篇

    ipromise赞 2阅读 2.1k

    头像
    JS工程化集锦

    specialcoder赞 2阅读 2k

    头像
    Node.js学习备案

    寒青赞 1阅读 1.6k

    头像
    运行npm update等命令出错后如何分析问题根源

    注销阅读 2.7k

    0 条评论
    得票最新