深入node.js 3 模板引擎原理 事件 文件操作 可读流的实现原理

最新推荐文章于 2023-12-01 21:58:06 发布
最新推荐文章于 2023-12-01 21:58:06 发布
阅读量532 收藏
点赞数
分类专栏： node.js系列 文章标签： node.js 前端 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lin_fightin/article/details/121690602
版权

模板引擎的实现

模板引擎是基于new Function + with 实现的。
ejs使用
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
实现：
思路：借助fs的readFile先读取文件内容，然后使用正则表达式替换掉即可。
在这里插入图片描述
在这里插入图片描述
打印的结果是一样的。
复杂的情况呢？拼接字符串，拼成想要的代码
在这里插入图片描述
在这里插入图片描述
主要难点就是在字符串的拼接，第二部分，将全文分为三部分，然后拼接对应的，如

let str = ""; 
with(obj){
str+= `<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    `
arr.forEach(item=>{
str+=`
        <li>
            ${item}
        </li>
        `
})
str+=`
</body>

</html>`}
 return str

这就是拼出来的字符串，然后再new Function,包裹一层函数，将with的obj传入，返回str。
在这里插入图片描述

大概长这样。
效果就是：
在这里插入图片描述
所以本质就是将获取到的内容，使用正则表达式匹配，拼接字符串成我们想要的内容，用with包裹，改变内部作用域，再通过new Function将str包装成一个函数，传入对应的值给obj。然后运行之后str就能正常通过作用域获取值赋值。

buffer

在服务端，需要一个东西来标识内存，但不能是字符串，因为字符串无法标识图片。node中使用buffer来标识内存的数据。他把内存转换成了16进制来显示（16进制比较短）buffer每个字节的取值范围就是0-0xff(十进制的255).
node中buffer可以和字符串任意的转换（可能出现乱码）
编码规范：ASCII -> GB8030/GBK -> unicode -> UTF8
Buffer代表的是内存，内存是一段固定空间，产生的内存是固定大小，不能随意增加。
扩容：需要动态创建一个新的内存，把内容迁移过去。
在这里插入图片描述
在这里插入图片描述
创建一个长度为5的buffer，有点像数组，但是数组可以扩展，而buffer不可以扩展。
还有一种声明buffer。在这里插入图片描述

Buffer.form。
一般使用alloc来声明一个buffer，或者把字符串转换成Buffer使用。文件操作也是采用Buffer形式。

buffer使用

无论是二进制还是16进制，表现得东西是一样的。

base64编码：

base64可以放在任何路劲的链接里，可以减少请求次数。但是文件大小会变大。比如webpack中的asset/type，把一些小的文件转换成了Base64编码内嵌到了文件当中，虽然可以减少请求次数，但也增大了文件的大小。
在这里插入图片描述
base64的来源就是将每个字节都转化为小于64的值。没有加密功能，因为规则很简单。如
在这里插入图片描述

  • 第一步：将buffer中每个位置的值转为二进制。如上。
    一个字节有八位，八位的最大值是255，有可能超过64。而base64编码是要将每个字节转化为小于64的值。所以就取每个字节的6位。6位的最大值就是2*6 - 1 = 63。也就是：
    在这里插入图片描述
  • 第二步：将38的形式转成64的，保证每个字节小于64。将其转为十进制。
    在这里插入图片描述
    在这里插入图片描述
  • 第三步，通过特定的编码规则转换即完成。
    在这里插入图片描述
    将我们获取到的十进制传入，因为每个字节都是小于64的，所以不超过。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    完成。

buffer的常用方法

除了form和alloc还有

slice
// slice
const a = Buffer.from([1,2,3,4,5])
const d = a.slice(0,2)
d[1] = 4
console.log(d);
console.log(a);

在这里插入图片描述
与数组的用法相同，但是他并不是浅复制，而是直接关联在一起。改变d也会改变a。而数组的slice是浅复制。改变原始数据的值不会改变。

copy

将Buffer的数据拷贝到另一个数据上。

const a = Buffer.from([1, 2, 3, 4, 5]);
const d = Buffer.alloc(5);
a.copy(d, 1, 2, 3); //四个参数，拷贝到哪里？从d的第一个开始拷贝 a的a[2]->a[3]
console.log(d);

