除了使用集群模式，还有各种各样扩展API的方式。在这篇教程中，我们将学习10种扩展Node.js API的方式。

我们经常会在处理项目的时候获取一些零散的知识以提高技能，必须通过不断地复习，才能将习得的技能应用到下次项目中。

这个方法一直奏效吗？我甚至不记得我昨天做了些什么。所以我写下了这篇教程，也是对自己知识的复盘。

我尝试记录下这些不常被提起扩展Node.js的方法。

本文提及的方法不一定是你最后的救命稻草，你可以在Node.js项目的任何阶段应用这些方法。

让我们来看看本文的内容：

1. 🚦使用节流
2. 🐢 优化数据库查询
3. ䷪ 使用断路器快速故障
4. 🔍 记录检查点
5. 🌠 使用Kafka而非HTTP请求
6. 🪝 小心内存泄露
7. 🐇 使用缓存
8. 🎏 使用连接池
9. 🕋 无缝扩展
10. 💎 OpenAPI兼容文档

使用节流

节流可以限制对服务器的访问，以防止请求过量。使用节流的好处非常明显：可以保护应用免受大量用户爆发的困扰，也可以防止拒绝服务攻击（Dos攻击）。

输入和输出的速率不匹配的时候，通常是应用节流机制的时候。特别是当入站流量远超过服务器可以（或者希望）处理的流量。

让我们通过图像来理解：

在应用程序和新闻推送服务器之间的第一个节点应用了节流：

1. 新闻推送服务（NFS）订阅了你的应用以发送通知。
2. 每秒向你的应用发送1000个请求。
3. 根据NFS的订阅计费计划，你的应用仅处理500个请求/秒。
4. 为前500个请求发送通知。

必须要注意的是，所有超过500个请求/秒以外的请求都会失败，需要NFS再次尝试发送请求。

当可以排队的时候，为什么要拒绝额外的请求？ 有以下理由：

1. 接受所有请求会使应用开始累积请求，这可能导致所有订阅你的应用的客户端出现单点故障（通过RAM/磁盘耗尽），包括NFS。
2. 你不应该接受超出客户订阅计划范围的请求（在我们的例子中是NFS）。

对于应用程序级别的速率限制，你可以使用Express.js API的中间件——express-rate-limit。对于网络级别的节流，你可以使用类似WAF的解决方案。

如果你使用的是发布-订阅机制，也可以限制消费者和订阅者。例如，你可以通过设置maxBytes选项来限制消费Kafka标签（topic）的字节数据。

优化数据库查询

有时你可能没有缓存数据，或者数据已经过期，查询数据成了唯一的选择。

发生这种情况时，请确保你的数据库做好了准备：第一步是拥有足够的RAM和磁盘IOPS（每秒输入输出量）。

其次，尽可能优化你的查询。对于初学者来说，做对这几件事很关键：

1. 查询时尽量使用索引字段，但不要过度索引。索引也有开销。
2. 对于删除，坚持软删除。如果需要永久删除，请推迟。（一个有趣的故事）
3. 在读取数据的时候，仅使用投影（projection）获取需要的字段。如果可以的话，去掉没有必要的元数据和方法。（例如，Mongoose提供lean)。
4. 尝试将数据库性能和用户体验分离。如果数据库上的CRUD可以在后台发生（即非阻塞），请执行此操作。不要让用户等待。
5. 使用更新查询直接更新所需字段。不要获取文档，更新字段，然后将整个文档保存回数据库。这会造成网络和数据库开销。

使用断路器快速故障

想象一下，你的Node.js应用程序出现突发流量，并且满足请求所需的外部服务器之一已关闭。你是否想在此后的每个请求中一直走死胡同？当然不！我们不想在注定要失败的请求上浪费时间和资源。

这就是使用断路器的核心思想：尽早失败、快速失败。

例如，如果100个请求中有50个失败，则在接下来的X秒内不允许对该外部服务器发出任何请求。它可以防止触发必然会失败的请求。

一旦线路复位，就允许请求通过。如果它们再次失败，则线路断开并重复循环。

可以查看Opposum以了解更多添加断路器的信息。你也可以在这里阅读更多关断路器的信息。

记录检查点

良好的日志记录设置可以帮助你快速发现错误。你可以创建可视化日志来了解应用程序的行为、设置警报和有效地调试。

你可以使用ELK stack来设置良好的日志记录和警报管道。

虽然日志记录是必不可少的工具，但很容易过度使用。如果记录所有内容，最终可能会耗尽磁盘IOPS，从而导致你的应用程序受到影响。

一个值得借鉴的经验是只记录检查点。

检查点可以是：

1. 当进入应用程序中的主控制流时以及在它们经过验证和清理之后的请求
2. 与外部服务/SDK/API交互时的请求和响应。
3. 对该请求的最终响应。
4. 为catch处理程序提供有用的错误消息（错误消息具有合理的默认值）。

另外： 如果一个请求在生命周期中经过多个服务器，你可以在日志中传递一个唯一ID，以跨服务器捕获特定请求。

使用Kafka而非HTTP请求

虽然存在HTTP请求的用例，但容易使用过度，请在不必要的时候避免使用HTTP请求。

让我们通过这个例子来理解：

假设我们要创建一个如Amazon一样的产品，这个产品包含两大服务：

1. 供应商服务
2. 库存服务

每当你收到来自供应商服务的新库存，就推送一个库存详情到Kafka标签。库存服务监听到这个标签，并且更新数据库以确认有新的补货。

请注意，你将库存数据推送到管道（pipeline）然后程序流，就可以继续其他的操作。程序会自动按照一定节奏消费库存服务。Kafka使服务解耦。

现在，如果你的库存服务出现了故障怎么办？如果是用HTTP请求就不容易处理。但如果使用Kafka，就可以重播预期的消息（例如使用kcat）。使用Kafka的话，数据被消费后不会丢失。

当某个商品重新回到库存，你可能希望向愿望清单包含这个商品的顾客推送消息。要实现这个功能，可以让通知服务和库存服务监听同样的标签。通过这种方式，就可以实现在不同的地方使用单个消息总线，并没有HTTP开销。

KafkaJS的开始页面分享了从Node.js应用的基础设置到上述功能的代码片段，我强烈推荐你查看，有很多内容值得研究。

小心内存泄露

如果你不编写保护内存安全的代码，并且不经常分析你的应用，很有可能造成服务器崩溃。

你可不希望自己的分析结果如下：

对于初学者，我建议：

1. 使用--inspect标志来执行 Node.js API。
2. 在Chrome浏览器打开chrome://inspect/#devices。
3. 点击 inspect > Memory tab > Allocation instrumentation on timeline。
4. 在执行一些应用功能。可以使用macOS的apache bench来同时发出多个请求，在终端执行 curl cheat.sh/ab查看怎么使用apache bench。
5. 停止记录并分析内存保持器。

如果发现任何大块的保留内存，请尝试将其最小化。这个话题相关的资源很多，你可以从谷歌搜索“如何防止 Node.js 中的内存泄漏”开始探索。

分析你的 Node.js 应用程序并寻找内存使用模式应该是常规做法。让我们把“分析驱动重构”（PDR）提上日程？

使用缓存避免过多的数据库查找

这么做的目的是不要每一次应用发出请求都连接一次数据库，使用缓存存储结果可以减少数据库的负载，提高应用性能。

有两种使用缓存的策略。

通过缓存写入可确保在发生写入操作时将数据插入数据库和缓存中。这可以使缓存保持相关，并带来更好的性能。缺点是因为不经常使用的数据也被存储到缓存中，所以缓存开销昂贵。

而在延迟加载中，数据仅在第一次读取时才写入缓存。第一次请求提供来自数据库的数据，但随后的请求使用缓存。它具有较小的成本，但增加了第一次请求的响应时间。

要决定缓存数据的TTL（或生存时间），请问自己：

1. 基础数据要多久更改一次？
2. 将过期数据返回给最终用户的风险是什么？

在允许的情况下，更长的TTL意味着更好的应用表现。

重要的是，为你的TTL添加一点增量。如果应用程序一时间收到大量流量，并且你的所有缓存数据立即过期，则可能导致数据库无法承受负载，从而影响用户体验。

最终TTL = TTL预估值 + 一点随机增量

TTL的计算

有许多缓存逐出的策略，保留默认值是一种有效且可接受的方法。

使用连接池

打开一个与数据库的独立连接开销很高。它涉及TCP握手、SSL、身份验证和授权检查等。

你可以利用连接池来取代独立连接。

一个连接池在任何给定时间都拥有多个连接。每当需要它时，池管理器都会分配任何可用/空闲连接。你可以跳过建立全新连接的冷启动阶段。

那么，为什么不最大化池中的连接数呢？因为它高度依赖于硬件资源。如果忽略这一点，可能会造成巨大的性能损失。

连接越多，每个连接的RAM越少，利用RAM的查询越慢（例如排序）。同样的原则也适用于磁盘和CPU。每个新连接都将被分配到资源。

你可以根据自己的需求调节连接数，对于初学者来说你可以在这里评估连接池的大小。

你可以在这里阅读连接池相关的内容。若你使用的是PostgreSQL，你可以使用node-postgres包。这是一个连接池的内置支持。

无缝扩展

当应用程序的用户群逐渐增长并且已经达到垂直扩展的上限时，你会怎么做？水平缩放。

垂直扩展意味着增加节点（CPU、内存等）资源，而水平扩展意味着增加更多的节点以平衡每个节点的负载。

如果你使用的是AWS，则可以利用自动扩展组（ASG），它根据预定义的规则（例如，当CPU利用率超过50% 时水平扩展服务器数量。

你可以通过提前规划行为来提前规划扩展和缩小的计划，以此来应对可以遇见的流量模式（如在世界杯期间的流媒体服务）。

准备好ASG后，在最前面添加负载均衡器将确保流量根据所选策略路由到所有实例（如round robin）。

PS： 预估单个服务器可以处理的请求（CPU、内存、磁盘等）并分配至少 30%以上的容量总不会错。

OpenAPI兼容文档

它可能不会直接影响扩展Node.js应用程序的能力，但我必须将其包含在列表中。如果你曾经做过API集成，你就知道为什么了。

在向前迈出一步之前，了解有关 API 的所有信息至关重要。它使设计的集成、迭代和推理变得容易，更不用说对开发速度的帮助。

确保为你的 Node.js API 创建 OpenAPI 规范（OAS）。

这使得你以行业标准的方式创建 API 文档。OAS充当单一的事实来源。如果定义得当，它会使与 API 的交互更加高效。

我在这里创建了一个API文档样本，你可以使用swagger inspector来监测任意API。

你可以在Swagger Hub dashboard找到所有API文档，以及创建一个新的文档。

行动起来吧！

我们研究了十个鲜为人知的扩展Node.js的最佳实践，以及如何开启每一个最佳时间。

现在轮到你对照这个清单并探索发现你的Node.js应用程序缺少了什么。

获取你的检查清单✨

希望这篇文章对你有所帮助，并在可扩展性方面为你提供了一些指导。这并不是所有最佳实践的详尽清单——我只是列出了这些我认为不常被提及的。

欢迎在Twitter上联系我。我很乐意听取你在使用其他最佳实践的经历和心得。

喜欢这篇文章吗？在这里获取更多后端提升小建议 💌。

长久以来，Heroku都是托管全栈应用的优秀平台。freeCodeCamp早期大量使用Heroku，其他各式各样的开源项目也是如此。

但由于Heroku决定停止免费提供服务，这一现象可能会发生改变。

你可能已经收到了Heroku的邮件，通知你从2022年11月28日开始，在该平台托管应用不再免费，你可以购买付费计划。

如果你想免费托管静态页面或者web应用可以使用Netlify，具体操作可以查看这篇文章，但对于后端应用来说，并不存在太多如Heroku一样部署体验比较好的免费网站。

在这篇文章中，我们将学习如何使用Render来部署搭配Express服务器的Node.js应用。 它的部署过程和Heroku一样简单，并且免费。

让我们开始吧。

在部署应用之前需要做什么？

根据使用Heroku的经验来看，每一个应用都部署在一个由Heroku随机分配的端点，可以使用process.env.PORT变量访问。

使用Render平台也是一样的。

所以你必须确保自己不是通过硬编码端点值来开启Express服务器，而是使用process.env.PORT变量：

const express = require("express");
const app = express();
const PORT = process.env.PORT || 3030;

// 你的代码

app.listen(PORT, () => {
  console.log(`server started on port ${PORT}`);
});

如何使用Render部署一个GitHub仓库

改好端点之后，就可以开始部署你的应用了。

我准备好了这个GitHub仓库来使用Render部署。这个GitHub仓库展示了一个排名前几位的仓库清单，以及每一个仓库获得的星星数量（以JSON的格式）。

让我们开始吧！

Render提供如下图各种注册方式：

一旦注册并登陆账号之后，你会看到控制面板：

点击Web Services选项卡下的 New Web Service按钮来部署Node.js应用。

你也可以通过点击网页头部你头像旁边的 New + 按钮来选择 Web Service选择卡。

点击之后，会看到以下画面：

点击GitHub菜单下方的Connect account按钮，会看到以下画面：

点击Configure链接，就可以允许Render选取你所有或者选择的GitHub仓库。

我希望只访问选择的仓库，也就是我需要部署的。所以我选择Only select repositories选项。

然后，点击在选择卡下方的Select repositories按钮，选择你想要部署的仓库。

选择完毕后，你会看到如下画面：

点击绿色按钮Install，使得Render有权访问你选择的仓库。

点击完毕后，你会被重定向到控制台，看到如下画面：

现在，点击Connect按钮，看到如下画面：

在Name框中，输入一个简短的名字来标识你的网站。

注意： 请保持Name值的简单，因为部署完毕后，它将成为应用的URL。 所以如果我将github-repos设置为Name的值，我的应用URL会成为https://github-repos.onrender.com。

所以请填写一个简单有意义的Name值。

如图填写剩下的部分：

在Build Command中填写yarn就等同于yarn install命令。Yarn是一个类似于npm的包管理工具，但是比npm要快。

如果你的入口文件是 index.js，在Start Command中填写node index.js。

填写完所有细节之后，向下滚动页面，会看到Plans区域，自动勾选的是免费计划。如果没有被勾选，请勾选好，因为我们的目的是免费部署应用。

再向下滑动页面会看到Advanced按钮。

如果你的应用使用了环境变量，你可以在Advanced设置中输入。也可以在这里添加 .env文件，这样就不用你手动一个一个地添加。

注意Auto-Deploy的默认值是Yes——所以一旦你向GitHub仓库推送了更新，它们就会被自动部署到Render。

如果你并不想每次更改仓库的时候都自动部署，你可以在 Auto-Deploy下拉菜单中选择No。

现在，点击Create Web Service按钮来开始部署过程。

部署可能需要等待一段时间，有时候如果页面卡在了“in progress”阶段，可以尝试刷新一下页面。

一旦部署完成，你可以看到如图，应用被部署，有一个Live 小标：

你可以点击在顶部的应用URL，在我的例子中，这个URL是https://github-repos.onrender.com/。

如果是首次部署应用，可能在访问网站的时候会遇到Page is not working报错。

等待一段时间，并且使用Ctrl + R或Cmd + R（Mac）来刷新页面。因为免费服务的硬件有限，所以Render平台需要一些时间来启动一个项目。

部署成功后，可以如下图一样看到你的应用：

提示: 想要JSON有格式地显示，你需要安装Chrome插件：JSON Formatter。

你或许知道，在使用Heroku的免费账户的时候，没如果没有新的请求进来，你的应用会在30分钟后进入到休眠模式。也就是如果再次请求需要花上一点时间。

同样的，使用Render的话，如果没有新的请求，应用会在15分钟后进入休眠模式。

感谢阅读！

你可以在这个仓库中找到完整的源代码。

你可以在这里查看实时demo。

如果你想从零开始学Redux，并且完成三个应用，以及一个完整的食物点单应用，可以查看我的Mastering Redux课程。

在这篇课程中，你将学习：

• 基础和高阶的Redux
• 如何管理复杂的数据和对象状态
• 如何使用多个reducer来管理复杂的redux状态
• 如果排除Redux应用的错误
• 如果通过使用react-redux库来在React中使用Redux并使得你的应用是响应式的
• 如何使用redux-thunk库来处理异步API调用
• 使用Redux编写三个不同的app

以及更多。

最后我们将从零开始搭建一个食物点单应用 ，包括付费模块和应用的部署。

想要了解JavaScript、React或者Node.js最新的消息吗？ 请在LinkedIn上关注我。

在这篇文章中，我将讲解如何优化使用 Node.js 编写的 API。

前提条件

想要充分了解本文内容，你必须了解以下概念：

• Node.js 的设置与安装
• 如何使用 Node 创建 API
• 如何使用 Postman
• JavaScript 的 async/await 工作原理
• Redis 的基础操作

API 优化到底指的是什么

优化包含了改善 API 的响应时间。响应时间越短，API 的速度越快。

我将在本文分享一些技巧，帮助你缩短响应时间、降低延迟、管理错误和吞吐量，并且最大限度地减少 CPU 和内存的使用。

如何优化 Node.js 的 API

1. 始终使用异步函数

异步函数就像 JavaScript 的心脏。因此，优化 CPU 使用率的最佳方法就是编写异步函数来执行非阻塞 I/O 操作。

I/O 操作包括对数据的读和写。它可以在数据库、云存储或者任何本地磁盘上进行。

在大量使用 I/O 操作的应用使用异步函数可以提高效率。因为由于没有阻塞 I/O，当一个请求在做输入/输出操作的时候，CPU 可以同时处理多个请求。

举例如下：

var fs = require('fs');
// 执行阻塞I/O
var file = fs.readFileSync('/etc/passwd');
console.log(file);
// 执行非阻塞I/O
fs.readFile('/etc/passwd', function(err, file) {
    if (err) return err;
    console.log(file);
});

• 使用 Node 包 fs 来处理文件
• readFileSync() 是同步函数，会在执行完成前阻塞线程
• readFile() 是异步函数，会立刻返回并在后台运行

2. 避免在 API 中使用 session 和 cookie，仅在 API 响应中发送数据

当我们使用 cookie 或者 session 来存储临时状态的时候，会占用非常多的服务器内存。

现在通用无状态 API，并且也有 JWT、OAuth 等验证机制。验证令牌保存在客户端以便服务器管理状态。

JWT 是基于 JSON 的用于 API 验证的安全令牌。JWT 可以被看到，但一旦发送就无法修改。JWT 只是一个序列并没有加密。OAuth 不是 API 或服务——相反，它是授权的开放标准。OAuth 是一组用于获取令牌的标准步骤。

同时，也不要把时间浪费在使用 Node.js 来服务静态文件。这方面 NGINX 和 Apache 做得更好。

使用 Node 搭建 API 的时候，不要在响应中发送完整的 HTML 页面。当仅有数据通过 API 发送的时候，Node 服务得会更好。大部分 Node 应用都使用 JSON 数据。

3. 优化数据库查询

优化 Node API 的重要一环是优化查询。特别是对于大型应用来说，我们需要多次查询数据库，所以一个糟糕的查询会降低应用的整体性能。

索引是一种优化数据库性能的方法，通过最小化处理查询时所需的磁盘访问次数来实现。它是一种数据结构技术，用于快速定位和访问数据库中的数据。索引是使用几个数据库列创建的。

假设我们有一个没有索引的数据库模式，并且数据库包含 100 万条记录。与带有索引的模式相比，使用没有索引的模式做一个简单的 find（查找）查询将扫描更多的记录来找到匹配的记录。

• 没有索引的查询

> db.user.find({email: 'ofan@skyshi.com'}).explain("executionStats")

• 有索引的查询

> db.getCollection("user").createIndex({ "email": 1 }, { "name": "email_1", "unique": true })
{
 "createdCollectionAutomatically" : false,
 "numIndexesBefore" : 1,
 "numIndexesAfter" : 2,
 "ok" : 1
}

两者之间扫描文件的数量相差巨大 ~ 1038：

4. 使用 PM2 集群模式优化 API

PM2 是为 Node.js 应用程序设计的生产流程管理器。它内置了负载平衡器，允许应用程序在不修改代码的情况下，作为多个进程运行。

使用 PM2 时的应用停机时间几乎为零。总体来说，PM2 确实可以提升 API 性能和并发性。

在生产环境中部署代码并运行以下命令以查看 PM2 集群如何在所有可用 CPU 上进行扩展：

pm2 start  app.js -i 0

5. 减少 TTFB（第一字节时间）

第一字节时间是一种测量方式，用作表示 Web 服务器或者其他网络资源的响应时间。TTFB 测量从用户或客户发出 HTTP 请求到客户的浏览器收到页面的第一个字节的时间。

所有用户访问浏览器的同一页面加载速度不可能在 100 毫秒之内，这仅仅是因为服务器和用户之间的物理距离。

我们可以通过使用 CDN 和全球本地数据中心缓存内容来减少第一个字节的时间。这有助于用户以最小的延迟访问内容。你可以从 Cloudflare 提供的 CDN 解决方案开始着手。

6. 使用带日志的错误脚本

监视 API 是否正常工作最好的办法是记录行为，于是记录日志就派上用场。

一个常见的办法是将记录打印在控制台上（使用console.log()）。

比console.log()更高效的方法是使用 Morgan、Buyan 和 Winston。我将在这里以 Winston 为例。

如何使用 Winston 记录 – 功能

• 支持 4 个可以自由选择的日志等级，如：info、error、verbose、debug、silly 和 warn
• 支持查询日志
• 简单的分析
• 可以使用相同的类型进行多个 transports 输出
• 捕获并记录 uncaughtException

可以使用以下命令行设置 Winston：

npm install winston --save

这里是使用 Winston 记录的基本配置：

const winston = require('winston');

let logger = new winston.Logger({
  transports: [
    new winston.transports.File({
      level: 'verbose',
      timestamp: new Date(),
      filename: 'filelog-verbose.log',
      json: false,
    }),
    new winston.transports.File({
      level: 'error',
      timestamp: new Date(),
      filename: 'filelog-error.log',
      json: false,
    })
  ]
});

logger.stream = {
  write: function(message, encoding) {
    logger.info(message);
  }
};

7. 使用 HTTP/2 而不是 HTTP

除了上述使用的这些技巧，我们还可以使用 HTTP/2 而不是 HTTP，因为它具备以下优势：

• 多路复用
• 头部压缩
• 服务器推送
• 二进制格式

它专注提高性能，并解决 HTTP 的问题。它使网页浏览更快、更容易，并且消耗更少的带宽。

8. 并行任务

使用 async.js 来运行任务。并行任务对 API 的性能有很大改善，它减少了延迟并最大限度地减少了阻塞操作。

并行意味着同时运行多个任务。当你并行任务的时候，不需要控制程序的执行顺序。

以下是一个数组异步并行的简单例子：

const async = require("async");
// 使用对象而不是数组
async.parallel({
  task1: function(callback) {
    setTimeout(function() {
      console.log('Task One');
      callback(null, 1);
    }, 200);
  },
  task2: function(callback) {
    setTimeout(function() {
      console.log('Task Two');
      callback(null, 2);
    }, 100);
    }
}, function(err, results) {
  console.log(results);
  // 结果相当于: {task2: 2, task1: 1}
});

在以上例子中，我们使用了 async.js 以异步的形式执行了两个任务。task 1 需要 200 毫秒完成，但是 task 2 不需要等待 task 1 完成后再执行 – 它在设定的 100 毫秒后执行。

并行任务对 API 的性能有很大的影响。它减少了延迟并最大限度地减少了阻塞操作。

9. 使用 Redis 缓存应用

Redis 是 Memcached 的高级版本。它通过在服务器的主内存中存储和检索数据来优化 API 响应时间。它提高了数据库查询的性能，也减少了访问延迟。

在下面的代码片段中，我们分别调用了不使用 Redis 和使用 Redis 的 API，并比较了响应时间。

响应时间差异巨大~ 899.37 毫秒：

以下是不使用 Redis 的 Node：

'use strict';

//定义需要的所有依赖项
const express = require('express');
const responseTime = require('response-time')
const axios = require('axios');

//加载 Express 框架
var app = express();

//创建在响应头中添加 X-Response-Time 的中间件
app.use(responseTime());

const getBook = (req, res) => {
  let isbn = req.query.isbn;
  let url = `https://www.googleapis.com/books/v1/volumes?q=isbn:${isbn}`;
  axios.get(url)
    .then(response => {
      let book = response.data.items
      res.send(book);
    })
    .catch(err => {
      res.send('The book you are looking for is not found !!!');
    });
};

app.get('/book', getBook);

app.listen(3000, function() {
  console.log('Your node is running on port 3000 !!!')
});

以下是使用 Redis 的 Node：

'use strict';

//定义需要的所有依赖项
const express = require('express');
const responseTime = require('response-time')
const axios = require('axios');
const redis = require('redis');
const client = redis.createClient();

//加载 Express 框架
var app = express();

//创建在响应头中添加 X-Response-Time 的中间件
app.use(responseTime());

const getBook = (req, res) => {
  let isbn = req.query.isbn;
  let url = `https://www.googleapis.com/books/v1/volumes?q=isbn:${isbn}`;
  return axios.get(url)
    .then(response => {
      let book = response.data.items;
      //设置string-key:缓存中的 isbn。以及缓存的内容: title
      // 设置缓存的过期时间为 1 个小时（60分钟）
      client.setex(isbn, 3600, JSON.stringify(book));

      res.send(book);
    })
    .catch(err => {
      res.send('The book you are looking for is not found !!!');
    });
};

const getCache = (req, res) => {
  let isbn = req.query.isbn;
  //对照服务器的 redis 检查缓存数据
  client.get(isbn, (err, result) => {
    if (result) {
      res.send(result);
    } else {
      getBook(req, res);
    }
  });
}
app.get('/book', getCache);

app.listen(3000, function() {
  console.log('Your node is running on port 3000 !!!')
)};

总结

在本指南中，我们了解了如何优化 Node.js API 的响应时间。

JavaScript 重度依赖函数，因此，使用异步函数可以使脚本运行得更快并且不阻塞。

除此之外，我们还可以使用缓存记忆（Redis）、数据库索引、TTFB 和 PM2 集群来提高响应速度。

最后请记住，注意路由的安全性并尽可能优化路由也很重要。我们不能为了提高 API 响应速度而妥协掉安全性。因此，在 Node.js 中构建优化的 API 时，应该保留所有标准安全检查。

你可以在 LinkedIn 上联系我。

后会有期！

不同的软件开发工具可能需要特定版本的 Node.js 和 NPM（Node 包管理器）。NPM 是一个用于管理从 NPM 注册表安装的包的工具。

此外，如果你正在制作 NPM 包，你可能需要使用不同版本的 Node.js 对其进行测试。这就是你应该安装 NVM 的原因。

NVM 是 Node Version Manager（Node 版本管理工具）的缩写，是一个命令行工具，用于管理和切换到不同版本的 Node.js。

在本文中，我将向你展示如何在 Windows 10 上下载和安装 NVM。

我还将向你展示如何在你的 Windows 计算机上设置和使用不同版本的 Node.js 和 NPM。

我们将涵盖的内容

• 如何在 Windows 10 中下载和安装 NVM
• 按照步骤下载 nvm-windows
• 如何在 Windows 10 上使用 NVM
• 如何使用 NVM 安装不同版本的 Node.js 和 NPM
• 总结

如何在 Windows 10 中下载和安装 NVM

正如我之前提到的，Windows 不支持 NVM，因为 NVM 仅在 Linux 和 Mac 上受支持。

你将在 Windows 机器上使用的是 “nvm-windows”。 nvm-windows 类似于 NVM，但不完全相同。

注意：如果你已经安装了 Node.js，你需要卸载它，这样在使用不同版本的 Node 和从 NPM 注册表安装包时不会导致错误。

之后重新启动你的电脑，打开命令提示符或 PowerShell，然后运行 ​​node -v 以确认 Node 已被卸载。

另外，如果你安装了 yarn，卸载它，安装 NVM 后重新安装它。你不想在安装和使用 NPM 注册表中的包时遇到奇怪的错误。

按照步骤下载 nvm-windows

第 1 步：前往 nvm-windows 仓库，然后单击立即下载

你将看到一个包含不同版本的 nvm-windows 的页面。

• 第 2 步：点击最新版本下载。目前，它是 2022 年 4 月 28 日的版本。

• 第 3 步：在你的计算机上找到安装程序并打开它，按照安装向导进行安装。

• 第 4 步：打开 PowerShell 或命令提示符并运行 nvm -v 以确认安装。

如果你收到与我上面相同的消息，则 nvm-windows 已成功安装，恭喜！

如何在 Windows 10 上使用 NVM

要使用 NVM，你需要以管理员身份打开 PowerShell 或命令提示符。你也可以使用 Git bash。

• 要以管理员身份打开 PowerShell，请右键单击开始并选择 “PowerShell（Admin）”。

• 要以管理员身份打开命令提示符，请搜索 “cmd” 并选择右侧的“以管理员身份打开”。

如何使用 NVM 安装不同版本的 Node.js 和 NPM

超级强大的 NVM 让你能够在你的机器上安装多个版本的 Node.js。

要安装最新版本的 Node，请运行 nvm install latest。

安装 Node 的长期支持（LTS）版本更好，因为它的 bug 更少。

要安装 LTS 版本的 Node，请运行 nvm install lts。

要安装特定版本的 Node，你需要先运行 nvm list available，以便查看可用的 Node 版本。

要安装该特定版本，请运行 nvm install node-version-number，例如，nvm install 14.20.0。

注意：一旦你安装了一个版本的 Node，就会为你安装相应版本的 NPM，所以你不需要单独安装 NPM。

如果你要使用的 NPM 版本不可用，请运行 npm install @npm version-number -g 进行安装。

现在，要查看你在 Windows 机器上安装的 Node 版本列表，请运行 nvm list。

要使用特定版本的 Node，请运行：

• nvm use latest 使用最新版本
• nvm use lts 使用长期支持版本
• nvm use version-number 使用你已安装的任何其他版本

总结

本文向你展示了如何在 Windows 10（nvm-windows）上安装 NVM，以及如何使用它来安装和管理不同版本的 Node.js。

提醒一下，以下是你将与 nvm-windows 一起使用的常用命令：

• nvm install node-version – 安装一个版本的 Node
• nvm list – 查看你机器上安装的 Node 版本
• nvm use node-version – 使用特定版本的 Node

感谢你阅读本文，继续编码吧:)

Node 是一个运行时环境，允许开发人员在服务器端在浏览器之外执行 JavaScript 代码。

而 NPM 是一个包管理器，用于将 JavaScript 包（也叫作 Node 模块）发布到 NPM 注册表。你还可以使用它来将软件包安装到你的应用程序中。

要安装 Node，你必须去 Nodejs 网站下载安装程序。下载后，你可以运行安装程序，按照步骤操作，同意条款和条件，然后在你的设备上安装程序。

安装 Node 时，你还会获得 npm CLI，你可以使用它来管理应用程序中的包。

但是，Node 和 NPM 可以单独更新到它们的最新版本，我将在下文中向你展示如何操作。

如何更新 Node

1. 使用 NPM 更新你的 Node 版本

要使用 NPM 更新 Node，你将安装 n 包，该包将用于交互式管理你设备上的 Node 版本。

以下是步骤：

清除 NPM 缓存

安装依赖时，会缓存一些模块，以提高后续下载的安装速度。所以首先你要清除 NPM 缓存。

安装 n 包

npm install -g n

你需要全局安装此包，因为它在根目录管理 Node 版本。

安装新版本的 Node

n lts
n latest

上面两个命令安装长期支持和最新版本的 Node.js。

删除以前安装的版本

n prune

