前端

服务端

计算机基础

Node 是一个 Javascript 运行环境(runtime)。实际上它是对 Google V8 引擎（应用于 Google Chrome 浏览器）进行了封装。V8 引擎执行 Javascript 的速度非常快，性能非常好。Node 对一些特殊用例进行了优化，提供了替代的 API，使得 V8 在非浏览器环境下运行得更好。例如，在服务器环境中，处理二进制数据通常是必不可少的，但 Javascript 对此支持不足，因此，V8.Node 增加了 Buffer 类，方便并且高效地 处理二进制数据。因此，Node 不仅仅简单的使用了 V8,还对其进行了优化，使其在各环境下更加给力。



NodeJS

### Node.js 的优点

#### 1. 高性能
Node.js 使用 V8 引擎，这是 Google Chrome 的 JavaScript 运行时，它将 JavaScript 代码编译成机器代码。这意味着 Node.js 能够提供高性能的网络应用。由于其非阻塞 I/O 和事件驱动架构，Node.js 特别适合处理大量并发连接，这对于实时应用程序（如游戏、聊天服务）和高流量服务是非常有利的。

#### 2. 单一语言开发
使用 Node.js，开发人员可以使用 JavaScript 编写前端和后端代码。这简化了开发流程，因为只需掌握一种语言和一套代码库即可。这也有助于前后端的高效协作。

#### 3. 强大的生态系统
Node.js 有一个庞大的生态系统，npm（Node.js 包管理器）是世界上最大的软件注册表。开发人员可以轻松地找到和共享各种库和工具，这有助于加快开发速度并减少重复造轮子的需要。

#### 4. 易于学习
由于 JavaScript 是最受欢迎的编程语言之一，许多开发人员已经熟悉它。这使得 Node.js 相对容易学习，尤其是对于那些已经有 JavaScript 经验的前端开发人员。

#### 5. 跨平台
Node.js 可以在多种平台上运行，包括 Windows、macOS、Linux，甚至在 Docker 容器中也能良好运作，这使得它非常灵活。

### Node.js 的缺点

#### 1. 单线程
虽然 Node.js 的单线程模型有助于处理高并发和简化开发，但它也意味着所有 I/O 密集型操作可能会阻塞事件循环，影响应用程序的整体性能。对于计算密集型任务，Node.js 可能不是最佳选择。

#### 2. 不稳定的API
Node.js 核心 API 的频繁变动曾经是一个问题，尽管现在已经相对稳定了。但开发者仍然需要留意 API 变动对项目的影响。

#### 3. 异步编程模型
Node.js 大量依赖异步代码，虽然这有助于提高性能，但也可能导致回调地狱（callback hell），使得代码难以理解和维护。尽管现在有 Promise 和 async/await 这样的解决方案，但对于新手来说，异步编程仍然可能是一个挑战。

#### 4. 性能瓶颈
Node.js 的性能虽然在处理 I/O 密集型任务时很出色，但在 CPU 密集型任务上可能就不那么理想。虽然可以通过创建子进程等方式来缓解这个问题，但这增加了复杂性。

#### 5. 年轻的工具
尽管 npm 生态系统非常庞大，但一些库和工具相对于其他语言的生态系统而言可能还不够成熟。这可能意味着更多的漏洞和不稳定性。

#### 实例
以性能为例，LinkedIn 将其后端服务从 Ruby on Rails 迁移到 Node.js，据报道提升了应用程序的性能，并显著减少了服务器需求。这展示了 Node.js 处理大规模网络服务时的性能优势。

nodejs 的优点和缺点？

Koa.js 是一个轻量级的 Node.js web 框架，用于构建快速的 web 应用和 API。要在 Koa.js 中实现文件上传的断点续传，我们需要使用额外的中间件和库来管理文件的分片上传和断点续传的逻辑。下面是实现这个功能的一般步骤：

### 1. 选择合适的中间件和库

- 使用 `koa-body` 或 `koa-multer` 中间件来处理文件上传。
- 选择支持断点续传的库，如 `tus-node-server` 或是使用流来手动处理。

### 2. 设置文件上传中间件

