node.js文件操作系统实例详解

本文实例讲述了node.js文件操作。分享给大家供大家参考，具体如下：

文件读取

普通读取

同步读取

var fs = require('fs');
var data;
try{
  data = fs.readfilesync('./fileforread.txt', 'utf8');
  console.log('文件内容: ' + data);
}catch(err){
  console.error('读取文件出错: ' + err.message);
}

输出如下：

/usr/local/bin/node readfilesync.js
文件内容: hello world

异步读取

var fs = require('fs');
fs.readfile('./fileforread.txt', 'utf8', function(err, data){
  if(err){
    return console.error('读取文件出错: ' + err.message);
  }
  console.log('文件内容: ' + data);
});

输出如下

/usr/local/bin/node readfile.js
文件内容: hello world

通过文件流读取

适合读取大文件

var fs = require('fs');
var readstream = fs.createreadstream('./fileforread.txt', 'utf8');
readstream
  .on('data', function(chunk) {
    console.log('读取数据: ' + chunk);
  })
  .on('error', function(err){
    console.log('出错: ' + err.message);
  })
  .on('end', function(){ // 没有数据了
    console.log('没有数据了');
  })
  .on('close', function(){ // 已经关闭，不会再有事件抛出
    console.log('已经关闭');
  });

输出如下

/usr/local/bin/node createreadstream.js
读取数据: hello world
没有数据了
已经关闭

文件写入

备注：以下代码，如果文件不存在，则创建文件；如果文件存在，则覆盖文件内容；

异步写入

var fs = require('fs');
fs.writefile('./fileforwrite.txt', 'hello world', 'utf8', function(err){
  if(err) throw err;
  console.log('文件写入成功');
});

同步写入

var fs = require('fs');
try{
  fs.writefilesync('./fileforwrite1.txt', 'hello world', 'utf8');
  console.log('文件写入成功');
}catch(err){
  throw err;
}

通过文件流写入

var fs = require('fs');
var writestream = fs.createwritestream('./fileforwrite1.txt', 'utf8');
writestream
  .on('close', function(){ // 已经关闭，不会再有事件抛出
    console.log('已经关闭');
  });
writestream.write('hello');
writestream.write('world');
writestream.end('');

相对底层的接口

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

• fd：写入的文件句柄。
• buffer：写入的内容。
• offset：将buffer从offset位置开始，长度为length的内容写入。
• length：写入的buffer内容的长度。
• position：从打开文件的position处写入。
• callback：参数为 (err, written, buffer)。written表示有xx字节的buffer被写入。

备注：fs.write(fd, buffer, offset, length[, position], callback)跟fs.write(fd, data[, position[, encoding]], callback)的区别在于：后面的只能把所有的data写入，而前面的可以写入指定的data子串？

文件是否存在

fs.exists()已经是deprecated状态，现在可以通过下面代码判断文件是否存在。

var fs = require('fs');
fs.access('./fileforread.txt', function(err){
  if(err) throw err;
  console.log('fileforread.txt存在');
});
fs.access('./fileforread2.txt', function(err){
  if(err) throw err;
  console.log('fileforread2.txt存在');
});

fs.access()除了判断文件是否存在（默认模式），还可以用来判断文件的权限。

备忘：fs.constants.f_ok等常量无法获取（node v6.1，mac 10.11.4下，fs.constants是undefined）

创建目录

异步版本（如果目录已存在，会报错）

var fs = require('fs');
fs.mkdir('./hello', function(err){
  if(err) throw err;
  console.log('目录创建成功');
});

同步版本

var fs = require('fs');
fs.mkdirsync('./hello');

删除文件

var fs = require('fs');
fs.unlink('./fileforunlink.txt', function(err){
  if(err) throw err;
  console.log('文件删除成功');
});
var fs = require('fs');
fs.unlinksync('./fileforunlink.txt');

创建目录

// fs.mkdir(path[, mode], callback)
var fs = require('fs');
fs.mkdir('sub', function(err){
  if(err) throw err;
  console.log('创建目录成功');
});
// fs.mkdirsync(path[, mode])
var fs = require('fs');
try{
  fs.mkdirsync('hello');
  console.log('创建目录成功');
}catch(e){
  throw e;
}

遍历目录

