Detailed interpretation of file system and streams in nodeJs

This article mainly introduces the detailed explanation of nodeJs file system (fs) and stream (stream). Now I share it with you and give you a reference.

1. Introduction

This article will introduce some API and parameter usage of node.js file system (fs) and stream (stream).

2. Directory

The file system will introduce the following methods:

1.fs.readFile

2.fs.writeFile

3.fs.open

4.fs.read

5.fs.stat

6.fs.close

7.fs.mkdir

8.fs.rmdir

9.fs.readdir

10.fs.unlink

Four types of stream Events for readable, writable, duplex, transform and stream objects.

3. Introduction to the main methods of file system fs

1. fs.readFile

The readFile method mainly reads the file content and operates asynchronously.

var fs = require('fs')
fs.readFile('a.txt',function(err,data){
  if (err){
    return console.error(err);
  }else{
    console.log("异步读取: " + data.toString());
  }
})

2. fs.writeFile

writeFile writes the file asynchronously, fs.writeFile(file, data[, options], callback)

var fs = require('fs')
console.log("准备写入文件")
fs.writeFile('input.txt',"写入的内容",function(err){
  if (err){
    return console.error(err);
  }else{
    console.log("写入成功");
  }
})

3. fs.open()

Open the file in asynchronous mode, fs.open(path, flags[, mode], callback)

var fs = require("fs");
// 异步打开文件
console.log("准备打开文件");
fs.open('a.txt', 'r+', function(err, fd) {//r+是以读写模式打开，fd为返回的文件描述符
  if (err) {
    return console.error(err);
  }
 console.log("文件打开成功！");   
});

4, fs.read()

This method reads files in asynchronous mode, format: fs.read(fd, buffer, offset, length, position, callback)

var fs = require("fs");
var buf = new Buffer(1024);

console.log("准备打开文件！");
fs.open('at.txt', 'r+', function(err, fd) {
  if (err) {
    return console.error(err);
  }
  fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
   if (err){
     console.log(err);
   }
   // 仅输出读取的字节
   if(bytes > 0){
     console.log(buf.slice(0, bytes).toString());
   }
  });
});

5, fs.stat()

This method obtains file information asynchronously. The format is: fs.stat(path, callback)

fs.stat('fs.js', function (err, stats) {
  console.log(stats.isFile());     //true
})

There are many methods for asynchronously returned instances of the stats class, such as stats.isFile() to determine whether it is a file, stats. isDirectory() determines whether it is a directory. . . . . .

6. fs.close()

fs.close() closes the file asynchronously. The syntax format is: fs.close(fd, callback). The parameters are as follows:

d - The file descriptor returned by the fs.open() method.

callback - callback function, no parameters.

7. fs.mkdir()

This method is to create a directory, the format is: fs.mkdir(path[, mode], callback), the parameters are as follows:

path :path.

mode: Directory permissions, default 0777.

callback: callback, no parameters.

var fs = require("fs");
console.log("创建目录/test/");
fs.mkdir("/test/",function(err){
  if (err) {
    return console.error(err);
  }
  console.log("创建/test目录成功。");
});

8, fs.rmdir()

Delete directory, syntax format: fs.rmdir(path,callback)

9, fs.readdir()

This method is to read the directory, the syntax format is: fs.readdir(path, callback), the callback function has two parameters, the first is err, and the second is the file array files in the directory.

var fs = require("fs");

console.log("查看 /tmp 目录");
fs.readdir("/tmp/",function(err, files){
  if (err) {
    return console.error(err);
  }
  files.forEach( function (file){
    console.log( file );
  });
});

10. fs.unlink()

This method is used to delete files, format: fs.unlink(path, callback)

var fs = require("fs");

console.log("准备删除文件！");
fs.unlink('input.txt', function(err) {
  if (err) {
    return console.error(err);
  }
  console.log("文件删除成功！");
});

4. stream Introduction to stream types and events

1. Stream: Stream is an abstract interface. There are four stream types:

1. readable: readable;

2. writable: writable operation;

3. duplex: readable and writable operation;

4. transform: operation Data is written and the result is read.

All stream objects are instances of EventEmitter. Common events are:

1. data: Triggered when data is readable,

2. end: Triggered when no data is readable,

3. error: Triggered when an error occurs,

4. finish: Complete trigger.

2. Read data from the stream

var fs = require("fs");
var data = '';

// 创建可读流
var readerStream = fs.createReadStream('input.txt');

// 设置编码为 utf8。
readerStream.setEncoding('UTF8');

// 处理流事件 --> data, end, and error
readerStream.on('data', function(chunk) {
  data += chunk;
});

readerStream.on('end',function(){
  console.log(data);
});

readerStream.on('error', function(err){
  console.log(err.stack);
});

console.log("程序执行完毕");

3. Write to the stream:

var fs = require("fs");
var data = '写入流数据';

// 创建一个可以写入的流，写入到文件 output.txt 中
var writerStream = fs.createWriteStream('output.txt');

// 使用 utf8 编码写入数据
writerStream.write(data,'UTF8');

// 标记文件末尾
writerStream.end();

// 处理流事件 --> data, end, and error
writerStream.on('finish', function() {
  console.log("写入完成。");
});

writerStream.on('error', function(err){
  console.log(err.stack);
});

console.log("程序执行完毕");

4. Pipe stream (pipe)

var fs = require("fs");

// 创建一个可读流
var readerStream = fs.createReadStream('input.txt');

// 创建一个可写流
var writerStream = fs.createWriteStream('output.txt');

// 管道读写操作
// 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中
readerStream.pipe(writerStream);
console.log("程序执行完毕");

5. Chained flow

Chaining is a mechanism that connects the output stream to another stream and creates multiple stream operation chains. Chained flows are generally used for pipeline operations.

Next we will use pipes and chains to compress and decompress files.

//压缩
var fs = require("fs");
var zlib = require('zlib');

// 压缩 input.txt 文件为 input.txt.gz
fs.createReadStream('input.txt')
 .pipe(zlib.createGzip())
 .pipe(fs.createWriteStream('input.txt.gz'));
console.log("文件压缩完成。");

//解压
var fs = require("fs");
var zlib = require('zlib');
// 解压 input.txt.gz 文件为 input.txt
fs.createReadStream('input.txt.gz')
 .pipe(zlib.createGunzip())
 .pipe(fs.createWriteStream('input.txt'));
console.log("文件解压完成。");

The above is what I compiled for everyone. I hope it will be helpful to everyone in the future.

Related articles:

How to implement panda tv navigation using jquery css3

How to implement timed hiding dialog boxes in jQuery

How to implement DIV delay for a few seconds before disappearing or displaying in JS/jQuery

Use native js to realize three-level linkage of provinces and municipalities

Use vue basics to create add, delete, modify and query

Detailed answers to JS operation clipboard

vue-router project Practical combat (detailed tutorial)

The above is the detailed content of Detailed interpretation of file system and streams in nodeJs. For more information, please follow other related articles on the PHP Chinese website!