此命令会删除以前安装的版本的缓存版本，只保留最新安装的版本。

2. 使用 NVM 更新你的 Node 版本

NVM 代表 Node 版本管理器，顾名思义，它可以帮助你管理节点版本。使用 NVM，你可以安装 Node 版本并指定项目使用的 Node 版本。

NVM 使得跨各种 Node 版本测试项目变得容易。

要使用 NVM 更新 Node 版本，你必须先安装 NVM。

这是 NVM 的安装指南。

安装后，你可以使用以下方式安装软件包：

nvm install [version]

你可以使用以下命令安装最新版本：

nvm install node

并使用以下命令卸载其他版本：

nvm uninstall [version]

安装了许多版本后，你可能还想指定在特定时间使用的版本。一种方法是设置一个默认别名，如下所示：

nvm alias default [version]

这样，Node 执行将以指定的版本运行。

3. 下载更新的 Node 二进制文件

你还可以从 Node.js 网站获取最新版本。在网站上面，你可以找到适用于你设备的最新和长期支持版本。

下载最新版本还会为你提供最新版本的 NPM。

如何更新 NPM

就像你使用 NPM 更新包一样，你也可以使用 NPM 来更新它自己。这是实现此目的的命令：

npm install -g npm@latest

此命令将全局安装最新版本的 NPM。

在 Mac 上，你可能必须在 NPM 之前使用 sudo 命令，因为这会将 NPM 安装在设备的根目录中，并且你需要权限才能执行此操作。

小结

在本文中，我们了解了如何将 Node 和 NPM 更新到最新版本。

回顾一下，当你安装 Node 时，你会自动获得 NPM。如果你还通过从网站安装二进制文件来更新 Node，你将获得更新的 NPM。

我们还看到了在你的设备上全局更新 Node 和 NPM 的其他方法。

在编程中，模块是一个程序的组成部分，具有一个或多个功能或值。

这些值也可以在整个程序中共享，并可以以不同的方式使用。

在这篇文章中，我将告诉你如何在 Node.js 中通过导出和导入模块来共享函数和值。

为什么要导出模块

你想导出模块，这样你就可以在你的应用程序的其他部分使用它们。

模块可以有不同的用途。它们可以提供简单的实用程序来修改字符串，可以提供 API 请求的方法，或者甚至可以提供常量和原始值。

当你导出一个模块时，你可以把它导入到你的应用程序的其他部分并使用它。

Node.js 支持 CommonJS 模块和 ECMAScript 模块。

在本文的其余部分，我们将专注于 CommonJS 模块，这是 Node.js 中打包模块的原始方法。

如果你想了解更多关于 ES 模块（以及 CommonJS 模块）的信息，你可以查看这份详细指南。

如何在 Node 中导出模块

Node.js 已经导出了内置的模块，例如 fs、path 和 http。但你也可以创建你自己的模块。

Node.js 将 Node 项目中的每个文件视为一个模块，可以从文件中导出值和功能。

例如，你有一个 utility 文件 utility.js，代码如下：

// utility.js

const replaceStr = (str, char, replacer) => {
  const regex = new RegExp(char, "g")
  const replaced = str.replace(regex, replacer)
  return replaced
}

utility.js 是一个模块，其他文件可以从中导入东西。但是 utility.js 目前并没有输出任何东西。

你可以通过检查每个文件中的全局 module 对象来验证这一点。当你打印这个 utility 文件中的 module 全局对象时，你有：

console.log(module)

// {
//   id: ".",
//   path: "...",
//   exports: {},
//   parent: null,
//   filename: "...",
//   loaded: false,
//   children: [],
//   paths: [
//     ...
//   ],
// }

module 对象有一个 exports 属性，正如你所看到的，它是一个空对象。

因此，任何试图从这个文件中导入任何东西的行为都会产生错误。

utility.js 文件有一个 replaceStr 方法，可以用一些其他字符替换字符串中的字符。我们可以从这个模块导出这个函数，供其他文件使用。

方法如下：

// utility.js

const replaceStr = (str, char, replacer) => {
  const regex = new RegExp(char, "g")
  const replaced = str.replace(regex, replacer)
  return replaced
}

module.exports = { replaceStr }
// or
exports.replaceStr = replaceStr

现在， replaceStr 可以在应用程序的其他部分使用。要使用它，你要像这样导入它：

const { replaceStr } = require('./utility.js')

// then use the function anywhere

module.exports vs exports in Node

你可以使用 module.exports 从一个模块中导出函数和值：

module.exports = { value1, function1 }

或者使用 exports：

exports.value1 = value1
exports.function1 = function1

区别是什么？

这些方法是相同的。基本上，exports 是对 module.exports 的引用。为了更好地理解这一点，让我们通过使用两种导出值的方式来填充 exports 对象：

const value1 = 50
exports.value1 = value1

console.log(module)
// {
//   id: ".",
//   path: "...",
//   exports: { value1: 50 },
//   parent: null,
//   filename: "...",
//   loaded: false,
//   children: [],
//   paths: [
//     ...
//   ],
// }

const function1 = function() {
  console.log("I am a function")
}
module.exports = { function1, ...module.exports }

console.log(module)

// {
//   id: ".",
//   path: "...",
//   exports: { function1: [Function: function1] },
//   parent: null,
//   filename: "...",
//   loaded: false,
//   children: [],
//   paths: [
//     ...
//   ],
// }

这里有两件事需要注意：

• exports 关键字是对 modules 对象中 exports 对象的引用。通过 exports.value1 = value1，它将 value1 属性添加到 module.exports 对象中，正如你在第一个日志中看到的那样。
• 第二条日志不再包含 value1 的导出。它只有使用 module.exports 导出的函数。为什么会这样呢？

module.exports = ... 是将一个新对象重新分配给 exports 属性的一种方式。这个新对象只包含函数，所以 value1 不再被导出。

那么有什么区别呢？

只用 exports 关键字导出数值是一种快速导出模块中数值的方法。你可以在顶部或底部使用这个关键字，它所做的只是填充 module.exports 对象。但如果你在一个文件中使用 exports，请坚持在整个文件中使用它。

使用 module.exports 是一种明确指定模块导出的方式。在一个文件中最好只存在一次。如果它存在两次，第二次声明就会重新分配 module.exports 属性，而模块只输出第二次声明中的内容。

因此，作为前面代码的解决方案，你可以像这样导出：

// ...
exports.value1 = value1

// ...
exports.function1 = function1

或者像这样：

// ...
module.exports = { value1, function1 }

总结

Node.js 项目中的每个文件都被视为一个模块，可以导出值供其他模块使用。

module.exports 是 Node.js 文件中的一个对象，用于保存该模块导出的值和函数。

在一个文件中声明一个 module.exports 对象，指定从该文件中导出的值。导出后，另一个模块可以通过 require 全局方法导入这些值。

注意：你可以得到这本手册的 PDF、ePub或Mobi 版本，以方便参考，或在你的 Kindle 或平板电脑上阅读。

Node.js 简介

本手册是 Node.js 的入门指南，它是服务器端 JavaScript 运行环境。

概况

Node.js 是一个 服务器 上的 JavaScript 运行环境。

Node.js 是开源的、跨平台的，自从2009年推出以来，它大受欢迎，现在在 Web 开发领域发挥着重要作用。如果 GitHub 的星星是一个流行的指示因素，那么拥有58000多颗星星就意味着非常流行。

Node.js 在浏览器之外运行 V8 JavaScript 引擎，这是 Chrome 浏览器的核心。Node.js 能够利用那些使 Chrome 浏览器的 JavaScript 运行变得非常快的成果，这使得 Node.js 能够从 V8 执行的巨大性能改进和即时编译中受益。得益于此，在 Node.js 中运行的 JavaScript 代码可以变得非常有性能。

一个 Node.js 应用程序是由一个单一的进程运行的（single process），不需要为每个请求创建一个新的线程（new thread）。Node在其标准库中提供了一套异步 I/O 原生语法，这将防止JavaScript 代码被阻塞，一般来说，Node.js 中的库是使用非阻塞范式编写的，使阻塞行为成为例外，而不是正常的。

当 Node.js 需要执行 I/O 操作时，比如从网络中读取数据、访问数据库或文件系统，而不是阻塞线程，Node.js 会在响应回来时恢复操作，而不是浪费 CPU 来等待。

这使得 Node.js 可以用一台服务器处理成千上万的并发连接，而不需要引入管理线程并发的负担，这将是错误的主要来源。

Node.js 有一个独特的优势，因为数百万为浏览器编写 JavaScript 的前端开发人员现在能够运行服务器端代码和前端代码，而不需要学习一种完全不同的语言。

在 Node.js 中，新的 ECMAScript 标准可以顺利使用，因为你不必等待所有用户更新他们的浏览器--你通过改变Node.js的版本来决定使用哪个 ECMAScript 版本，你还可以通过运行带有标志（flags）的 Node 来启用特定的实验性功能。

Node.js 有大量的库

凭借其简单的结构，Node包管理器（NPM）帮助 Node.js 的生态系统激增。现在，NPM registry 托管了近50万个开源包，你可以自由使用。

一个Node.js应用程序的例子

Node.js 最常见的例子 Hello World 是一个网络服务器：

const http = require('http')
const hostname = '127.0.0.1'
const port = 3000

const server = http.createServer((req, res) => {  
    res.statusCode = 200  
    res.setHeader('Content-Type', 'text/plain')  
    res.end('Hello World\n')
})

server.listen(port, hostname, () => {  
  console.log(`Server running at http://${hostname}:${port}/`)
})

要运行这个片段，将其保存为 server.js 文件，并在终端运行 node server.js。

这段代码首先包括 Node.js http模块。

Node.js有一个惊艳的 标准库，包括对网络的一流支持。

http 的 createServer() 方法创建一个新的HTTP服务器并返回。

该服务器被设置为在指定的端口和主机名上监听。当服务器准备好时，回调函数被调用，在这种情况下，通知我们服务器正在运行。

每当收到一个新的请求，request event 被调用，提供两个对象：一个请求（一个 http.IncomingMessage 对象）和一个响应（一个 http.ServerResponse 对象）。

这两个对象对于处理HTTP调用是必不可少的。

第一个对象提供请求的细节。在这个简单的例子中，这个没有被使用，但是你可以访问请求头和请求数据。

第二个对象是用来返回数据给调用者的。

在这种情况下:

res.statusCode = 200

我们将 "statusCode" 属性设置为 "200"，以表示成功响应。

我们设置 Content-Type 头:

res.setHeader('Content-Type', 'text/plain')

……我们最后关闭响应，将内容作为一个参数添加到 end()：

res.end('Hello World\n')

Node.js 框架和工具

Node.js 是一个低代码（low-level）平台。为了让开发者更容易、更有趣，成千上万的库被建立在Node.js 之上。

其中许多人随着时间的推移成为了流行的选择。这里有一个不全面的列表，列出了我认为非常相关和值得学习的那些：

• Express
  创建一个网络服务器的最简单而强大的方法之一。它的极简方法和对服务器核心功能的无偏见关注是其成功的关键。
• Meteor
  一个令人难以置信的强大的全栈框架，赋予你用JavaScript构建应用程序的同构方法，在客户端和服务器上共享代码。曾经是一个提供一切的现成工具，现在它与前端库如React、Vue 和 Angular 集成。Meteor也可以用来创建移动应用程序。
• Koa
  由Express背后的同一个团队建立，Koa旨在更简单和更小，建立在多年的知识之上。这个新项目的诞生是由于需要在不破坏现有社区的情况下，创造不兼容的变化。
• Next.js
  这是一个用于渲染服务器端的 React 应用程序的框架。
• Micro
  这是一个非常轻量级的服务器，用于创建异步的HTTP微服务。
• Socket.io
  这是一个实时通信引擎，用于构建网络应用。

Node.js 的简史

回顾 2009 年到今天的 Node.js 的历史

信不信由你，Node.js 只有 9 年的历史。

相比之下，JavaScript 有 23 年的历史，而我们所知的网络（在引入Mosaic之后）有25年的历史。

对于一项技术来说，9年的时间实在是太短了，但Node.js似乎已经存在了很久。

我有幸从 Node.js 的早期就开始工作，当时它只有2年的历史，尽管信息很少，但你已经可以感觉到它是一个巨大的东西。

在这一节中，我想画出 Node.js 在历史上的大图景，把事情看清楚。

一段小的历史

JavaScript 是一种编程语言，是在网景公司创建的，作为一种脚本工具，在他们的浏览器 Netscape Navigator 中操作网页。

网景公司的部分商业模式是销售网络服务器，其中包括一个名为 “Netscape LiveWire” 的环境，它可以使用服务器端的 JavaScript 创建动态页面。因此，服务器端JavaScript的想法并不是由 Node.js引入的，它就像 JavaScript 一样古老--但在当时它并不成功。

导致 Node.js 崛起的一个关键因素是时机。几年前，JavaScript 开始被认为是一种严肃的语言，这要归功于 “Web 2.0” 应用程序，它们向世界展示了网络上的现代体验是什么样的（想想谷歌地图或GMail）。

由于浏览器的竞争，JavaScript 引擎的性能标准大大提高了，这种竞争仍在继续。每个主要浏览器背后的开发团队每天都在努力工作，为我们提供更好的性能，这对 JavaScript 这个平台来说是一个巨大的胜利。Chrome V8，即 Node.js 背后使用的引擎，就是其中之一，特别是它的 Chrome JavaScript 引擎。

但当然，Node.js 的流行并不只是因为纯粹的运气或时机。它引入了许多关于如何在服务器上用 JavaScript 编程的创新思维。

2009

Node.js的诞生

第一种形式的 npm 的诞生

2010

Express 诞生

Socket.io 诞生

2011

npm达到1.0版本

公司开始采用 Node。LinkedIn, Uber

Hapi 诞生

2012

被采用的速度非常快

2013

第一个使用 Node.js 的大型博客平台: Ghost

Koa 诞生

2014

大事件: IO.js 是 Node.js 的一个重要分叉，目标是引入ES6支持，并快速推进。

2015

Node.js 基金会 诞生

IO.js 回归到 Node.js 中

npm引入了私有模块

Node 4 发布（之前没有发布过1、2、3版本）

2016

leftpad 事件

Yarn 诞生：Node 6 发布

2017

npm 更专注于安全：Node 8 发布

HTTP/2

V8 在其测试套件中引入了 Node，正式将 Node 作为除 Chrome 之外的 JavaScript 引擎的目标。

每周 30 亿次 npm 下载

2018

Node 10 发布

ES modules.

mjs 实验性支持

如何安装 Node.js

如何在你的系统上安装 Node.js：使用软件包管理器、官方网站安装程序或 nvm

Node.js 可以通过不同的方式进行安装。这篇文章强调了最常见和最方便的方式。

所有主要平台的官方软件包都可以使用这里。

安装 Node.js 的一个非常方便的方法是通过包管理器。在这种情况下，每个操作系统都有自己的。

在macOS上，Homebrew 是事实上的标准，而且一旦安装，就可以通过在 CLI 中运行这个命令，非常容易地安装 Node.js：

brew install node

其他用于 Linux 和 Windows 的软件包管理器被列出 这里。

nvm 是运行 Node.js 的一种流行方式。它允许你轻松地切换 Node.js 的版本，并安装新的版本来尝试，并在发生故障时轻松回滚，例如。

它对于用旧的 Node.js 版本测试你的代码也非常有用。

我的建议是，如果你刚刚开始，而且你还没有使用 Homebrew，就使用官方安装程序。否则，Homebrew是我最喜欢的解决方案。

使用 Node.js，你需要知道多少 JavaScript？

如果你刚刚开始学习 JavaScript，你需要对这门语言有多深的了解？

作为一个初学者，你很难达到对自己的编程能力有足够信心的程度。

在学习编程的过程中，你可能也会迷惑不解，到底哪里是 JavaScript 的终点，哪里是 Node.js 的起点，反之亦然。

我建议你在深入学习 Node.js 之前，先对主要的 JavaScript 概念有一个很好的掌握：

• Lexical Structure（语法结构）
• Expressions（表示式）
• Types （类型）
• Variables （变量）
• Functions （函数）
• this
• Arrow Functions （箭头函数）
• Loops （循环）
• Loops and Scope （循环和作用域）
• Arrays （数组）
• Template Literals （模板文字）
• Semicolons （分号）
• Strict Mode （严格模式）
• ECMAScript 6, 2016, 2017 （ES6 ES2016 ES2017标准）

有了这些概念，你就可以在浏览器和 Node.js 中成为一名熟练的 JavaScript 开发者了。

以下概念也是理解异步编程的关键，这也是 Node.js 的一个基本部分：

• 异步编程（Asynchronous programming）和回调（callbacks）
• 定时器（Timers）
• Promises
• Async and Await
• 闭包（Closures）
• 事件循环（The Event Loop）

幸运的是，我写了一本免费的电子书，解释了所有这些主题，它叫做 JavaScript基础知识。这是你能找到的学习所有这些的最紧凑的资源。

Node.js 和浏览器之间的差异

在 Node.js 中编写 JavaScript 应用程序与在浏览器内为网络编程有什么不同。

浏览器和 Node 都使用 JavaScript 作为其编程语言。

构建在浏览器中运行的应用程序与构建 Node.js 应用程序是完全不同的事情。

尽管它始终是 JavaScript，但有一些关键的区别，使体验有了根本的不同。

编写 Node.js 应用程序的前端开发者有一个巨大的优势--语言仍然是一样的。

你有一个巨大的机会，因为我们知道全面、深入地学习一门编程语言是多么困难。通过使用相同的语言来执行你在网络上的所有工作--无论是在客户端还是在服务器上--你就处于一个独特的优势地位。

生态系统的变化。

在浏览器中，大多数时候你所做的是与DOM或其他网络平台 API（如 Cookies ）进行交互。当然，这些并不存在于 Node.js 中。你没有 document、window 和所有其他由浏览器提供的对象。

而且在浏览器中，我们没有 Node.js 通过其模块提供的所有好用的 API，如文件系统访问功能。

另一个很大的区别是，在 Node.js 中你可以控制环境。除非你正在构建一个任何人都可以在任何地方部署的开源应用程序，否则你知道你将在哪个版本的 Node.js 上运行该应用程序。与浏览器环境相比，你不能奢侈地选择你的访问者将使用什么浏览器。

这意味着你可以编写所有你的 Node 版本支持的现代 ES6-7-8-9 的 JavaScript。

由于 JavaScript 的发展如此之快，但浏览器可能有点慢，用户的升级也有点慢--有时在网络上，你只能使用旧的 JavaScript/ECMAScript 版本。

你可以使用 Babel 将你的代码转换为兼容 ES5 的版本，然后再运到浏览器上，但在 Node.js 中，你就不需要这样了。

另一个区别是，Node.js 使用 CommonJS 模块系统，而在浏览器中，我们开始看到 ES 模块标准被实施。

在实践中，这意味着你暂时在 Node.js 中使用 require()，而在浏览器中使用 import（译者注：Node 13.2.0 起开始正式支持 ES Modules，可以在 Node 中使用 import :)。

V8 JavaScript 引擎

V8 是谷歌浏览器的 JavaScript 引擎的名字。在使用 Chrome 浏览器浏览时，它能接收我们的JavaScript 并执行它。

V8 提供了运行时环境，在其中执行 JavaScript。DOM 和其他网络平台 API 是由浏览器提供的。

最酷的是，JavaScript 引擎是独立于它所承载的浏览器的。这一关键特征使 Node.js 的崛起成为可能。V8 早在2009年就被 Node.js 选择为引擎，随着 Node.js 的普及，V8成为现在为大量用JavaScript 编写的服务器端代码提供动力的引擎。

Node.js 的生态系统是巨大的，由于它的存在，V8也为桌面应用程序提供了动力，比如 Electron 等项目。

其他 JS 引擎

其他浏览器有自己的 JavaScript 引擎：

• Firefox使用 Spidermonkey
• Safari使用 JavaScriptCore (也叫Nitro)
• Edge使用 Chakra（译者注： 现在Edge放弃自己的引擎，使用chrome一样的引擎，即V8）

还有很多JavaScript引擎。

所有这些引擎都实现了ECMA ES-262标准，也叫ECMAScript，即JavaScript使用的标准。

对性能的追求

V8 是用 C++ 编写的，而且它在不断改进。它是可移植的，可以在 Mac、Windows、Linux 和其他一些系统上运行。

在这个 V8 介绍中，我将忽略 V8 的实现细节。它们可以在更权威的网站上找到，包括 V8官方网站，而且它们随着时间的推移而变化，往往是很大的变化。

V8一直在发展，就像周围的其他JavaScript引擎一样，以加快网络和 Node.js 生态系统的发展。

在网络上，有一场多年来一直在进行的性能竞赛，我们（作为用户和开发者）从这场竞争中获益良多，因为我们年复一年地得到更快和更优化的机器。

编译（Compilation）

一般来说，JavaScript 被认为是一种解释语言，但现代的 JavaScript 引擎不再只是解释JavaScript，而是对其进行编译。

这发生在 2009 年，当时 SpiderMonkey JavaScript 编译器被添加到 Firefox 3.5 中，每个人都遵循这个想法。

JavaScript 由V8内部编译，采用实时制（JIT）编译，以加快执行速度。

这可能看起来违反直觉，。但自从2004年谷歌地图问世以来，JavaScript 已经从一般执行几十行代码的语言发展到在浏览器中运行的几千到几十万行的完整应用程序。

我们的应用程序现在可以在浏览器中运行数小时，而不仅仅是一些表单验证规则或简单的脚本。

在这个新世界里，编译JavaScript是非常有意义的，因为虽然可能需要多花一点时间来让JavaScript就绪，但一旦完成，它的性能就会比纯粹的解释代码高得多。

如何退出 Node.js 程序

终止一个 Node.js 应用程序有多种方法。

在控制台中运行程序时，你可以用 ctrl-C 关闭它，但我想在这里讨论的是以编程方式退出。

让我们从最激烈的一个开始，看看为什么你最好不使用它。

process 核心模块提供了一个方便的方法，允许你以编程方式退出Node.js程序：process.exit()。

当 Node.js 运行这一行时，进程会立即被强制终止。

这意味着任何正在等待的回调，任何仍在发送的网络请求，任何文件系统访问，或写到 stdout 或 stderr 的进程--都将立即被强制地终止。

如果这对你来说是好的，你可以传递一个整数，向操作系统发出退出代码的信号:

process.exit(1)

默认情况下，退出代码是`0'，这意味着成功。不同的退出代码有不同的含义，你可能想在自己的系统中使用这些代码，让程序与其他程序沟通。

你可以阅读更多关于退出代码的内容 这里。

你也可以设置 process.exitCode 属性:

process.exitCode = 1

而当程序后来结束时，Node.js 将返回该退出代码。

当所有的处理完成后，一个程序会优雅地退出。

很多时候，我们用 Node.js 启动服务器，比如这个 HTTP 服务器:

const express = require('express')
const app = express()
app.get('/', (req, res) => {  res.send('Hi!')})
app.listen(3000, () => console.log('Server ready'))

这个程序永远不会结束。如果你调用 process.exit()，任何正在等待或运行的请求都会被终止。这是不好的。

在这种情况下，你需要给命令发送一个 `SIGTERM' 信号，并通过进程信号处理程序来处理:

注意： process 不需要 require，它是自带的。

const express = require('express')
const app = express()

app.get('/', (req, res) => {  res.send('Hi!')})

app.listen(3000, () => console.log('Server ready'))

process.on('SIGTERM', () => {  
  app.close(() => {
      console.log('Process terminated')  
  })
})

什么是信号？信号是一种便携式操作系统接口（POSIX）的互通系统：为了通知一个进程发生的事件而向其发送的通知。

SIGKILL 是告诉一个进程立即终止的信号，最好是像 process.exit() 那样。

SIGTERM 是告诉一个进程优雅地终止的信号。它是进程管理器发出的信号，如 upstart 或 supervisord 和其他的。

你可以从程序内部，在另一个函数中发送这个信号:

process.kill(process.pid, 'SIGTERM')

或者从另一个正在运行的Node.js程序，或者在你的系统中运行的任何其他应用程序，知道你想终止的进程的PID。

如何从 Node.js 读取环境变量

Node的 process 核心模块提供了 env 属性，它承载了所有在进程启动时设置的环境变量。

下面是一个访问 NODE_ENV 环境变量的例子，该变量默认设置为 development。

process.env.NODE_ENV // "development"

在脚本运行前将其设置为 production 将告诉 Node.js，这是一个生产环境。

以同样的方式，你可以访问你设置的任何自定义环境变量。

在哪里托管一个 Node.js 应用程序

一个 Node.js 应用程序可以被托管在很多地方，这取决于你的需求。

下面是一个非详尽的清单，当你想部署你的应用程序并使其可以公开访问时，你可以探索这些选项。

我将列出从最简单和受限制到更复杂和强大的选项。

最简单的选择：本地隧道

即使你有一个动态 IP，或者你在一个 NAT 下，你也可以部署你的应用程序，并使用本地隧道从你的计算机上提供请求。

这个选项适合于一些快速测试、演示产品或与一小部分人分享应用程序。

一个在所有平台上都可用的非常好的工具是 ngrok。

使用它，你只需输入 ngrok PORT，你想要的端口就会暴露在互联网上。你会得到一个 ngrok.io 的域名，但如果付费订阅，你可以得到一个自定义的 URL 以及更多的安全选项（记住，你的机器是向公共互联网开放的）。

你可以使用的另一项服务是 localtunnel。

零配置部署

Glitch

Glitch 是一个 playground，是一种比以往任何时候都更快地建立你的应用程序的方式，并看到它们在自己的 glitch.com 子域上运行。你目前不能拥有一个自定义域名，而且还有一些 限制，但它真的很适合做原型。它看起来很有趣（这是个优点），而且它不是一个傻瓜式的环境--你得到了 Node.js 的所有功能，一个 CDN，安全的证书存储，GitHub 导入/导出和更多。

由 FogBugz 和 Trello 背后的公司（以及 Stack Overflow 的共同创建者）提供。

我经常使用它来做演示。

Codepen

Codepen 是一个了不起的平台和社区。你可以创建一个有多个文件的项目，并以自定义域名进行部署。

Serverless

无服务器（Serverless）是一种发布应用的方式，而且完全没有服务器需要管理。无服务器是一种范式，你把你的应用发布为功能，它们在网络端点上做出响应（也叫FAAS--功能即服务）。

非常受欢迎的解决方案有:

• Serverless Framework
• Standard Library

它们都为在 AWS Lambda 和其他基于 Azure 或谷歌云的 FAAS 解决方案上发布，提供了一个抽象层。

PAAS

PAAS 是 Platform As A Service 的缩写。这些平台解决了很多你在部署应用时应该担心的事情。

Zeit Now

Zeit 是一个有趣的选择。你只需在终端输入 now，它就会负责部署你的应用程序。有一个有限制的免费版本，而付费版本则更强大。你只需忘记有一个服务器，你只需部署应用程序。

Nanobox

Nanobox

Heroku

Heroku 是一个神奇的平台。

这是一篇好文章，在Heroku上开始使用Node.js.

Microsoft Azure

Azure 是微软的云产品。

查看 在Azure中创建一个Node.js Web应用.

Google Cloud Platform

Google Cloud 是你的应用程序的一个了不起的结构。

他们有一个很好的Node.js文档部分.

Virtual Private Server（虚拟私有服务器）

在本节中，你会找到常见的选择,从友好到更不友好的顺序排列:

• Digital Ocean
• Linode
• Amazon Web Services, 我特别提到 Amazon Elastic Beanstalk，因为它抽象了一点 AWS 的复杂性。

因为他们提供了一个空的Linux机器，你可以在上面工作，所以这些没有具体的教程。

在VPS类别中还有很多选择，这些只是我使用的和我推荐的。

Bare metal（裸金属）

另一个解决方案是获得一个 裸机金属服务器，安装一个Linux发行版，把它连接到互联网上（或者每月租一个，比如你可以使用 虚拟裸金属服务）。

如何使用 Node.js REPL

REPL 是 Read-Evaluate-Print-Loop 的缩写，它是一种快速探索 Node.js 功能的好方法。

node 命令是我们用来运行 Node.js 脚本的命令:

node script.js

如果我们省略文件名，我们在 REPL 模式下使用它:

node

如果你现在在你的终端尝试一下，会发生这样的情况:

node

该命令保持在空闲模式，等待我们输入什么。

提示：如果你不确定如何打开你的终端，谷歌 “How to open terminal on ”。

REPL正在等待我们输入一些JavaScript代码。

从简单的开始，然后按下 enter 键:

> console.log('test')
> test
> undefined

第一个值 test，是我们告诉控制台要打印的输出，然后我们得到 undefined，这是运行 console.log() 的返回值。

现在我们可以输入一行新的 JavaScript 了。

通过使用 tab 键完成自动补全

REPL最酷的地方是它是互动的。

当你写代码时，如果你按下 tab 键，REPL 将尝试自动完成你写的内容，以匹配你已经定义的变量或预定义的变量。

探索 JavaScript 对象

试着输入一个 JavaScript 类的名称，如 Number，加一个点，然后按 tab。

REPL将打印出你可以访问该类的所有属性和方法:

探索全局对象（global objects）

你可以通过输入 "global. "并按 "tab "来检查你可以访问的globals对象:

The _ special variable （特殊变量）

如果在一些代码之后，你输入_，这将会打印出最后一个操作的结果。

点命令（Dot commands）

REPL有一些特殊的命令，都以点.开头。它们是

• .help: 显示点命令的帮助。
• .editor: 启用更多的编辑器，可以轻松地编写多行JavaScript代码。一旦你进入这个模式，输入ctrl-D就可以运行你写的代码。
• .break: 当输入一个多行表达式时，输入.break命令将中止继续输入。与按下ctrl-C相同。
• .clear: 将REPL上下文重置为空对象，并清除当前正在输入的任何多行表达式。
• .load: 加载一个JavaScript文件，相对于当前工作目录。
• .save: 将你在REPL会话中输入的所有内容保存到一个文件（指定文件名）
• .exit: 退出repl（与按两次ctrl-C相同）

REPL知道你什么时候在输入一个多行语句，而不需要调用.editor。

例如，如果你开始键入一个迭代，像这样:

[1, 2, 3].forEach(num =>; {

并按下 "enter"，REPL 将转到一个以 3 个点开始的新行，表明你现在可以继续在该块上工作。

... console.log(num)... })

如果你在一行的结尾处输入 .break，多行模式将停止，语句不会被执行。

Node.js，接受来自命令行的参数

如何在 Node.js 程序中接受从命令行传递的参数

在调用 Node.js 程序时，你可以使用以下方式传递任意数量的参数:

node app.js

参数可以是独立的，也可以有一个键和一个值。

例如:

node app.js flavio

或者

node app.js name=flavio

这改变了你在 Node.js 代码中检索该值的方式。

你检索它的方式是使用 Node.js 内置的 process 对象。

它暴露了一个 argv 属性，这是一个包含所有命令行调用参数的数组。

第一个参数是 node 命令的完整路径。

第二个元素是正在执行的文件的完整路径。

所有的附加参数都是从第三个位置开始往前出现。

你可以用一个循环遍历所有的参数（包括节点路径和文件路径）:

process.argv.forEach((val, index) => {  
  console.log(`${index}: ${val}`)
})

你可以通过创建一个排除前两个参数的新数组，只获得额外的参数:

const args = process.argv.slice(2)

如果你有一个没有索引名称的参数，像这样:

node app.js flavio

你可以通过以下方式访问它

const args = process.argv.slice(2)
args[0]

在这种情况下:

node app.js name=flavio

args[0] 的值是 name=flavio，而你需要对它进行解析。最好的方法是使用 minimist，它有助于处理参数:

const args = require('minimist')(process.argv.slice(2))
args['name'] //flavio

使用 Node.js 输出到命令行

如何使用 Node.js 打印到命令行控制台，从基本的 console.log 到更复杂的情况。

使用控制台模块的基本输出

Node.js提供了一个 console模块，它提供了大量非常有用的方法来与命令行进行交互。

它基本上与你在浏览器中找到的 console 对象相同。

最基本和最常用的方法是 console.log()，它将你传递给它的字符串打印到控制台。

如果你传递一个对象，它将把它渲染成一个字符串。

你可以向 console.log 传递多个变量，例如:

const x = 'x'
const y = 'y'
console.log(x, y)

而 Node.js 会同时打印。

我们还可以通过传递变量和格式指定器来格式化短语，让它看起来更漂亮。

例如:

console.log('My %s has %d years', 'cat', 2)

• %s 格式化变量为字符串
• %d 或者 %i 格式化变量为整数
• %f 格式化一个变量为浮点数
• %O 用于打印一个对象的表示方法

比如:

console.log('%O', Number)

清空控制台

console.clear() 清空控制台（其行为可能取决于所使用的控制台）

元素统计

console.count() 是一个很方便的方法。

以此代码为例:

const x = 1
const y = 2
const z = 3 
console.count(  'The value of x is ' + x + ' and has been checked .. how many times?')
console.count(  'The value of x is ' + x + ' and has been checked .. how many times?')
console.count(  'The value of y is ' + y + ' and has been checked .. how many times?')

发生的情况是，count 将计算一个字符串被打印的次数，并在其旁边打印出计数。

你可以只统计 apples 和 oranges:

const oranges = ['orange', 'orange']
const apples = ['just one apple'] 
oranges.forEach(fruit => {console.count(fruit)}) 
apples.forEach(fruit => {console.count(fruit)})

打印堆栈跟踪

在有些情况下，打印一个函数的调用堆栈跟踪是很有用的，也许是为了回答这个问题。"你是如何到达代码的这一部分的？”

你可以使用 console.trace():

const function2 = () => console.trace()
const function1 = () => function2()
function1()

这将打印出堆栈跟踪。如果我在 Node REPL 中尝试这样做，会打印出以下内容:

Trace    
at function2 (repl:1:33)    
at function1 (repl:1:25)    
at repl:1:1    
at ContextifyScript.Script.runInThisContext (vm.js:44:33)    
at REPLServer.defaultEval (repl.js:239:29)    
at bound (domain.js:301:14)    
at REPLServer.runBound [as eval] (domain.js:314:12)    
at REPLServer.onLine (repl.js:440:10)    
at emitOne (events.js:120:20)    
at REPLServer.emit (events.js:210:7)

计算花费的时间

你可以使用 time() 和 timeEnd() 轻松计算出一个函数的运行时间。

const doSomething = () => console.log('test')
const measureDoingSomething = () => {
    console.time('doSomething()')     //do something, and measure the time it takes doSomething() 
    doSomething()
    console.timeEnd('doSomething()')
}

measureDoingSomething()

stdout 和 stderr

正如我们所看到的，console.log 很适合在控制台中打印信息。这就是所谓的标准输出（stdout）。

console.error 打印到 stderr 流（stream）。

它不会出现在控制台，但会出现在错误日志中。

输出颜色

你可以通过使用转义序列给控制台中的文本输出着色。转义序列是一组标识颜色的字符。

Example:

console.log('\x1b[33m%s\x1b[0m', 'hi!')

你可以在 Node REPL 中尝试这样做，它将以黄色打印 hi!。

然而，这只是低级别的方法。为控制台输出着色的最简单方法是使用一个库。Chalk 就是这样一个库，除了着色之外，它还可以帮助其他的样式设计，比如将文本加粗、斜体或下划线。

你用 npm install chalk 安装它，然后你就可以使用它:

const chalk = require('chalk')
console.log(chalk.yellow('hi!'))

使用 chalk.yellow 比记住转义代码要方便得多，而且代码的可读性也很强。

查看我在上面发布的 Chalk 项目链接，了解更多的使用实例。

创建一个进度条

Progress 是一个很棒的软件包，可以在控制台中创建一个进度条。使用 npm install progress 来安装它。

这个片段创建了一个10步的进度条，每100毫秒完成一步。当进度条完成后，我们会清除间隔时间:

const ProgressBar = require('progress')
const bar = new ProgressBar(':bar', { total: 10 })
const timer = setInterval(() => {
    bar.tick()
    if (bar.complete) { 
      clearInterval(timer) 
    }
}, 100)

在 Node.js 中接受来自命令行的输入

如何使 Node.js CLI 程序具有交互性？

Node 从第7版开始就提供了 readline模块 来执行这个任务：从一个可读流中获取输入，比如 process.stdin 流，在 Node 程序的执行过程中，它就是终端输入，一次一个行。

const readline = require('readline')
                .createInterface({
                  input: process.stdin, output: process.stdout 
                })
readline.question(`What's your name?\n`, (name) => {
    console.log(`Hi ${name}!`)
    readline.close()
})

这段代码询问用户名，一旦输入文本并且用户按了回车键，我们就会发送一个问候语。

question() 方法显示第一个参数（一个问题）并等待用户输入。一旦回车键被按下，它就会调用回调函数。

在这个回调函数中，我们关闭 readline 接口。

readline 提供了其他几个方法，我将让你在我上面 链接 文档中查看它们。

如果你需要要求一个密码，现在最好是回显它，而是显示一个*符号。

最简单的方法是使用 readline-sync，它在API方面非常相似，可以开箱即用。

一个更完整和抽象的解决方案是由 Inquirer.js 提供。

你可以用 npm install inquirer 来安装它，然后你可以像这样复制上面的代码:

const inquirer = require('inquirer')
const questions = [{ type: 'input', name: 'name', message: "What's your name?", }]
inquirer.prompt(questions).then(answers => { 
    console.log(`Hi ${answers['name']}!`) 
})

Inquirer.js 可以让你做很多事情，比如问多个选择，有单选按钮，确认选项等等。

值得了解所有的替代方案，特别是 Node.js 提供的内置方案，但如果你打算将 CLI 输入提高到一个新的水平，Inquirer.js 是一个最佳选择。

使用 exports 从 Node.js 文件中暴露功能（Expose functionality）

如何使用 module.exports API 将数据暴露给你的应用程序中的其他文件，或者也暴露给其他应用程序。

Node.js 有一个内置的模块系统。

一个 Node.js 文件可以导入其他 Node.js 文件所暴露的功能。

当你想导入一些东西时，你可以使用:

const library = require('./library')

导入驻扎在当前文件夹中的 library.js 文件中所暴露的功能。

在这个文件中，功能必须在被其他文件导入之前被公开。

文件中定义的任何其他对象或变量默认为私有，不向外界公开。

这就是 module 系统提供的 module.exports API所允许我们做的。

当你把一个对象或一个函数指定为新的 exports 属性时，这就是被暴露的东西。因此，它可以被导入到你的应用程序的其他部分，或者其他应用程序中。

你可以通过2种方式做到这一点。

首先是给 module.exports 指定一个对象，这是一个由模块系统提供的开箱即用的对象，这将使你的文件只导出那个对象:

const car = {  brand: 'Ford',  model: 'Fiesta'}
module.exports = car

//..in the other file
const car = require('./car')

第二种方式是将导出的对象作为 exports 的一个属性。这种方式允许你导出多个对象、函数或数据:

const car = {  brand: 'Ford',  model: 'Fiesta'}
exports.car = car

或直接

exports.car = {  brand: 'Ford',  model: 'Fiesta'}

而在另一个文件中，你将通过引用你导入的一个属性来使用它:

const items = require('./items')items.car

或者

const car = require('./items').car

module.exports 和 exports 之间有什么区别？

前者暴露了 它所指向的对象。后者暴露了它所指向的对象的 属性。

npm 简介

npm 是 node 软件包管理器。

2017年1月，超过35万个软件包被报告列在 npm registry 中，使其成为地球上最大的单一语言代码库，你可以肯定有一个软件包用于（几乎！）一切。

它开始时是一种下载和管理Node.js包的依赖关系的方式，但后来它也成为了一个用于前端 JavaScript 的工具。

npm 做了很多事情。

下载

npm 管理你项目的依赖项下载。

安装所有的依赖项

如果一个项目有一个 packages.json 文件，通过运行

npm install

它将在 node_modules 文件夹中安装项目所需的一切，如果它不存在，则创建它。

安装单个软件包

你也可以通过运行以下命令来安装一个特定的软件包

npm install <package-name>

通常你会看到在这个命令中加入更多的标志（flags）:

• --save 安装并添加条目到 package.json 文件中 dependencies。
• --save-dev 安装并添加条目到 package.json 文件 devDependencies 中。

区别主要在于，devDependencies 通常是开发工具，如测试库，而 dependencies 是与生产中的应用捆绑在一起的。

更新软件包

更新也很容易，通过运行

npm update

npm 将检查所有软件包是否有满足你的版本约束的较新版本。

你可以指定一个单独的软件包来更新:

npm update <package-name>

版本管理

除了普通的下载，npm 还管理版本，所以你可以指定一个包的任何特定版本，或者要求比你所需要的版本高或低。

很多时候，你会发现一个库只与另一个库的主要版本兼容。

或者一个库的最新版本中的一个bug，仍未被修复，导致了一个问题。

指定一个库的明确版本也有助于让每个人都处于同一个确切的软件包版本上，这样整个团队就会运行同一个版本，直到 package.json 文件被更新。

在所有这些情况下，版本管理都有很大帮助，npm 遵循语义版本管理（semver）标准。

运行任务

package.json 文件支持一种指定命令行任务的格式，可以通过使用

npm <task-name>

例如:

{
    "scripts": {
        "start-dev": "node lib/server-development",
        "start": "node lib/server-production"
    }
}

使用这个功能来运行Webpack是非常普遍的:

{
    "scripts": {
        "watch": "webpack --watch --progress --colors --config webpack.conf.js",
        "dev": "webpack --progress --colors --config webpack.conf.js",
        "prod": "NODE_ENV=production webpack -p --config webpack.conf.js",
    }
}

因此，与其输入那些容易忘记或打错的长命令，你可以运行

npm watch 
npm dev 
npm prod

npm在哪里安装软件包？

当你使用npm（或 yarn）安装一个软件包时，你可以执行2种类型的安装:

• a local install （本地安装）
• a global install （全局安装）

默认情况下，当你输入一个 "npm install "命令时，例如:

npm install lodash

包被安装在当前文件树下的 node_modules 子文件夹中。

在这种情况下，npm 也会在当前文件夹中的 package.json 文件的 dependencies 属性中添加 lodash 条目。

使用 -g 标志进行全局安装:

npm install -g lodash

当这种情况发生时，npm 不会将软件包安装在本地文件夹下，而是会使用一个全局位置。

具体在哪里？

npm root -g 命令将告诉你该位置在你的机器上的确切位置。

在MacOS或Linux上，这个位置可以是 /usr/local/lib/node_modules。 在 Windows 上应该是C:\Users\YOU\AppData\Roaming\npm\node_modules

然而，如果你使用 nvm 来管理 Node.js 的版本，这个位置会有所不同。

例如，我使用 nvm，我的软件包位置显示为 /Users/flavio/.nvm/versions/node/v8.9.0/lib/node_modules。

如何使用或执行一个用 npm 安装的软件包

如何在你的代码中包含并使用安装在 node_modules 文件夹中的软件包

当你使用 npm 安装一个包到你的 node_modules 文件夹，或者全局安装，你如何在你的Node代码中使用它？

假设你安装了 lodash，一个流行的 JavaScript 工具库，使用

npm install lodash

这将在本地的 node_modules 文件夹中安装该软件包

要在你的代码中使用它，你只需要用 require 将它导入你的程序:

const _ = require('lodash')

如果你的软件包是一个可执行文件呢？

在这种情况下，它将把可执行文件放在 node_modules/.bin/ 文件夹下。

一个简单的演示, 使用 cowsay。

cowsay 软件包提供了一个命令行程序，执行该程序可以让一头牛说些什么（也可以是其他动物）。

当你使用 npm install cowsay 来安装这个包时，它将自己和一些依赖项安装在 node_modules 文件夹:

有一个隐藏的.bin文件夹，它包含cowsay二进制文件的符号链接。

你如何执行这些？

你当然可以输入 ./node_modules/.bin/cowsay 来运行它，它也可以工作，但是 npx，包括在最近版本的 npm 中（从5.2开始），是一个更好的选择。你只需运行:

npx cowsay

而npx会找到软件包的位置。

package.json 指南

package.json 文件是很多基于 Node.js 生态系统的应用代码库中的一个关键元素。

如果你用 JavaScript 工作，或者你曾经与一个 JavaScript 项目、Node.js 或前端项目互动，你肯定见过 package.json 文件。

那是做什么用的？你应该知道些什么，你可以用它做哪些很酷的事情？

package.json 文件是你项目的清单。它可以做很多事情，完全不相关。例如，它是一个工具配置的中央仓库。它也是 npm 和 yarn 存储它所安装的软件包的名称和版本的地方。

文件结构

下面是一个 package.json 文件的例子:

{}

它是空的! 对于一个应用程序来说,package.json 文件中应该包含什么并没有固定的要求。唯一的要求是遵循 JSON 格式，否则它不能被试图以编程方式访问其属性的程序读取。

如果你正在构建一个 Node.js 包，你想通过 npm 发布，事情就会发生根本性的变化，你必须有一套属性来帮助其他人使用它。我们将在后面看到更多关于这方面的内容。

这是另一个 package.json:

{  "name": "test-project"}

它定义了一个 name 属性，它告诉了这个文件所在的同一文件夹中包含的应用程序或包的名称。

这里有一个更复杂的例子，我从一个 Vue.js 应用样本中提取了这个例子:

{
    "name": "test-project",
    "version": "1.0.0",
    "description": "A Vue.js project",
    "main": "src/main.js",
    "private": true,
    "scripts": {
        "dev": "webpack-dev-server --inline --progress --config build/webpack.dev.conf.js",
        "start": "npm run dev",
        "unit": "jest --config test/unit/jest.conf.js --coverage",
        "test": "npm run unit",
        "lint": "eslint --ext .js,.vue src test/unit",
        "build": "node build/build.js"
    },
    "dependencies": {
        "vue": "^2.5.2"
    },
    "devDependencies": {
        "autoprefixer": "^7.1.2",
        "babel-core": "^6.22.1",
        "babel-eslint": "^8.2.1",
        "babel-helper-vue-jsx-merge-props": "^2.0.3",
        "babel-jest": "^21.0.2",
        "babel-loader": "^7.1.1",
        "babel-plugin-dynamic-import-node": "^1.2.0",
        "babel-plugin-syntax-jsx": "^6.18.0",
        "babel-plugin-transform-es2015-modules-commonjs": "^6.26.0",
        "babel-plugin-transform-runtime": "^6.22.0",
        "babel-plugin-transform-vue-jsx": "^3.5.0",
        "babel-preset-env": "^1.3.2",
        "babel-preset-stage-2": "^6.22.0",
        "chalk": "^2.0.1",
        "copy-webpack-plugin": "^4.0.1",
        "css-loader": "^0.28.0",
        "eslint": "^4.15.0",
        "eslint-config-airbnb-base": "^11.3.0",
        "eslint-friendly-formatter": "^3.0.0",
        "eslint-import-resolver-webpack": "^0.8.3",
        "eslint-loader": "^1.7.1",
        "eslint-plugin-import": "^2.7.0",
        "eslint-plugin-vue": "^4.0.0",
        "extract-text-webpack-plugin": "^3.0.0",
        "file-loader": "^1.1.4",
        "friendly-errors-webpack-plugin": "^1.6.1",
        "html-webpack-plugin": "^2.30.1",
        "jest": "^22.0.4",
        "jest-serializer-vue": "^0.3.0",
        "node-notifier": "^5.1.2",
        "optimize-css-assets-webpack-plugin": "^3.2.0",
        "ora": "^1.2.0",
        "portfinder": "^1.0.13",
        "postcss-import": "^11.0.0",
        "postcss-loader": "^2.0.8",
        "postcss-url": "^7.2.1",
        "rimraf": "^2.6.0",
        "semver": "^5.3.0",
        "shelljs": "^0.7.6",
        "uglifyjs-webpack-plugin": "^1.1.1",
        "url-loader": "^0.5.8",
        "vue-jest": "^1.0.2",
        "vue-loader": "^13.3.0",
        "vue-style-loader": "^3.0.1",
        "vue-template-compiler": "^2.5.2",
        "webpack": "^3.6.0",
        "webpack-bundle-analyzer": "^2.9.0",
        "webpack-dev-server": "^2.9.1",
        "webpack-merge": "^4.1.0"
    },
    "engines": {
        "node": ">= 6.0.0",
        "npm": ">= 3.0.0"
    },
    "browserslist": ["> 1%", "last 2 versions", "not ie <= 8"]
}

这里有很多的事情要做:

• name 设置应用程序/包的名称
• version 设置应用程序/包的名称
• description 是对应用程序/包的简要描述
• main 设置应用程序的入口点
• private 如果设置为 true 可以防止应用程序/软件包被意外地发布到 npm
• scripts 定义了一组你可以运行的node脚本
• dependencies 设置一个作为依赖项安装的 npm 包的列表
• devDependencies 设置一个作为开发依赖的 npm 包的列表
• engines 设置该软件包/应用程序适用于哪些版本的 Node
• browserslist 用于告诉你要支持哪些浏览器（以及它们的版本）

所有这些属性都被 npm 或其他我们可以使用的工具所使用。

属性分类

本节详细描述了你可以使用的属性。我指的是 包（package），但同样的事情也适用于你不作为包使用的本地应用程序。

这些属性大多只在 npm网站 上使用，其他的由与你的代码交互的脚本使用，如 npm 或其他。

name

设置软件包的名称。

例如:

{"name": "test-project"}

该名称必须少于214个字符，不能有空格，只能包含小写字母、连字符（-）或下划线（_）。

这是因为当一个软件包在 npm 上发布时，它会根据这个属性获得自己的URL。

author

列出软件包作者的名字

例如:

{
    "author": "Flavio Copes <flavio@flaviocopes.com> (https://flaviocopes.com)"
}

也可与此格式一起使用:

{
    "author": {
        "name": "Flavio Copes",
        "email": "flavio@flaviocopes.com",
        "url": "https://flaviocopes.com"
    }
}

contributors

除了作者之外，该项目还可以有一个或多个贡献者。这个属性是一个数组，列出他们。

例如:

{
    "contributors": ["Flavio Copes <flavio@flaviocopes.com> (https://flaviocopes.com)"]
}

也可与此格式一起使用:

{
    "contributors": [{
        "name": "Flavio Copes",
        "email": "flavio@flaviocopes.com",
        "url": "https://flaviocopes.com"
    }]
}

bugs

链接到软件包的issues跟踪器，很可能是GitHub issues页面

比如:

{  "bugs": "https://github.com/flaviocopes/package/issues"}

homepage

设置软件包的主页

例子:

{  "homepage": "https://flaviocopes.com/package"}

version

表示软件包的当前版本。

例子:

{"version": "1.0.0"}

这个属性遵循版本的语义版本（semver）符号，这意味着版本总是用3个数字表示。x.x.x。

第一个数字是主要版本，第二个是次要版本，第三个是补丁版本。

这些数字是有意义的：一个只修复bug的版本是补丁版本，一个引入了向后兼容的变化的版本是次要版本，一个主要版本可以有突破性的变化。

license

表示该软件包的许可证。

例如:

{"license": "MIT"}

keywords

这个属性包含一个与你的包所做的事情相关联的关键词。

例如:

{"keywords": [  "email",  "machine learning",  "ai"]}

这有助于人们在浏览类似的软件包或浏览npm官网时找到你的软件包。

description

这个属性包含了对软件包的简要描述.

例如:

{"description": "A package to work with strings"}

如果你决定将你的软件包发布到npm上，这样人们就能发现软件包的内容，这就特别有用。

repository

这个属性指定了这个软件包仓库的位置。

例如:

{"repository": "github:flaviocopes/testing"}

注意github前缀。 还有其他受欢迎的服务：:

{"repository": "gitlab:flaviocopes/testing"}

{"repository": "bitbucket:flaviocopes/testing"}

你可以明确地设置所使用的版本控制系统:

{"repository": {  "type": "git",  "url": "https://github.com/flaviocopes/testing.git"}}

你可以使用不同的版本控制系统:

{"repository": {  "type": "svn",  "url": "..."}}

main

设置包的入口点。

当你在一个应用程序中导入这个包时，应用程序就会在这里搜索模块的出口。

例如:

{"main": "src/main.js"}

private

如果设置为 "true"，可以防止应用程序/软件包被意外地发布在 "npm" 上

例如:

{"private": true }

scripts

定义了一组你可以运行的 node 脚本

例如:

{
  "scripts": {
    "dev": "webpack-dev-server --inline --progress --config build/webpack.dev.conf.js",
    "start": "npm run dev",
    "unit": "jest --config test/unit/jest.conf.js --coverage",
    "test": "npm run unit",
    "lint": "eslint --ext .js,.vue src test/unit",
    "build": "node build/build.js"
  }
}

这些脚本是命令行应用程序。你可以通过调用 npm run XXXX 或 yarn XXXX 来运行它们，其中 XXXX 是命令名称。

例如:
npm run dev

你可以为命令使用任何你想要的名字，而且脚本可以做任何你想要的事情。

dependencies

设置一个作为依赖项安装的 npm 包的列表。

当你使用 npm 或 yarn 安装一个包时:

npm install <PACKAGENAME>
yarn add <PACKAGENAME>

该软件包会自动插入该列表中。

例如:

 {"dependencies": {  "vue": "^2.5.2"}}

devDependencies

设置一个作为开发依赖的 npm 包的列表。

它们与 dependencies 不同，因为它们只能安装在开发机器上，不需要在生产中运行代码。

当你使用 npm 或 yarn 安装一个包时:

npm install --dev <PACKAGENAME>
yarn add --dev <PACKAGENAME>

该软件包会自动插入该列表中。

比如:

{"devDependencies": {  "autoprefixer": "^7.1.2",  "babel-core": "^6.22.1"}}

engines

设置该软件包/应用程序适用于哪些版本的Node.js和其他命令。

例如:

{"engines": {  "node": ">= 6.0.0",  "npm": ">= 3.0.0",  "yarn": "^0.13.0"}}

browserslist

是用来告诉你要支持哪些浏览器（以及它们的版本）。它被 Babel、Autoprefixer 和其他工具引用，只为你的目标浏览器添加所需的 polyfills（降级方案）和fallbacks（回退方案）。

例如:

{"browserslist": [  "> 1%",  "last 2 versions",  "not ie <= 8"]}

这种配置意味着你要支持所有至少有1%使用量的浏览器的最后两个主要版本（来自 CanIUse.com统计），但IE8和更低版本除外（见更多 浏览器列表）。

Command-specific properties

package.json 文件也可以承载特定命令的配置，例如 Babel、ESLint 等等。

每一个都有一个特定的属性，如 eslintConfig，babel 和其他。这些都是特定的命令，你可以在各自的命令/项目文档中找到如何使用它们。

Package versions

你在上面的描述中看到了这样的版本号。~3.0.0 或 ^0.13.0。它们是什么意思，你还可以使用哪些其他的版本指定符？

该符号指定了你的软件包接受哪些更新，来自该依赖关系。

鉴于使用semver（语义版本管理），所有的版本都有3位数字，第一位是主要版本，第二位是次要版本，第三位是补丁版本，你有这些规则:

• ~: 如果你写 ~0.13.0, 你想只更新补丁版本。0.13.1可以，但0.14.0不可以。
• ^: 如果你写 ^0.13.0, 你想更新补丁和次要版本。0.13.1, 0.14.0等等。
• *: 如果你写 *, 这意味着你接受所有的更新，包括主要版本的升级。
• >: 你接受比你指定的版本高的任何版本。
• >=: 你接受任何等于或高于你指定的版本。
• <=: 你接受任何等于或低于你指定的版本。
• <: 你接受比你指定的版本低的任何版本。

也有其他规则:

• no symbol：你只接受你指定的那个特定版本
• latest：你想使用最新的可用版本

你可以将上述大部分的范围结合起来，就像这样。1.0.0 || >=1.1.0 < 1.2.0，以使用1.0.0或1.1.0以上的一个版本，但低于1.2.0。

package-lock.json 文件

package-lock.json 文件是在安装 Nodo包时自动生成的。

在版本5中，NPM 引入了 package-lock.json 文件。

那是什么？你可能知道 package.json 文件，它更常见，存在的时间也更长。

该文件的目的是跟踪每一个安装的软件包的确切版本，这样，即使软件包被维护者更新，产品也能以同样的方式100%重现。

这解决了 package.json 未解决的一个非常具体的问题。在 package.json 中，你可以使用 semver 注解来设置你想升级到哪个版本（补丁或小版本），例如:

• 如果你写 ~0.13.0, 你想只更新补丁版本。0.13.1可以，但 0.14.0 不行。
• 如果你写 ^0.13.0, 你想更新补丁和次要版本。0.13.1, 0.14.0 等等。
• 如果你写 0.13.0, 这就是将被使用的确切版本，永远都是 0.13.0。

你不会向 Git 提交你的 node_modules 文件夹，它通常是巨大的，当你试图通过使用 npm install 命令在另一台机器上复制项目时，如果你指定了~语法，并且一个包的补丁版本已经发布，那就会被安装。对于 ^ 和次要版本也是如此。

如果你指定了准确的版本，如例子中的 "0.13.0"，你就不会受到这个问题的影响。

可能是你，也可能是另一个人在世界的另一端试图通过运行 npm install 来初始化这个项目。

所以你的原始项目和新初始化的项目实际上是不同的。即使一个补丁或小版本不应该引入破坏性的变化，我们都知道bug可以（所以，他们会）潜入。

package-lock.json 将你当前安装的每个软件包的版本in stone上，npm 在运行 npm install 时将使用这些确切的版本。

这个概念并不新鲜，其他编程语言的包管理器（如 PHP 中的 Composer）多年来也使用类似的系统。

package-lock.json 文件需要提交到你的 Git 仓库，如果项目是公开的或者你有合作者，或者你使用 Git 作为部署的来源，那么它可以被其他人取走。

当你运行 npm update 时，依赖的版本将在 package-lock.json 文件中更新。

一个例子

这是一个 package-lock.json 文件的结构示例，当我们在一个空的文件夹中运行 npm install cowsay 时，我们得到了这个文件:

{
    "requires": true, "lockfileVersion": 1, "dependencies": {
        "ansi-regex": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=" }, "cowsay": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/cowsay/-/cowsay-1.3.1.tgz", "integrity": "sha512-3PVFe6FePVtPj1HTeLin9v8WyLl+VmM1l1H/5P+BTTDkMAjufp+0F9eLjzRnOHzVAYeIYFF5po5NjRrgefnRMQ==", "requires": { "get-stdin": "^5.0.1", "optimist": "~0.6.1", "string-width": "~2.1.1", "strip-eof": "^1.0.0" } }, "get-stdin": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-5.0.1.tgz", "integrity": "sha1-Ei4WFZHiH/TFJTAwVpPyDmOTo5g=" }, "is-fullwidth-code-point": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=" }, "minimist": { "version": "0.0.10", "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.10.tgz", "integrity": "sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8=" }, "optimist": {
            "version": "0.6.1", "resolved": "https://registry.npmjs.org/optimist/-/optimist-0.6.1.tgz", "integrity": "sha1-2j6nRob6IaGaERwybpDrFaAZZoY=",

                "requires": { "minimist": "~0.0.1", "wordwrap": "~0.0.2" }
        }, "string-width": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", "requires": { "is-fullwidth-code-point": "^2.0.0", "strip-ansi": "^4.0.0" } }, "strip-ansi": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", "requires": { "ansi-regex": "^3.0.0" } }, "strip-eof": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=" }, "wordwrap": { "version": "0.0.3", "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz", "integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=" }
    }
}

我们安装了 cowsay，它依赖于:

• get-stdin
• optimist
• string-width
• strip-eof

反过来，这些软件包需要其他的软件包，我们可以从 "requires "属性中看到，有些软件包有:

• ansi-regex
• is-fullwidth-code-point
• minimist
• wordwrap
• strip-eof

它们按字母顺序被添加到文件中，每一个都有一个 version 字段，一个指向软件包位置的 resolved 字段，以及一个 integrity 字符串，我们可以用来验证该软件包。

查找一个npm包的安装版本

查看所有安装的 npm 包的最新版本，包括它们的依赖关系:

npm list

例如:

❯ npm list/Users/flavio/dev/node/cowsay
  └─┬ cowsay@1.3.1  
    ├── get-stdin@5.0.1  
    ├─┬ optimist@0.6.1  
    │ ├── minimist@0.0.10  
    │ └── wordwrap@0.0.3  
    ├─┬ string-width@2.1.1  
      ├── is-fullwidth-code-point@2.0.0  
      │ └─┬ strip-ansi@4.0.0  
      │   └── ansi-regex@3.0.0  
      └── strip-eof@1.0.0

你也可以直接打开 package-lock.json 文件，但这涉及一些用眼睛查看。

npm list -g 也是一样的，只是针对全局安装的软件包。

要想只得到你的顶层软件包（基本上是你告诉 npm 安装的和你在 package.json 中列出的那些），运行 npm list --depth=0:

❯ npm list --depth=0/Users/flavio/dev/node/cowsay
   └── cowsay@1.3.1

你可以通过指定名称来获得一个特定软件包的版本:

❯ npm list cowsay/Users/flavio/dev/node/cowsay
  └── cowsay@1.3.1

这也适用于你安装的软件包的依赖性:

❯ npm list minimist/Users/flavio/dev/node/cowsay
  └─┬ cowsay@1.3.1  
    └─┬ optimist@0.6.1    
      └── minimist@0.0.10

如果你想查看npm仓库中软件包的最新可用版本，运行npm view [package_name] version:

❯ npm view cowsay version

1.3.1

安装一个旧版本的 npm 包

安装一个旧版本的 npm 包可能对解决兼容性问题有帮助。

你可以使用 @ 语法来安装一个npm包的旧版本:

npm install <package>@<;version>

例如:

npm install cowsay

安装1.3.1版本（在撰写本文时）。

安装1.2.0 版本:

npm install cowsay@1.2.0

同样的情况也可以用全局包来做:

npm install -g webpack@4.16.4

你也可能对列出一个包的所有以前的版本感兴趣。你可以用 npm view <package> versions 来做:

❯ npm view cowsay versions

[ '1.0.0',  '1.0.1',  '1.0.2',  '1.0.3',  '1.1.0',  '1.1.1',  '1.1.2',  '1.1.3',  '1.1.4',  '1.1.5',  '1.1.6',  '1.1.7',  '1.1.8',  '1.1.9',  '1.2.0',  '1.2.1',  '1.3.0',  '1.3.1' ]

将所有 Node 的依赖关系更新为最新版本

当你使用 npm install <packagename> 安装一个软件包时，该软件包的最新可用版本会被下载并放在 node_modules文件夹 中，并且在你当前文件夹中的package.json 和 package-lock.json 文件中添加相应条目。

npm会计算依赖关系，并安装那些最新的可用版本。

假设你安装了 [cowsay][85]，一个很酷的命令行工具，可以让你让cow（牛）说东西。

当你 npm安装cowsay 时，这个条目被添加到 package.json 文件中:

{  "dependencies": {    "cowsay": "^1.3.1"  }}

这是 package-lock.json 的摘录，为了清晰起见，我把嵌套的依赖关系去掉了:

{
    "requires": true,
    "lockfileVersion": 1,
    "dependencies": {
        "cowsay": {
            "version": "1.3.1",
            "resolved": "https://registry.npmjs.org/cowsay/-/cowsay-1.3.1.tgz",
            "integrity": "sha512-3PVFe6FePVtPj1HTeLin9v8WyLl+VmM1l1H/5P+BTTDkMAjufp+0F9eLjzRnOHzVAYeIYFF5po5NjRrgefnRMQ==",
            "requires": {
                "get-stdin": "^5.0.1",
                "optimist": "~0.6.1",
                "string-width": "~2.1.1",
                "strip-eof": "^1.0.0"
            }
        }
    }
}

现在这2个文件告诉我们，我们安装了cowsay的1.3.1版本，而我们的更新规则是 ^1.3.1，对于npm的版本规则（后面会解释）意味着npm可以更新到补丁和小版本。0.13.1，0.14.0，以此类推。

如果有一个新的次要版本或补丁版本，我们输入 npm update，安装的版本就会被更新，package-lock.json 文件就会勤奋地填上新的版本。

package.json 保持不变。

为了发现新发布的软件包，你可以运行 npm outdated。

下面是我很久没有更新的一个软件库中的一些过时的软件包的列表:

其中一些更新是主要版本。运行 npm update 不会更新这些版本。主要版本从不以这种方式更新，因为它们（顾名思义）会带来破坏性的变化，而 npm 想为你省去麻烦。

要将所有软件包更新到新的主要版本，请在全局安装 npm-check-updates 包:

npm install -g npm-check-updates

然后运行:

ncu -u

这将升级 package.json 文件中的所有版本提示，到 dependencies 和 devDependencies，所以 npm 可以安装新的主要版本（major version）。

现在你已经准备好运行更新:

npm update

如果你刚下载的项目没有 node_modules 的依赖，你想先安装全新版本，只要运行

npm install

使用 npm 进行语义版本管理

语义版本管理（Semantic Versioning）是一种用来为版本提供意义的惯例。

如果说Node.js包中有什么了不起的东西，那就是所有的人都同意使用语义版本控制（Semantic Versioning）来进行版本编号。

语义版本控制的概念很简单：所有的版本都有3位数字。x.y.z。

• 第一个数字是主版本（major version）
• 第二位数字是次要版本 （minor version）
• 第三位数字是补丁版本 （patch version）

当你制作一个新的版本时，你不会随心所欲地提高一个数字，而是有规则的:

• 当你对API进行不兼容的修改时，你要提高主版本的等级
• 当你以向后兼容的方式增加功能时，你要提高次要版本的数量
• 当你进行向后兼容的 bug 修复时，你要提高补丁版本

这个惯例在所有的编程语言中都被采用，而且每个 npm 包都要遵守这个惯例，这一点非常重要，因为整个系统都依赖于此。

为什么这么重要？

因为 npm 设置了一些规则，我们可以在 package.json文件 中使用，以便在运行 npm update 时，选择它可以将我们的软件包更新到哪些版本。

规则使用这些符号:

• ^
• ~
• =
• >=
• <
• <=
• =
• -
• ||

让我们看看这些规则的细节:

• ^: 如果你写 ^0.13.0，当运行 npm update， 它可以更新到补丁（patch）和次要版本（minor version）: 0.13.1, 0.14.0 等。
• ~: 如果你写 ~0.13.0, 当运行 npm update，它可以更新到补丁（patch）: 0.13.1是可以的, 但 0.14.0 不行。
• >: 你接受比你指定的版本高的任何版本
• >=: 你接受任何等于或高于你指定的版本
• <=: 你接受任何等于或低于你指定的版本
• <: 你接受比你指定的版本低的任何版本
• =: 你接受确切的版本
• -: 你接受一定范围的版本。例如: 2.1.0 - 2.6.2
• ||: 你结合一组。例如: < 2.1 || > 2.6

你可以结合这些符号，例如使用 1.0.0 || >=1.1.0 <1.2.0 来表示使用 1.0.0 或 1.1.0 以上的一个版本，但低于1.2.0。

也有其他规则:

• no symbol：你只接受你指定的那个特定版本（1.2.1）。
• latest：你想使用最新的可用版本

在本地或全球范围内卸载 npm 包

要卸载你以前本地安装的软件包（使用 npm install <package-name> 在 node_modules 文件夹下），请运行:

npm uninstall <package-name>

使用 -S 标志，或 --save，这个操作也将删除 package.json 文件 中的引用。

如果软件包是一个开发依赖，列在 package.json 文件的 devDependencies 中，你必须使用 -D/--save-dev 标志从文件中删除它:

npm uninstall -S <package-name>
npm uninstall -D <package-name>

如果软件包在全局范围内**安装，你需要添加 -g/--global 标志:

npm uninstall -g <package-name>

例如:

npm uninstall -g webpack

你可以在你系统的任何地方运行这个命令，因为你目前所在的文件夹并不重要。

全局或本地软件 npm 包

一个软件包最好在什么时候全局安装？以及为什么？

本地包和全局包的主要区别:

• 本地包 安装在你运行 npm install <package-name> 的目录下，并且它们被放在这个目录下的 node_modules 文件夹中。
• 全局包 都放在你系统中的一个地方（具体位置取决于你的设置），不管你在哪里运行 npm install -g <package-name>。

在你的代码中，它们都是以同样的方式被导入:

require('package-name')

那么，你应该在什么时候以一种或另一种方式安装呢？

一般来说，所有的软件包都应该以本地包的方式安装。

这可以确保你的电脑中可以有几十个应用程序，如果需要的话，都可以运行每个软件包的不同版本。

更新全局软件包会使你的所有项目都使用新的版本，你可以想象这可能会在维护方面造成噩梦，因为一些软件包可能会破坏与其他依赖的兼容性，等等。

所有的项目都有自己的本地包，即使这看起来是一种资源的浪费，但与可能产生的负面影响相比，它是微不足道的。

当一个软件包提供了一个可执行的命令，你可以从shell（CLI）中运行，并且在不同的项目中重复使用时，它应该被全局地安装。

你也可以在本地安装可执行命令，并使用 npx 运行它们，但有些软件包最好是全局安装。

你可能知道的流行的全局软件包的很好的例子:

• npm
• create-react-app
• vue-cli
• grunt-cli
• mocha
• react-native-cli
• gatsby-cli
• forever
• nodemon

你的系统中可能已经有一些全局安装的软件包。你可以通过运行:

npm list -g --depth 0

在你的终端.

npm dependencies（依赖关系） 和 devDependencies（开发依赖关系）

一个包什么时候是依赖关系，什么时候是开发依赖关系？

当你使用 npm install <package-name> 安装一个 npm 包时，你是把它为一个依赖。

该包会自动列在 package.json 文件的 dependencies 列表中（从 npm 5 开始：在你必须手动指定 --save 之前）。

当你添加 -D 标志，或 --save-dev 时，你就把它作为一个开发依赖项来安装，这就把它添加到 devDependencies 列表中。

开发依赖是指仅用于开发的软件包，在生产中不需要。例如，测试包、webpack 或 Babel。

当你在 生产环境 中时，如果你输入 npm install，并且该文件夹包含 package.json 文件，它们就会被安装（译者注： devDependencies 的 npm 包也会被安装），因为 npm 认为这是一个开发部署。

你需要设置 --production flag （npm install --production），以避免安装这些开发依赖项。

npx Node包运行器

npx 是一种非常酷的运行 Node.js 代码的方式，并提供了许多有用的功能。

在本节中，我想介绍一个非常强大的命令，从2017年7月发布的5.2版本开始，npm 中就有这个命令,npx。

如果你不想安装 npm，你可以将 npx 作为一个 独立的包 来安装。

npx 让你运行用 Node.js 构建并通过 npm 注册表发布的代码。

轻松地运行本地命令

Node.js 的开发者曾经将大多数可执行的命令作为全局包发布，以便让它们添加到系统的路径（path）中并可以执行。

这是一种痛苦，因为你无法真正安装同一命令的不同版本。

运行 npx commandname 会自动在项目的 node_modules 文件夹中找到该命令的正确引用，不需要知道确切的路径，也不需要在全局和用户的路径中安装包。

免安装的命令执行

npm 还有一个很好的功能，就是允许运行命令而不需要先安装它们。

这相当有用，主要是因为:

1. 你不需要安装任何东西
2. 你可以使用语法 @version 来运行同一命令的不同版本

使用 npx 的一个典型示范是通过 cowsay 命令。cowsay 将打印一头牛，说你在命令中写的东西。比如:

cowsay "Hello" 将打印出

< Hello >
 -------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

现在，这需要你之前从npm全局安装了 cowsay 命令，否则当你试图运行该命令时，你会得到一个错误。

npx 允许你在没有本地安装的情况下运行该npm命令:

npx cowsay "Hello"

现在，这是一个有趣的无用命令。其他情况包括:

• 运行 vue CLI 工具来创建新的应用程序并运行它们：npx vue create my-vue-app
• 使用 create-react-app 创建一个新的React应用：npx create-react-app my-react-app

以及更多。

一旦下载，下载的代码将被抹去。

使用不同的 Node.js 版本运行一些代码

使用 @ 来指定版本，并将其与 node npm 包相结合:

npx node@6 -v #v6.14.3
npx node@8 -v #v8.11.3

这有助于避免像 nvm 或其他 Node 版本管理工具的使用。

直接从 URL 中运行任意的代码片段

npx 并不仅能运行在npm注册表上发布的软件包。

你可以运行位于 GitHub gist 中的代码，例如:

npx https://gist.github.com/zkat/4bc19503fe9e9309e2bfaa2c58074d32

当然，在运行不受你控制的代码时，你需要小心，因为巨大的权力伴随着巨大的责任。

The Event Loop（事件循环）

事件循环是了解JavaScript的最重要的方面之一。本节解释了JavaScript如何在单线程中工作的内部细节，以及它如何处理异步函数。

我已经用JavaScript编程多年了，但我从来没有 完全 理解过事情是如何在幕后运作的。不了解这个概念的细节是完全可以的。但是像往常一样，知道它是如何工作的是很有帮助的，而且在这一点上你可能只是有点好奇。

你的JavaScript代码是单线程（single threaded）运行的。每次只有一件事在发生。

这是一个实际上非常有帮助的限制，因为它简化了很多你编程的方式，而不用担心并发问题。

你只需要注意如何写你的代码，避免任何可能阻塞线程的东西，比如同步网络调用或无限 循环。

一般来说，在大多数浏览器中，每个浏览器标签都有一个事件循环，以使每个进程都被隔离，避免一个有无限循环的网页或繁重的处理过程阻塞你整个浏览器。

该环境管理着多个并发的事件循环，以处理例如API调用。Web Workers 也是在自己的事件循环中运行。

你主要需要关注的是，你的代码会在一个事件循环中运行，写代码时要考虑到这个事情，避免阻塞它。

阻塞事件循环

任何 JavaScript 代码，如果需要花费太长的时间将控制权返回到事件循环中，就会阻断页面中任何 JavaScript 代码的执行，甚至阻断UI线程，用户就无法点击、滚动页面，等等。

JavaScript 中几乎所有的 I/O 原生语句都是无阻塞的。如网络请求、Node.js 文件系统操作，等等。阻塞是个例外，这就是为什么 JavaScript 如此基于回调，以及最近的 promises 和 async/await 的原因。

The call stack（调用栈）

调用栈是一个 LIFO 队列（Last In, First Out）。

事件循环不断检查调用栈（call stack），看是否有任何函数需要运行。

在这样做的同时，它将发现的任何函数调用添加到调用栈中，并按顺序执行每个函数。

你知道你可能熟悉的错误堆栈跟踪，在调试器或浏览器控制台中？

浏览器查找调用堆栈中的函数名称，以告知你当前调用是由哪个函数发起的：

一个简单的事件循环解释

举个例子:

const bar = () => console.log('bar')
const baz = () => console.log('baz')
const foo = () => {  
  console.log('foo')  
  bar()  
  baz()
}

foo()

这段代码打印出:

foo
bar
baz

正如预期的那样。

当这段代码运行时，首先调用 foo()。在 foo() 中，我们首先调用 bar()，然后我们调用baz()。

在这一点上，调用栈看起来像这样:

事件循环在每个迭代中都会查看调用栈中是否有东西，并执行它:

直到调用栈为空。

排列函数执行

上面的例子看起来很正常，没有什么特别的地方。JavaScript找到要执行的东西，按顺序运行它们。

我们来看看如何推迟一个函数，直到堆栈清空。

setTimeout(() => {},0) 的用例是调用一个函数，但要在代码中的其他函数都执行完后再执行它。

以此为例:

const bar = () => console.log('bar')

const baz = () => console.log('baz')

const foo = () => {  
  console.log('foo') 
  setTimeout(bar, 0) 
  baz()
}

foo()

这段代码的打印结果，也许是令人惊讶的:

foo
baz
bar

当这段代码运行时，首先 foo() 被调用。在 foo() 中，我们首先调用 setTimeout，传递 bar 作为参数，我们指示它立即尽可能快地运行，传递 0 作为计时器。然后我们调用 baz()。

在这一点上，调用栈看起来像这样:

以下是我们程序中所有函数的执行顺序:

为什么会发生这种情况？

消息队列

当 setTimeout() 被调用时，浏览器或Node.js开始计时。一旦定时器过期，在这种情况下，由于我们把 0 作为超时，回调函数就会被放到消息队列中。

消息队列也是用户启动的事件（如点击和键盘事件或获取响应）在您的代码有机会对其做出反应之前排队的地方。 或者像 onLoad 这样的 DOM 事件。

循环优先考虑调用栈。 它首先处理它在调用栈中找到的所有内容，一旦那里没有任何内容，它就会去获取消息队列中的内容。

我们不必等待像 setTimeout、fetch或其他东西的函数来做它们自己的工作，因为它们是由浏览器提供的，而且它们生活在自己的线程上。例如，如果你把 setTimeout 的超时时间设为2秒，你就不必等待2秒，等待发生在其他地方。

ES6 Job Queue（ES6任务队列）

ECMAScript 2015引入了Job Queue的概念，Promises（也在ES6/ES2015中引入）也使用了这个概念。这是一种尽快执行异步函数结果的方法，而不是放在调用栈的最后。

在当前函数结束之前解析的 Promise 将在当前函数之后立即执行。

我觉得用游乐园的过山车来比喻很好：消息队列让你回到队列中，排在所有其他人之后，而工作队列是一张快速通行票，让你在完成前一项工作后马上再坐一次。

Example:

const bar = () => console.log('bar')

const baz = () => console.log('baz')

const foo = () => {  
  console.log('foo')  
  setTimeout(bar, 0)  
  new Promise((resolve, reject) => resolve('should be right after baz, before bar'))
                                  .then(resolve => console.log(resolve))
                                  
  bar()
}

foo()

这打印出:

foo
baz
should be right after foo, before barbar

这是Promises（以及建立在Promises 之上的 async/await）和通过 setTimeout() 或其他平台API的普通异步函数之间的巨大区别。

理解process.nextTick()

当你试图理解Node.js的事件循环时，它的一个重要部分是 process.nextTick()。它以一种特殊的方式与事件循环互动。

每当事件循环进行一次完整的旅行，我们称它为tick。

当我们向 process.nextTick() 传递一个函数时，我们指示引擎在当前操作结束时，在下一个事件循环tick开始前调用这个函数:

process.nextTick(() => {
  //do something
})

事件循环正忙于处理当前的函数代码。

当这个操作结束时，JavaScript引擎会运行该操作期间传递给 nextTick 调用的所有函数。

这是我们可以告诉JavaScript引擎异步处理一个函数的方法（在当前函数之后），但要尽快，不要排队。

调用 setTimeout(() => {}, 0) 将在下一个tick中执行该函数，比使用 nextTick() 时晚得多。

当你想确保在下一个事件循环迭代中，代码已经被执行时，使用 nextTick()。

了解 setImmediate()

当你想异步执行一些代码，但又想尽快执行时，一个选择是使用 Node.js 提供的 setImmediate() 函数:

setImmediate(() => {
  //run something
})

作为 setImmediate() 参数传递的函数都是一个回调，会在事件循环的下一次迭代中执行。

setImmediate() 与 setTimeout(() => {}, 0)（传递0ms的超时）和 from process.nextTick() 有何不同？

传递给 process.nextTick() 的函数将在事件循环的当前迭代中执行，在当前操作结束后。这意味着它将总是在 setTimeout() 和 setImmediate() 之前执行。

具有0ms延迟的 setTimeout() 回调与 setImmediate() 非常相似。执行顺序取决于各种因素，但它们都将在事件循环的下一次迭代中运行。

定时器

在编写JavaScript代码时，你可能想延迟一个函数的执行。学习如何使用 setTimeout() 和 setInterval() 来安排未来的函数。

setTimeout()

在编写JavaScript代码时，你可能想延迟一个函数的执行。这就是 setTimeout 的工作。

你可以指定一个稍后执行的回调函数，以及一个表达你希望它多长时间运行的值，单位是毫秒:

setTimeout(() => {
  //do something
}, 2000)// runs after 2 seconds

setTimeout(() => {
  //do something
}, 50)// runs after 50 milliseconds

这种语法定义了一个新的函数。你可以在这里调用任何你想调用的其他函数，或者你可以传递一个现有的函数名和一组参数:

const myFunction = (firstParam, secondParam) => {
  // do something
}
setTimeout(myFunction, 2000, firstParam, secondParam)// runs after 2 seconds

setTimeout() 返回定时器ID。这通常是不使用的，但你可以存储这个ID，如果你想删除这个预定函数的执行，可以清除它:

const id = setTimeout(() => {
  // should run after 2 seconds
}, 2000) 
clearTimeout(id)   // 取消定时器

Zero delay（零延迟）

如果你指定超时延迟为 0，回调函数将尽快执行，但在当前函数执行之后:

setTimeout(() => {
  console.log('after ')
}, 0)

console.log(' before ')

将打印出 before after.

这对于避免在密集型任务上阻塞CPU，并在执行繁重的计算时让其他函数被执行，通过在调度器中排队的函数特别有用。

一些浏览器（IE 和 Edge）实现了一个 setImmediate() 方法，可以实现这个完全相同的功能，但它不是标准的，在其他浏览器上不可用。但它是 Node.js 的一个标准函数。

setInterval()

setInterval() 是一个类似于 setTimeout() 的函数，但有一点不同。它不是运行一次回调函数，而是在你指定的特定时间间隔（以毫秒为单位）永远运行它:

setInterval(() => {
    // runs every 2 seconds
}, 2000) 

上面的函数每2秒运行一次，除非你用 clearInterval 告诉它停止，并把 setInterval 返回的定时器id传给它:

const id = setInterval(() => {
  // runs every 2 seconds
}, 2000)

通常在 setInterval 回调函数中调用 clearInterval，让它自动判断是否应该再次运行或停止。例如，这段代码在 App.somethingIWait 的值为 arrived 时才运行。

const interval = setInterval(function() {  
  if (App.somethingIWait === 'arrived') {    
    clearInterval(interval)
  }}, 100)// otherwise do things  

递归设置超时

setInterval 每隔 n 毫秒启动一个函数，完全不考虑函数何时执行完毕。

如果一个函数花费的时间总是一样的，那就没问题了:

也许该函数需要不同的执行时间，取决于网络条件，例如:

也许一个长期执行的项目会与下一个项目重叠:

为了避免这种情况，你可以安排一个递归的setTimeout，当回调函数完成时被调用:

const myFunction = () => {  // do something
   setTimeout(myFunction, 1000)
} 
   
setTimeout(myFunction()}, 1000)

实现这一设想:

setTimeout 和 setInterval 在 Node.js 中也可以使用，通过 Timer模块。

Node.js还提供了 setImmediate()，相当于使用 setTimeout(() => {}, 0)，主要用于与 Node.js 事件循环一起工作。

异步编程（Asynchronous Programming）和回调（Callbacks）

JavaScript 默认是同步的，而且是单线程的。这意味着，代码不能创建新的线程，也不能并行运行。

编程语言中的异步性

计算机在设计上是异步的。

异步的意思是，事情可以独立于主程序流程而发生。

在目前的消费类计算机中，每个程序都在一个特定的时间段内运行，然后它停止执行，让另一个程序继续执行。这件事的运行周期非常快，不可能注意到，我们认为我们的计算机同时运行许多程序，但这是一种错觉（除了在多处理器机器上）。

程序在内部使用中断，这是一种向处理器发出的信号，以获得系统的处理。

我不会去研究这个的内部情况，但只要记住，程序是异步的，在需要注意之前停止执行是正常的，计算机可以在这期间执行其他事情。当一个程序在等待来自网络的响应时，它不能停止处理器，直到请求完成。

通常情况下，编程语言是同步的，有些语言提供了一种管理异步性的方法，在语言中或通过库。C、Java、C#、PHP、Go、Ruby、Swift、Python，它们默认都是同步的。其中一些语言通过使用线程来处理异步性，生成一个新的进程。

JavaScript

JavaScript 默认是同步的，并且是单线程的。 这意味着代码无法创建新线程并并行运行。

代码行一个接一个地依次执行。

例如:

const a = 1
const b = 2
const c = a * b
console.log(c)
doSomething()

但是 JavaScript 是在浏览器内部诞生的。 一开始，它的主要工作是响应用户操作，如 onClick、onMouseOver、onChange、onSubmit 等。 它如何使用同步编程模型做到这一点？

答案就在它的环境中。 浏览器通过提供一组可以处理此类功能的 API 来提供一种方法。

最近，Node.js 引入了非阻塞 I/O 环境，将这一概念扩展到文件访问、网络调用等。

Callbacks（回调）

你不可能知道用户何时会点击一个按钮，所以你要做的是为点击事件定义一个事件处理程序。

这个事件处理程序接受一个函数，当事件被触发时，该函数将被调用:

document.getElementById('button')
        .addEventListener('click', () => {
            console.log('button clicked')
        })//item clicked

这就是所谓的回调。

回调是一个简单的函数，它作为一个值传递给另一个函数，只有当事件发生时才会被执行。我们可以这样做，因为JavaScript有的函数是一等公民，它可以被分配给变量并传递给其他函数（称为高阶函数）。

常见的做法是将所有的客户端代码包裹在 "window "对象的 "load "事件监听器中，只有当页面准备好时才运行回调函数:

window.addEventListener('load', () => {})//window loaded  //do what you want

回调无处不在，不仅仅是在DOM事件中使用。

一个常见的例子是通过使用定时器:

setTimeout(() => {  
  // runs after 2 seconds
}, 2000)

XHR请求 也接受回调，在这个例子中，通过给一个属性分配一个函数，当一个特定的事件发生时（在这个例子中，请求的状态改变），该函数将被调用:

const xhr = new XMLHttpRequest()
xhr.onreadystatechange = () => {  
   if (xhr.readyState === 4) {
      xhr.status === 200 ? console.log(xhr.responseText) : console.error('error')
}}

xhr.open('GET', 'https://yoursite.com')
xhr.send()

处理回调中的错误

你如何用回调来处理错误？一个很常见的策略是使用 Node.js 采用的方法：任何回调函数的第一个参数是错误对象，错误优先的回调。

如果没有错误，该对象是 null。如果有错误，它包含一些错误的描述和其他信息。

fs.readFile('/file.json', (err, data) => {  
      if (err !== null) {    //handle error    
         console.log(err)    
         return 
      }
      console.log(data) //no errors, process data 
})

使用回调会遇到的问题

回调非常适合简单的情况！

但是，每个回调都会增加一层嵌套。 当你有很多回调时，代码很快就会变得复杂:

window.addEventListener('load', () => {  
  document.getElementById('button')
          .addEventListener('click', () => {
            setTimeout(() => {
              items.forEach(item => {}) 
            }, 2000)
          })     //your code here
})

这只是一个简单的4级代码，但我见过更多级别的嵌套，这很不好玩。

我们如何解决这个问题呢？

回调的替代方案

从ES6开始，JavaScript 引入了几个功能，帮助我们处理不涉及使用回调的异步代码:

• Promises (ES6)
• Async/Await (ES8)

Promises

Promises 是处理 JavaScript 中异步代码的一种方式，而不需要在代码中写太多的回调。

Promises 简介

承诺通常被定义为一个最终会变得可用的值的代理。

虽然已经存在多年，但它们在 ES2015 中被标准化并引入，现在它们在 ES2017 中被 async 函数所取代。

**异步函数（Async functions）**使用 Promise API 作为其构建模块，因此，即使在较新的代码中，你可能会使用异步函数而不是 Promise，理解它们也是基本的。

Promises是如何工作的

一旦一个 Promises 被调用，它将开始处于待定状态。这意味着调用者函数继续执行，同时等待 Promises 做它自己的处理，并给调用者函数一些反馈。

在这一点上，调用者函数等待它在**解决的状态（resolved state）下返回promises，或者在拒绝的状态（rejected state）**下返回 Promises，但是你知道 JavaScript 是异步的，所以函数继续执行，而承诺在做它的工作。

哪些 JS API 使用 Promises?

除了你自己的代码和库的代码外，Promises 还被标准的现代网络 API 所使用，如:

• the Battery API
• the Fetch API
• Service Workers

在现代 JavaScript 中，你发现自己不可能不使用承诺，所以让我们直接开始研究它们。

创建 Promise

Promise API 暴露了一个 Promise 构造函数，你可以使用 new Promise() 来初始化它:

let done = true
const isItDoneYet = new Promise(  (resolve, reject) => {
       if (done) { 
         const workDone = 'Here is the thing I built'
         resolve(workDone)
       } else {
         const why = 'Still working on something else'      
         reject(why)    
       }  
})

正如你所看到的，承诺会检查 done 全局常量，如果是真的，我们会返回一个已解决（resolved）的 Promise，否则就是拒绝（rejected ）的 resolved 。

使用 resolve 和 reject 我们可以返回一个值，在上面的例子中我们只是返回一个字符串，但也可以是一个对象。

消费（Consuming）Promise

在上一节中，我们介绍了如何创建一个 Promise。

现在让我们来看看promise如何被消费或使用。

const isItDoneYet = new Promise()//...

const checkIfItsDone = () => { 
  isItDoneYet.then((ok) => {console.log(ok)})
             .catch((err) => {console.error(err)})
}

运行 checkIfItsDone() 将执行 isItDoneYet() 承诺，并等待它的解析，使用 then 回调，如果有错误，它将在 catch 回调中处理。

链式 Promises

一个 Promise 可以返回给另一个 Promise，形成一个 Promise 链。

Fetch API 给出了一个很好的 Promise 链的例子，它是 XMLHttpRequest API 上面的一层，我们可以用它来获取一个资源，并在获取资源的时候排队执行一连串的 Promise。

Fetch API是一个基于promise的机制，调用 fetch() 等同于使用 new Promise() 定义我们自己的 Promise。

Promises链的例子

const status = (response) => {  
   if (response.status >= 200 && response.status < 300) 
      { return Promise.resolve(response)  }  
   return Promise.reject(new Error(response.statusText))}

const json = (response) => response.json()
fetch('/todos.json')
.then(status)
.then(json)
.then((data) => {console.log('Request succeeded with JSON response', data)})
.catch((error) => { console.log('Request failed', error) })

在这个例子中，我们调用 fetch() 从当前目录中找到的 todos.json 文件中获得一个 TODO 项目的列表，并且我们创建了一个 Promises 链。

运行 fetch() 返回一个 response，它有许多属性，在这些属性中我们引用了:

• status, 一个代表HTTP状态代码的数字值
• statusText, 一个状态信息，如果请求成功，就是 OK

response 也有一个 json() 方法，它返回一个 Promise，该 Promise 将对 body 的内容进行处理并转化为 JSON。

所以在这些前提下，会发生这样的事情：链中的第一个 Promise是我们定义的一个函数，叫做status()，它检查响应状态，如果不是一个成功的响应（在200和299之间），它拒绝这个 Promise（rejects the promise）。

这个操作将导致承诺链跳过所有列出的链式 Promise，直接跳到底部的 catch() 语句，记录 Request failed 文本和错误信息。

如果成功了，它会调用我们定义的 json() 函数。由于前一个 Promise 在成功时返回了 response 对象，我们得到它作为第二个 Promise 的输入。

在这种情况下，我们返回经过处理的 JSON 数据，所以第三个 Promise 直接接收 JSON:

.then((data) => { 
  console.log('Request succeeded with JSON response', data)
})

我们只需将其记录到控制台。

处理错误

在上一节的例子中，我们有一个附加到 Promise 链上的 catch。

当 Promise 链中的任何东西失败并引发错误或拒绝 Promise 时，控制就会转到链下最近的 catch() 语句。

new Promise((resolve, reject) => {
        throw new Error('Error')}) 
       .catch((err) => { console.error(err) })

或者这样写

new Promise((resolve, reject) => { 
    reject('Error')})
    .catch((err) => { console.error(err) })

Cascading（层叠）errors

如果在 catch() 里面你引发了一个错误，你可以附加第二个 catch() 来处理它，以此类推。

new Promise((resolve, reject) => {throw new Error('Error')})
      .catch((err) => { throw new Error('Error') })  
      .catch((err) => { console.error(err) })

Orchestrating（协调） Promises

Promise.all()

如果你需要同步不同的 Promise，Promise.all() 可以帮助你定义一个 Promise 列表，并在它们都被解决（resolved）后执行一些操作。

例如:

const f1 = fetch('/something.json')
const f2 = fetch('/something2.json')

Promise.all([f1, f2])
       .then((res) => {console.log('Array of results', res)})
       .catch((err) => {console.error(err)})

ES2015的析构赋值 语法允许你也这样做:

Promise.all([f1, f2])
       .then(([res1, res2]) => {
          console.log('Results', res1, res2)
       })

当然，你并不局限于使用 fetch，任何 Promise 都可以使用。

Promise.race()

Promise.race() 在你传递给它的第一个 Promise 得到解决时运行，它只运行一次所附的回调，并使用第一个 Promise 的解决结果。

例如:

const first = new Promise((resolve, reject) => {
  setTimeout(resolve, 500, 'first')
})
 
const second = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'second')
})

Promise.race([first, second]).then((result) => {  
  console.log(result) 
})// second

Common error, Uncaught TypeError: undefined is not a promise

如果你在控制台得到 Uncaught TypeError: undefined is not a promise,请确保你使用 new Promise()，而不是仅仅使用 Promise()。

Async and Await

探索 JavaScript 中异步函数的现代方法。

JavaScript在很短的时间内从回调（callback）发展到了 Promise（ES2015），而从ES2017开始，异步 JavaScript 通过 async/await 语法变得更加简单。

异步函数是 Promises 和生成器（generators）的结合，基本上，它们是 Promises 的更高层次的抽象。让我重复一遍：async/await 是建立在 Promises 之上的。

为什么会引入 async/await？

它们减少了围绕 Promises 的模板, 以及链式 Promises 的 don’t break the chain 的限制。

当 Promises 在 ES2015 中被引入时，它们旨在解决异步代码的问题，而且它们确实做到了，但在 ES2015 和 ES2017 之间的两年时间里，显然 Promises 不可能成为最终的解决方案。

Promises 的引入是为了解决著名的回调地狱（callback hell）问题，但它们本身就引入了复杂性，而且是语法上的复杂性。

它们是很好的基元（primitives），围绕它们可以向开发者展示更好的语法，所以当时机成熟的时候，我们得到了同步函数（async functions）。

它们使代码看起来是同步的，但在幕后却是异步的和非阻塞的。

它是如何工作的

一个 "async" 函数会返回一个 Promise，比如在这个例子中:

const doSomethingAsync = () => {
  return new Promise((resolve) => {
    setTimeout(() => resolve('I did something'), 3000) 
  })
}