同步版本，注意：fs.readdirsync()只会读一层，所以需要判断文件类型是否目录，如果是，则进行递归遍历。

// fs.readdirsync(path[, options])
var fs = require('fs');
var path = require('path');
var getfilesindir = function(dir){
  var results = [ path.resolve(dir) ];
  var files = fs.readdirsync(dir, 'utf8');
  files.foreach(function(file){
    file = path.resolve(dir, file);
    var stats = fs.statsync(file);
    if(stats.isfile()){
      results.push(file);
    }else if(stats.isdirectory()){
      results = results.concat( getfilesindir(file) );
    }
  });
  return results;
};
var files = getfilesindir('../');
console.log(files);

异步版本：（todo）

文件重命名

// fs.rename(oldpath, newpath, callback)
var fs = require('fs');
fs.rename('./hello', './world', function(err){
  if(err) throw err;
  console.log('重命名成功');
});
fs.renamesync(oldpath, newpath)
var fs = require('fs');
fs.renamesync('./world', './hello');

监听文件修改

fs.watch()比fs.watchfile()高效很多（why）

fs.watchfile()

实现原理：轮询。每隔一段时间检查文件是否发生变化。所以在不同平台上表现基本是一致的。

var fs = require('fs');
var options = {
  persistent: true, // 默认就是true
  interval: 2000 // 多久检查一次
};
// curr, prev 是被监听文件的状态, fs.stat实例
// 可以通过 fs.unwatch() 移除监听
fs.watchfile('./fileforwatch.txt', options, function(curr, prev){
  console.log('修改时间为: ' + curr.mtime);
});

修改fileforwatch.txt，可以看到控制台下打印出日志

/usr/local/bin/node watchfile.js
修改时间为: sat jul 16 2016 19:03:57 gmt+0800 (cst)
修改时间为: sat jul 16 2016 19:04:05 gmt+0800 (cst)

为啥子？莫非单纯访问文件也会触发回调？

if you want to be notified when the file was modified, not just accessed, you need to compare curr.mtime and prev.mtime.

在 v0.10 之后的改动。如果监听的文件不存在，会怎么处理。如下

note: when an fs.watchfile operation results in an enoent error, it will invoke the listener once, with all the fields zeroed (or, for dates, the unix epoch). in windows, blksize and blocks fields will be undefined, instead of zero. if the file is created later on, the listener will be called again, with the latest stat objects. this is a change in functionality since v0.10.

fs.watch()

fs.watch(filename[, options][, listener]) fs.unwatchfile(filename[, listener])

这接口非常不靠谱（当前测试用的v6.1.0），参考

fs.watch(filename[, options][, listener])#

注意：fs.watch()这个接口并不是在所有的平台行为都一致，并且在某些情况下是不可用的。recursive这个选项只在mac、windows下可用。

问题来了：

1. 不一致的表现。
2. 不可用的场景。
3. linux上要recursive咋整。

the fs.watch api is not 100% consistent across platforms, and is unavailable in some situations. the recursive option is only supported on os x and windows.

备忘，不可用的场景。比如网络文件系统等。

for example, watching files or directories can be unreliable, and in some cases impossible, on network file systems (nfs, smb, etc), or host file systems when using virtualization software such as vagrant, docker, etc.

另外，listener回调有两个参数，分别是event、filename。其中，filename仅在linux、windows上会提供，并且不是100%提供，所以，尽量不要依赖filename。

在linux、osx上，fs.watch()监听的是inode。如果文件被删除，并重新创建，那么删除事件会触发。同时，fs.watch()监听的还是最初的inode。（api的设计就是这样的）

结论：怎么看都感觉这个api很不靠谱，虽然性能比fs.watchfile()要高很多。

先来个例子，在osx下测试了一下，简直令人绝望。。。无论是创建、修改、删除文件，evt都是rename。。。

var fs = require('fs');
var options = {
  persistent: true,
  recursive: true,
  encoding: 'utf8'
};
fs.watch('../', options, function(event, filename){
  console.log('触发事件:' + event);
  if(filename){
    console.log('文件名是: ' + filename);
  }else{
    console.log('文件名是没有提供');
  }
});

修改下fileforwatch.txt，看到下面输出。。。感觉打死也不想用这个api。。。

贴下环境：osx 10.11.4, node v6.1.0。