copy四个参数，分别是拷贝的目标d。从d的第几个长度开始。拷贝a的第2到第3位。
所以应该是 <Buffer 00 03 00 00 00 >
在这里插入图片描述

concat

用于拼接buffer
在这里插入图片描述
在这里插入图片描述
Buffer.concat(arr, index)
第二个参数是拼接出来的Buffer的长度，如果大于原本的长度，用00填写。

Buffer.myConcat = function (
  bufferList,
  length = bufferList.reduce((a, b) => a + b.length, 0)
) {
  let bigBuffer = Buffer.alloc(length);
  let offset = 0;
  bufferList.forEach((item) => {
    //使用copy每次拷贝一份然后offset向下走。
    item.copy(bigBuffer, offset);
    offset += item.length;
  });
  return bigBuffer
};

借助copy，逐个拷贝一份即可。
在这里插入图片描述
在这里插入图片描述

文件操作

fs模块有两种基本api，同步，异步。
io操作，input，output，输入输出。
在这里插入图片描述在这里插入图片描述
读取时默认是buffer类型。
写入的时候，默认会将内容以utf8格式写入，如果文件不存在则创建。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
读取的data是Buffer类型，写入的是utf8格式。
这种读写适合小文件

读取文件某段内容的办法

在这里插入图片描述
fs.open用于打开一个文件。fs.read用来读取内容并且写入到buffer中。
在这里插入图片描述
fs.write用于将内容写入某个文件之中。如上，打开了b.txt，然后用fs.wirte。五个参数，分别是fd，buffer，从buffer的第0个位置，到buffer的第0个位置，从b.txt的第0位开始写，回调函数。

在这里插入图片描述
在这里插入图片描述
写入成功。
这种写法也不太美观，每次都需要fs.open然后fs.read或者fs.wirte，容易造成回调地狱。

流 Stream的出现

源码的实现步骤：
fs的CreateReadStrem是new了一个ReadStream，他是基于Stream的Readable类的，然后自己实现了_read方法。供Stream.prototype.read调用。

  • 1 内部会先open文件，然后直接直接继续读取操作，默认是调用了pause暂停。
  • 2 监听用户是否绑定了data事件，resume，是的话开始读取事件
  • 3 调用fs.read 将数据读取出来。
  • 4 调用this.push去emit data事件，然后判断是否可以读取更多再去读取。
    第一种： fs.readFile（需要将文件读取到磁盘中，占用内容）=>fs.wirteFile
    第二种： fs.open => fs.read => fs.write 回调地狱。
    实现读取三个字节写入三个字节。采用fs.open fs.read fs.write的方法。
    实现copy方法。
    在这里插入图片描述

看实现：在这里插入图片描述
首先创建一个三字节的Buffer。
然后使用fs.open打开要读取和要写入的文件。
在这里插入图片描述
因为我们是每三个每三个读取，所以需要采用递归方式，一直读取文件。在这里插入图片描述
直到读取完毕，调用回调函数。fs.read和fs.write的参数都是类似的，即fd,buffer,buffer的start,buffer的end，读取文件/写入文件的start、回调函数（err，真正读取到的个数/真正写入的个数）
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
现在基本实现了读一部分，写一部分，但是读写的逻辑写在一起了，需要把他拆开。

流 Stream模块

可读流

不是一下子把文件都读取完毕，而是可以控制读取的个数和读取的速率。
流的概念跟fs没有关系，fs基于stream模块底层扩展了一个文件读写方法。
在这里插入图片描述
所以fs.open,fs.read等需要的参数，createReadStream也需要、
在这里插入图片描述
返回一个对象，获取需要监听data事件。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
close事件在end事件之后触发。
由此可以看出：流的内部基于 fs.open fs.close fs.read fs.write以及事件机制。
在这里插入图片描述
暂停是不再触发data事件
在这里插入图片描述
rs.resume()是恢复。
在这里插入图片描述
在这里插入图片描述

实现readStream