```javascript
const Koa = require('koa');
const koaBody = require('koa-body');

const app = new Koa();

app.use(koaBody({
 multipart: true,
 formidable: {
 // 设置临时文件夹，用于保存上传的文件
 uploadDir: './uploads',
 keepExtensions: true,
 }
}));
```

### 3. 实现分片上传逻辑

分片的处理可以通过前端上传时携带分片信息，并在后端进行相应的处理：

```javascript
app.use(async ctx => {
 if (ctx.url === '/upload' && ctx.method === 'POST') {
 // 获取上传文件
 const file = ctx.request.files.file;
 const { name, path } = file;
 
 // 获取分片信息等其他元数据，比如分片索引、总分片数、文件标识符等
 const { index, total, identifier } = ctx.request.body;

 // 根据文件标识符和分片索引生成分片的唯一存储路径
 const chunkPath = `./uploads/${identifier}_${index}`;

 // 将上传的分片文件移动到分片存储路径
 const fs = require('fs');
 const readable = fs.createReadStream(path);
 const writable = fs.createWriteStream(chunkPath);
 readable.pipe(writable);

 // 确认分片上传成功后，可以删除原上传的临时文件
 fs.unlink(path, (err) => {
 if (err) throw err;
 });

 ctx.body = '分片上传成功';
 }
});
```

### 4. 断点续传和文件重组逻辑

- 保存文件分片信息，可以使用数据库或者文件系统。
- 定期检查已上传的分片，提供断点续传的信息给前端。
- 前端在上传前检查已上传的分片，只上传未完成的部分。
- 全部分片上传完毕后，后端合并分片。

```javascript
// 假设有一个合并分片的方法
async function mergeChunks(chunks, dest) {
 // 合并所有分片
 // ...
}

app.use(async ctx => {
 if (ctx.url === '/merge' && ctx.method === 'POST') {
 const { identifier, total } = ctx.request.body;
 const chunks = [];
 for (let i = 0; i < total; i++) {
 chunks.push(`./uploads/${identifier}_${i}`);
 }

 // 调用合并分片的方法
 await mergeChunks(chunks, `./uploads/${identifier}.final`);

 ctx.body = '文件上传和合并成功';
 }
});
```

### 5. 处理异常和错误

在整个上传、续传、合并的过程中，要对可能发生的异常和错误进行处理，确保系统的稳定性。

### 6. 前端实现

前端需要使用支持断点续传的库（如 tus-js-client）或自己实现相关逻辑，包括如何分片、如何处理续传以及如何在上传完成后提示用户。

以上是在 Koa.js 中实现文件上传断点续传的大体步骤。实际的逻辑可能会更加复杂，包括如何确保并发上传时分片的正确性，如何处理网络异常等多种情况。

koa.js 如何实现文件上传的断点续传？

在判断一个JavaScript文件是用于Node.js环境还是浏览器环境时，可以从以下几个方面进行分析： 

1. **模块系统**:
 * **Node.js**: 使用 `require`和 `module.exports`或者 `import/export`（在启用了ES模块的情况下）来处理模块。如果你看到这样的代码，很可能该文件是为Node.js环境编写的。例如:
 <pre><section class="markdown-code"><div class="markdown-code__head"><div class="markdown-code__head-language">javascript<svg width="16" height="16" viewBox="0 0 48 48" fill="none"><path d="M13 12.4316V7.8125C13 6.2592 14.2592 5 15.8125 5H40.1875C41.7408 5 43 6.2592 43 7.8125V32.1875C43 33.7408 41.7408 35 40.1875 35H35.5163" stroke="#333" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"></path><path d="M32.1875 13H7.8125C6.2592 13 5 14.2592 5 15.8125V40.1875C5 41.7408 6.2592 43 7.8125 43H32.1875C33.7408 43 35 41.7408 35 40.1875V15.8125C35 14.2592 33.7408 13 32.1875 13Z" fill="none" stroke="#333" stroke-width="4" stroke-linejoin="round"></path></svg></div></div><div><code class="language-javascript">const fs = require('fs');
 module.exports = function() { /* ... */ };</code></div></section></pre>
 * **浏览器**: 传统的浏览器环境使用 `<script>`标签来加载JavaScript文件，而现代浏览器支持ES模块，使用 `import/export`。如果文件中存在如 `document`或 `window`这样的全局对象，说明它是为浏览器环境编写的。例如:
 <pre><section class="markdown-code"><div class="markdown-code__head"><div class="markdown-code__head-language">javascript<svg width="16" height="16" viewBox="0 0 48 48" fill="none"><path d="M13 12.4316V7.8125C13 6.2592 14.2592 5 15.8125 5H40.1875C41.7408 5 43 6.2592 43 7.8125V32.1875C43 33.7408 41.7408 35 40.1875 35H35.5163" stroke="#333" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"></path><path d="M32.1875 13H7.8125C6.2592 13 5 14.2592 5 15.8125V40.1875C5 41.7408 6.2592 43 7.8125 43H32.1875C33.7408 43 35 41.7408 35 40.1875V15.8125C35 14.2592 33.7408 13 32.1875 13Z" fill="none" stroke="#333" stroke-width="4" stroke-linejoin="round"></path></svg></div></div><div><code class="language-javascript">document.getElementById('example');</code></div></section></pre>