触发事件:rename
文件名是: fs/fileforwatch.txt___jb_bak___
触发事件:rename
文件名是: fs/fileforwatch.txt
触发事件:rename
文件名是: fs/fileforwatch.txt___jb_old___
触发事件:rename
文件名是: .idea/workspace.xml___jb_bak___
触发事件:rename
文件名是: .idea/workspace.xml
触发事件:rename
文件名是: .idea/workspace.xml___jb_old___

修改所有者

参考linux命令行，不举例子了。。。

fs.chown(path, uid, gid, callback) fs.chownsync(path, uid, gid) fs.fchown(fd, uid, gid, callback) fs.fchownsync(fd, uid, gid)

修改权限

可以用fs.chmod()，也可以用fs.fchmod()。两者的区别在于，前面传的是文件路径，后面传的的文件句柄。

1. fs.chmod)、fs.fchmod()区别：传的是文件路径，还是文件句柄。
2. fs.chmod()、fs.lchmod()区别：如果文件是软连接，那么fs.chmod()修改的是软连接指向的目标文件；fs.lchmod()修改的是软连接。

fs.chmod(path, mode, callback) fs.chmodsync(path, mode)

fs.fchmod(fd, mode, callback) fs.fchmodsync(fd, mode)

fs.lchmod(path, mode, callback)# fs.lchmodsync(path, mode)

例子：

var fs = require('fs');
fs.chmod('./fileforchown.txt', '777', function(err){
  if(err) console.log(err);
  console.log('权限修改成功');
});

同步版本：

var fs = require('fs');
fs.chmodsync('./fileforchown.txt', '777');

获取文件状态

区别：

• fs.stat() vs fs.fstat()：传文件路径 vs 文件句柄。
• fs.stat() vs fs.lstat()：如果文件是软链接，那么fs.stat()返回目标文件的状态，fs.lstat()返回软链接本身的状态。

fs.stat(path, callback) fs.statsync(path)

fs.fstat(fd, callback) fs.fstatsync(fd)

fs.lstat(path, callback) fs.lstatsync(path)

主要关注class: fs.stats。

首先是方法

• stats.isfile() -- 是否文件
• stats.isdirectory() -- 是否目录
• stats.isblockdevice() -- 什么鬼
• stats.ischaracterdevice() -- 什么鬼
• stats.issymboliclink() (only valid with fs.lstat()) -- 什么鬼
• stats.isfifo() -- 什么鬼
• stats.issocket() -- 是不是socket文件

官网例子：

{
 dev: 2114,
 ino: 48064969,
 mode: 33188,
 nlink: 1,
 uid: 85,
 gid: 100,
 rdev: 0,
 size: 527,
 blksize: 4096,
 blocks: 8,
 atime: mon, 10 oct 2011 23:24:11 gmt, // 访问时间
 mtime: mon, 10 oct 2011 23:24:11 gmt, // 文件内容修改时间
 ctime: mon, 10 oct 2011 23:24:11 gmt, // 文件状态修改时间
 birthtime: mon, 10 oct 2011 23:24:11 gmt // 创建时间
}

• atime：access time // 访问时间
• mtime:: modified time // 文件内容修改时间
• ctime: changed time. // 文件状态修改时间，比如修改文件所有者、修改权限、重命名等
• birthtime: birth time // 创建时间。在某些系统上是不可靠的，因为拿不到。

例子：

var fs = require('fs');
var gettimedesc = function(d){
  return [d.getfullyear(), d.getmonth()+1, d.getdate()].join('-') + ' ' + [d.gethours(), d.getminutes(), d.getseconds()].join(':');
};
fs.stat('./fileforstat.txt', function(err, stats){
  console.log('文件大小: ' + stats.size);
  console.log('创建时间: ' + gettimedesc(stats.birthtime));
  console.log('访问时间: ' + gettimedesc(stats.atime));
  console.log('修改时间: ' + gettimedesc(stats.mtime));
});

输出如下：

/usr/local/bin/node stat.js
文件大小: 3613
创建时间: 2016-7-16 12:40:49
访问时间: 2016-7-16 12:40:49
修改时间: 2016-7-16 12:40:49

process finished with exit code 0

同步的例子：