从vscode调试源码得知在这里插入图片描述
实现思路：

  • createReadStream内部new了一个ReadStream的实例，ReadStream是来自于Stream模块。
  • 做一系列参数默认后， 调用this.open方法，这个方法会去调用fs.open去打开文件，打开之后触发事件，从回调的形式发布订阅模式，然后监听事件，当发现有用户注册了data事件之后，调用fs.read，j监听open事件，在open之后再去读取文件等等。
  • 这样我们的读写逻辑就分离开了，从回调的形式变成了发布订阅模式，有利于解耦。
    第一步：
    在这里插入图片描述
    第一步：参数初始化，并调用fs.open
    在这里插入图片描述
    open打开之后会触发open事件，注意，这里是异步的
    第二步： 监听用户注册的data事件，当用户注册了data事件才去调用fs.read。调用this.read的时候open还没完成。
    在这里插入图片描述

在这里插入图片描述
所以第一次read的时候需要判断，然后只监听一次open事件，重复打开read事件。
在这里插入图片描述
这个end和start配合，表示读取文件从哪到哪的位置，但是end是包后的，比如上面的end为4，实际上读取到的是5。
在这里插入图片描述
创建buffer存放读取的内容，再判断应该读取多少内容，以哪个小为准。
在这里插入图片描述
然后打开fs.read。将读取到的buffer发布出去。再次调用this.read去继续读取。在这里插入图片描述start=1,end=4，读取到2345的内容，正确。
在这里插入图片描述
不给end，每次3个3个的读取。
在这里插入图片描述
接着实现暂停，需要一个开关。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
这样就基本完成了。
在这里插入图片描述
在这里插入图片描述

总结：

一开始实现的的copy方法，也是利用fs.open, fs.read, fs.write等，通过回调的形式完成的，这样虽能完成，但是内聚度较高，容易形成回调地狱。
而基于fs模块，和events模块，实现的可读流，可以有效的解耦刚才的代码，通过发布订阅模式，在一开始订阅事件，在每个时间点对应发布事件，然后代码执行，各司其职。
open和close是文件流独有的，
可读流具备：on (‘data’ | ‘end’ | ‘error’), resume, pause这些方法。

相关代码：
// copy
const fs = require("fs");
const path = require("path");

// let buf = Buffer.alloc(3);
// //open打开一个文件，第一个参数是路劲，第二个参数是打开文件用途，第三个是回调函数。
// fs.open(path.resolve(__dirname, "a.txt"), "r", function (err, fd) {
//   // fd 是file descriptor文件描述
//   console.log("fd", fd);
//   //读取a.txt的内容，并且将内容写入buf中的第0个位置到3第三个位置，从a.txt的第六个位置开始
//   fs.read(fd, buf, 0, 3, 3, function (err, data) {
//     fs.open(path.resolve(__dirname, "./b.txt"), "w", function (err, fd2) {
//       fs.write(fd2, buf, 0, 3, 0, function (err, data2) {
//         console.log("buf", buf);
//         console.log("data2", data2);
//       });
//     });
//   });
// });

function copy(source, target, cb) {
  const BUFFER_SIZE = 3;
  const buffer = Buffer.alloc(BUFFER_SIZE);
  //每次读入文件的位置
  let r_offset = 0;
  //每次写入新文件的位置
  let w_offset = 0;

  //读取一部分数据，写入一部分数据

  //第三个参数可以是权限  权限有三个组合 rwx 可读可写可执行 r的权限是4，w的权限是2，x的权限是1  421 = 777 可写可读可执行
  // 0o666表示最大的权限，默认不用写。

  //读取的文件必须要存在。写入文件不存在会创建，如果文件有内容会清空。
  fs.open(source, "r", function (err, fd1) {
    //打开写的文件
    fs.open(target, "w", function (err, fd2) {
      //每次读取三个写入三个，回调的方式实现的功能，需要用递归
      // 同步代码则可以采用while循环

      function next() {
        fs.read(
          fd1,
          buffer,
          0,
          BUFFER_SIZE,
          r_offset,
          function (err, bytesRed) {
            // bytesRed真正读取到的个数
            if (err) {
              cb("读取失败");
              return;
            }
            if (bytesRed) {
              //将读取到的内容写入target目标
              fs.write(
                fd2,
                buffer,
                0,
                bytesRed,
                w_offset,
                function (err, written) {
                  if (err) retrun;
                  // written 真正写入的个数
                  r_offset += bytesRed; //每次写入之后，下一次读取的内容就该往前进
                  w_offset += written;
                  next();
                }
              );
            } else {
              //读取内容为空，结束
              fs.close(fd1, () => {});
              fs.close(fd2, () => {});
              cb();
            }
          }
        );
      }
      next();
    });
  });
}