当你想调用这个函数时，你要在前面加上 await，调用代码将停止直到承诺被解决或拒绝（promise is resolved or rejected）。有一点需要注意：客户端函数必须定义为 async。

这是一个例子:

const doSomething = async () => {    
  console.log(await doSomethingAsync())
}

一个简短的例子

这是一个简单的 async/await 的例子，用于异步运行一个函数:

const doSomethingAsync = () => { 
  return new Promise((resolve) => { 
    setTimeout(() => resolve('I did something'), 3000) 
  })
}

const doSomething = async () => { 
  console.log(await doSomethingAsync())
}

console.log('Before')
doSomething()
console.log('After')

上述代码将向浏览器控制台打印以下内容:

Before
After
I did something //after 3s

Promise all the things

在任何函数前加上 async 关键字意味着该函数将返回一个 promise。

即使它没有明确地这样做，也会在内部使其返回一个promise。

这就是为什么这段代码是有效的:

const aFunction = async () => { return 'test'}

aFunction().then(alert) // This will alert 'test'

跟下面的是相同的:

const aFunction = async () => { 
  return Promise.resolve('test')
}

aFunction().then(alert) // This will alert 'test'

代码阅读起来更简单

正如你在上面的例子中看到的，我们的代码看起来非常简单。与使用普通承诺的代码相比，它有链式和回调函数。

而这只是一个非常简单的例子，主要的好处将出现在代码更复杂的时候。

例如，这里是你如何获得一个JSON资源并解析它，使用 Promises:

const getFirstUserData = () => {  
       return fetch('/users.json') // get users list    
      .then(response => response.json()) // parse JSON    
      .then(users => users[0]) // pick first user    
      .then(user => fetch(`/users/${user.name}`)) // get user data    
      .then(userResponse => response.json()) // parse JSON
}

getFirstUserData()

这里是用以下方式提供的相同功能,通过使用 await/async:

const getFirstUserData = async () => { 
        const response = await fetch('/users.json')  // get users list  
        const users = await response.json() // parse JSON  const user = users[0] // pick first user  
        const userResponse = await fetch(`/users/${user.name}`) // get user data 
        const userData = await user.json() // parse JSON  return userData
}

getFirstUserData()

串联多个的异步函数

async 函数可以很容易地串联起来，而且语法比普通的 Promises 更易读:

const promiseToDoSomething = () => { return 
  new Promise(resolve => { 
    setTimeout(() => resolve('I did something'), 10000) 
  }
)}

const watchOverSomeoneDoingSomething = async () => { 
  const something = await promiseToDoSomething()    
  return something + ' and I watched'
}

const watchOverSomeoneWatchingSomeoneDoingSomething = async () => { 
  const something = await watchOverSomeoneDoingSomething()  
  return something + ' and I watched as well'
}

watchOverSomeoneWatchingSomeoneDoingSomething().then((res) => { 
     console.log(res)
})

将会打印:

I did something and I watched and I watched as well

更容易调试

调试 Promises 是很难的，因为调试器不会在异步代码上断点。

async/await 使之变得非常容易，因为对编译器来说，它就像同步代码。

Node.js 事件发送器（Event Emitter）

你可以在 Node.js 中使用自定义事件。

如果你在浏览器中使用 JavaScript，你就知道用户的大部分交互是通过事件处理的：鼠标点击、键盘按键、对鼠标移动的反应等等。

在后端，Node.js为我们提供了使用 events模块 建立类似系统的选择。

这个模块特别提供了 EventEmitter 类，我们将用它来处理我们的事件。

你可以用以下方式初始化它:

const eventEmitter = require('events').EventEmitter()

这个对象暴露了 on 和 emit 方法，以及其他许多方法。

• emit 用于触发一个事件。
• on 用于添加一个回调函数，当事件被触发时将被执行。

例如，让我们创建一个start事件，作为提供一个样本的问题，我们对该事件的反应只是记录到控制台:

eventEmitter.on('start', () => {  
  console.log('started')
})

当我们运行:

eventEmitter.emit('start')

事件处理函数被触发，我们得到控制台日志。

你可以通过将参数作为附加参数传递给 emit() 来给事件处理程序传递参数:

eventEmitter.on('start', (number) => {  
  console.log(`started ${number}`)
})
eventEmitter.emit('start', 23)

多个参数:

eventEmitter.on('start', (start, end) => {  
  console.log(`started from ${start} to ${end}`)
})
eventEmitter.emit('start', 1, 100)

EventEmitter 对象还公开了其他几个与事件互动的方法，比如:

• once(): 添加一个一次性的监听器
• removeListener() / off(): 从一个事件中删除一个事件监听器
• removeAllListeners(): 删除一个事件的所有监听器。

HTTP请求如何工作

当你在浏览器中输入一个 URL 时，从开始到结束会发生什么？

本节介绍浏览器如何使用 HTTP/1.1 协议执行页面请求。

如果你曾经做过一次面试，你可能会被问到。"当你在谷歌搜索框中输入东西并按下回车键时会发生什么？"。

这是你被问到的最多的问题之一。人们只是想看看你是否能解释一些相当基本的概念，以及你是否了解互联网的实际运作。

在本节中，我将分析当你在浏览器的地址栏中输入一个 URL 并按下回车键时会发生什么。

在本节中，我将分析当你在浏览器的地址栏中输入一个 URL 并按下回车键时会发生什么。

这是很少变化的技术，它为人类有史以来最复杂、最广泛的生态系统之一提供动力。

HTTP协议

我只分析 URL 请求。

现代浏览器有能力知道你在地址栏中写的东西是一个实际的URL还是一个搜索词，如果它不是一个有效的URL，它们将使用默认的搜索引擎。

我假设你输入了一个实际的 URL。

当你输入URL并按下回车键时，浏览器首先建立完整的URL。

与 MacOS/Linux 有关的事情

仅供参考。Windows可能会对一些事情的处理方式略有不同。

DNS 查询阶段

浏览器开始进行 DNS 查询以获得服务器的 IP 地址。

域名对我们人类来说是方便记忆，但互联网的组织方式是，计算机可以通过其 IP 地址查询服务器的确切位置，这是一组数字，如 222.324.3.1（IPv4）。

首先，它检查 DNS 的本地缓存，看这个域名最近是否已经被解析。

Chrome 有一个方便的DNS缓存可视化工具，你可以在这个网址上看到：chrome://net-internals/#dns（复制并粘贴到Chrome浏览器地址栏）

如果没有找到，浏览器就使用DNS解析器，使用 gethostbyname POSIX 系统调用来检索主机信息。

gethostbyname

gethostbyname：浏览器首先查找本地主机文件，在 macOS 或 Linux 上，该文件位于 /etc/hosts，以查看系统是否在本地提供了该信息。

如果这没有提供任何关于域名的信息，系统会向DNS服务器发出请求。

DNS服务器的地址存储在系统偏好中。

这些是2个流行的 DNS 服务器:

• 8.8.8.8: 谷歌公共 DNS 服务器
• 1.1.1.1: CloudFlare DNS 服务器

大多数人使用他们的互联网供应商提供的 DNS 服务器。

浏览器使用 UDP 协议执行 DNS 请求。

TCP 和 UDP 是计算机网络的两个基础性协议。它们处于相同的概念层面，但 TCP 是面向连接的，而 UDP 是一个无连接的协议，更轻巧，用于发送消息，开销很小。

如何进行 UDP 请求不在本手册的范围内。

DNS 服务器的缓存中可能有该域名的 IP。如果没有，它将询问根域名服务器。那是一个驱动整个互联网的系统（由 13 个实际的服务器组成，分布在地球上）。

DNS 服务器并不知道地球上每一个域名的地址。

它所知道的是顶级 DNS 解析器的位置。

顶级域名是域名的扩展名：.com、.it、.pizza 等等。

一旦根 DNS 服务器收到请求，它就将请求转发到该顶级域名（TLD）DNS 服务器。

假设你正在寻找 flaviocopes.com。根域名的 DNS 服务器返回 .com TLD 服务器的 IP。

现在，我们的 DNS 解析器将缓存该 TLD 服务器的 IP，所以它不必再向根 DNS 服务器询问它。

TLD DNS 服务器将拥有我们正在寻找的域名的权威性域名服务器的 IP 地址。

怎么会这样？当你购买一个域名时，域名注册商会向域名服务器发送适当的 TDL。当你更新名称服务器时（例如，当你改变主机提供商时），这些信息将由你的域名注册商自动更新。

这些是主机提供商的 DNS 服务器。它们通常不止一个，以作为备份。

例如:

• ns1.dreamhost.com
• ns2.dreamhost.com
• ns3.dreamhost.com

DNS 解析器从第一个开始，试图询问你要找的域名（也包括子域名）的 IP。

这就是IP地址的最终真实来源。

现在我们有了 IP 地址，我们可以继续我们的旅程了。

TCP 请求握手

有了服务器的 IP 地址，现在浏览器可以启动一个 TCP 连接。

TCP 连接在完全初始化之前需要进行一些握手，然后就可以开始发送数据。

一旦连接建立，我们可以发送请求

发送请求

请求是一个纯文本文件，以通信协议确定的精确方式结构化。

它由3个部分组成:

• 请求行
• 请求头
• 请求体

请求行

请求行设置了，在一个单行上:

• HTTP 方法
• 资源位置
• 协议版本

例如:

GET / HTTP/1.1

请求头

请求头是一组 "字段：值 "对，用于设置某些值。

有两个强制性的字段，一个是 host，另一个是 Connection，而所有其他字段是可选:

Host: flaviocopes.comConnection: close

Host 表示我们想要的目标域名，而 Connection 总是被设置为 close，除非连接必须保持开放。

一些最常用的请求头（header）字段是:

• Origin
• Accept
• Accept-Encoding
• Cookie
• Cache-Control
• Dnt

但还有更多。

请求头（head）部分由一个空行结束。

请求体

请求体是可选的，在 GET 请求中不使用，但在 POST 请求中非常使用，有时也用于其他动词，它可以包含 JSON 格式的数据。

由于我们现在分析的是一个 GET 请求，所以请求体是空白的，我们不做更多研究。

The response（响应）

一旦发送请求，服务器就会对其进行处理并发回一个响应。

响应以状态代码和状态信息开始。如果请求成功并返回 200:

200 OK

该请求可能会返回一个不同的状态代码和信息，比如这些信息之一:

404 Not Found
403 Forbidden
301 Moved Permanently
500 Internal Server Error
304 Not Modified
401 Unauthorized

然后，响应包含一个 HTTP 头的列表和响应体（因为我们是在浏览器中发出请求，所以它将是 HTML）。

解析（Parse）HTML

浏览器现在已经收到了 HTML，并开始解析它，它将重复我们对页面所需的所有资源所做的完全相同的过程:

• CSS 文件
• 图像
• 图标
• JavaScript 文件
• ……

浏览器是如何渲染页面的，这不在我们的讨论范围之内，但重要的是要明白，我所描述的过程不仅仅是针对 HTML 页面，而是针对任何通过 HTTP 提供的项目。

用 Node.js 建立一个 HTTP 服务器

这里是我们在介绍使用 Node.js HTTP 网络服务器实现 Hello World 应用程序:

const http = require('http')
const port = 3000
const server = http.createServer((req, res) => {  
  res.statusCode = 200  
  res.setHeader('Content-Type', 'text/plain')
  res.end('Hello World\n')
})

server.listen(port, () => {  
  console.log(`Server running at http://${hostname}:${port}/`)
})s

让我们简单地分析一下。我们包括 http模块。

我们使用该模块来创建一个 HTTP 服务器。

该服务器被设置为监听指定的端口，3000。当服务器准备好时，listen 回调函数被调用。

我们传递的回调函数是在每个请求到来时都要执行的函数。每当收到一个新的请求，request event 被调用，提供两个对象：一个请求（一个 http.IncomingMessage 对象）和一个响应（一个 http.ServerResponse 对象）。

request 提供了请求的细节。通过它，我们可以访问请求头和请求数据。

response 用于填充我们要返回给客户端的数据。

response 用于填充我们要返回给客户端的数据:

res.statusCode = 200

我们将 statusCode 属性设置为 200，以表示响应成功。

我们还设置了 Content-Type 头:

res.setHeader('Content-Type', 'text/plain')

然后我们结束关闭响应，将内容作为参数添加到 end():

res.end('Hello World\n')

用 Node.js 做 HTTP 请求

如何用 Node.js 执行 HTTP 请求，使用 GET、POST、PUT 和 DELETE。

我使用 HTTP 一词，但 HTTPS 才是应该到处使用的（译者注：HTTPS 更安全），因此这些例子使用 HTTPS 而不是 HTTP。

Perform a GET Request

const https = require('https')
const options = { 
  hostname: 'flaviocopes.com', 
  port: 443, path: '/todos', 
  method: 'GET' 
}

const req = https.request(options, (res) => {
    console.log(`statusCode: ${res.statusCode}`)
    res.on('data', (d) => { process.stdout.write(d) })
})

req.on('error', (error) => { console.error(error) })

req.end()

Perform a POST Request

const https = require('https')

const data = JSON.stringify({  todo: 'Buy the milk'})

const options = {  
  hostname: 'flaviocopes.com',
  port: 443,  path: '/todos',  
  method: 'POST',  
  headers: {'Content-Type':'application/json', 'Content-Length': data.length  }
}

const req = https.request(options, (res) => { 
  console.log(`statusCode: ${res.statusCode}`)
})

res.on('data', (d) => {process.stdout.write(d)})

req.on('error', (error) => {console.error(error)})

req.write(data)
req.end()

PUT 和 DELETE

PUT 和 DELETE 请求使用相同的 POST 请求格式，只是改变 options.method 值。

在 Node.js 中使用 Axios 的 HTTP 请求

Axios 是一个非常流行的 JavaScript 库，你可以用来执行 HTTP 请求，它可以在浏览器和 Node.js 平台上工作。

它支持所有的现代浏览器，包括对 IE8 和更高版本的支持。

它是 promise-based, 这让我们可以非常容易编写异步/等待代码来执行 XHR 请求。

与原生的 Fetch API 相比，使用 Axios 有很多优势:

• 支持旧的浏览器（Fetch 需要一个 polyfill，即降级方案）
• 可以中止请求
• 可以设置响应超时
• 有内置的 CSRF 保护
• 支持上传进度
• 执行自动 JSON 数据转换
• 可以在 Node.js 中使用

安装

Axios 可以用 npm 安装:

npm install axios

或者 yarn:

yarn add axios

或简单地使用 unpkg.com，在你的页面引用:

<script src="https://unpkg.com/axios/dist/axios.min.js"></script>

Axios API

你可以从 axios 对象中开始一个 HTTP 请求:

axios({  
  url: 'https://dog.ceo/api/breeds/list/all',  
  method: 'get',  
  data: {foo:'bar'}
})

但为了方便起见，你一般会使用:

• axios.get()
• axios.post()

(就像在 jQuery 中你会使用 $.get() 和 $.post() 而不是 $.ajax())

Axios 为所有的 HTTP 动词提供了方法，这些动词不太流行，但仍在使用:

• axios.delete()
• axios.put()
• axios.patch()
• axios.options()

和一个方法来获取一个请求的 HTTP 头信息，并丢弃正文（discarding the body）:

• axios.head()

GET 请求

使用 Axios 的一个方便方法是使用现代（ES2017）的 async/await 语法。

这个 Node.js 例子查询了 Dog API，使用 axios.get() 检索了所有狗的品种列表，并对它们进行了统计:

const axios = require('axios')

const getBreeds = async () => { 
  try {  
       return await axios.get('https://dog.ceo/api/breeds/list/all')  
  } 
  catch (error) {    
    console.error(error)  
  }
}

const countBreeds = async () => {  
  const breeds = await getBreeds()
  if (breeds.data.message) {
    console.log(`Got ${Object.entries(breeds.data.message).length} breeds`) 
  }
}

countBreeds()

如果你不想使用 async/await，你可以使用 Promises 语法:

const axios = require('axios')

const getBreeds = () => {  
  try { 
    return axios.get('https://dog.ceo/api/breeds/list/all')
  } 
  catch (error) {
    console.error(error) 
   }
}

const countBreeds = async () => {  
  const breeds = getBreeds().then(response => { 
    if (response.data.message) {       
      console.log(`Got ${Object.entries(response.data.message).length} breeds`)
    }
  }).catch(error => {
    console.log(error)})
}

countBreeds()

在GET请求中添加参数

一个 GET 响应可以在 URL 中包含参数，像这样 https://site.com/?foo=bar。

使用 Axios，你可以通过简单地使用该 URL 来执行:

axios.get('https://site.com/?foo=bar')

或者你可以在选项中使用一个 params 属性:

axios.get('https://site.com/', {  params: {    foo: 'bar'  }})

POST 请求

执行 POST 请求就像执行 GET 请求一样，但你使用的不是 axios.get，而是 axios.post:

axios.post('https://site.com/')

一个包含 POST 参数的对象是第二个参数:

axios.post('https://site.com/', {  foo: 'bar'})

在 Node.js 中使用 WebSockets

WebSockets 是网络应用中 HTTP 通信的替代方案。

它们在客户端和服务器之间提供了一个长期的、双向的通信通道。

一旦建立，通道就会保持开放，提供一个非常快速的连接，延迟和开销都很低。

浏览器对 WebSockets 的支持

所有现代浏览器都支持 WebSockets。

WebSockets与HTTP有什么不同

HTTP 是一个非常不同的协议，并且有不同的通信方式。

HTTP 是一个请求/响应协议：服务器在客户端请求时返回一些数据。

WebSockets:

• 服务器可以向客户端发送一个消息，而不需要客户端明确请求什么
• 客户端和服务器可以同时彼此对话
• 发送消息所需的数据开销非常小。这意味着低延迟的通信

WebSockets 非常适用于实时和长期的通信。

HTTP 非常适用于偶尔的数据交换和由客户端发起的互动。

HTTP 的实现要简单得多，而 WebSockets 则需要更多的开销。

安全的 WebSockets

始终使用安全的、加密的 WebSockets 协议，wss://。

ws:// 指的是不安全的 WebSockets 版本（WebSockets 的http://），由于明显的原因，应该避免使用。

创建一个新的 WebSockets 连接

const url = 'wss://myserver.com/something'
const connection = new WebSocket(url)

connection 是一个 WebSocket 对象。

当连接被成功建立时，"open" 事件被触发。

通过给 connection 对象的 onopen 属性分配一个回调函数来监听它:

connection.onopen = () => {} //...

如果有任何错误，onerror 函数回调被触发:

connection.onerror = error => { 
  console.log(`WebSocket error: ${error}`)
}

使用 WebSockets 向服务器发送数据

一旦连接被打开，你就可以向服务器发送数据。

你可以在 onopen 回调函数中方便地这样做:

connection.onopen = () => {  connection.send('hey')}

使用 WebSockets 从服务器接收数据

在 onmessage 上使用回调函数进行监听，当收到 message 事件时被调用:

connection.onmessage = e => {  console.log(e.data)}

在 Node.js 中实现一个 WebSockets 服务器

ws 是一个用于 Node.js 的流行的 WebSockets 库。

我们将用它来建立一个 WebSockets 服务器。它也可以用来实现一个客户端，并使用 WebSockets 在两个后端服务之间通信。

使用以下方法轻松地安装它:

yarn init
yarn add ws

你需要写的代码非常少:

const WebSocket = require('ws')
const wss = new WebSocket.Server({ port: 8080 })
wss.on('connection', ws => {  ws.on('message', message => { 
  console.log(`Received message => ${message}`)  
})  
ws.send('ho!')})

这段代码在 8080 端口（WebSockets 的默认端口）创建了一个新的服务器，并在建立连接时添加了一个回调函数，向客户端发送 ho!，并记录它收到的消息。

请看 Glitch 上的一个运行中的例子

Here 是一个 WebSockets 服务器的活例子。

Here 是一个与服务器互动的 WebSockets 客户端。

在 Node.js 中使用文件描述符

在你能够与文件系统中的文件互动之前，你必须获得一个文件描述符。

文件描述符是使用 fs 模块提供的 open() 方法打开文件时返回的东西:

const fs = require('fs')
fs.open('/Users/flavio/test.txt', 'r', (err, fd) => { })//fd is our file descriptor

注意我们用 r 作为 fs.open() 调用的第二个参数。

这个标志意味着我们打开文件进行阅读。

你经常使用的其他标志是