2. **全局对象**:
 * **Node.js**: 具有特定的全局对象，如 `global`, `process`, `__dirname`和 `__filename`。如果代码中使用了这些对象，说明它是为Node.js环境设计的。
 * **浏览器**: 浏览器具有自己的全局对象，如 `window`, `document`, `navigator`等。这些通常不会在Node.js环境中出现。
3. **内置模块/包**:
 * **Node.js**: Node.js有一些内置模块，如 `fs`, `http`, `path`等，这些模块只存在于Node.js中。
 * **浏览器**: 浏览器则提供了如 `DOM API`, `WebAPIs`等，它们不是Node.js的一部分。
4. **API的使用**:
 * **Node.js**: Node.js有一些专有的API，例如与文件系统交互、创建服务端网络应用等。
 * **浏览器**: 浏览器则提供了DOM操作、事件监听、Web存储等API。
5. **注释和文档**:
 * **代码注释**: 有时候开发者会在文件顶部留下注释说明这段代码的用途。
 * **项目文档**: 查看包含该文件的项目的 `README.md`或其他文档文件，通常会有环境要求的说明。
6. **构建工具和配置文件**:
 * 项目中的构建工具配置文件（如 `webpack.config.js`, `Gruntfile.js`, `Gulpfile.js`等）会提供关于目标环境的线索。这些工具常用于浏览器环境中的JavaScript代码打包。
7. **文件扩展名**:
 * 尽管这不是一个强制规则，有时候Node.js模块会使用 `.mjs`来指明它是一个ES模块。而传统的浏览器脚本可能会使用 `.js`。

**示例**: 假设我们有以下代码：

<pre><section class="markdown-code"><div class="markdown-code__head"><div class="markdown-code__head-language">javascript<svg width="16" height="16" viewBox="0 0 48 48" fill="none"><path d="M13 12.4316V7.8125C13 6.2592 14.2592 5 15.8125 5H40.1875C41.7408 5 43 6.2592 43 7.8125V32.1875C43 33.7408 41.7408 35 40.1875 35H35.5163" stroke="#333" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"></path><path d="M32.1875 13H7.8125C6.2592 13 5 14.2592 5 15.8125V40.1875C5 41.7408 6.2592 43 7.8125 43H32.1875C33.7408 43 35 41.7408 35 40.1875V15.8125C35 14.2592 33.7408 13 32.1875 13Z" fill="none" stroke="#333" stroke-width="4" stroke-linejoin="round"></path></svg></div></div><div><code class="language-javascript">const http = require('http');

http.createServer((req, res) => {
 res.writeHead(200, {'Content-Type': 'text/plain'});
 res.end('Hello World\n');
}).listen(3000, '127.0.0.1');

console.log('Server running at http://127.0.0.1:3000/');</code></div></section></pre>

这个例子中，代码使用了 `require`来加载Node.js的 `http`模块，创建了一个服务器，并打印了一个消息表明服务器正在运行。从这些信息中可以明确地看出这是一个为Node.js环境编写的JavaScript文件。

如何判断一个 JS 文件是用于Node.js 还是普通浏览器？

在浏览器和Node.js中，事件循环是实现非阻塞I/O操作的核心机制，尽管它们在高层面上非常相似，但具体实现上有几个主要区别。以下是我将回顾的几点关键差异及其例子：