copy("./a.txt", "b.txt", (err, data) => {
  console.log("copy success");
});

createStream的实现

const EventMitter = require("events");
const fs = require("fs");
class ReadStream extends EventMitter {
  constructor(path, options = {}) {
    super();
    this.path = path;
    //操作
    this.flags = options.flags || "r";
    this.encoding = options.encoding || null;
    this.autoClose = options.autoClose || true;
    this.start = options.start || 0;
    this.end = options.end || Infinity; //读取的个数，包后的，如果是1 ，就可能读取到0，1，2
    this.highWaterMark = options.highWaterMark || 64 * 1024;
    this.emitClose = options.emitClose || false;
    this.offset = this.start; // 每次读取文件的位移数

    this.flowing = true; //暂停继续开关

    this.open(); // 文件操作，注意这个方法是异步的。

    // events可以监听newListener，可以获取注册的所有事件
    this.on("newListener", function (type) {
      if (type === "data") {
        //用户订阅了data事件，才去读取。
        this.read(); //这时候文件还没open，fd为undefined。
      }
    });
  }

  pause() {
    //暂停
    this.flowing = false;
  }

  resume() {
    //继续
    if (!this.flowing) {
      this.flowing = true;
      this.read();
    }
  }

  destory(err) {
    if (err) {
      this.emit("error", err);
    }
    if (this.autoClose) {
      fs.close(this.fd, () => {
        this.emit("close");
      });
    }
  }

  read() {
    //希望在open之后打开
    if (typeof this.fd !== "number") {
      this.once("open", (fd) => {
        //之前实现的copy这段逻辑是写在了fs.open里面，换成发布订阅模式之后就可以分离出来。
        this.read(); //第二次read的时候，fd有值了
      });
    } else {
      //判断每次读取多少。因为this.end是包后的，比如start = 0, end = 1, 那么读取的就是 0 , 1, 2所以需要+1
      const howMutchToRead = Math.min(
        this.end - this.offset + 1,
        this.highWaterMark
      );
      const buffer = Buffer.alloc(howMutchToRead);
      fs.read(
        this.fd,
        buffer,
        0,
        howMutchToRead,
        this.offset,
        (err, byteRead) => {
          if (err) {
            this.destory(err);
          } else {
            if (byteRead) {
              //读取到文件，发布data事件,发送真正读取到的内容
              this.offset += byteRead;
              this.emit("data", buffer.slice(0, byteRead));
              this.flowing && this.read();
            } else {
              this.emit("end");
              if (this.autoClose) {
                this.destory();
              }
            }
          }
        }
      );
    }
  }

  open() {
    fs.open(this.path, this.flags, (err, fd) => {
      if (err) {
        //报错：
        this.destory(err);
      }
      //从回调的形式变成了发布订阅模式
      this.fd = fd;
      this.emit("open", fd);
    });
  }
}

const rs = new ReadStream("./a.txt", {
  flags: "r", //创建可读流。
  encoding: null, //默认Buffer
  autoClose: true, //自动关闭，相当于读取完毕调用fs.close
  emitClose: true, //触发close事件
  start: 0, //从文件哪里开始读取
  highWaterMark: 3, //每次读取的数据个数，默认是64*1025字节。
  //end: 4, // 比如这个就会读取 1到5的内容
});

rs.on("open", () => {
  console.log("文件打开了");
});

// rs.on("data", (data) => {
//   console.log("监听Data事件", data);
// });

// //底层还是 fs.open fs.read fs.close
// const rs = fs.createReadStream("./a.txt", {
//   flags: "r", //创建可读流。
//   encoding: null, //默认Buffer
//   autoClose: true, //自动关闭，相当于读取完毕调用fs.close
//   emitClose: true, //触发close事件
//   start: 0, //从文件哪里开始读取
//   highWaterMark: 3, //每次读取的数据个数，默认是64*1025字节。
// }); //返回一个对象

//没监听前，是非流动模式，监听后，是流动模式。

//监听data事件，并且不停触发
rs.on("data", function (chunk) {
  console.log(chunk);
  //暂停
  rs.pause();
});

