请问大家: NodeJs只能做的两件事是什么？
这也能做,那也能做~
just joke~
实际上,所有后台语言都能做的两件事是： 文件操作和网络编程.
这其实是所有语言的根本。 计算机无外乎就是文件和通信。Linux中,是把一切都当做文件,如果理解了这一点那就无可厚非了.
所以,这里,我想介绍一下NodeJS中一个重要的模块--fs.
这里我给大家放一个我的框架图~
(为什么不是http? 懒~)
let's start.
针对于fs,我们切实围绕几个问题来吧~
fs是如何操作文件的？
drain和write到底是什么关系?
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.htmlen~ fs模块的基本内容就介绍到这里吧~ 大家有兴趣可以参考nodeJS官网. 由于nodeJs还年轻,以后的路还很长~ 刚把得~
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。