<Node.js实战 > 笔记

第一章进入Node世界

事件驱动->> EventLoop
非阻塞I/O模型 ->>异步I/O

2005年 Ajax革命后, JS变成被人们用来编写真正的,重要的程序的语言

2008年 Chrome发布 V8诞生, JS性能大幅提升

Node本身由于异步I/O的使用, 可以让服务器随时处于响应状态.

第三章 Node编程基础

3.1 Node功能的组织和重用

Node新手要面对的两个难题:

如何组织代码
如何做异步编程

避免影响全剧作用域

PHP使用命名空间
Ruby通过模块
Node模块打包

// 导出 pMoudle.js
exports.printName = function(name){
    return `${name} printed`
}

// 引入, 参数是文件的相对路径, 也可以是绝对路径
var pMoudle  = require('./pMoudle.js')

// 使用
pMoudle.printName('dhy')

注意:

如果你创建了一个既有exports又有module.exports 的模块，那它会返回module.exports，而exports会被忽略。

exports只是对module.exports的一个全局引用，最初被定义为一个可以添加属性的空对象。所以exports.myFunc只是 module.exports.myFunc的简写。

使用node_modules就可以免除使用相对路径的引入方式.

两个模块引用相同的模块, 第二个文件就不用去访问和计算模块的源文件了. 实际上第二个引入有机会修改缓存的数据。

3.2 异步编程的技术

响应逻辑

回调: 通常用来定义一次性响应的逻辑
事件监听: 本质上也是一个回调, 不同的是,它跟一个概念实体相关联.

回调:

var net = require("net");
var server = net.createServer(socket => {
  socket.on("data", data => {
    socket.write(data);
  });
});

事件监听:

var EventEmitter = require("event").EventEmitter;
var channel = new EventEmitter();
// 监听事件
channel.on("join", e => {
  console.log("Welcome!" + e);
});

// 发射事件
channel.emit("join", "dhy");

3.3 异步逻辑序列化

串行: 一个接着一个做
并行: 不需要一个接着一个, 多个任务可以同时执行.

串行的使用场景: 随机选择RSS预定源中获取一篇文章的标题和URL,并显示出来.

读取预定源URL列表的文件
解析文件内容
向预定源发送HTTP请求获取数据
解析得到的数据, 得到标题和URL

以上每一步的操作,都依赖于上一步的结果.

示例代码

var fs = require("fs");
var request = require("request");
var htmlparser = require("htmlparser");
var configFilename = "./rss_feeds.txt";

function checkForRSSFile() {
  fs.exists(configFilename, function(exists) {
    if (!exists) {
      return next(new Error("Missing RSS file:" + configFilename));
    }
    next(null, configFilename);
  });
}

function readRSSFile(configFilename) {
  fs.readFile(configFilename, (err, feedList) => {
    if (err) return next(err);

    feedList = feedList
      .toString()
      .replace(/^\s+|\s+$/g, "")
      .split("\n");
    var random = Math.floor(Math.random() * feedList.length);
    next(null, feedList[random]);
  });
}

function downloadRSSFeed(feedUrl) {
  request({ uri: feedUrl }, (err, res, body) => {
    if (err) return next(err);
    if (res.statusCode != 200)
      return next(new Error("Abnormal response status code"));
    next(null, body);
  });
}

function parseRssFeed(rss) {
  var handler = new htmlparser.RssHandler();
  var parser = new htmlparser.Parse(handler);
  parser.parseComplete(rss);
  if (!handler.dom.items.length) {
    return next(new Error("No RSS items found"));
  }

  var item = handler.dom.items.shift();
  console.log(item.title);
  console.log(item.link);
}

var tasks = [checkForRSSFile, readRSSFile, downloadRSSFeed, parseRssFeed];

function next(err, result) {
  if (err) throw err;
  var currentTask = tasks.shift();
  if (currentTask) {
    currentTask(result);
  }
}

next();

并行的使用场景: 读取几个文本文件的内容, 并输出单词在整个文件中出现的次数.

读取文件目录下的文件列表
定义每个文件的任务. 每个任务都会调用一个异步读取文件的函数并读文件中使用单词计数
把定义好的任务,放入调用数组
开始执行

文件的解读可以是并行执行的, 最后把结果汇总即可

示例代码

var fs = require("fs");
var completedTasks = 0;
var tasks = [];
var wordCounts = {};
var filesDir = "./test";

// 当任务全部执行完成后, 列出文件中用到的每个单词以及用了多少次
function checkIfComplete() {
  completedTasks++;
  if (completedTasks === tasks.length) {
    for (const index in wordCounts) {
      console.log(index + ": " + wordCounts[index]);
    }
  }
}

// 对文本中出现的单词计数
function countWordsInText(text) {
  var words = text
    .toString()
    .toLowerCase()
    .split(/\W+/)
    .sort();
  for (const index in words) {
    var word = words[index];
    if (word) {
      wordCounts[word] = wordCounts[word] ? wordCounts[word] + 1 : 1;
    }
  }
}

fs.readdir(filesDir, (err, files) => {
  if (err) throw err;
  for (const index in files) {
    var task = file => () => {
      fs.readFile(file, (err, text) => {
        if (err) throw err;
        countWordsInText(text);
        checkIfComplete();
      });
    };
    tasks.push(task(filesDir + "/" + files[index]));
  }

  for (const task in tasks) {
    tasks[task]();
  }
});

流行的流程控制工具: Nimble, Step, Seq