• r+ 打开文件进行读写
• w+ 打开文件进行读写，将流定位在文件的开头。如果文件不存在，将被创建。
• a 打开文件进行写入，将数据流定位在文件的末端。如果不存在，文件将被创建。
• a+ `打开文件进行读写，将数据流定位在文件的末端。如果不存在，文件被创建。

你也可以通过使用 fs.openSync 方法来打开文件，它不是在回调中提供文件描述符对象，而是返回它:

const fs = require('fs')
try {  
  const fd = fs.openSync('/Users/flavio/test.txt', 'r')
} catch (err) {  
    console.error(err)
}

一旦你得到了文件描述符，无论你选择什么方式，你都可以执行所有需要它的操作，比如调用 fs.open() 和许多其他与文件系统互动的操作。

Node.js 文件统计（stats）

每个文件都带有一组细节，我们可以使用 Node.js 检查。

特别是，使用 fs 模块提供的 stat() 方法。

你通过一个文件路径来调用它，一旦 Node.js 得到了文件的细节，它将调用你传递的带有 2 个参数的回调函数：一个错误信息和文件统计:

const fs = require('fs')fs.stat('/Users/flavio/test.txt', (err, stats) => { 
  if (err) { 
    console.error(err) 
    return  
  } 
}) //we have access to the file stats in `stats`

Node.js 还提供了一个同步方法，它可以阻塞线程，直到文件统计准备就绪:

const fs = require('fs')
try { 
  const stats = fs.stat('/Users/flavio/test.txt')
} 
catch (err) { 
   console.error(err)
}

文件信息被包含在 stats 变量中。我们可以用 stats 提取什么样的信息？

很多，包括:

• 如果文件是一个目录或一个文件，使用 stats.isFile() 和 stats.isDirectory()
• 如果文件是一个符号链接，使用 stats.isSymbolicLink()
• 使用 stats.size 来计算文件的字节数

还有其他高级方法，但你在日常编程中会用到的大部分方法是这样的:

const fs = require('fs')fs.stat('/Users/flavio/test.txt', (err, stats) => {
   if (err) {
     console.error(err)   
     return  
   }
   stats.isFile() //true  
   stats.isDirectory() //false  
   stats.isSymbolicLink() //false  
   stats.size //1024000 //= 1MB})
}

Node.js 文件路径

系统中的每个文件都有一个路径。

在 Linux 和 MacOS 上，一个路径可能看起来像:

/users/flavio/file.txt

而 Windows 电脑则不同，它的结构如:

C:\users\flavio\file.txt

在你的应用程序中使用路径时，你需要注意，因为必须考虑到这种差异。

你在你的文件中包括这个模块，使用:

const path = require('path')

你可以开始使用它的方法。

从路径中获取信息

给定一个路径，你可以用这些方法提取其中的信息:

• dirname: 获取文件的父文件夹
• basename: 获取文件名部分
• extname: 获得文件的扩展名

例如:

const notes = '/users/flavio/notes.txt'

path.dirname(notes) // /users/flavio
path.basename(notes) // notes.txt
path.extname(notes) // .txt

你可以通过给 basename 指定第二个参数来获得不带扩展名的文件名:

path.basename(notes, path.extname(notes)) //notes

使用路径工作

你可以通过使用 path.join() 来连接一个路径的两个或多个部分:

const name = 'flavio'path.join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt'

你可以使用 path.resolve() 从相对路径获得绝对路径计算:

path.resolve('flavio.txt') //'/Users/flavio/flavio.txt' if run from my home folder

在这种情况下，Node.js 将简单地把 /flavio.txt 追加到当前工作目录。如果你指定了第二个参数文件夹，resolve 将使用第一个作为第二个的基础:

path.resolve('tmp', 'flavio.txt')// '/Users/flavio/tmp/flavio.txt' if run from my home folder

如果第一个参数以斜线开头，这意味着它是一个绝对路径:

path.resolve('/etc', 'flavio.txt')// '/etc/flavio.txt'

path.normalize() 是另一个有用的函数，它将尝试计算实际的路径，当它包含像.或.这样的相对指定符，或双斜线时:

path.normalize('/users/flavio/..//test.txt') // /users/test.txt

但是 resolve 和 normalize 不会 检查路径是否存在。它们只是根据得到的信息计算出一个路径。

用 Node.js 读取文件

在 Node.js 中读取文件的最简单方法是使用 fs.readFile() 方法，将文件路径和一个回调函数传递给它，该函数将被调用，并带有文件数据（和错误）:

const fs = require('fs')
fs.readFile('/Users/flavio/test.txt', (err, data) => {  
  if (err) {    
    console.error(err)    
    return  
  }  
  console.log(data)
})

或者，你可以使用同步版本 fs.readFileSync():

const fs = require('fs')
try {  
  const data = fs.readFileSync('/Users/flavio/test.txt') 
  console.log(data)
} catch (err) {  
  console.error(err)
}

默认编码是 "utf8"，但你可以使用第二个参数指定一个自定义编码。

fs.readFile() 和 fs.readFileSync() 都是在返回数据之前读取内存中的全部文件内容。

这意味着大文件会对你的内存消耗和程序的执行速度产生重大影响。

在这种情况下，一个更好的选择是使用流（streams）读取文件内容。

用 Node.js 写文件

在 Node.js 中写入文件的最简单方法是使用 fs.writeFile() API。

例如:

const fs = require('fs')
const content = 'Some content!'
fs.writeFile('/Users/flavio/test.txt', content, (err) => {  
  if (err) {
    console.error(err)    
    return  
  }  
})//file written successfully

或者，你可以使用同步版本 fs.writeFileSync():

const fs = require('fs')
const content = 'Some content!'
try {  
  const data = fs.writeFileSync('/Users/flavio/test.txt', content) 
  //file written successfully
} 
catch (err) {  
  console.error(err)
}

默认情况下，如果文件已经存在，该 API 将 替换 该文件的内容。

你可以通过指定一个标志（flag）来修改默认值:

fs.writeFile('/Users/flavio/test.txt', content, { flag: 'a+' }, (err) => {})

你可能会用到的标志（flags）:

• r+ 打开文件进行读写。
• w+ 打开文件进行读写，将流定位在文件的开头。如果文件不存在，将被创建。
• a 打开文件进行写入，将数据流定位在文件的末端。如果不存在，文件将被创建。
• a+ 打开文件进行读写，将数据流定位在文件的末端。如果不存在，该文件将被创建

你可以找到更多关于 flags 的信息

追加到一个文件中

一个方便的方法是 fs.appendFile() (和它的 fs.appendFileSync() 对应同步的方法)，将内容附加到文件的末尾:

const content = 'Some content!'
fs.appendFile('file.log', content, (err) => {  
  if (err) { 
    console.error(err)    
    return  
  }  
})//done!

使用流（streams）

所有这些方法在把控制权返回给你的程序之前都会把全部内容写入文件（在异步版本中，这意味着执行回调）。

在这种情况下，一个更好的选择是使用流（streams）来写文件内容。

在 Node.js 中使用文件夹

Node.js fs 核心模块提供了许多方便的方法，你可以用来处理文件夹。

检查一个文件夹是否存在

使用 fs.access() 来检查文件夹是否存在，并且 Node.js 可以用其权限来访问它。

创建文件夹

使用 fs.mkdir() 或 fs.mkdirSync() 来创建一个新文件夹:

const fs = require('fs')
const folderName = '/Users/flavio/test'
try {  
   if (!fs.existsSync(dir))
     {fs.mkdirSync(dir)}
} catch (err){ 
   console.error(err)
}

读取一个目录的内容

使用 fs.readdir() 或 fs.readdirSync 来读取一个目录的内容。

这段代码读取一个文件夹的内容，包括文件和子文件夹，并返回其相对路径:

const fs = require('fs')
const path = require('path')
const folderPath = '/Users/flavio'
fs.readdirSync(folderPath)

你可以得到完整的路径:

fs.readdirSync(folderPath)
  .map(fileName => {
     return path.join(folderPath, fileName)
})

你还可以过滤结果，只返回文件，并排除文件夹:

const isFile = fileName => {
  return fs.lstatSync(fileName).isFile()
}
fs.readdirSync(folderPath).map(fileName => { 
   return path.join(folderPath, fileName).filter(isFile)
})

重命名文件夹

使用 fs.rename() 或 fs.renameSync() 来重命名文件夹。

第一个参数是当前路径，第二个参数是新路径:

const fs = require('fs')
fs.rename('/Users/flavio', '/Users/roger', (err) => { 
    if (err) {
      console.error(err)    
      return  
    }  
})//done

fs.renameSync() 是同步版本:

const fs = require('fs')
try { fs.renameSync('/Users/flavio', '/Users/roger')
} catch (err) {  
  console.error(err)
}

删除文件夹

使用 fs.rmdir() 或 fs.rmdirSync() 来删除一个文件夹。

删除一个有内容的文件夹可能比你需要的更复杂。

在这种情况下，我建议安装 fs-extra 模块，它非常受欢迎，维护得很好，它可以直接替换 fs 模块，在其基础上提供更多的功能。

在这种情况下，remove() 方法是你想要的。

用以下方法安装它:

npm install fs-extra

像这样使用它:

const fs = require('fs-extra')
const folder = '/Users/flavio'
fs.remove(folder, err => {console.error(err)})

它也可以与 Promises 一起使用:

fs.remove(folder).then(() => {done}).catch(err => {
  console.error(err)
}) //done 

或者使用 async/await:

async function removeFolder(folder) {  
  try { 
    await fs.remove(folder)
  }//done 
  catch (err) {console.error(err) }
}

const folder = '/Users/flavio'
removeFolder(folder)

Node.js fs 模块

fs 模块提供了很多非常有用的功能来访问文件系统并与之互动。

不需要安装它。作为 Node.js 核心的一部分，它可以通过简单地要求它来使用:

const fs = require('fs')

一旦你这样做，你就可以使用它的所有方法，其中包括:

• fs.access(): 检查文件是否存在，并且Node可以用其权限访问它。
• fs.appendFile(): 将数据追加到文件中。如果文件不存在，就创建它
• fs.chmod(): 改变一个由文件名指定的文件的权限。相关的: fs.lchmod(), fs.fchmod()
• fs.chown(): 改变由文件名指定的文件的所有者和组。相关的: fs.fchown(), fs.lchown()
• fs.close(): 关闭一个文件描述符
• fs.copyFile(): 复制一个文件
• fs.createReadStream(): 创建一个可读文件流
• fs.createWriteStream(): 创建一个可写的文件流
• fs.link(): 为文件创建一个新的硬链接
• fs.mkdir(): 创建一个新的文件夹
• fs.mkdtemp(): 创建一个临时目录
• fs.open(): 设置文件模式
• fs.readdir(): 读取一个目录的内容
• fs.readFile(): 读取一个文件的内容. 相关的: fs.read()
• fs.readlink(): 读取一个符号链接的值
• fs.realpath(): 将相对文件路径指针 (., ..) 解析为全路径
• fs.rename(): 重命名一个文件或文件夹
• fs.rmdir(): 删除一个文件夹
• fs.stat(): 返回由文件名识别的文件的状态。相关的: fs.fstat(), fs.lstat()
• fs.symlink(): 创建一个新的符号链接到一个文件
• fs.truncate(): 将文件名标识的文件截断到指定长度。相关的: fs.ftruncate()
• fs.unlink(): 删除一个文件或一个符号链接
• fs.unwatchFile(): 停止监视一个文件的变化
• fs.utimes(): 改变由文件名标识的文件的时间戳。 相关的: fs.futimes()
• fs.watchFile(): 开始监视一个文件的变化。相关的: fs.watch()
• fs.writeFile(): 向文件写入数据。 相关的: fs.write()

关于 fs 模块的一个特别之处是，所有的方法默认都是异步的，但它们也可以通过附加 Sync 而同步工作。

例子:

• fs.rename()
• fs.renameSync()
• fs.write()
• fs.writeSync()

这对你的应用流程有很大的影响。

Node 10 包括对基于 Promise 的API的 实验性支持。

例如，让我们检查 fs.rename() 方法。异步 API 是用一个回调来实现的:

const fs = require('fs')
fs.rename('before.json', 'after.json', (err) => {  
     if (err) {    
       return console.error(err)  
    }
})//done

一个同步的 API 可以这样使用，用一个 try/catch 块来处理错误:

const fs = require('fs')
try {
  fs.renameSync('before.json', 'after.json')//done
} catch(err) {  
  console.error(err)
}

这里的关键区别是，在第二个例子中，你的脚本的执行将被阻塞，直到文件操作成功。

Node.js 的路径模块

path 模块提供了很多非常有用的功能，可以访问文件系统并与之互动。

没有必要安装它。作为 Node.js 核心的一部分，它可以通过简单地要求它来使用:

const path = require('path')

这个模块提供了 path.sep，它提供了路径段的分隔符（在 Windows下为 /，在 Linux/MacOS下为 /），以及 path.delimiter，它提供了路径分隔符（在 Windows 下为；，在 Linux/MacOS下为：）。

这些是 路径 方法。

path.basename()

返回一个路径的最后部分。第二个参数可以过滤掉文件扩展名:

require('path').basename('/test/something') //something
require('path').basename('/test/something.txt') //something.txt
require('path').basename('/test/something.txt', '.txt') //something

path.dirname()

返回一个路径的目录部分:

require('path').dirname('/test/something') // /test
require('path').dirname('/test/something/file.txt') // /test/something

path.extname()

返回一个路径的扩展部分:

require('path').dirname('/test/something') // ''
require('path').dirname('/test/something/file.txt') // '.txt'

path.isAbsolute()

如果它是一个绝对路径，则返回 true:

require('path').isAbsolute('/test/something') // true
require('path').isAbsolute('./test/something') // false

path.join()

连接一个路径的两个或多个部分:

const name = 'flavio'
require('path').join('/', 'users', name, 'notes.txt') //'/users/flavio/notes.txt'

path.normalize()

试图计算实际路径，当它包含相对指定符如 . 或 ..，或双斜线（//）:

require('path').normalize('/users/flavio/..//test.txt') ///users/test.txt

path.parse()

解析一个对象的路径和组成它的片段:

• root: 根目录
• dir: 从根开始的文件夹路径
• base: 文件名+扩展名
• name: 文件名
• ext: 扩展名

例如:

require('path').parse('/users/test.txt')

结果:

{  root: '/',  dir: '/users',  base: 'test.txt',  ext: '.txt',  name: 'test'}

path.relative()

接受两个路径作为参数。基于当前工作目录，返回从第一个路径到第二个路径的相对路径。

例如:

require('path').relative('/Users/flavio', '/Users/flavio/test.txt') //'test.txt'
require('path').relative('/Users/flavio', '/Users/flavio/something/test.txt') //'something/test.txt'

path.resolve()

你可以使用 path.resolve() 获得从相对路径得到绝对路径:

path.resolve('flavio.txt') //'/Users/flavio/flavio.txt' if run from my home folder

通过指定第二个参数，resolve 将使用第一个参数作为第二个参数的基础:

path.resolve('tmp', 'flavio.txt')//'/Users/flavio/tmp/flavio.txt' if run from my home folder

如果第一个参数以斜线开头，这意味着它是一个绝对路径:

path.resolve('/etc', 'flavio.txt')//'/etc/flavio.txt'

Node.js 的 os 模块

这个模块提供了许多功能，你可以用来从底层的操作系统和程序运行的计算机上检索信息，并与之进行交互。

const os = require('os')

有几个有用的属性告诉我们一些与处理文件有关的关键事情:

os.EOL 给出了行的定界符序列。在 Linux和MacOS 上是 \n，而在 Windows 上是 \r\n。

当我说 Linux 和 MacOS 时，我指的是 POSIX 平台。为了简单起见，我排除了其他不太流行的操作系统，Node 可以在上面运行。

os.constants.signals 告诉我们所有与处理进程信号有关的常量，如 SIGHUP, SIGKILL 等。

os.constants.errno 设置错误报告的常量，如 EADDRINUSE、EOVERFLOW 等。

你可以全部阅读 这里。

现在让我们看看 os 提供的主要方法:

• os.arch()
• os.cpus()
• os.endianness()
• os.freemem()
• os.homedir()
• os.hostname()
• os.loadavg()
• os.networkInterfaces()
• os.platform()
• os.release()
• os.tmpdir()
• os.totalmem()
• os.type()
• os.uptime()
• os.userInfo()

os.arch()

返回标识底层架构的字符串，如 arm, x64, arm64.

os.cpus()

返回你系统上可用的 CPU 的信息。

例如:

[{
    model: 'Intel(R) Core(TM)2 Duo CPU     P8600  @ 2.40GHz',
    speed: 2400,
    times: {
        user: 281685380,
        nice: 0,
        sys: 187986530,
        idle: 685833750,
        irq: 0
    }
}, {
    model: 'Intel(R) Core(TM)2 Duo CPU     P8600  @ 2.40GHz',
    speed: 2400,
    times: {
        user: 282348700,
        nice: 0,
        sys: 161800480,
        idle: 703509470,
        irq: 0
    }
}]

os.endianness()

返回 BE 或 LE，取决于 Node.js 是用 Big Endian or Little Endian 编译的。

os.freemem()

返回代表系统中空闲内存的字节数。

os.homedir()

返回到当前用户的主目录的路径。

例如：

'/Users/flavio'

os.hostname()

返回主机名。

os.loadavg()

返回操作系统对负载平均值的计算结果。

它只在 Linux 和 MacOS 上返回一个有意义的值。

例如：

[ 3.68798828125, 4.00244140625, 11.1181640625 ]

os.networkInterfaces()

返回你系统中可用的网络接口的详细信息。

例如:

{
    lo0: [{
        address: '127.0.0.1',
        netmask: '255.0.0.0',
        family: 'IPv4',
        mac: 'fe:82:00:00:00:00',
        internal: true
    }, {
        address: '::1',
        netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
        family: 'IPv6',
        mac: 'fe:82:00:00:00:00',
        scopeid: 0,
        internal: true
    }, {
        address: 'fe80::1',
        netmask: 'ffff:ffff:ffff:ffff::',
        family: 'IPv6',
        mac: 'fe:82:00:00:00:00',
        scopeid: 1,
        internal: true
    }],
    en1: [{
        address: 'fe82::9b:8282:d7e6:496e',
        netmask: 'ffff:ffff:ffff:ffff::',
        family: 'IPv6',
        mac: '06:00:00:02:0e:00',
        scopeid: 5,
        internal: false
    }, {
        address: '192.168.1.38',
        netmask: '255.255.255.0',
        family: 'IPv4',
        mac: '06:00:00:02:0e:00',
        internal: false
    }],
    utun0: [{
        address: 'fe80::2513:72bc:f405:61d0',
        netmask: 'ffff:ffff:ffff:ffff::',
        family: 'IPv6',
        mac: 'fe:80:00:20:00:00',
        scopeid: 8,
        internal: false
    }]
}

os.platform()

返回 Node.js 编译时使用的平台：

• darwin
• freebsd
• linux
• openbsd
• win32
• ……more

os.release()

返回一个字符串，用于识别操作系统的发行号。

os.tmpdir()

返回指定的临时文件夹的路径。

os.totalmem()

返回代表系统中可用的总内存的字节数。

os.type()

识别操作系统：

• Linux
• Darwin on MacOS
• Windows_NT on Windows

os.uptime()

返回计算机自上次重启以来的运行秒数。

Node.js 的事件模块

events 模块为我们提供了 EventEmitter 类，它是在 Node.js 中处理事件的关键。

我在这方面发表了一篇完整的 文章，所以在这里我将只描述 API，而不进一步举例说明如何使用它。

const EventEmitter = require('events')
const door = new EventEmitter()

事件监听器吃自己的狗粮（译者注： dog food 是指自己写的代码），使用这些事件:

• newListener 当一个监听器被添加
• removeListener 当一个监听器被移除

当一个监听器被移除：

• emitter.addListener()
• emitter.emit()
• emitter.eventNames()
• emitter.getMaxListeners()
• emitter.listenerCount()
• emitter.listeners()
• emitter.off()
• emitter.on()
• emitter.once()
• emitter.prependListener()
• emitter.prependOnceListener()
• emitter.removeAllListeners()
• emitter.removeListener()
• emitter.setMaxListeners()

emitter.addListener()

别名 emitter.on().

emitter.emit()

发出一个事件。它按注册的顺序同步调用每个事件监听器。

emitter.eventNames()

返回一个字符串数组，代表在当前 EventListener 上注册的事件：

door.eventNames()

emitter.getMaxListeners()

获取可以添加到 EventListener 对象中的最大监听器数量，默认为 10，但可以通过使用 setMaxListeners() 增加或减少：

door.getMaxListeners()

emitter.listenerCount()

获取作为参数传递的事件的监听数量：

door.listenerCount('open')

emitter.listeners()

获取作为参数传递的事件的监听者数组：

door.listeners('open')

emitter.off()

别名 emitter.removeListener()，在 Node 10 加入的。

emitter.on()

添加一个回调函数，当一个事件被发出时被调用。

使用案例:

door.on('open', () => {console.log('Door was opened')})

emitter.once()

添加一个回调函数，在注册后第一次发出事件时被调用。这个回调函数只被调用一次，不会再被调用。

const EventEmitter = require('events')
const ee = new EventEmitter()

ee.once('my-event', () => {  
  //call callback function once
})

emitter.prependListener()

当你使用 on 或 addListener 添加监听器时，它在监听器队列中被最后添加，并被最后调用。使用 prependListener，它将在其他监听器之前被添加和调用。

emitter.prependOnceListener()

当你使用 once 添加一个监听器时，它在监听器队列中最后被添加，并最后被调用。使用 prependOnceListener，它将在其他监听器之前被添加和调用。

emitter.removeAllListeners()

移除监听某一特定事件的事件发射器对象的所有监听者：

door.removeAllListeners('open')

emitter.removeListener()

删除一个特定的监听器。你可以这样做，在添加回调函数时，将其保存到一个变量中，这样你以后就可以引用它了：

const doSomething = () => {
  door.on('open', doSomething)
  door.removeListener('open', doSomething)
}

emitter.setMaxListeners()

设置一个人可以添加到 EventListener 对象中的最大监听器数量，默认为 10，但可以增加或减少:

door.setMaxListeners(50)

Node.js http 模块

Node.js 的 http 模块提供了有用的函数和类来建立一个 HTTP 服务器。它是 Node.js 网络的一个关键模块。

它可以用以下方式引入：

const http = require('http')

该模块提供了一些属性和方法，以及一些类。

Properties

http.METHODS

此属性列出了所有支持的 HTTP 方法：

> require('http').METHODS
[ 'ACL',  'BIND',  'CHECKOUT',  'CONNECT',  'COPY',  'DELETE',  'GET',  'HEAD',  'LINK',  'LOCK',  'M-SEARCH',  'MERGE',  'MKACTIVITY',  'MKCALENDAR',  'MKCOL',  'MOVE',  'NOTIFY',  'OPTIONS',  'PATCH',  'POST',  'PROPFIND',  'PROPPATCH',  'PURGE',  'PUT',  'REBIND',  'REPORT',  'SEARCH',  'SUBSCRIBE',  'TRACE',  'UNBIND',  'UNLINK',  'UNLOCK',  'UNSUBSCRIBE' ]

http.STATUS_CODES

此属性列出了所有的HTTP状态代码及其描述：

> require('http').STATUS_CODES
{ '100': 'Continue',  '101': 'Switching Protocols',  '102': 'Processing',  '200': 'OK',  '201': 'Created',  '202': 'Accepted',  '203': 'Non-Authoritative Information',  '204': 'No Content',  '205': 'Reset Content',  '206': 'Partial Content',  '207': 'Multi-Status',  '208': 'Already Reported',  '226': 'IM Used',  '300': 'Multiple Choices',  '301': 'Moved Permanently',  '302': 'Found',  '303': 'See Other',  '304': 'Not Modified',  '305': 'Use Proxy',  '307': 'Temporary Redirect',  '308': 'Permanent Redirect',  '400': 'Bad Request',  '401': 'Unauthorized',  '402': 'Payment Required',  '403': 'Forbidden',  '404': 'Not Found',  '405': 'Method Not Allowed',  '406': 'Not Acceptable',  '407': 'Proxy Authentication Required',  '408': 'Request Timeout',  '409': 'Conflict',  '410': 'Gone',  '411': 'Length Required',  '412': 'Precondition Failed',  '413': 'Payload Too Large',  '414': 'URI Too Long',  '415': 'Unsupported Media Type',  '416': 'Range Not Satisfiable',  '417': 'Expectation Failed',  '418': 'I\'m a teapot',  '421': 'Misdirected Request',  '422': 'Unprocessable Entity',  '423': 'Locked',  '424': 'Failed Dependency',  '425': 'Unordered Collection',  '426': 'Upgrade Required',  '428': 'Precondition Required',  '429': 'Too Many Requests',  '431': 'Request Header Fields Too Large',  '451': 'Unavailable For Legal Reasons',  '500': 'Internal Server Error',  '501': 'Not Implemented',  '502': 'Bad Gateway',  '503': 'Service Unavailable',  '504': 'Gateway Timeout',  '505': 'HTTP Version Not Supported',  '506': 'Variant Also Negotiates',  '507': 'Insufficient Storage',  '508': 'Loop Detected',  '509': 'Bandwidth Limit Exceeded',  '510': 'Not Extended',  '511': 'Network Authentication Required' }

http.globalAgent

指向 Agent 对象的全局实例，它是 http.Agent 类的一个实例。

它用于管理 HTTP 客户端的连接持久性和重用，是 Node.js HTTP 网络的一个关键组件。

在后面的 http.Agent 类描述中会有更多内容。

Methods

http.createServer()

返回一个 http.Server 类的新实例。

用法:

const server = http.createServer((req, res) => {})//handle every single request with this callback

http.request()

http.get()

向服务器发出一个 HTTP 请求，创建一个 http.ClientRequest 类的实例。

Classes

HTTP模块提供了5个类（classes）：

• http.Agent
• http.ClientRequest
• http.Server
• http.ServerResponse
• http.IncomingMessage

http.Agent

Node创建了一个 http.Agent 类的全局实例来管理HTTP客户端的连接持久性和重复使用，这是 Node HTTP 网络的一个关键组成部分。

这个对象确保每一个向服务器发出的请求都是排队的，并且一个套接字被重复使用。

它还维护一个套接字池。这是性能方面的关键。

http.ClientRequest

当 http.request() 或 http.get() 被调用时，一个 http.ClientRequest 对象被创建。

当收到一个响应时，response 事件会被调用，并以一个 http.IncomingMessage 实例作为参数。

响应的返回数据可以通过两种方式读取:

• 你可以调用 response.read() 方法
• 在 response 事件处理程序中，你可以为 data 事件设置一个事件监听器，所以你可以监听流进的数据。

http.Server

这个类通常在使用 http.createServer() 创建一个新的服务器时被实例化并返回。

一旦你有了一个服务器对象，你就可以访问它的方法：

• close() 停止服务器接受新的连接
• listen() 启动HTTP服务器并监听连接

http.ServerResponse

由http.Server创建，并作为第二个参数传递给它所触发的 request 事件。

通常在代码中被称为 res：

const server = http.createServer((req, res) => { })//res is an http.ServerResponse object

你总是在处理程序中调用的方法是 end()，它关闭了响应，消息已经完成，服务器可以把它发送给客户端。它必须在每个响应中被调用。

这些方法是用来与 HTTP 头信息交互的：

• getHeaderNames() 获得已经设置的 HTTP 头的名称列表
• getHeaders() 获得一份已经设置的 HTTP 头的副本
• setHeader('headername', value) 设置一个 HTTP 头的值
• getHeader('headername') 获取一个已经设置的 HTTP 头信息
• removeHeader('headername') 删除一个已经设置的 HTTP 头
• hasHeader('headername') 如果响应中设置了该头信息，则返回 true
• headersSent() 如果头信息已经被发送到客户端，则返回 true

在处理完头信息后，你可以通过调用 response.writeHead() 将它们发送给客户端，它接受 statusCode 作为第一个参数、可选的状态信息和头信息对象。

要在响应体中向客户端发送数据，你可以使用 write()。它将发送缓冲的数据到 HTTP 响应流中。

如果使用 response.writeHead() 还没有发送头信息，它将首先发送头信息，并在请求中设置状态码和信息，你可以通过设置 statusCode 和 statusMessage 属性值来编辑:

response.statusCode = 500
response.statusMessage = 'Internal Server Error'

http.IncomingMessage

一个 "http.IncomingMessage" 对象是通过以下方式创建的：

• http.Server 监听 request 事件
• http.ClientRequest 监听 "response" 事件

它可以用来访问响应（response）：

• status，使用 statusCode 和 statusMessage 方法
• headers，使用 headers 方法或 rawHeaders
• HTTP method 使用它的 method method
• HTTP version 使用 httpVersion method
• URL 使用 url method
• 使用 "socket "方法的底层套接字

由于http.IncomingMessage 实现了可读流接口，所以数据可以使用流访问。

Node.js流（Streams）

流是支持 Node.js 应用程序的基本概念之一。

它们是一种有效处理读/写文件、网络通信或任何种类的端到端信息交换的方式。

流不是 Node.js 特有的概念。几十年前，它们就被引入到 Unix 操作系统中，程序之间可以通过管道操作符（|）传递流进行交互。

例如，在传统的方式中，当你告诉程序读取一个文件时，文件被读入内存，从头到尾，然后你处理它。

使用流，你会一块一块地读取它，处理它的内容，而不把它全部保留在内存中。

Node.js的 stream模块 提供了所有流媒体API的基础。

为什么是流？

流基本上提供了使用其他数据处理方法的两个主要优势：

• 内存效率: 你不需要在处理数据之前在内存中加载大量的数据
• 时间效率: 一旦你有了数据，就开始处理，而不是等到整个数据负载可用时才开始，这需要的时间要少得多。

一个流的例子

一个典型的例子是从磁盘上读取文件的例子。

使用Node.js fs 模块，你可以读取一个文件，并在与你的 http 服务器建立新的连接时通过 HTTP 提供服务：

const http = require('http')
const fs = require('fs')
const server = http.createServer(function (req, res) {
  fs.readFile(__dirname + '/data.txt', (err, data) => {
    res.end(data) })
})
server.listen(3000)

readFile() 读取文件的全部内容，并在完成后调用回调函数。

回调函数中的 res.end(data) 将返回文件内容给 HTTP 客户端。

如果文件很大，这个操作将花费相当多的时间。下面是用流写的同样的东西：

const http = require('http')
const fs = require('fs')
const server = http.createServer((req, res) => {  
  const stream = fs.createReadStream(__dirname + '/data.txt')
  stream.pipe(res)
})
server.listen(3000)

我们不是等到文件被完全读完，而是一旦有了准备好的数据块，就开始把它流向 HTTP 客户端。

pipe()

上面的例子使用了 stream.pipe(res) 一行：在文件流中调用了 pipe() 方法。

这段代码做了什么？它接收源文件，并将其输送到一个目的地。

你在源流上调用它，所以在本例中，文件流被管道到 HTTP 响应。

pipe() 方法的返回值是目标流，这是一个非常方便的东西，让我们可以连锁调用多个 pipe()，像这样:

src.pipe(dest1).pipe(dest2)

这个结构做相同的事：

src.pipe(dest1)
dest1.pipe(dest2)

Node.js 的流（stream） API

由于它们的优势，许多 Node.js 核心模块提供了原生的流处理能力，最显著的是：

• process.stdin 返回一个连接到 stdin 的流
• process.stdout 返回连接到 stdout 的流
• process.stderr 返回一个与 stderr 相连的流
• fs.createReadStream() 创建一个到文件的可读流
• fs.createWriteStream() 创建一个到文件的可写流
• net.connect() 发起一个基于流的连接
• http.request() 返回 http.ClientRequest 类的一个实例，这是一个可写流
• zlib.createGzip() 使用 gzip（一种压缩算法）将数据压缩到一个流中
• zlib.createGunzip() 解压一个 gzip 流
• zlib.createDeflate() 使用 deflate（一种压缩算法）将数据压缩到一个流中
• zlib.createInflate() 解压一个 deflate 流

不同类型的流

有四种类型的流：

• Readable: 你可以用管道输送，但不能用管道进入（你可以接收数据，但不能向它发送数据）。当你向一个可读流推送数据时，它被缓冲，直到消费者开始读取数据。
• Writable: 你可以用管道进入，但不能用管道离开（你可以发送数据，但不能从它接收）
• Duplex: 一个既可以管入又可以管出的流，基本上是一个可读流和可写流的组合。
• Transform: 类似于 Duplex，但输出是其输入的变换

如何创建一个可读流

我们从 stream 模块获得 可读(Readable) 流，并初始化它：

const Stream = require('stream')
const readableStream = new Stream.Readable()

现在，流已经被初始化，我们可以向它发送数据了：

readableStream.push('hi!')
readableStream.push('ho!')

如何创建一个可写流

为了创建一个可写流，我们扩展了基础的 Writable 对象，并实现了它的 _write() 方法。

首先创建一个流对象：

const Stream = require('stream')
const writableStream = new Stream.Writable()

然后执行 _write：

writableStream._write = (chunk, encoding, next) => {
  console.log(chunk.toString())
  next()
}

你现在可以用管道输送一个可读流：

process.stdin.pipe(writableStream)

如何从一个可读流中获取数据

我们如何从一个可读流中读取数据？使用一个可写流：

const Stream = require('stream')
const readableStream = new Stream.Readable()
const writableStream = new Stream.Writable()
writableStream._write = (chunk, encoding, next) => { 
  console.log(chunk.toString())
  next()
}

readableStream.pipe(writableStream)

readableStream.push('hi!')
readableStream.push('ho!')

你也可以直接消费一个可读流，使用 readable 事件：

readableStream.on('readable', () => {
  console.log(readableStream.read())
})

如何向可写流发送数据

使用流 write() 方法：

writableStream.write('hey!\n')

向一个可写的流发出信号，当你想停止写入

使用 end() 方法：

const Stream = require('stream')
const readableStream = new Stream.Readable()
const writableStream = new Stream.Writable()
writableStream._write = (chunk, encoding, next) => {
  console.log(chunk.toString())    
  next()
}
readableStream.pipe(writableStream)
readableStream.push('hi!')
readableStream.push('ho!')
writableStream.end()

使用 MySQL 和 Node.js 的基础知识

MySQL 是世界上最流行的关系型数据库之一。

Node.js 生态系统有几个不同的包，允许你与 MySQL 接口，存储数据，检索数据，等等。

我们将使用 mysqljs/mysql，这个包在 GitHub 上有超过 12,000 颗星，已经存在多年。

安装Node.js MySql包

安装命令:

npm install mysql

初始化与数据库的连接

你首先要引入包：

const mysql = require('mysql')

并创建一个连接：

const options = {  
  user: 'the_mysql_user_name', 
  password: 'the_mysql_user_password',  
  database: 'the_mysql_database_name'
}

const connection = mysql.createConnection(options)

你通过调用以下命令启动一个新的连接：

connection.connect(err => {  
  if (err) {  
      console.error('An error occurred while connecting to the DB')    
      throw err  
  }
})

连接选项

在上面的例子中，options 对象包含 3 个选项：

const options = {  
  user: 'the_mysql_user_name',  
  password: 'the_mysql_user_password',
  database: 'the_mysql_database_name'
}

你还可以使用很多，包括：

• host, 数据库主机名，默认为 localhost
• port, MySQL服务器端口号，默认为 3306
• socketPath, 用于指定 Unix 套接字，而不是主机和端口
• debug, 默认为禁用，可用于调试
• trace, 默认为启用，当发生错误时打印堆栈跟踪
• ssl, 用于设置与服务器的SSL连接（不在本教程范围内）

执行一个 SELECT 查询

现在你已经准备好在数据库上执行一个 SQL 查询。查询一旦执行，将调用一个回调函数，其中包含一个最终的错误、结果和字段（fields）：

connection.query('SELECT * FROM todos', (error, todos, fields) => {  
  if (error) { 
    console.error('An error occurred while executing the query')    
    throw error  
  }  
  console.log(todos)
})

你可以传入将被自动转义的值：

const id = 223
connection.query('SELECT * FROM todos WHERE id = ?', [id], (error, todos, fields) => {  
  if (error) { 
    console.error('An error occurred while executing the query')    
    throw error  
  }  
  console.log(todos)
})

要传递多个值，只需在你作为第二个参数传递的数组中放入更多元素即可：

const id = 223const author = 'Flavio'
connection.query('SELECT * FROM todos WHERE id = ? AND author = ?', [id, author], (error, todos, fields) => {  
  if (error) {
    console.error('An error occurred while executing the query')    
    throw error  
  }  
  console.log(todos)
})

执行一个INSERT 语句

你可以传递一个对象：

const todo = {  thing: 'Buy the milk'  author: 'Flavio'}
connection.query('INSERT INTO todos SET ?', todo, (error, results, fields) => {  
  if (error) {    
    console.error('An error occurred while executing the query')    
    throw error  
  }
})

如果表有一个 "自动增量" 的主键，其值将在 "results.insertId" 值中返回:

const todo = {  thing: 'Buy the milk'  author: 'Flavio'}
connection.query('INSERT INTO todos SET ?', todo, (error, results, fields) => {  
  if (error) {    
    console.error('An error occurred while executing the query')    
    throw error  
  }
}  
const id = results.resultId 
console.log(id))

关闭连接

当你需要终止与数据库的连接时，你可以调用 end() 方法:

connection.end()

这可以确保任何未决的查询被发送，并且连接被优雅地终止。

开发环境和生产环境之间的区别

你可以为生产和开发环境进行不同的配置。

Node.js假定它总是在开发环境中运行。你可以通过设置 NODE_ENV=production 环境变量向 Node.js 发出信号，表明你正在生产环境中运行。

这通常是通过执行以下命令来完成的:

export NODE_ENV=production

在 Shell 中，但最好把它放在你的 Shell 配置文件中（比如 Bash shell 的 .bash_profile ），因为否则在系统重启的情况下，这个设置会失效。

你也可以通过在你的应用程序初始化命令前加上环境变量来应用它:

NODE_ENV=production node app.js

这个环境变量是一个惯例，在外部库中也被广泛使用。

将环境设置为 production 通常可以确保以下：

• 日志记录保持在最小的、必要的水平上
• 更多的缓存级别，以优化性能

例如 Pug，Express 使用的模板库，如果 NODE_ENV 没有设置为 production，则在开发（development）模式下进行编译。在开发模式下，Express 视图在每个请求中都被编译，而在生产（production）模式下，它们被缓存起来。还有很多例子。

Express 提供了特定于环境的配置钩子，这些钩子根据NODE_ENV变量值自动调用：

app.configure('development', () => {})//...
app.configure('production', () => {})//...
app.configure('production', 'staging', () => {})//...

例如，你可以用它来为不同的模式设置不同的错误处理程序：

app.configure('development', () => {
  app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
})

app.configure('production', () => {
  app.use(express.errorHandler())
})

结语

我希望对 Node.js 的介绍，能帮助你开始使用它，或者帮助你掌握它的一些概念。希望你现在知道的足够多，可以开始创造一些好东西！

在这篇文章中，我们将使用 Node、Express 和 MongoDB 构建一个 RESTful API。我们将为创建数据、读取数据、更新数据和删除数据（基本 CRUD 操作）创建端点（endpoints）。

但在我们开始之前，请确保你的系统中已经安装了 Node。如果没有，请到 https://nodejs.org/en/download/ 下载并安装它。

让我们先做一下基本设置

在一个空文件夹中，运行以下命令：

npm init

这个命令会问你各种细节，比如你的项目名称、作者、存储库等等。然后它将在该文件夹中生成一个 package.json 文件。

{
  "name": "rest-api-express-mongo",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Package.json file

这个 Package.json 文件将包含所有的脚本，如如何运行应用程序，或如何测试应用程序，以及所有的依赖。

我们现在需要安装一些依赖项。

npm i express mongoose nodemon dotenv

这里，

1. Express 将被用于中间件，以创建各种 CRUD 端点
2. Mongoose 用于使用各种查询来管理 MongoDB 中的数据
3. Nodemon 用于在我们每次保存文件时重新启动我们的服务器
4. Dotenv 管理 .env 文件

因此，请继续安装它们。

在它们完成安装后，创建一个名为 index.js. 的文件，这将是我们应用程序的入口。

而在这个文件中，让我们添加 Express 和 Mongoose，并运行该文件。

const express = require('express');
const mongoose = require('mongoose');

现在，将 Express 的内容转移到一个名为 app 的新常量中。

const express = require('express');
const mongoose = require('mongoose');

const app = express();

现在，让我们修改这个文件，在 3000 端口监听。

const express = require('express');
const mongoose = require('mongoose');

const app = express();

app.use(express.json());

app.listen(3000, () => {
    console.log(`Server Started at ${3000}`)
})

现在，服务器被设置在 端口3000。让我们写脚本来启动我们的服务器。我们还添加了 app.use。在这里面，我们有一个代码片段，允许我们接受 JSON 格式的数据。

在package.json文件中，添加一个脚本，内容如下：

"scripts": {
    "start": "nodemon index.js"
},

这意味着我们可以使用 npm start 启动我们的服务器，它将使用我们之前安装的 Nodemon 包运行。

在终端中输入 npm start，我们将在终端中看到以下输出:

如何配置 MongoDB 数据库

现在，让我们来配置 mongoDB 数据库。前往 https://account.mongodb.com/account/login 并创建你的账户，如果你已经有一个账户，则可以登录。

登录后，我们要创建一个数据库。

因此，创建一个 Free Shared Cluster。

它将会要求你输入用户名和密码，输入它们。

然后，添加你的 IP 地址。

点击完成并关闭。

我们的集群将需要一些时间来完成，所以让我们等待吧。同时，在项目文件夹中创建一个名为 .env 的文件。

并在集群主页中，点击连接按钮。

将出现以下窗口：

点击 MongoDB Compass，它将返回以下字符串。同时，下载并安装 MongoDB Compass。

将你的用户名和密码添加到这个你以前使用过的字符串中。最后的连接字符串将看起来像这样:

mongodb+srv://nishant:********@cluster0.xduyh.mongodb.net/testDatabase

这里，nishant 是用户名，其次是密码，最后是数据库名称。

所以，把这个字符串粘贴到 .env 文件中。

DATABASE_URL = mongodb+srv://nishant:*******@cluster0.xduyh.mongodb.net/testDatabase

现在在 MongoDB Compass 中，也添加这个字符串。

然后，点击 Connect。

在这里，我们将得到两个数据库，这是默认的。第三个将在以后自动创建。

现在，让我们在脚本文件 index.js 中导入我们的 .env 文件的内容。

require('dotenv').config();

const mongoString = process.env.DATABASE_URL

在这里，我们将字符串存储到一个名为 mongoString. 的变量中。

现在，让我们使用 Mongoose 将数据库连接到我们的服务器。

mongoose.connect(mongoString);
const database = mongoose.connection

现在，我们必须根据我们的数据库连接是成功还是失败，抛出一个成功或错误信息。

database.on('error', (error) => {
    console.log(error)
})

database.once('connected', () => {
    console.log('Database Connected');
})

这里，database.on 意味着它将连接到数据库，如果连接失败，将抛出任何错误。而 database.once 意味着它将只运行一次。如果它成功了，它将显示一条信息：数据库已连接。

以下是到此为止的全部代码：

require('dotenv').config();

const express = require('express');
const mongoose = require('mongoose');
const mongoString = process.env.DATABASE_URL;

mongoose.connect(mongoString);
const database = mongoose.connection;

database.on('error', (error) => {
    console.log(error)
})

database.once('connected', () => {
    console.log('Database Connected');
})
const app = express();

app.use(express.json());

app.listen(3000, () => {
    console.log(`Server Started at ${3000}`)
})

如何为端点（Endpoints）创建我们的路由

创建一个名为 routes 的文件夹，并在里面制作一个名为 routes.js 的文件。

将此文件导入我们的主脚本文件 index.js 中。

const routes = require('./routes/routes');

另外，让我们使用这个路由文件（routes.js）。

const routes = require('./routes/routes');

app.use('/api', routes)

这里，这个 app.use 需要两样东西。一个是基础端点（base endpoint），另一个是路由的内容。现在，我们所有的端点将从'/api'开始。

我们会得到一个错误，因为我们在路由文件里面没有任何东西。所以，让我们添加它们。

const express = require('express');

const router = express.Router()

module.exports = router;

在这里，我们使用 Express 中的 Router，并且我们也使用 module.exports 导出了它。现在，我们的应用程序可以正常工作了。

如何编写我们的端点（Endpoints）

现在，让我们在这个路由文件中写入我们的端点。我们将有五条路由用于以下 actions：

1. 将数据发布到数据库
2. 从数据库中获取所有数据
3. 获取基于 ID 的数据
4. 基于 ID 更新数据
5. 根据 ID 删除数据

因此，让我们为这些 actions 创建路由：

//Post Method
router.post('/post', (req, res) => {
    res.send('Post API')
})

//Get all Method
router.get('/getAll', (req, res) => {
    res.send('Get All API')
})

//Get by ID Method
router.get('/getOne/:id', (req, res) => {
    res.send('Get by ID API')
})

//Update by ID Method
router.patch('/update/:id', (req, res) => {
    res.send('Update by ID API')
})

//Delete by ID Method
router.delete('/delete/:id', (req, res) => {
    res.send('Delete by ID API')
})

我们有五个方法，使用 REST 方法的 Post、Get、Patch 和 Delete。

这个路由器把路由作为第一个参数。然后，在第二个参数中，它正在接受一个回调。

在回调中，我们有一个 res 和一个 req。res 表示响应，req 表示请求。我们使用 res 来向我们的客户端，如 Postman，或任何前端客户端发送响应。而我们使用 req 来接收来自客户端应用程序（如 Postman）或任何前端客户端的请求。

然后在回调 body 中，我们要打印一条消息，说明是响应 API 消息。

保存这个，然后打开 Postman 来检查端点（endpoints）。如果你没有，请下载 Postman。它是测试 API 端点的一个好工具。

在地址栏中添加这个地址，然后点击发送，或按回车键。

我们将在 Postman 的正文中得到这个消息，因为我们只是使用 res.send. 发送一个消息。

现在，让我们从一个客户应用中获取一个响应。让我们简单地打印一个 ID。

我们必须首先改变 getOne 函数。我们使用 req.params.id 获取 ID，然后使用 res.send. 将其发送到客户端应用程序。

//Get by ID Method
router.get('/getOne/:id', (req, res) => {
    res.send(req.params.id)
})

localhost:3000/api/getOne/1000

在地址栏中添加这个端点（endpoint）。这里，我们使用 getOne 端点，后面是 ID。然后，点击发送。

我们将在 Postman 的响应 body 中获得 ID。

如何创建模型

现在，让我们创建一个模型，它将定义我们的数据库结构。

创建一个名为 model 的文件夹，里面有一个名为 model.js 的文件。

const mongoose = require('mongoose');

const dataSchema = new mongoose.Schema({
    name: {
        required: true,
        type: String
    },
    age: {
        required: true,
        type: Number
    }
})

module.exports = mongoose.model('Data', dataSchema)

在这里，我们有一个定义数据库结构的模式，它有一个 name 和一个 age 属性。这两个字段都有类型，而且都是必填的。

然后，我们简单地导出模式模型。

现在，在 routes.js 文件中导入这个模型。

const Model = require('../models/model');

如何向数据库 post 数据

让我们使用刚刚创建的模型创建要发布（post）的数据体。

router.post('/post', (req, res) => {
    const data = new Model({
        name: req.body.name,
        age: req.body.age
    })
})

我们的 name 和 agg 是接受来自 req body 的 name 和 age。我们从客户端应用如Postman，或任何前端客户端如 React 或 Angular. 获得这些数据。

我们还将创建一个try-catch块来处理成功信息和错误。

//Post Method
router.post('/post', (req, res) => {
    const data = new Model({
        name: req.body.name,
        age: req.body.age
    })

    try{

    }
    catch(error){
        
    }
})

在尝试块中，我们使用 data.save() 来保存 data。然后，我们将数据存储在一个叫做 dataToSave 的常量中。

我们还将成功的消息与数据一起发送到响应体中（response body）。

在 catch 块中，我们将接收任何错误，如果我们得到任何错误。

//Post Method
router.post('/post', (req, res) => {
    const data = new Model({
        name: req.body.name,
        age: req.body.age
    })

    try {
        const dataToSave = data.save();
        res.status(200).json(dataToSave)
    }
    catch (error) {
        res.status(400).json({message: error.message})
    }
})

现在，让我们从 Postman 添加一些数据。但在这之前，这个函数需要异步工作。所以，我们将使用 async-await。

router.post('/post', async (req, res) => {
    const data = new Model({
        name: req.body.name,
        age: req.body.age
    })

    try {
        const dataToSave = await data.save();
        res.status(200).json(dataToSave)
    }
    catch (error) {
        res.status(400).json({message: error.message})
    }
})

如果我们在正文中添加数据并点击发送，我们将得到以下结果：

它也在生成一个唯一的 ID。打开 MongoDB Compass 应用程序，你会看到数据库和你刚刚创建的这条记录。

如何获得所有数据

获取数据也很简单，只需几行代码：

router.get('/getAll', async (req, res) => {
    try{
        const data = await Model.find();
        res.json(data)
    }
    catch(error){
        res.status(500).json({message: error.message})
    }
})

这里，我们使用 Model.find 方法从数据库中获取所有数据。然后，我们将其以 JSON 格式返回。如果我们有一个错误，我们也会得到它。

如果我们在 Postman 中调用这个端点（endpoint），我们将在 Postman 主体中得到一个对象的数组。

如何根据 ID 获取数据

这个方法也很简单。我们只需要在一个叫做 findById 的方法中传递文档的 ID，也就是 req.params.id。

//Get by ID Method
router.get('/getOne/:id', async (req, res) => {
    try{
        const data = await Model.findById(req.params.id);
        res.json(data)
    }
    catch(error){
        res.status(500).json({message: error.message})
    }
})

如果我们点击发送，我们将根据 ID 获得数据。

如何根据 ID 来更新和删除数据

首先，让我们使用 补丁（patch） 方法来针对更新方法。

//Update by ID Method
router.patch('/update/:id', async (req, res) => {
    try {
        const id = req.params.id;
        const updatedData = req.body;
        const options = { new: true };

        const result = await Model.findByIdAndUpdate(
            id, updatedData, options
        )

        res.send(result)
    }
    catch (error) {
        res.status(400).json({ message: error.message })
    }
})

在这里，我们有三个参数传递给 findByIdAndUpdate 方法，我们用它来通过 ID 找到一个文档并更新它。

其中 req.params.id 是常量 id，updatedData 包含 req.body，还有 options，它指定了是否在 body 中返回更新的数据。

现在我们来测试一下。只要粘贴一个特定文件的 ID，然后点击发送，也要改变端点（endpoints）。

我们正在使用一个 ID 进行更新，而且它正在被更新。

删除也很简单，让我们来实现它：

//Delete by ID Method
router.delete('/delete/:id', async (req, res) => {
    try {
        const id = req.params.id;
        const data = await Model.findByIdAndDelete(id)
        res.send(`Document with ${data.name} has been deleted..`)
    }
    catch (error) {
        res.status(400).json({ message: error.message })
    }
})

我们在这里获取 ID，然后使用 Model.findByIdAndDelete 来删除该字段，同时传递 ID。

我们将更新的数据存储在一个常量 data 中。

在响应中，我们将得到这样的消息：具有特定名称的文档已经被删除。

如果我们测试一下，我们会得到以下结果：

所以，所有五个方法都完成了。我们可以发布数据和获取所有的数据（也基于 ID）。我们还可以更新它们和删除它们。

谢谢你阅读本文

在这篇文章中，你了解了如何使用 Node、Express 和 MongoDB 设计和开发一个 RESTful API。

现在你可以使用这些端点来构建一个全栈应用程序，使用 Vanilla JavaScript、React、Angular、Next 或 Vue.js。

你也可以看看我关于同一主题的视频，RESTful APIs - 使用 Node、Express 和 MongoDB 构建 RESTful API

欢迎从 GitHub 下载代码并进行实验。

祝你学习愉快！

当你第一次学习JavaScript时，最难理解的概念之一是该语言的异步处理（asynchronous processing）模式。对于我们大多数人来说，学习异步编程看起来差不多是这样的：

如果你第一次使用async时不是这样，请认为自己是个天才。

尽管它很难学，但如果你想使用JavaScript和Node.js构建网络应用程序和服务器，异步编程是至关重要的，因为JS代码默认是异步的。

异步编程基础知识

那么，究竟什么是异步处理模型，或“非阻塞I/O”模型（如果你是Node.js用户，你可能已经听说过）？

这里有一个很长的，请不要看的描述：在异步处理模型中，当你的应用程序引擎与外部各方（如文件系统或网络）进行交互时，它不会等到从这些各方得到一个结果，才做下一步。相反，它继续进行后续的任务，只有在得到结果的信号后才回到之前的外部各方进行处理。

为了理解Node.js的默认异步处理模型，我们来看看一个假设的圣诞老人工作室。在任何工作开始之前，圣诞老人将不得不阅读来自世界各地的孩子们的每一封可爱的信。

然后，他将弄清所要求的礼物，将物品名称翻译成精灵语，然后将指令传递给我们每个勤劳的精灵，他们有不同的专长：红色的擅长木制玩具，蓝色的擅长填充玩具，绿色的精通做机器人玩具。

今年，由于COVID-19大流行，只有一半的圣诞老人的精灵可以到他的车间来帮忙。不过，因为他很聪明，圣诞老人决定不等每个精灵准备完礼物（也就是同步工作），而是继续翻译和传递他那堆信中的指示。

诸如此类......

当他正准备读另一封信时，红色精灵通知圣诞老人，他已经完成了准备好了第一份礼物。然后，圣诞老人从红色精灵手中接过礼物，并把它放在一边。

然后他继续翻译和传递下一封信。

由于他只需要包装一个预先制作好的飞行机器人，绿精灵可以迅速完成准备工作并将礼物交给圣诞老人。

经过一整天艰苦的异步工作，圣诞老人和精灵们设法完成了所有的礼物准备工作。由于他改进了异步工作模式，尽管受到大流行病的重创，圣诞老人的工作室还是在创纪录的时间内完成了工作。

这就是异步或非阻塞I/O处理模型的基本思想。现在让我们看看它在Node.js中是如何具体完成的。

Node.js的事件循环

你可能听说过Node.js是单线程的。然而，确切地说，只有Node.js中的事件循环是单线程的，它与后台C++工作线程池交互。Node.js的处理模式有四个重要组成部分:

• 事件队列（Event Queue）: 在程序中声明的任务，或通过回调 callbacks从处理线程池中返回。（在我们的圣诞老人工作室里，相当于给圣诞老人的那堆信）
• 事件循环（Event Loop）: Node.js的主线程，促进事件队列和工人线程池进行操作--包括异步和同步。（这里是圣诞老人 🎅）
• （后台线程池）Background thread pool: 这些线程做任务的实际处理，这可能是I/O阻塞（例如调用和等待外部API的响应）。（这些是我们车间里勤奋的精灵 🧝🧝‍♀️🧝‍♂️。）

你可以将这种处理模式可视化，如下所示：

图片来源：c-sharpcorner.com

让我们看看一个实际的代码片段，看看这些代码的作用：

console.log("Hello");
https.get("https://httpstat.us/200", (res) => {
  console.log(`API returned status: ${res.statusCode}`);
});
console.log("from the other side");

如果我们执行上面这段代码，我们会在标准输出中得到这个结果：

Hello
from the other side
API returned status: 200

那么Node.js引擎是如何执行上述代码片段的呢？它从调用栈中的三个函数开始：

然后，“Hello” 被打印到控制台，相应的函数调用从堆栈中删除。

然后，对https.get的函数调用（即对相应的URL进行获取请求）被执行，并被委托给工人线程池，并附加一个回调。

对console.log的下一个函数调用被执行，from the other side被打印到控制台。

现在网络调用已经返回了一个响应，然后回调函数的调用将进入回调队列（callback queue）中。请注意，这一步可能发生在紧接着的上一步之前（即 从另一边得到打印），尽管通常情况下不是这样的。

然后回调被放在我们的调用栈（call stack）中：

然后我们会在控制台（console）看到 “API返回状态：200”，像这样：

通过促进回调队列（callback queue）和调用栈（call stack），Node.js中的事件循环以异步方式有效地执行我们的JavaScript代码。

JavaScript和Node.js的同步编程的发展历史 async/await

现在你对异步执行和Node.js事件循环的内部工作有了很好的理解，让我们深入了解JavaScript中的async/await。我们将看看它是如何工作的，从最初的回调驱动（callback-driven）的实现到最新闪目耀人的async/await关键字。

JavaScript中的回调（Callbacks）

OG处理JavaScript引擎的异步性的方法是通过回调。回调基本上是在同步或I/O阻塞操作结束后执行的函数。

这种模式的一个直接例子是内置的setTimeout函数，它将在执行回调之前等待一定数量的毫秒。

setTimeout(2000, () => {
  console.log("Hello");
});

虽然将回调加到阻塞操作上很方便，但这种模式也带来了一些问题：

• 回调地狱（Callback hell）
• 控制反转（不是好的那种！）。

什么是回调地狱？

让我们再看看圣诞老人和他的精灵们的例子。为了准备一份礼物，圣诞老人的工作室必须进行几个不同的步骤（每个步骤都要用setTimeout模拟不同的时间）：

function translateLetter(letter, callback) {
  return setTimeout(2000, () => {
    callback(letter.split("").reverse().join(""));
  });
}
function assembleToy(instruction, callback) {
  return setTimeout(3000, () => {
    const toy = instruction.split("").reverse().join("");
    if (toy.includes("wooden")) {
      return callback(`polished ${toy}`);
    } else if (toy.includes("stuffed")) {
      return callback(`colorful ${toy}`);
    } else if (toy.includes("robotic")) {
      return callback(`flying ${toy}`);
    }
    callback(toy);
  });
}
function wrapPresent(toy, callback) {
  return setTimeout(1000, () => {
    callback(`wrapped ${toy}`);
  });
}

这些步骤需要按照特定的顺序进行：

translateLetter("wooden truck", (instruction) => {
  assembleToy(instruction, (toy) => {
    wrapPresent(toy, console.log);
  });
});
// 结果是“wrapped polished wooden truck”

由于我们这样做，在这个过程中增加更多的步骤将意味着把内部的回调推到右边，并最终进入回调地狱，如图所示：

回调看起来是有顺序的，但有时执行的顺序并不遵循你屏幕上显示的内容。有了多层嵌套的回调，你很容易失去对整个程序流程的大局观，产生更多的错误，或者只是在写代码时变得更慢。

那么你如何解决这个问题呢？简单地将嵌套的回调模块化为命名的函数，你将有一个很好的左对齐的程序，很容易阅读。

function assembleCb(toy) {
  wrapPresent(toy, console.log);
}
function translateCb(instruction) {
  assembleToy(instruction, assembleCb);
}
translateLetter("wooden truck", translateCb);

控制反转（Inversion of Control）

回调模式的另一个问题是，你并没有决定高阶函数如何执行你的回调。他们可能在函数的结尾处执行，这是传统的做法，但他们也可能在函数的开始处执行，或者多次执行。

基本上，你只能任由依赖关系所有者摆布，而且你可能永远不知道他们什么时候会破坏你的代码。

为了解决这个问题，作为一个依赖性用户，你能做的并不多。然而，如果你自己曾经是一个依赖关系的所有者，请一定要：

• 坚持传统的回调签名，将错误作为第一个参数
• 只在高阶函数的末尾执行一次回调
• 记录绝对需要的任何不合常规的东西，并始终以向后兼容为目标

JavaScript中的Promises

Promises 是为了解决上述回调的问题而创建的。Promises确保了JavaScript用户：

• 坚持用他们的签名resolve和reject函数进行特定的约定。
• 将回调函数链接到一个排列整齐的、自上而下的流程。

我们之前关于圣诞老人工作室准备礼物的例子可以用这样的promises来重写：

function translateLetter(letter) {
  return new Promise((resolve, reject) => {
    setTimeout(2000, () => {
      resolve(letter.split("").reverse().join(""));
    });
  });
}
function assembleToy(instruction) {
  return new Promise((resolve, reject) => {
    setTimeout(3000, () => {
      const toy = instruction.split("").reverse().join("");
      if (toy.includes("wooden")) {
        return resolve(`polished ${toy}`);
      } else if (toy.includes("stuffed")) {
        return resolve(`colorful ${toy}`);
      } else if (toy.includes("robotic")) {
        return resolve(`flying ${toy}`);
      }
      resolve(toy);
    });
  });
}
function wrapPresent(toy) {
  return new Promise((resolve, reject) => {
    setTimeout(1000, () => {
      resolve(`wrapped ${toy}`);
    });
  });
}

顺利地进行了一系列的步骤：

translateLetter("wooden truck")
  .then((instruction) => {
    return assembleToy(instruction);
  })
  .then((toy) => {
    return wrapPresent(toy);
  })
  .then(console.log);
// This would produce the exact same present: wrapped polished wooden truck

然而，promises 也不是没有问题的。我们链条中每个节点的数据都有不同的作用域，只能访问从紧邻的前一个步骤或父作用域传递过来的数据。

例如，我们的礼物包装步骤可能想使用翻译步骤的数据：

function wrapPresent(toy, instruction) {
  return Promise((resolve, reject) => {
    setTimeout(1000, () => {
      resolve(`wrapped ${toy} with instruction: "${instruction}`);
    });
  });
}