var fs = require('fs');
var gettimedesc = function(d){
  return [d.getfullyear(), d.getmonth()+1, d.getdate()].join('-') + ' ' + [d.gethours(), d.getminutes(), d.getseconds()].join(':');
};
var stats = fs.statsync('./fileforstat.txt');
console.log('文件大小: ' + stats.size);
console.log('创建时间: ' + gettimedesc(stats.birthtime));
console.log('访问时间: ' + gettimedesc(stats.atime));
console.log('修改时间: ' + gettimedesc(stats.mtime));

访问/权限检测

例子：

// fs.access(path[, mode], callback)
var fs = require('fs');
fs.access('./fileforaccess.txt', function(err){
  if(err) throw err;
  console.log('可以访问');
});

同步版本：

// fs.accesssync(path[, mode])
var fs = require('fs');
// 如果成功，则返回undefined，如果失败，则抛出错误（什么鬼）
try{
  fs.accesssync('./fileforaccess.txt');
}catch(e){
  throw(e);
}

文件打开/关闭

比较底层的接口，实际需要用到的机会不多。需要用到的时候看下文档就行。

• flags：文件打开模式，比如r、r+、w、w+等。可选模式非常多。
• mode：默认是666，可读+可写。

fs.open(path, flags[, mode], callback) fs.opensync(path, flags[, mode]) fs.close(fd, callback) fs.closesync(fd)

文件读取（底层）

相对底层的读取接口，参数如下

• fd：文件句柄。
• buffer：将读取的文件内容写到buffer里。
• offset：buffer开始写入的位置。（在offset开始写入，还是offset+1？）
• length：要读取的字节数。
• position：文件从哪个位置开始读取。如果是null，那么就从当前位置开始读取。（读取操作会记录下上一个位置）

此外，callback的回调参数为(err, bytesread, buffer)

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

追加文件内容

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

• file：可以是文件路径，也可以是文件句柄。（还可以是buffer？）
• data：要追加的内容。string或者buffer。
• options
  • encoding：编码，默认是utf8
  • mode：默认是0o666
  • flag：默认是a

注意：如果file是文件句柄，那么

• 开始追加数据前，file需要已经打开。
• file需要手动关闭。

var fs = require('fs');
fs.appendfile('./extra/fileforappend.txt', 'helo', 'utf8', function(err){
  if(err) throw err;
  console.log('append成功');
});

文件内容截取

fs.truncate(path, len, callback) fs.truncatesync(path, len)

fs.ftruncate(fd, len, callback) fs.ftruncatesync(fd, len)

用途参考。

要点：

• offset不会变化。比如通过fs.read()读取文件内容，就需要特别注意。
• 如果len小于文件内容长度，剩余文件内容部分会丢失；如果len大于文件内容长度，那么超出的部分，会用\0进行填充。
• 如果传的是文件路径，需要确保文件是可写的；如果传的是文件句柄，需要确保文件句柄已经打开并且可写入。

the truncate() and ftruncate() functions cause the regular file named by path or referenced by fd to be truncated to a size of precisely length bytes.

if the file previously was larger than this size, the extra data is lost. if the file previously was shorter, it is extended, and the extended part reads as null bytes ('\0').

the file offset is not changed.

with ftruncate(), the file must be open for writing; with truncate(), the file must be writable.

修改文件属性（时间）

• path/fd：文件路径/文件句柄
• atime：access time。上一次访问文件数据的时间。
• mtime：modified time。修改时间。

fs.utimes(path, atime, mtime, callback) fs.utimessync(path, atime, mtime)

fs.futimes(fd, atime, mtime, callback) fs.futimessync(fd, atime, mtime)

备注，在命令行下可以

• 通过stat查看文件的状态信息，包括了上面的atime、mtime。
• 通过touch修改这几个时间。

创建文件链接

fs.symlink(target, path[, type], callback) fs.symlinksync(target, path[, type])

fs.link(srcpath, dstpath, callback) fs.linksync(srcpath, dstpath)

link() creates a new link (also known as a hard link) to an existing file.

软链接、硬链接区别：参考 或者 [这个]。()

• 硬链接：inode相同，多个别名。删除一个硬链接文件，不会影响其他有相同inode的文件。
• 软链接：有自己的inode，用户数据块存放指向文件的inode。

参考。

创建临时目录

