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),参考 https://github.com/nodejs/node/issues/7420

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)

用途参考linux说明文档

要点:

  • 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.

软链接、硬链接区别:参考 或者 [这个]。(https://www.jb51.net/article/96135.htm)

  • 硬链接: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程序设计有所帮助。

(0)

相关推荐

  • Node.js中文件操作模块File System的详细介绍

    File System的缩写是fs,该模块提供本地文件的读写能力. Nodejs导入文件系统模块(fs)语法如下所示: var fs = require("fs"); 异步和同步 Node.js文件系统(fs模块)模块中的方法均有异步和同步版本,例如读取文件内容的函数有异步的fs.readFile()和同步的fs.readFileSync() . 异步的方法函数最后一个参数为回调函数,回调函数的第一个参数包含了错误信息(error).同步则没有回调函数. 建议大家是用异步方法,比起同步

  • node.js中fs文件系统目录操作与文件信息操作

    目录操作 如果存在该目录,就创建失败 同步创建目录fs.mkdirSync(path, [mode]) const fs = require('fs'); let mkdir = './mkdir'; fs.mkdir(mkdir, (err) => { if (err) { console.log(`mkdir ${mkdir} file failed~`); } else { console.log(`mkdir ${mkdir} file success~`); } }); 读取目录 如果

  • 从零学习node.js之文件操作(三)

    一.文件操作 在文件操作里,主要是有文件读写,创建.移动文件等. 1.1 读取文件 读取文本文件时,如.txt, .js, .json等文件,直接使用readFile就可以获取文件的内容. // server.js var fs = require('fs'); fs.readFile('./data.txt', 'utf-8', function(err, data){ if(err) throw err; console.log(data); }); 读取图片时,我们是不能直接输出到控制台中

  • Node.js文件操作详解

    Node有一组数据流API,可以像处理网络流那样处理文件,用起来很方便,但是它只允许顺序处理文件,不能随机读写文件.因此,需要使用一些更底层的文件系统操作. 本章覆盖了文件处理的基础知识,包括如何打开文件,读取文件某一部分,写数据,以及关闭文件. Node的很多文件API几乎是UNIX(POSIX)中对应文件API 的翻版,比如使用文件描述符的方式,就像UNIX里一样,文件描述符在Node里也是一个整型数字,代表一个实体在进程文件描述符表里的索引. 有3个特殊的文件描述符--1,2和3.他们分别

  • Node.js中常规的文件操作总结

    前言 Node.js 提供一组类似 UNIX(POSIX)标准的文件操作API. Node 导入文件系统模块(fs)语法如下所示: var fs = require("fs") fs模块是文件操作的封装,它提供了文件的读取.写入.更名.删除.遍历目录.链接等POSIX文件系统操作.与其他模块不同的是,fs模块中所有的操作都提供了异步和同步的两个版本,例如读取文件内容的函数有异步的fs.readFile()和同步的fs.readFileSync() . 一. 目录操作 1. 创建目录 创

  • Node.js文件操作方法汇总

    Node.js和其他语言一样,也有文件操作.先不说node.js中的文件操作,其他语言的文件操作一般也都是有打开.关闭.读.写.文件信息.新建删除目录.删除文件.检测文件路径等.在node.js中也是一样,也都是这些功能,可能就是api与其他语言不太一样. 一.同步.异步打开关闭 /** * Created by Administrator on 2016/3/21. */ var fs=require("fs"); //同步读 fs.openSync = function(path,

  • 基于node.js的fs核心模块读写文件操作(实例讲解)

    node.js 里fs模块 常用的功能 实现文件的读写 目录的操作 - 同步和异步共存 ,有异步不用同步 - fs.readFile 都不能读取比运行内存大的文件,如果文件偏大也不会使用readFile方法 - 文件大分流读取,stream - 引入fs模块 - let fs=require('fs') 同步读取文件 -fs.readFileSync('路径',utf8); let result=fs.readFileSync('./1.txt','utf8'); 异步读取文件,用参数err捕获

  • Node.js程序中的本地文件操作用法小结

    Node最引以为傲的就是它有一个非常小的核心.有一些语言绑定了完整的POSIX API,而 Node实现了尽可能少的绑定,并通过同步.异步或流API形式暴露他们. 这种方法意味着,操作系统中有一些非常方便的功能,需要在Node中重建.这是一个教你如何使用文件系统软件包的实用教程. 引用文件 与文件系统的交互很重要的一点是要指向正确的文件.由于NPM的包使用相对路径引用,所以你不能把路径写死在代码.有两个主要方式来以确保包能引用到正确的文件: // 使用 `path.join()` 而不是 `+`

  • 详解Node.js读写中文内容文件操作

    由于Node.js仅支持如下编码:utf8, ucs2, ascii, binary, base64, hex,并不支持中文GBK或GB2312之类的编码, 因此如果要读写GBK或GB2312格式的文件的中文内容,必须要用额外的模块:iconv-lite 1.安装模块:npm install iconv-lite 2.演示代码,把下面的代码复制到一个文件中,假设是ch.js(注意:js文件必须保存为utf8编码格式): // 加载File System读写模块 var fs = require(

  • Node.js Streams文件读写操作详解

    Node.js 天生异步和事件驱动,非常适合处理 I/O 相关的任务.如果你在处理应用中 I/O 相关的操作,你可以利用 Node.js 中的流(stream).因此,我们先具体看看流,理解一下它们是怎么简化 I/O 操作的吧. 流是什么 流是 unix 管道,让你可以很容易地从数据源读取数据,然后流向另一个目的地. 简单来说,流不是什么特别的东西,它只是一个实现了一些方法的 EventEmitter .根据它实现的方法,流可以变成可读流(Readable),可写流(Writable),或者双向

  • Node.js本地文件操作之文件拷贝与目录遍历的方法

    文件拷贝 NodeJS 提供了基本的文件操作 API,但是像文件拷贝这种高级功能就没有提供,因此我们先拿文件拷贝程序练手.与 copy 命令类似,我们的程序需要能接受源文件路径与目标文件路径两个参数. 小文件拷贝 我们使用 NodeJS 内置的 fs 模块简单实现这个程序如下. var fs = require('fs'); function copy(src, dst) { fs.writeFileSync(dst, fs.readFileSync(src)); } function main

随机推荐