这倒是一个典型的 "内存共享 "的线程问题。为了解决这个问题，我们应该使用Promise.all和"通过通信共享数据，而不是通过共享数据进行通信"，而不是使用父级范围内的变量。

translateLetter("wooden truck")
  .then((instruction) => {
    return Promise.all([assembleToy(instruction), instruction]);
  })
  .then((toy, instruction) => {
    return wrapPresent(toy, instruction);
  })
  .then(console.log);
// This would produce the present: wrapped polished wooden truck with instruction: "kcurt nedoow"

JavaScript中的Async/Await

最后但绝对不是最不重要的，最靓的仔是async/await。它非常容易使用，但也有一些风险。

Async/await解决了Promise的内存共享问题，把所有的东西都放在同一个范围内。我们之前的例子可以很容易地改写成这样：

(async function main() {
  const instruction = await translateLetter("wooden truck");
  const toy = await assembleToy(instruction);
  const present = await wrapPresent(toy, instruction);
  console.log(present);
})();
// This would produce the present: wrapped polished wooden truck with instruction: "kcurt nedoow"

然而，尽管用async/await写异步代码很容易，但也很容易犯错误，造成性能漏洞。

现在让我们把我们的例子圣诞老人工作室的场景本地化，以包装礼物并把它们装到雪橇上。

function wrapPresent(toy) {
  return Promise((resolve, reject) => {
    setTimeout(5000 * Math.random(), () => {
      resolve(`wrapped ${toy}`);
    });
  });
}
function loadPresents(presents) {
  return Promise((resolve, reject) => {
    setTimeout(5000, () => {
      let itemList = "";
      for (let i = 0; i < presents.length; i++) {
        itemList += `${i}. ${presents[i]}\n`;
      }
    });
  });
}

你可能犯的一个常见错误是这样执行步骤：

(async function main() {
  const presents = [];
  presents.push(await wrapPresent("wooden truck"));
  presents.push(await wrapPresent("flying robot"));
  presents.push(await wrapPresent("stuffed elephant"));
  const itemList = await loadPresents(presents);
  console.log(itemList);
})();

但是，圣诞老人是否需要 等待每件礼物被逐一包装好后再装车？当然不需要。礼物应该是同时包装的。你可能会经常犯这个错误，因为你很容易写出await，而没有考虑到这个关键字的阻塞性（blocking nature）。

为了解决这个问题，我们应该把礼物包装的步骤捆绑在一起，一次性执行：

(async function main() {
  const presents = await Promise.all([
    wrapPresent("wooden truck"),
    wrapPresent("flying robot"),
    wrapPresent("stuffed elephant"),
  ]);
  const itemList = await loadPresents(presents);
  console.log(itemList);
})();

以下是一些建议的步骤，以解决你的Node.js代码中的并发性能问题：

• 在你的代码中找出有多个连续等待的hotspots
• 检查它们是否相互依赖（即一个函数使用另一个函数返回的数据）
• 用Promise.all使独立的函数调用同时进行

打包（文章，而不是圣诞礼物😂）

祝贺你读到了本文的结尾，我已经尽力让这篇文章变得更短。这篇文章，但JavaScript中的异步话题实在是太广泛了。

下面是一些关键的收获：

• 将你的JavaScript回调模块化以避免回调地狱
• 坚持使用JS回调的惯例
• 在使用promises的时候，通过Promise.all来共享数据
• 要注意async/await代码的性能影响

We ❤️ JavaScript :)

感谢阅读

最后，如果你喜欢我的文章，请到我的博客了解类似的文章，并关注我的推特。🎉

如果你尝试使用 apt-package manager 安装最新版本的 Node，你最终会得到 v10.19.0。这是 Ubuntu 应用商店中的最新版本，但不是 NodeJS 的最新发布版本。

这是因为当一个软件的新版本发布时，Ubuntu 团队可能需要几个月的时间才能在官方 Ubuntu 商店中进行测试和发布。因此，要获得任何软件的最新版本，我们可能不得不使用开发人员发布的私有包。

在本教程中，我们要做的是获取 v12.18.1（LTS - 具有长期支持）或 v14.4 的 Node。要获取最新版本，我们可以使用 nodesource 或 nvm（Node 版本管理器）。我将向你展示如何使用这两种方法。

此处的所有命令都将使用 Ubuntu CLI/终端运行。

使用 NVM——我的首选方法

我喜欢 nvm，因为它允许我为不同的项目使用不同的 Node 版本。

有时，你可能正在与使用不同版本 Node 的人合作项目，你需要将 Node 版本切换到项目所需的版本。为此，nvm 是最好的工具。

安装 NVM

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash

要检查 nvm 是否已安装，请键入 nvm --version。如果你得到一个像 0.35.3 这样的版本号，那么你就知道 nvm 安装成功了。

重新启动终端以使更改生效。

安装 NodeJS

接下来，让我们安装 Nodejs 版本 14.4。

只需运行 nvm install 14.4.0。

你可以使用类似的命令来安装所需的任何版本的 node，例如 nvm install 12.18.1。

此命令会自动安装 nodejs 以及最新的 npm 版本，即 v6.14.5。

如果你需要切换 Node 版本，可以简单地运行 nvm use <版本号>，例如 nvm use v12.18.1。

要列出使用 nvm 安装的不同 Node 版本，请运行 nvm ls。

安装 Nodesource

运行以下命令告诉 Ubuntu 我们要从 nodesource 安装 Nodejs。

curl -sL https://deb.nodesource.com/setup_14.x | sudo -E bash -

注意 v14.4.0 是 Node 的最新版本，但目前没有 LTS - 为其提供长期支持。要使用 LTS 安装最新版本的 Node，请将上面命令中的 14 更改为 12。

系统可能会提示你输入 root 用户的密码。输入它并按回车键。

安装 NodeJS

一旦我们完成了 Nodesource 的设置，我们现在可以安装 Nodejs v14.4。
运行 sudo apt-get install -y nodejs。

完成后，我们可以检查是否安装了最新版本的 Node。只需在终端中输入 nodejs -v，它就会返回 v14.4.0。

此时你应该已经自动安装了 npm。要检查你拥有的 npm 版本，请运行 npm version。如果你没有获得包含最新版本的 npm 6.14.5 的对象，{ npm: '6.14.5' }，那么你可以通过运行以下命令手动更新 npm：

npm install -g npm@latest

如果你遇到任何由于 npm 未安装而无法更新的问题，你可以先使用 sudo apt-get install -y npm 安装 npm，然后运行上面的命令进行更新。

要运行某些 npm 包，我们还需要运行 sudo apt install build-essential。

就是这些！

你已经在你的 Ubuntu 机器上安装了最新版本的 NodeJS 和 NPM。

去构建伟大的产品吧:)

所有理论依据来源于 node.js源码。（版本略）

0x00 总有面试官要刁难朕

我们不妨看一下这样的题目

console.log(1)

setTimeout(() => {
  console.log(2)
}, 0)

Promise.resolve().then(() => {
	console.log(3)
}).then(() => {
	console.log(4)
})

console.log(5)

请问上面代码的打印结果？
▇▇▇▇▇▇▇▇▇▇  <--- 刮开查看答案

对吧，无数次被这种装X面试题恶心。

小声哔哔：谁项目里会这样写代码？

不过恶心归恶心，不管有没有实用性，透过这些题目来弄清楚技术的真相，是没有坏处的。

我们的目标是：以后还有类似的题目，不管千变万化，直接通关。

0x01 没有银弹，还是要拿源码说话

为了证明不是胡说八道，先贴出关键源码。

// 来自 deps/uv/src/unix/core.c
while (r != 0 && loop->stop_flag == 0) {
    uv__update_time(loop); 
    uv__run_timers(loop); // ⭐️ timer
    ran_pending = uv__run_pending(loop); // ⭐️ 上一个循环一些没来得及做完的事
    uv__run_idle(loop); // ⭐️ 底层用，暂时不懂
    uv__run_prepare(loop); // ⭐️ 底层用，暂时不懂

	/*
	* 忽略几行不重要的
    */
    
    uv__io_poll(loop, timeout); // ⭐️io, network or file system 等等
    uv__run_check(loop); // ⭐️ setImmediate
    uv__run_closing_handles(loop); // ⭐️ event on('close')

    if (mode == UV_RUN_ONCE) {
     // 这里不重要
    }

    r = uv__loop_alive(loop);
    if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT)
     // 这里不重要
  }

然后我们开始逐个去了解。

timer

这部分主要是检查有没有可以执行的定时器，包括但不限于setTimeout``setInterval。

这里的的具体实现在deps/uv/src/unix/timer.c，简单说就是使用一个最小堆(小顶堆), 把时间最接近的一个取出来，判断当前时间是否可以执行。

pending

这个阶段是执行 上一个循环poll阶段还没来得及处理的callback。

这句话，在下面介绍poll阶段的时候才回过头来理解。

idle + prepare

按文档说是底层预留的，暂时我还没研究清楚。请忽略。

poll

关键！这个阶段处理的，就是我们比较熟悉的network , fs之类的异步操作回调。就是说你去请求一个远程的接口，那么回调函数会在poll阶段执行。

然后就是跟上面pending的关联。

由于uv__io_poll代码有点长就不贴了，有兴趣自己去看。

一般来说，我们的每一个阶段，都会处理完已经就绪的所有callback，如果poll阶段触发大量的 callback，就会占用很多的时间。

我们的uv当然是不会设计成这样的，所以，它会从timer里拿到最小的(未来最快到达的)一个定时器的时间，作为poll阶段的 timeout。

如果timeout到了，还有callback没开始执行的，对不起，请到pending队列里。

可能是uv认为，poll阶段的callback，相对来说对“准时”不太敏感，所以通过这样尽量确保timer的执行不会误差太多。

check

为什么叫做check我也不清楚。

但是这个阶段将会运行我们 setImmediate注册的回调。

很震惊吧，setImmediate完全就不是timer那一族的~~~~

closing_handles

执行close事件注册的回调，放在循环的最后一个阶段，也是合情合理。

0x03 那么我们练习一下

关于process.nextTick

nextTick 是个复杂的实现，需要另外开一篇来讲解。

为了方便下面的练习，我暂时先把结论放出来。

nextTick会直接追加在每一个阶段末尾，就是说，如果timer阶段的回调里有process.nextTick，通过这个来注册的回调，会在紧接着的pending之前就执行。

✏️ 题目一

setTimeout(() => {
  console.log('A')
}, 0)

setImmediate(() => {
  console.log('B')
})

答案：

AB 或 BA

解释：

首先这里的第一个知识点，是timer的第二个参数，取值范围是 [1, 2^31 - 1]。也就是说，这个 0 会被当成 1 处理。

然后根据运行环境的差异，如果进入到当前循环前，已经过去了 1ms ,那就打印 AB。

否则，如果在 1ms 内就开始了本次循环，那timer还没准备后，就会在下一次循环触发，自然就打印 BA。

✏️ 题目二

const fs = require('fs')

fs.readFile(__filename, () => {
  setTimeout(() => {
    console.log('A')
  }, 0)

  setImmediate(() => {
    console.log('B')
  })
})

答案：

BA 

解释

知识点在于fs.readFile，这个是 io操作，它的整个回调会在poll阶段执行。
而poll之后马上进入check，所以正好先执行了刚注册的setImmediate。

setTimeout自然就要等到下一个循环的timer阶段。

✏️ 题目三，这个划重点

setImmediate(() => {
  console.log('1')
  setImmediate(() => {
    console.log('2')
  })
  process.nextTick(() => {
    console.log('nextTick')
  })
})

setImmediate(() => {
  console.log('3')
})

答案：

1 3 nextTick 2

解释：

首先，最外层的两个setImmediate会顺序注册到同一个check阶段，而上面提到nextTick会直接追加到当前阶段末尾，所以是1 3 nextTick而不是1 nextTick 3 。

而内层的setImmediate会注册到下一次循环的check阶段，所以 2最后打印。

请细品。

0x04 继续练习之前，讲讲 promise

和 process.nextTick类似，promise的回调也是在当前阶段的末尾追加。

不过有意思的是，process.nextTick拥有更高的优先级。

这个实现细节，也是需要另外一篇文章来讲解（挖坑+1）。。。。

0x05 继续练习吧

✏️ 题目四

const promise = Promise.resolve()

promise.then(() => {
  console.log('A')
})

process.nextTick(() => {
  console.log('B')
})

答案：

BA

解释

无需解释，先记住二者的优先级。

✏️ 题目五

setTimeout(() => {
  console.log(1)
}, 0)

new Promise((resolve, reject) => {
  console.log(2)
  for (let i = 0; i < 10000; i++) {
    i === 9999 && resolve()
  }
  console.log(3)
}).then(() => {
  console.log(4)
})
console.log(5)

答案：

2 3 5 4 1

解释

这里有个知识点，new Promise的参数是同步执行的。

所以 2 3 5都是同步顺序输出的。

然后 then 在一个同步的for循环后触发，会追加到本阶段末尾，所以4紧接着输出。

最后是setTimeout，会在下一个循环的timer阶段执行，输出 1

🐸 BOSS戦