fs.mkdtemp(prefix, callback) fs.mkdtempsync(prefix)

备忘：跟普通的随便找个目录，创建个随机名字的文件夹，有什么区别？

代码示例如下：

var fs = require('fs');
fs.mkdtemp('/tmp/', function(err, folder){
  if(err) throw err;
  console.log('创建临时目录: ' + folder);
});

输出如下：

/usr/local/bin/node mkdtemp.js
创建临时目录: /tmp/cxw51o

找出软连接指向的真实路径

fs.readlink(path[, options], callback) fs.readlinksync(path[, options])

如下面例子，创建了个软链接指向fileforreadlink.txt，通过fs.readlink()就可以找出原始的路径。

var fs = require('fs');
var randomfilename = './extra/fileforreadlink-' + string(math.random()).slice(2, 6) + '.txt';
fs.symlinksync('./extra/fileforreadlink.txt', randomfilename);
fs.readlink(randomfilename, 'utf8', function(err, linkstring){
  if(err) throw err;
  console.log('链接文件内容: ' + linkstring);
});

类似终端下直接运行readlink。对于软链接文件，效果同上面代码。对于硬链接，没有输出。

➜  extra git:(master) ✗ readlink fileforreadlink-9827.txt
./extra/fileforreadlink.txt
➜  extra git:(master) ✗ readlink fileforlinkhard.txt
➜  extra git:(master) ✗ readlink fileforlinksoft.txt
./extra/fileforlink.txt

真实路径

fs.realpath(path[, options], callback) fs.realpathsync(path[, options])

例子：（不能作用于软链接？）

var fs = require('fs');
var path = require('path');
// fileforrealpath1.txt 是普通文件,正常运行
fs.realpath('./extra/inner/fileforrealpath1.txt', function(err, resolvedpath){
  if(err) throw err;
  console.log('fs.realpath: ' + resolvedpath);
});
// fileforrealpath.txt 是软链接, 会报错,提示找不到文件
fs.realpath('./extra/inner/fileforrealpath.txt', function(err, resolvedpath){
  if(err) throw err;
  console.log('fs.realpath: ' + resolvedpath);
});
console.log( 'path.resolve: ' + path.resolve('./extra/inner/fileforrealpath.txt') );

输出如下：

path.resolve: /users/a/documents/git-code/git-blog/demo/2015.05.21-node-basic/fs/extra/inner/fileforrealpath.txt
fs.realpath: /users/a/documents/git-code/git-blog/demo/2015.05.21-node-basic/fs/extra/inner/fileforrealpath1.txt
/users/a/documents/git-code/git-blog/demo/2015.05.21-node-basic/fs/realpath.js:12
    if(err) throw err;
            ^
error: enoent: no such file or directory, realpath './extra/inner/fileforrealpath.txt'
    at error (native)
process finished with exit code 1

删除目录

fs.rmdir(path, callback) fs.rmdirsync(path)

例子如下：

var fs = require('fs');
fs.rmdir('./dirforremove', function(err){
  if(err) throw err;
  console.log('目录删除成功');
});

不常用

缓冲区内容写到磁盘

fs.fdatasync(fd, callback) fs.fdatasyncsync(fd)

可以参考这里：

1、sync函数 sync函数只是将所有修改过的块缓冲区排入写队列，然后就返回，它并不等待实际写磁盘操作结束。 通常称为update的系统守护进程会周期性地（一般每隔30秒）调用sync函数。这就保证了定期冲洗内核的块缓冲区。命令sync(1)也调用sync函数。
2、fsync函数 fsync函数只对由文件描述符filedes指定的单一文件起作用，并且等待写磁盘操作结束，然后返回。 fsync可用于数据库这样的应用程序，这种应用程序需要确保将修改过的块立即写到磁盘上。
3、fdatasync函数 fdatasync函数类似于fsync，但它只影响文件的数据部分。而除数据外，fsync还会同步更新文件的属性。 对于提供事务支持的数据库，在事务提交时，都要确保事务日志（包含该事务所有的修改操作以及一个提交记录）完全写到硬盘上，才认定事务提交成功并返回给应用层。

待确认

1. 通篇的mode，待确认。
2. fs.access()更多用法（涉及 fs.constants.f_ok等权限）

希望本文所述对大家node.js程序设计有所帮助。