rs.on("end", function () {
  console.log("读取完毕");
});

rs.on("close", function () {
  console.log("文件关闭");
});

setInterval(() => {
  console.log("一秒后");
  rs.resume();
}, 1000);
coderlin_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
NodeJS中的事件驱动程序实现原理解析
weixin_49669470的博客
09-23 876
前言 Node.js 使用事件驱动模型，当web server接收到请求，就把它关闭然后进行处理，然后去服务下一个web请求。 当这个请求完成，它被放回处理队列，当到达队列开头，这个结果被返回给用户。 这个模型非常高效可扩展性非常强，因为 webserver 一直接受请求而不等待任何读写操作。（这也称之为非阻塞式IO或者事件驱动IO） 在事件驱动模型中，会生成一个主循环来监听事件，当检测到事件时触发回调函数。 整个事件驱动的流程就是这么实现的，非常简洁。有点类似于观察者模式，事件相当于一个主题(Su
node.js:基于文件操作的crud小案例
06-16
在本教程中，我们将深入探讨如何使用Node.js、Express框架和Art-Template模板引擎实现一个简单的CRUD（创建、读取、更新、删除）应用程序，该应用以文件为数据存储，不依赖任何数据库系统。 首先，`Node.js`是基于...
理解一下Buffer.from(), Buffer.alloc()
chmldch的博客
06-18 1万+
Buffer.from(), Buffer.alloc() 都是创建一个buffer， Buffer.from()从字符串或者数组创建一个buffer, Buffer.alloc()是创建一个指定大小的buffer。 用法示例 // 从字符串创建一个buffer const buffer1 = Buffer.from('regis'); console.log(buffer1); // 输出结果 <Buffer 72 65 67 69 73> // 从一个数组创建一个buffer con
Buffer.from和Nodejs支持的字符编码
camille的专栏
04-06 2406
utf16le - 2 或 4 个字节，小字节序编码的 Unicode 字符。意思是：从一个包含指定encoding的字节中创建Buffer。二者最终都是回归到 http.ServerResponse.Use 的 response.end() 方法。utf8 - 多字节编码的 Unicode 字符。如果设置去掉高位的话，这种编码是非常快的。从语义来看，前者更适合没有任何响应数据的场景，而后者更适合于存在响应数据的场景。latin1 - 一种把 Buffer 编码成一字节编码的字符串的方式。
08-Buffer
HZ~的博客
09-09 553
Buffer初识 在引入 TypedArray 之前，JavaScript 语言没有用于读取或操作二进制数据流的机制。 Buffer 类是作为 Node.js API 的一部分引入的，用于在 TCP 流、文件系统操作、以及其他上下文中与八位字节流进行交互。这是来自 Node.js 官网的一段描述，比较晦涩难懂，总结起来一句话 Node.js 可以用来处理二进制流数据或者与之进行交互。 Buffer 用于读取或操作二进制数据流，做为 Node.js API 的一部分使用时无需 require，用于操作网络协议
Node 中文乱码 编码转换 Buffer.from
最新发布
qq_70020706的博客
12-01 506
Node 中文乱码 使用 Buffer.from 编码 转换 latin1 和utf8编码 互相转换 const text="编码" //将utf8编码 转换 为 latin1 编码 //latin1 = '编ç' const latin1 = Buffer.from(text, "utf8").toString("latin1") //将latin1 编码 转换 为 utf8 编码 //utf8 = '编码' const utf8 = Buffer.from(latin1, "latin1
Node.js-Node.js机器人平台
08-09
Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境，它让开发者能够使用 JavaScript 在服务器端编写可伸缩的网络应用。这个“Node.js-Node.js机器人平台”项目，显然旨在利用 Node.js 的特性来构建智能机器...
使用Node.js写一个代码生成器的方法步骤
10-17
总结来说，使用Node.js创建代码生成器的关键在于理解数据和模板之间的关系，选择合适的模板引擎（如nunjucks），以及利用构建工具（如gulp）来自动化处理模板编译和文件操作。这样不仅可以提高开发效率，还能灵活地...
Node.jsWeb开发实战（慕课版）-教学大纲.docx
11-07
7. **文件和目录操作**：讲解Node.js中对文件和目录的操作，包括读写、截断、删除、复制等，使学生能够处理与文件系统相关的任务。 8. **Express框架**：深入探讨Express，学习request和response对象，以及中间件的...
小程序二进制图片 buffer存储_系统性学习 Nodejs（4）——Buffer
weixin_39867559的博客
11-21 582
往期传送门Node.js 基础概念手写 require手写 events(发布订阅)Buffer 是什么在 Node 中，我们总是会遇到处理二进制数据的情况，比如文件操作、图片处理、网络 IO 等等。为了能够处理二进制数据，Node 引入了 Buffer。归根结底，Buffer 是一个存储二进制数据的特殊对象，它对外暴露了操作二进制数据的能力。计算机是如何存储数据的非科班出身的程序员可能对二进制都...
BufferForm.Designer_缓冲区分析_arcengine_
10-01
Arcengine+ Visual Studio2012 实现gis系统的缓冲区功能，非常完美的代码，质量好效率高，且容易实现。当然也请多多指教，相互学习。里面是代码。
Buffer.from()
weixin_30733003的博客
11-05 2766
Buffer.from(array) array {Array} 使用一个8位字节的数组分配一个新的 Buffer。 const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]); // creates a new Buffer containing ASCII bytes // ['b','u','f','f','e','r'] 如果...
Nodejs之Buffer数据转ReadSteam
halations的博客
09-07 3807
当要处理的是一个文件时 stream = fs.createReadStream('./content.txt') 返回一个readStream（文件读取流，输入流）对象。（可读流） 当处理的是一个Buffer时，用createReadStream就会报错 fs.createReadStream不是用来做Buffer到ReadStream的转换的。虽然它接受一个Buffer，但Buffer里面放的仍然应该是一个文件路径。它只不过帮你做了文本解码。 正确的Buffer转ReadStream的写
如何用ArrayBuffer构造一个form请求
凹凸实验室
04-21 656
本文主要介绍form数据的格式以及如何用代码手动构造一个请求。一、常用的form enctype类型：application/x-www-form-urlencodedform默认的编码方式，会编码特殊文字，也是jq等库ajax提交数据默认的编码格式multi/formdata这种方式可以提交文本+二进制格式text/plain只编码空格符，这种方式不太常用其中比较复杂的是multi/formda...
Buffer.from(str[, encoding])
weixin_30809173的博客
11-05 1571
Buffer.from(str[, encoding]) Node.js FS模块方法速查 str {String} 需要编码的字符串 encoding {String} 编码时用到，默认：'utf8' 创建一个新的 Buffer 包含给定的 JavaScript 字符串 str。如果提供 encoding 参数，将标识字符串的字符编码。如果没有提供 encoding 参数，默认为 'utf8...
js Buffer常用方法
热门推荐
chijiajing的博客
10-24 2万+
//构造 //alloc构造 10个空间 16进制格式,所以数字16显示为10 var buf1=Buffer.alloc(10,16); console.log(buf1); //allocUnsafe构造 //分配10个空间,但空间内的数据不一定为空 var buf2=Buffer.allocUnsafe(10); //类似于java里面StringBuffer的...
nodejs中的buffer的用法
vue
04-04 1894
1、buffer的介绍 在引入TypedArray之前，JavaScript 语言没有用于读取或操作二进制数据流的机制。Buffer类是作为 Node.js API 的一部分引入的，用于在 TCP 流、文件系统操作、以及其他上下文中与八位字节流进行交互。 现在可以使用TypedArray，Buffer类以更优化和更适合 Node.js 的方式实现了Uint8Array...
node中的读取流createReadStream、写入流createWriteStream和管道流pipe
12-10 9519
一、读取流createReadStream 现在在data目录下有input.txt文件，其内容很多，如下 const fs = require('fs') let readStream = fs.createReadStream('./data/input.txt'); let count = 0; let str = "" readStream.on('data', data => { str += data; count++ }) readStream.on(
精通Express.js：构建与测试Node.js应用实战
3. **视图系统与模板引擎**：探讨如何使用模板引擎如Jade（Pug）、EJS等来创建动态网页，实现数据和视图的分离。 4. **请求与响应对象**：讲解如何通过请求对象获取客户端信息，以及如何使用响应对象向客户端发送...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

coderlin_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值