### 1. 任务源和处理方式

**浏览器：**
浏览器的事件循环主要处理来自Web API的任务，这些可以是DOM事件、Ajax回调、setTimeout等。它使用了宏任务（macro tasks）和微任务（micro tasks）的概念。宏任务包括script（整体代码）、setTimeout、setInterval和I/O，而微任务主要包括Promise.then、MutationObserver。在一个事件循环中，每次只会从宏任务队列中取出一个任务执行，然后执行所有可用的微任务。

**Node.js：**
Node.js的事件循环由libuv库实现，包括了多个阶段，如timers、I/O callbacks、poll、check、close callbacks等。Node.js中处理任务更为复杂，各个阶段几乎都有自己的队列。timers阶段处理setTimeout和setInterval回调，poll阶段负责I/O事件回调，而setImmediate的回调会在check阶段执行。

**例子：**
在浏览器中，`Promise.resolve().then()`会在当前宏任务完成后立即执行，因为微任务总是在宏任务之后清空。
在Node.js中，由于事件循环的阶段性，可能会在执行微任务时插入其他类型的任务，例如，如果在I/O操作完成后添加了一个setImmediate，邑可能在当前阶段的微任务和下一阶段的微任务之间执行。

### 2. 定时器的精度

**浏览器：**
浏览器的定时器（如setTimeout和setInterval）的精度相对较低，早期定时器至少有4ms的延迟（根据HTML5标准规定），而现代浏览器偶尔会有更高的延迟，以帮助减少后台标签页的能耗。

**Node.js：**
Node.js定时器的精度通常更高，因为服务器端的环境对实时性和性能有更高的要求。Node.js的事件循环可以精确到毫秒。

**例子：**
在浏览器中设置 `setTimeout(fn, 1)`可能实际上在4ms后才执行回调，而在Node.js中，相同的设置会尽量接近1ms执行回调。

### 3. 默认行为和扩展性

**浏览器：**
浏览器的事件循环通常是不可见和不可控制的，由浏览器内核管理。

**Node.js：**
Node.js的事件循环可以通过C++插件和核心模块进行扩展，给开发者提供了更多控制。例如，使用libuv库，开发者能够接触到底层的事件循环机制。

**例子：**
Node.js的开发者可以编写本地插件，通过直接与libuv交互来修改或增强事件循环的行为，而这在浏览器端是做不到的。

### 4. 性能和优化

**浏览器：**
浏览器的事件循环是为了优化用户界面和用户互动设计的，因此，许多优化都是围绕用户体验和界面响应性进行的。

**Node.js：**
Node.js的事件循环是针对I/O密集型操作进行优化的，特别是网络和文件系统操作。


[Event Loop] 浏览器和nodejs事件循环有什么区别？

在Node.js中，可以利用`cluster`模块开启多个进程，以此来充分地利用多核CPU的资源。`cluster`模块可以创建一组Node.js进程，它们共享同一个服务器端口。

以下是一个使用`cluster`模块的基本步骤：

1. 导入`cluster`模块和其他必须的模块。
2. 使用`cluster.isMaster`判断当前是否是主进程（Master）。
3. 在主进程中，可以使用`cluster.fork()`来创建工作进程（Worker）。
4. 在工作进程中，执行实际的应用代码，如HTTP服务器的监听等。
5. 监听相应的事件来处理工作进程的启动、在线、退出等情况。

进程之间的通信可以通过以下方式：

- 主进程通过`worker.send()`发送消息到工作进程。
- 工作进程通过`process.send()`发送消息到主进程。
- 监听`message`事件来接收消息。

下面是一个创建多个工作进程并实现主工作进程通信的简单示例：

```javascript
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
 console.log(`主进程 ${process.pid} 正在运行`);

 // 衍生工作进程。
 for (let i = 0; i < numCPUs; i++) {
 const worker = cluster.fork();

 // 主进程接收工作进程发送的消息
 worker.on('message', (msg) => {
 console.log(`主进程收到消息 '${msg}' 来自工作进程 ${worker.process.pid}`);
 });
 }

 cluster.on('exit', (worker, code, signal) => {
 console.log(`工作进程 ${worker.process.pid} 已退出`);
 });
} else {
 // 工作进程可以共享任何TCP连接。
 // 在本例中，它是一个 HTTP 服务器。
 http.createServer((req, res) => {
 res.writeHead(200);
 res.end('你好世界\n');

 // 工作进程向主进程发送消息
 process.send(`工作进程 ${process.pid} 收到请求`);
 }).listen(8000);

 console.log(`工作进程 ${process.pid} 已启动`);
}
```