setImmediate(() => {
  console.log(1)
  setTimeout(() => {
    console.log(2)
  }, 100)
  setImmediate(() => {
    console.log(3)
  })
  process.nextTick(() => {
    console.log(4)
  })
})
process.nextTick(() => {
  console.log(5)
  setTimeout(() => {
    console.log(6)
  }, 100)
  setImmediate(() => {
    console.log(7)
  })
  process.nextTick(() => {
    console.log(8)
  })
})
console.log(9)

答案：

9 5 8 1 7 4 3 6 2

解释：

你已经是一个成熟的程序员了，试着用上面的知识自己来解释吧。

Tips 可以尝试画出来，一共经过了多少个循环， 每个循环的每个阶段执行了什么。

但在我们深入研究构建服务器之前，让我们更多地了解 Babel 是什么。

什么是 Babel

Babel 是一个 JavaScript 编译器。它是一种流行的工具，可帮助你使用 JavaScript 编程语言的最新功能。

为什么在 Node.js 中使用 Babel

你是否曾经打开过使用 Node.js/Express 构建的后端仓库——你首先看到的是 ES6 导入和导出语句以及其他一些很酷的 ES6 语法特性？

Babel 让这一切成为可能。请记住，Babel 是一种流行的工具，可让你使用 JavaScript 的最新功能。现在许多框架都在底层使用 Babel 来编译它们的代码。

例如，如果没有像 Babel 这样的编译器的帮助，Node 就不能使用 ES6 导入和导出语句以及 ES6 语法的其他一些很酷的特性。

因此，在本教程中，我将向你展示如何快速配置你的 Node 应用程序以兼容大多数 ES6 语法。

很棒吧？我们开始吧！

准备

本教程假设你具备以下条件：

• Node.js 基础知识
• 你的电脑上已安装 Node
• 你选择的任何代码或文本编辑器

开始

让我们配置一个基本的 Node 应用程序，我们将在本教程中使用它。

新建一个文件夹。在本教程中，我将调用我的 node-babel。现在将文件夹添加到工作区，并打开你的终端。

让我们初始化应用程序并创建一个 package.json 文件：

npm init

此命令将显示一些我们希望保持原样的配置步骤。因此，在整个配置过程中按 enter 键或 return 键都可以正常工作。

完成后，创建一个名为 “index.js” 的新文件，它将作为我们的入口点。

如何配置和安装 Babel

现在，我们将安装 Babel 系列的三个包，它们是：

@babel/cli, @babel/core and @babel/preset-env

我们使用以下命令安装软件包：

npm install --save-dev @babel/cli @babel/core @babel/preset-env

我们想使用 --save-dev 来安装它们作为模块开发的依赖项。

所以当你完成安装，创建一个名为 .babelrc 的新文件来配置 Babel。

touch .babelrc

这个文件将包含我们想要添加到 Babel 的所有选项。所以现在，让我们使用我通常在我的应用程序中用于开发的配置。你可以复制它并添加到你的程序：

{
  "presets": [
    ["@babel/env", {
      "targets": {
        "node": "current"
      }
    }]
  ],
  "plugins": [
    "@babel/plugin-proposal-class-properties",
    "@babel/plugin-proposal-object-rest-spread"
  ]
}

上面的配置是我用来告诉 Babel 的，是的，我不仅要使用我的导入和导出语句，还要使用 class 特性以及 ES6 中的 rest 和 spread 运算符。

厉害吧？让我们继续。

如何配置一个简单的服务器

现在打开我们之前创建的 “index.js” 文件，并添加以下代码以生成一个简单的服务器：

import http from 'http';

const server = http.createServer((req, res) => {
  res.end('Hello from the server');
}).listen(4001);

console.log('Server is up and running');

export default server;

使用上面的示例代码，服务器将侦听端口 4001，然后在我们访问该端口时向我们发送 “Hello from the server” 响应。

Package.json 脚本配置

我们现在有一个简单的服务器。要运行它，我们必须在使用 Node.js 运行之前转译我们的代码。为此，请打开 “package.json” 文件并添加此构建和启动脚本：

  "scripts": {
+   "build": "babel index.js -d dist",
    "start": "npm run build && node dist/index.js"
  }

很棒，现在我们用以下命令启动服务器：

npm start

访问 localhost:4001，你应该会收到以下响应：

如何使用 Nodemon 监视和重启你的服务器

为了防止每次更改应用程序时自己重新启动服务器，我们需要安装 nodemon。你可以使用以下命令将 nodemon 安装到你的应用程序，以将其安装为开发依赖项：

npm install --save-dev nodemon

然后我们重新配置我们的 package.json 脚本：

  "scripts": {
    "build": "babel index.js -d dist",
    "start": "npm run build && nodemon dist/index.js"
  }

太棒了，现在这是我们 Node 应用程序的最终代码，以及运行 “npm start” 启动服务器时应该得到的结果。

从上图可以看出，我们的服务器已启动并正在运行。你现在可以使用 ES6 语法中的 import 和 export 语句以及 ES6 提供的其他很棒的功能，例如 Node 应用程序中的 rest 和 spread 运算符。

总结

在本教程中，我们学习了如何使用 Babel 在 Node 应用程序中使用 ES6 语法。

请注意，你可以在 .babelrc 文件中添加更多配置，不限于我们在本教程中介绍的内容，你可以随意调整或更改它。

你可以在这里找到示例代码：https://github.com/Veri5ied/node-babel。

编程愉快！

原文：How to Setup Babel in Node.js，作者：Alvin Okoro

高可用 API 有如下衡量标准：

• 速度（API 响应时间）
• 文档（清晰简洁的文档，能够很好的描述 API）
• 架构和持续性（代码可维护可扩展）

这篇教程我们将要通过 Node.js、MongoDB、Fastify 和 Swagger 搭建高可用后端架构。

源代码已经托管到了 GitHub 3 上。

开始之前

你应该具有初级\中极 JavaScript 知识，了解 Node.js 和 MongoDB，知道什么是 REST APIS。

下面是相关链接：

• JavaScript 2
• Node.js 1
• MongoDB 1
• REST APIS 3

涉及的技术

• Fastify 3
• Mongoose
• Swagger 1

可以在标签页中打开这些链接，随时查阅。

需要安装的环境：

• NodeJS/NPM
• MongoDB
• Postman

除此之外，还需要 IDE 和 终端，我在 Mac 用的是 iTerm2 ，在 Windows 上用的是 Hyper。

让我们开始吧

打开终端初始化项目，执行下面的代码：

mkdir fastify-api
cd fastify-api
mkdir src
cd src
touch index.js
npm init

上面的代码，创建了两个新目录，然后切换到了新建的路径下，创建了一个 index.js 文件并通过 npm 初始化项目。

在初始化新项目的时候会提示输入一些值，这些值可以留空在稍后更新。

完成后，src 目录下生成了 package.json。在这个文件里你可以更改工程初始化时留空的值。

接下来安装将要用到的所有的依赖库：

npm i nodemon mongoose fastify fastify-swagger boom

下面是在它们的官网引用的介绍：

nodemon

nodemon 是 node.js 应用的开发工具，当检测到目录下的文件改变时它会自动重启 node 应用。

使用 nodemon 不需要更改代码，它是 node 命令的封装，直接在执行脚本的时候用 nodemon替换 node 即可。

把下面的代码添加到 package.json 文件里来使用 nodemon：

"start": "./node_modules/nodemon/bin/nodemon.js ./src/index.js"

这时 package.json 文件应该这样：

{
  "name": "fastify-api",
  "version": "1.0.0",
  "description": "A blazing fast REST APIs with Node.js, MongoDB, Fastify and Swagger.",
  "main": "index.js",
  "scripts": {
  "start": "./node_modules/nodemon/bin/nodemon.js ./src/index.js",
  "test": "echo \"Error: no test specified\" && exit 1"
},
  "author": "Siegfried Grimbeek <siegfried.grimbeek@gmail.com> (www.siegfriedgrimbeek.co.za)",
  "license": "ISC",
  "dependencies": {
  "boom": "^7.2.2",
  "fastify": "^1.13.0",
  "fastify-swagger": "^0.15.3",
  "mongoose": "^5.3.14",
  "nodemon": "^1.18.7"
  }
}

mongoose

Mongoose 提供了一个直截了当、基于 schema 的应用数据 model 解决方案。它包括了内置类型转换、校验、构建查询、业务逻辑钩子等功能，可直接使用。

fastify 3

Fastify 是一个高度专注于以最少的开销和强大的插件架构提供最佳开发者体验的 web 框架。Fastify 受到Hapi 和 Express 的启发，是目前最快的 web 框架之一。

fastify-swagger 1

Swagger 1 文档生成器速度很快。它通过 routes 里声明的 schema 生成符合 swagger 规范的文档。

boom

boom 提供一个返回 HTTP 错误的工具集。

启动服务开始创建第一个路由

在 index.js 里添加如下代码：

// Require the framework and instantiate it
const fastify = require('fastify')({
  logger: true
})

// Declare a route
fastify.get('/', async (request, reply) => {
  return { hello: 'world' }
})

// Run the server!
const start = async () => {
  try {
    await fastify.listen(3000)
    fastify.log.info(`server listening on ${fastify.server.address().port}`)
  } catch (err) {
    fastify.log.error(err)
    process.exit(1)
  }
}
start()

在这里引入了 Fastify 框架，声明了第一个 route 并在 port 3000 上启动了服务，代码很容易理解但是要注意初始化 Fastify 时传入了可选的对象：

// Require the fastify framework and instantiate it
const fastify = require('fastify')({
  logger: true
})

上面的代码开启了默认关闭的 Fastify 内置日志功能。

在终端的 src 目录下运行下面的代码：

npm start

浏览器访问 http://localhost:3000/ 会看到 {hello:world}。

回到 index.js 开始配置数据库。

启动 MongoDB 创建 model

安装 MongoDB，打开终端运行以下命令启动 MongoDB。

mongod

在 MongoDB 里不需要手动创建数据库。只需要在配置的时候指定数据库名，当数据存储的时候， MongoDB 会自动创建数据库。

在 index.js 里添加如下代码：

...
// Require external modules
const mongoose = require('mongoose')
// Connect to DB
mongoose.connect(‘mongodb://localhost/mycargarage’)
 .then(() => console.log(‘MongoDB connected…’))
 .catch(err => console.log(err))
...

在上面的代码里我们引入了 Mongoose 来连接 MongoDB 数据库。数据库名是 mycargarage，如果一切顺利，在终端里会看到 MongoDB connected...。

注意不需要手动重启 app，因为我们之前添加了 Nodemon 库。

现在数据库已经运行，可以创建第一个 Model 了。在 src 路径下创建一个名为 models 的新文件夹，在里面创建一个 Car.js 文件，添加如下代码：

// External Dependancies
const mongoose = require('mongoose')

const carSchema = new mongoose.Schema({
  title: String,
  brand: String,
  price: String,
  age: Number,
  services: {
    type: Map,
    of: String
  }
})

module.exports = mongoose.model('Car', carSchema)

上面的代码声明的 carSchema 包含了和 cars 相关的所有信息。除了两个基本数据类型: String和 Number。还用到了相对比较陌生的 Map，可以在这里 2阅读更多。接着导出了 carSchema，以便在 app 里使用。

也可以把 routes、controllers 和 config 的代码都放到 index.js 文件里，但是为了代码可维护，这里每个组件都有它自己的文件夹。

创建 car controller

在 src 下创建 controllers 文件夹，在文件夹里创建 carController.js 文件：

// External Dependancies
const boom = require('boom')

// Get Data Models
const Car = require('../models/Car')

// Get all cars
exports.getCars = async (req, reply) => {
  try {
    const cars = await Car.find()
    return cars
  } catch (err) {
    throw boom.boomify(err)
  }
}

// Get single car by ID
exports.getSingleCar = async (req, reply) => {
  try {
    const id = req.params.id
    const car = await Car.findById(id)
    return car
  } catch (err) {
    throw boom.boomify(err)
  }
}

// Add a new car
exports.addCar = async (req, reply) => {
  try {
    const car = new Car(req.body)
    return car.save()
  } catch (err) {
    throw boom.boomify(err)
  }
}

// Update an existing car
exports.updateCar = async (req, reply) => {
  try {
    const id = req.params.id
    const car = req.body
    const { ...updateData } = car
    const update = await Car.findByIdAndUpdate(id, updateData, { new: true })
    return update
  } catch (err) {
    throw boom.boomify(err)
  }
}

// Delete a car
exports.deleteCar = async (req, reply) => {
  try {
    const id = req.params.id
    const car = await Car.findByIdAndRemove(id)
    return car
  } catch (err) {
    throw boom.boomify(err)
  }
}

carController.js

代码看起来有点长，其实很简单。

• 引入了 boom 来处理错误：boom.boomify(err)。
• 导出了所有的函数以便在 route 里引入。
• 每个函数都是异步的，使用了 await 表达式，这样在执行异步函数的时会候暂停运行直到程序调用传入的 Promise 的 resolve，然后继续异步函数的执行并返回 resolved 值。点击点解更多
• 每个函数代码都在 try/catch 语句里。点击了解更多
• 每个函数都有两个参数：req (request) 和 reply。教程里只用到了 request 参数，用来访问 request body、 参数以及处理数据。点击了解更多

注意代码 31 行：

const car = new Car({ …req.body })

用到了扩展运算符。点击了解更多

注意代码 42 行：

const { …updateData } = car

使用了 JavaScript 解构赋值和扩展运算符。点击了解更多

另外，代码还用到了一些标准的 Mongoose 方法来操作数据库。

可能你已经迫不及待的想要运行你的 API 测试一下了，但是在开始之前，还需要把 controller 连接到 routes，把 routes 连接到 app 上。

创建导入 routes

同样，在项目根目录下创建 routes 文件夹。在文件夹内创建 index.js 文件，文件代码如下：

// Import our Controllers
const carController = require('../controllers/carController')

const routes = [
  {
    method: 'GET',
    url: '/api/cars',
    handler: carController.getCars
  },
  {
    method: 'GET',
    url: '/api/cars/:id',
    handler: carController.getSingleCar
  },
  {
    method: 'POST',
    url: '/api/cars',
    handler: carController.addCar,
    // schema: documentation.addCarSchema
  },
  {
    method: 'PUT',
    url: '/api/cars/:id',
    handler: carController.updateCar
  },
  {
    method: 'DELETE',
    url: '/api/cars/:id',
    handler: carController.deleteCar
  }
]

module.exports = routes

在这里我们引入了 controller 并且把每个函数分发到了相应的 routes 上。

每个 route 都是由 method、url、和 handler 组成，访问路由会调用相应 app 函数。

上面 routes 里出现的的 :id 是向路由里传递参数的一个常见做法，它允许以下面这种形式传入 id：

http://127.0.0.1:3000/api/cars/5bfe30b46fe410e1cfff2323

文件建立关联，测试 API

现在大部分功能都已完成，需要做的只是把他们连接起来，启动 API 服务。导入 routes，在 index.js 文件里添加如下代码：

const routes = require(‘./routes’)

接下来需要遍历 routes 数组，然后在 Fastify 里面初始化。可以用下面的代码实现，、在 index.js 文件里添加：

routes.forEach((route, index) => {
 fastify.route(route)
})

现在准备好测试了！

API 测试有一个很棒的工具 Postman。我们在request 的 body 里以 raw object 做为参数。

查询所有 cars:

查询指定 car：

添加新 car：

services 看起来是空的，实际上数据已经添加到了数据库里了

更新 car：

删除 car：

现在一个全功能 API 已具备，还差文档，别怕，用 Swagger 可以方便的生成。

添加 Swagger

现在创建 config 文件夹。在里面创建 swagger.js 文件，文件代码如下：

exports.options = {
  routePrefix: '/documentation',
  exposeRoute: true,
  swagger: {
    info: {
      title: 'Fastify API',
      description: 'Building a blazing fast REST API with Node.js, MongoDB, Fastify and Swagger',
      version: '1.0.0'
    },
    externalDocs: {
      url: 'https://swagger.io',
      description: 'Find more info here'
    },
    host: 'localhost',
    schemes: ['http'],
    consumes: ['application/json'],
    produces: ['application/json']
  }
}

上面的代码是将要传入到 fastify-swagger 插件的 option object，在index.js 里添加如下代码：

// Import Swagger Options
const swagger = require(‘./config/swagger’)
// Register Swagger
fastify.register(require(‘fastify-swagger’), swagger.options)

在启动服务之后还需要添加如下代码：

...
await fastify.listen(3000)
fastify.swagger()
fastify.log.info(`listening on ${fastify.server.address().port}`)
...

如果一切顺利访问 http://localhost:3000/documentation，效果如下：

是不是很简单？现在有了随着 API 自动更新的文档，可以任意在 routes 里面添加信息了点击此处阅读更多

接下来

现在基本 API 已经成型，可以扩展成能想象的任何应用，有一万种可能。

接下在的教程里，我们将要集成 GraphQL，最后会集成前端的 Vue.js。

原文链接：How to build blazing fast REST APIs with Node.js, MongoDB, Fastify and Swagger，作者：Siegfried Grimbeek

本篇文章可以作为 npm（Node.js 最喜欢的伙伴）的一个基本学习指南。

自 2009 年以来，Node.js 一直席卷全球。成千上万个系统基于 Node.js 构建，促使开发者在社区宣称“JavaScript 正在吞噬软件”。

Node 成功的主要因素之一是它广受欢迎的软件包管理器——npm，因为 npm 使 JavaScript 开发人员可以快速方便地共享软件包， 例如 lodash  和 moment。

在我撰写这篇文章时，npm 已帮助发布了 130 万个软件包，每周下载量超过 160 亿次！ 这些数字对于任何软件工具来说都非常厉害。 所以，现在让我们讨论一下 npm 到底是什么。

NPM 是什么

npm（“Node 包管理器”）是 JavaScript 运行时 Node.js 的默认程序包管理器。

它也被称为“Ninja Pumpkin Mutants”，“Nonprofit Pizza Makers”，以及许多其他随机名称，你可以在  npm-expansions  上探索这些名称。

npm 由两个主要部分组成:

• 用于发布和下载程序包的 CLI（命令行界面）工具
• 托管 JavaScript 程序包的  在线存储库

为了更直观地解释，我们可以将存储库  npmjs.com  视为一个物流集散中心，该中心从卖方（npm 包裹的作者）那里接收货物的包裹，并将这些货物分发给买方（npm 包裹的用户）。

为了促进此过程，npmjs.com  物流集散中心雇用了一群勤劳的袋熊（npm CLI），他们将被分配给每个  npmjs.com  用户作为私人助理。 因此，dependencies（依赖项）会如下传递给 JavaScript 开发人员：

发布 JS 软件包的过程如下：

让我们看看这只袋熊如何协助想要在项目中使用 JavaScript 包的开发人员。下面我们还将看到它们（npm CLI）如何帮助开源向导将其出色的库推向世界。

package.json

每个 JavaScript 项目（无论是 Node.js 还是浏览器应用程序）都可以被当作 npm 软件包，并且通过  package.json  来描述项目和软件包信息。

我们可以将  package.json  视为快递盒子上的运输信息。

当运行  npm init  初始化 JavaScript/Node.js 项目时，将生成  package.json  文件，文件内的内容(基本元数据)由开发人员提供：

• name：JavaScript 项目或库的名称。
• version：项目的版本。通常，在应用程序开发中，由于没有必要对开源库进行版本控制，因此经常忽略这一块。但是，仍可以用它来定义版本。
• description：项目的描述。
• license：项目的许可证。

npm scripts

package.json  还支持一个  scripts  属性，可以把它当作在项目本地运行的命令行工具。例如，一个 npm 项目的  scripts部分可能看起来像这样：

{
  "scripts": {
    "build": "tsc",
    "format": "prettier --write **/*.ts",
    "format-check": "prettier --check **/*.ts",
    "lint": "eslint src/**/*.ts",
    "pack": "ncc build",
    "test": "jest",
    "all": "npm run build && npm run format && npm run lint && npm run pack && npm test"
  }
}

eslint，prettier，ncc，jest  不是安装为全局可执行文件，而是安装在项目本地的 node_modules/.bin/ 中。

最新引入的  npx  使我们可以像在全局安装程序一样运行这些  node_modules  项目作用域命令，方法是在其前面加上  npx ...（即npx prettier --write ** / *。ts）。

dependencies vs devDependencies

这两个以键值对象的形式出现，其中 npm 库的名称为键，其语义格式版本为值。 大家可以看看 Github 的 TypeScript 操作模板中的示例：

{
  "dependencies": {
    "@actions/core": "^1.2.3",
    "@actions/github": "^2.1.1"
  },
  "devDependencies": {
    "@types/jest": "^25.1.4",
    "@types/node": "^13.9.0",
    "@typescript-eslint/parser": "^2.22.0",
    "@zeit/ncc": "^0.21.1",
    "eslint": "^6.8.0",
    "eslint-plugin-github": "^3.4.1",
    "eslint-plugin-jest": "^23.8.2",
    "jest": "^25.1.0",
    "jest-circus": "^25.1.0",
    "js-yaml": "^3.13.1",
    "prettier": "^1.19.1",
    "ts-jest": "^25.2.1",
    "typescript": "^3.8.3"
  }
}

这些依赖通过带有  --save  或  --save-dev  标志的  npm install  命令安装。 它们分别用于生产和开发/测试环境。 在下一节中，我们将更深入地研究这些软件包的安装。

同时，理解语义版本前面的符号非常重要（假设你已经阅读 semver 的  major.minor.patch  模型）：

• ^：表示最新的次版本，例如， ^1.0.4  可能会安装主版本系列  1  的最新次版本 1.3.0。
• 〜：表示最新的补丁程序版本，与  ^  类似， 〜1.0.4  可能会安装次版本系列 1.0  的最新次版本1.0.7。

所有这些确切的软件包版本都将记录在  package-lock.json  文件中。

package-lock.json

该文件描述了 npm JavaScript 项目中使用的依赖项的确切版本。如果  package.json  是通用的描述性标签，则  package-lock.json  是成分表。

就像我们通常不会读取食品包装袋上的成分表（除非你太无聊或需要知道）一样，package-lock.json  并不会被开发人员一行一行进行读取。

package-lock.json  通常是由  npm install  命令生成的，也可以由我们的 NPM CLI 工具读取，以确保使用  npm ci  复制项目的构建环境。

用户如何使用 NPM

从前面提到的 130 万个发布的软件包中，有 160 亿次下载，可以推断出，大多数 npm 用户都朝这个方向使用 npm。所以，了解如何使用这个强大的工具会很有帮助。

npm install

这是现在我们开发 JavaScript/Node.js 应用程序时最常用的命令。

默认情况下，npm install <package-name>  将安装带有  ^  版本号的软件包的最新版本。npm 项目上下文中的  npm install  将根据  package.json  规范将软件包下载到项目的  node_modules  文件夹中，从而升级软件包的版本（并重新生成  package-lock.json  ）。 npm install <package-name>  可以基于  ^  和  〜  版本匹配。

如果要在全局上下文中安装程序包，可以在机器的任何地方使用它，则可以指定全局标志  -g（例如  live-server）。

npm 使安装 JavaScript 软件包非常容易，以至于经常错误地使用此命令。 导致一些程序员对 npm 开这样的玩笑：

但是，npm 包太大、太深这样的问题可以通过  --production  标志来拯救！在上一节中，我们讨论了分别用于生产和开发/测试环境的  dependencies  和  devDependencies  。 这个  --production  标志是如何在  node_modules  中进行区别的。

通过将此标志附加到  npm install  命令，我们将仅从  dependencies  安装软件包，从而将  node_modules  的大小大大减小到应用程序正常运行所必需的大小。——不应该将  devDependencies  引入生产环境！

npm ci

因此，如果  npm install --production  对于生产环境是最佳选项，那么是否必须有一个对本地环境，测试环境最合适的选项？

答案是  npm ci。

就像如果  package_lock.json  尚不存在于项目中一样，无论何时调用  npm install  都会生成它，npm ci  会消耗该文件来下载项目所依赖的每个软件包的确切版本。

这样，无论是用于本地开发的笔记本电脑还是 Github Actions 等 CI（持续集成）构建环境，我们都可以确保项目上下文在不同机器上保持完全相同。

npm audit

随着越来越多的软件包发布，并且易于安装，因此 npm 软件包容易受到恶意作者的恶意攻击，例如这些。

意识到生态系统存在问题，npm.js 组织提出了  npm audit  的主意。 他们维护了一个安全漏洞列表，开发人员可以使用  npm audit  命令来审核项目中的依赖项。

npm audit  为开发人员提供了有关漏洞以及是否有要修复的版本的信息，例如：

如果补救措施在下一个不间断的版本升级中可用，则可以使用  npm audit fix  来自动升级受影响的依赖项的版本。

作者如何使用 NPM

我们已经了解了作为用户，如何通过 NPM CLI 有效得使用 NPM，但是作为作者又如何使用呢？

npm publish

将软件包发送到  npmjs.com  非常容易，因为我们只需要运行  npm publish  。 棘手的部分（并非专门针对 npm 软件包作者）是确定软件包的版本。

根据  semver.org  的经验法则：

1. 当你进行不兼容的 API 更改时使用 MAJOR 版本
2. 以向后兼容的方式添加功能时使用 MINOR 版本
3. 进行向后兼容的 bug 修复时使用 PATCH 版本

在发布软件包时，遵循上述规则尤为重要，可以确保你不会破坏任何人的代码，因为 npm 中匹配的默认版本是^（又称下一个次版本）。

❤️  npm  ❤️  JavaScript  ❤️  Node.js  ❤️

了解了以上知识，我们就可以开始有效地使用 npm 并指挥可爱的袋熊大军啦！

原文：What is npm? A Node Package Manager Tutorial for Beginners，作者：Stanley Nguyen

用这个地址生成的二维码也是密密麻麻，虽不影响微信长按扫码，一旦二维码尺寸缩一点点，图片马上就会糊掉，导致摄像头直接扫码会难以识别。

那这种情况下， 我们自然就会想到如果使用短链接减少url的字符，生成的码自然就会变得容易识别了，同时还会使url更美观且易于转发。现在市面上可用的就是微博的t.cn和一些第三方的生成短链接工具，但这两类工具都有一些使用上的问题，例如：t.cn现在的规则是会出现一个中转页不会直接跳转，而第三方的工具因为是一个公共平台，有时可能会因一些不良信息导致整个平台无法访问。

那与其这样，不如我们自己来实现一个短链接平台吧，实现一个短链接平台原理上也非常简单，搞定两部分就行了：1.保存长短链接的对应关系。2.通过短链接查询长连接并重定向。

为了高效，我这使用的是node和mongodb，下面我们就来开始动手吧。

首先，我们先创建一个express工程：

express -e demo

   change directory:
     > cd demo

   install dependencies:
     > npm install

   run the app:
     > SET DEBUG=demo:* & npm start

然后进入demo目录并安装express必要依赖：

npm install

同时通过 npm 安装我们需要用到的 mongoose 和 shortid 和 body-parser：

npm install mongoose
npm install shortid
npm install body-parser

下面分别对使用到的这三个包简单说明一下：

• 在这个应用中，我们使用了 mongodb，之所以选择它是因为执行高效且低开销，所以执行起来也很高效，不过如果使用其他数据库也是没问题的。这里的mongoose就是npm的一个包，主要是为程序提供连接mongodb并增删查改的功能。
• 通过使用shortid可以生成一个指定字符不重复的编码，便于我们生成类似xxx.com/ngTsfdgh 类似红字部分的编码。
• 由于我们生成短链接部分的api使用的是post方法，使用body-parser可以多扩展一种body编码类型解析能力。

首先设置MongoDB的连接信息

module.exports = {
    mongo_base_connection_url: 'mongodb://localhost:27017',
    mongo_db: 'mongodb://localhost:27017/shorturl',
    mongo_options: {
        autoReconnect: true,
        keepAlive: true,
        reconnectTries: 50,
        reconnectInterval: 1000,
        connectTimeoutMS: 5000000,
    }
}
console.log("Connection local mongo db");

数据库模型定义

因为我们的对应关系是需要通过短链接查询长连接，所以这里我们主要以存储短链接和长连接为主，另外大家也可以根据自己需要添加链接点击统计之类的字段，方便后期统计。

var mongoose = require('mongoose');
var Schema = mongoose.Schema;
 
var urlSchema = new Schema({
  shortUrl: String,
  longUrl: String
});
 
module.exports = mongoose.model('UrlTable', urlSchema);

定义express路由

因为这个应用我们只有生成和Redirect两个功能，所以这里只有两个页面即可完成所有工作。

var index = require('./routes/index');
var url = require('./routes/url');
app.use('/', index);
app.use('/url', url);

生成短链接页面

const express = require("express");
const router = express.Router();
const shortId = require('shortid');
const UrlTable = require('../models/urltable');
const mongoose = require('mongoose');
var setup = require('../dbconfig/db');
 
router.post('/', function(req, res, next) {
    var params = req.body;
    var url = params.longUrl;
shortId.characters(' 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ^*')
    var shortid = shortId.generate();
    var objurl = { shortUrl: shortid, longUrl: url};
    mongoose.connect(setup.mongo_db, setup.mongo_options);
    UrlTable.create(objurl, function (err, objurl) {
      //if (err) console.log(err);
      res.send("http://localhost:3000/" + shortid);
    });
    return;
});

指定生成 shortId 字符的范围并生成：

shortId.characters('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')

var shortid = shortId.generate();

为数据库构建符合要求的数据模型：

var objurl = { shortUrl: shortid, longUrl: url};

最后，连接数据库并保存后将短链接结果返回客户端：

mongoose.connect(setup.mongo_db, setup.mongo_options);
UrlTable.create(objurl, function (err, objurl) {
//if (err) console.log(err);
res.send("http://localhost:3000/" + shortid);
});

短链接跳转页面

const express = require("express");
const router = express.Router();
const UrlTable = require('../models/urltable');
const mongoose = require('mongoose');
var setup = require('../dbconfig/db');
 
router.get('/:shortUrl', function (req, res, next) {
    var shortUrl = req.params.shortUrl;
    mongoose.connect(setup.mongo_db, setup.mongo_options);
    UrlTable.findOne({ shortUrl:shortUrl }).then((result) => {
       //待添加错误处理
    res.redirect(result.longUrl);
    })
});
 
module.exports = router;

这个页面为了便于快速跳转，我们就使用get接收参数，这个页面功能就很简单了，接参查询并跳转。

接收短链接码：

var shortUrl = req.params.shortUrl;

连接数据库查询并跳转：

mongoose.connect(setup.mongo_db, setup.mongo_options);

    UrlTable.findOne({ shortUrl:shortUrl }).then((result) => {

           //待添加错误处理

      res.redirect(result.longUrl);

 })

后期大家可以对一些错误异常处理，数据统计等做一些增强，这里就不做补充了。

下面让我们启用应用开始测试吧。

启动应用并测试

npm start

启动后，默认的访问端口为3000，我们首先测试下短链接生成页，这里我们post一个名为longUrl的长链接参数，数据对象为：

{"longUrl" : "https://demo.grapecity.com.cn/spreadjs/SpreadJSTutorial/features/tables/basic-table/purejs"}

成功升成了如下短链接：

http://localhost:3000/iGE6ZlDmh

我们只要通过访问短链接能正常跳转至保存的长连接即可。

这样就测试通过了，其实代码量不大，原理也很简单。大家如果自己有较短的域名的话，上线后会让链接变得更短、更美观，这样一个属于我们自己短链接生成平台就开发完成了。下面附上源码，执行npm install 即可自动安装所有依赖，如果大家有问题，可通过评论区告诉我。

源码下载>>

我们在葡萄城官网发布更多文章，欢迎阅读！