在这个例子中，主进程创建了和CPU核心数量相同的工作进程，并设置了接受消息的监听器。每当工作进程接收到HTTP请求时，它就会向主进程发送一个消息。主进程监听到消息后，在控制台中输出相关信息。

这种模式让Node.js应用可以在多核CPU上以更高效的方式运行，而且主工作进程之间的消息传递机制让它们可以交换信息。

nodejs如何开启多进程，进程之间如何通讯？

Node.js 中的 `DllPlugin` 及相关的 `DllReferencePlugin` 主要是用于改善构建时间和实现代码分离，在 Webpack 构建过程中使用。`DllPlugin` 用来打包出一个个独立的动态链接库文件，而 `DllReferencePlugin` 则用于在主应用程序中引用这些动态链接库。

以下是使用 `DllPlugin` 的具体步骤：

### 步骤 1: 创建 DLL 文件

首先，你需要在项目中创建一个 webpack 配置文件专门用于构建 DLL。

```javascript
// webpack.dll.config.js
const path = require('path');
const webpack = require('webpack');

module.exports = {
 entry: {
 vendor: ['lodash', 'react'] // 假设我们希望将 lodash 和 react 打包成一个 DLL
 },
 output: {
 path: path.join(__dirname, 'dist'),
 filename: '[name].dll.js', // 输出的文件名
 library: '[name]_library' // 全局变量名，其他模块会从此变量上获取到里面的模块
 },
 plugins: [
 new webpack.DllPlugin({
 path: path.join(__dirname, 'dist', '[name]-manifest.json'),
 name: '[name]_library'
 })
 ]
};
```

这个配置会将 `lodash` 和 `react` 打包成一个名为 `vendor.dll.js` 的文件，并生成一个 `vendor-manifest.json` 文件。

### 步骤 2: 在主配置中引用 DLL

然后，在你的主 `webpack` 配置文件中，你需要使用 `DllReferencePlugin` 来引用上一步中生成的 `vendor-manifest.json` 文件。

```javascript
// webpack.config.js
const path = require('path');
const webpack = require('webpack');

module.exports = {
 // ...你的其他配置
 plugins: [
 // ...你的其他插件
 new webpack.DllReferencePlugin({
 context: __dirname,
 manifest: require('./dist/vendor-manifest.json') // 引入 DLL 的 manifest 文件
 })
 ],
 // ...其余配置
};
```

### 步骤 3: 在 HTML 中引入 DLL 文件

最后，你需要确保在应用程序加载前，先在 HTML 文件中引入这些 DLL 文件。例如：

```html
<!DOCTYPE html>
<html>
<head>
 <title>My App</title>
</head>
<body>
 <script src="./dist/vendor.dll.js"></script>
 
</body>
</html>
```

### 使用例子

假设你有一个大型项目，每次构建都需要很长时间，因为第三方库例如 `React`、`Vue` 或 `Lodash` 并不经常更改，但它们每次都会被重新编译。通过使用 DLL，你可以将这些库预编译成静态资源，以便在开发过程中重复使用，从而减少了构建时需要处理的工作量，并加快了构建速度。

使用 DLL 时需要注意的是，当你更新了 DLL 中的依赖项时，你需要重新构建 DLL 文件。同时，应当确保在生产环境构建中不包含 DLL 的引用，或者确保 DLL 是最新的，以避免因为版本不一致带来的问题。

总的来说，`DllPlugin` 提高了开发效率，尤其是在大型项目和频繁构建的环境中，它可以显著减少构建时间并提升开发体验。

NodeJS面试题手册

nodejs 的优点和缺点？

koa.js 如何实现文件上传的断点续传？

如何判断一个 JS 文件是用于Node.js 还是普通浏览器？

[Event Loop] 浏览器和nodejs事件循环有什么区别？

nodejs如何开启多进程，进程之间如何通讯？

nodejs 如何使用 DllPlugin 动态链接库？