跳到主要内容

介绍下如何实现 token 加密​

实现 Token 加密通常涉及以下两个主要方面：

  1. 生成 Token：首先，你需要生成一个 Token。Token 是一个字符串，用于标识用户身份或授权信息。生成 Token 可以使用各种算法，如 HMAC、JWT、OAuth 等，具体选择取决于你的需求和系统架构。

  2. 加密 Token：生成的 Token 可能包含敏感信息，因此在传输或存储过程中需要进行加密以保护数据安全。以下是一些常用的加密方法：

    • 对称加密：对称加密使用同一个密钥进行加密和解密。常见的对称加密算法包括 AES、DES、3DES 等。你可以使用 Node.js 中的 crypto 模块或其他加密库来执行对称加密操作。

    • 非对称加密：非对称加密使用公钥和私钥配对进行加密和解密。常见的非对称加密算法包括 RSA、ECC 等。在非对称加密中，公钥用于加密，私钥用于解密。你可以使用 Node.js 中的 crypto 模块或其他加密库来执行非对称加密操作。

    • 散列函数（哈希函数）：散列函数将输入数据映射为固定长度的哈希值。常见的散列函数包括 SHA-256、MD5 等。散列函数通常用于生成密码的哈希值，而不是加密整个 Token。

在实现 Token 加密时，你需要根据具体需求选择适当的加密方法。以下是一个示例，演示如何使用 Node.js 中的 crypto 模块生成和加密 Token：

const crypto = require('crypto');

// 生成 Token
function generateToken() {
  const token = 'your_token_data_here';
  // 在此处添加生成 Token 的逻辑
  return token;
}

// 加密 Token
function encryptToken(token) {
  const secretKey = 'your_secret_key_here';
  const cipher = crypto.createCipher('aes-256-cbc', secretKey);
  let encryptedToken = cipher.update(token, 'utf8', 'hex');
  encryptedToken += cipher.final('hex');
  return encryptedToken;
}

// 生成并加密 Token
const token = generateToken();
const encryptedToken = encryptToken(token);

console.log('Token:', token);
console.log('Encrypted Token:', encryptedToken);

在上述示例中，我们首先定义了 generateToken() 函数，用于生成 Token 数据。你可以根据实际需求编写逻辑来生成特定格式的 Token。

然后，我们定义了 encryptToken() 函数，用于加密生成的 Token。在示例中，我们使用 AES 对称加密算法，使用预定义的密钥 secretKey 创建了一个加密器（cipher）。然后，我们使用 cipher.update() 方法将 Token 数据进行加密，最后使用 cipher.final() 方法完成加密，并返回加密后的结果。

最后，我们生成 Token，并将其传递给 encryptToken() 函数进行加密。最终，我们打印生成的 Token 和加密后的 Token。

请注意，上述示例仅为演示目的，并没有涵盖所有加密细节和安全性考虑。在实际应用中，你需要根据具体需求和安全标准选择适当的加密算法，并采取必要的安全措施来保护 Token 的生成和加密过程。

什么是jwt？如何生成jwt？​

JWT（JSON Web Token）是一种用于在网络应用之间传递信息的开放标准（RFC 7519）。它使用 JSON 对象来安全地在各方之间传输信息。JWT 在身份验证和授权方面非常常见，特别是在分布式系统和单点登录（SSO）场景中。

JWT 由三个部分组成，它们使用点号进行分隔：

  1. Header（头部）：包含描述 JWT 的元数据信息，例如算法和令牌类型。它使用 Base64 编码进行序列化。

  2. Payload（负载）：包含要传输的声明或数据。声明是有关实体（通常是用户）和其他数据的陈述性语句。Payload 也使用 Base64 编码进行序列化。

  3. Signature（签名）：由头部、负载、密钥和指定的签名算法生成的签名。用于验证传输的 JWT 是否经过篡改。

生成 JWT 的一般过程如下：

  1. 创建一个包含所需声明的 JSON 对象，也就是负载部分。
  2. 创建一个头部 JSON 对象，指定所使用的算法和令牌类型。
  3. 对头部和负载进行 Base64 编码，形成 JWT 的前两部分。
  4. 使用指定的密钥和签名算法（如 HMAC、RSA 等）对前两部分进行签名，生成签名部分。
  5. 将前两部分和签名部分用点号连接成一个字符串，形成最终的 JWT。

以下是一个使用 Node.js 的示例代码，展示如何生成 JWT：

const jwt = require('jsonwebtoken');

// 生成 JWT
function generateJWT(payload, secretKey, options) {
  return jwt.sign(payload, secretKey, options);
}

// 示例使用
const payload = {
  userId: '123456',
  username: 'john.doe',
  role: 'admin'
};
const secretKey = 'your_secret_key_here';
const options = {
  expiresIn: '1h' // 设置过期时间，例如1小时
};
const token = generateJWT(payload, secretKey, options);

console.log('JWT:', token);

在上述示例中，我们使用 jsonwebtoken 库来生成 JWT。generateJWT() 函数接收三个参数：payload（负载部分的数据）、secretKey（用于签名的密钥）和 options（可选的配置选项）。

我们定义了一个示例的 payload，其中包含了用户ID、用户名和角色等信息。然后，我们指定了一个密钥 secretKey 和一个过期时间选项 expiresIn（这里设置为1小时）。最后，我们调用 generateJWT() 函数并传递这些参数，生成 JWT，并将其存储在 token 变量中。

请注意，密钥 secretKey 应该是保密的，并且只有服务器端知道。在验证 JWT 时，需要使用相同的密钥进行解码和验证签名。

此示例仅涵盖了 JWT 的生成过程，验证和解码 JWT 时需要进行额外的步骤。在实际应用中，你还需要验证签名、检查过期时间等。

基于 Token 的身份验证：JSON Web Token（附：Node.js 项目）

Node 环境中的事件循环（Event Loop)​

Node.js 环境中的事件循环（Event Loop）是 Node.js 实现的一种机制，用于处理异步操作和事件回调。它是 Node.js 实现非阻塞（非同步）I/O 的核心部分，确保在单线程的环境下处理大量并发操作。

下面是 Node.js 环境中事件循环的基本流程：

  1. 执行全局代码： 当 Node.js 启动时，会先执行全局代码，并初始化相应的环境。

  2. 执行事件循环阶段： Node.js 事件循环由多个阶段组成，每个阶段都有特定的任务和回调函数队列。事件循环的每个阶段会不断循环执行以下步骤：

    • 检查定时器（Timers）： 执行到达设定的定时器时间的回调函数。
    • 处理待定的 I/O 回调（Pending I/O callbacks）： 执行某些异步 I/O 回调函数，如网络请求的回调。
    • 执行闲置（idle）和系统操作（system）： 执行一些系统操作和闲置的回调函数。
    • 检查轮询（Poll）： 处理 I/O 相关的回调函数，执行 I/O 操作。如果没有 I/O 操作需要处理，则等待新的事件被添加到队列中。
    • 执行检查（Check）： 执行 setImmediate() 注册的回调函数。
    • 执行关闭（Close Callbacks）： 执行一些关闭的回调函数，如 socket.on('close', ...)。

  3. 执行微任务队列： 在事件循环的每个阶段结束后，会执行微任务队列中的所有微任务（Promise 和 process.nextTick() 注册的回调函数）。

  4. 重复执行事件循环阶段： 事件循环会不断重复执行上述步骤，直到没有更多的回调函数需要执行。如果没有待处理的回调函数，事件循环会暂时挂起，等待新的事件触发。

在 Node.js 的事件循环中，异步操作通常通过回调函数、Promise、事件监听器等方式注册，并在适当的阶段执行。事件循环的机制使得 Node.js 能够高效地处理大量并发请求和异步操作，而不会阻塞主线程。

了解 Node.js 事件循环的工作原理对于编写高效的 Node.js 应用程序非常重要，可以避免阻塞和死锁问题，以及优化异步操作的执行顺序和性能。

如何部署 Node.js 应用？如何处理负载均衡中 Session 的一致性问题？​

部署 Node.js 应用通常包括以下步骤：

  1. 开发和测试：在本地环境中开发和测试你的 Node.js 应用。
  2. 选择部署平台：你可以选择各种云服务平台，如 AWS、Azure、Google Cloud 等，或者你自己的服务器。
  3. 打包应用：你可以使用工具如 Docker 来打包你的应用和所有依赖项。
  4. 上传和运行：将你的应用上传到你选择的平台，并运行它。

在使用负载均衡时，处理 Session 一致性问题的常见方法有：

  1. 粘性会话（Sticky Session）：粘性会话是一种将客户端的请求在一段时间内都路由到同一台服务器的方法。这样，用户的 session 数据在服务器上可以保持一致。但是，这种方法可能会导致负载分布不均。

  2. 分布式 Session：将 session 数据存储在所有服务器都可以访问的地方，如数据库或者缓存（如 Redis）。这样，无论请求被路由到哪台服务器，都可以获取到相同的 session 数据。

  3. JWT（JSON Web Tokens）：JWT 是一种无状态的认证方式，服务器不需要存储 session 数据。服务器只需要在用户登录时返回一个签名的 JWT，客户端在后续的请求中携带这个 JWT，服务器通过验证 JWT 的签名来认证用户。这种方法完全避免了 session 一致性的问题，但是 JWT 的大小通常会比 session ID 大，如果 JWT 包含大量数据，可能会增加网络传输的开销。

以上就是部署 Node.js 应用和处理负载均衡中 Session 一致性问题的一些基本方法，希望对你有所帮助！

如何提升 Node.js 代码的运行稳定性？​

提升 Node.js 代码运行稳定性的方法有很多，以下是一些常见的建议：

  1. 错误处理：正确处理错误是提升代码稳定性的关键。你应该尽可能捕获所有可能的错误，并对其进行适当的处理。例如，使用 try...catch 语句捕获运行时错误，使用 .catch() 处理 Promise 中的错误，监听 error 事件处理流中的错误等。

  2. 单元测试和集成测试：通过编写测试用例，你可以确保代码的各个部分都按预期工作，同时也可以在修改代码后验证是否引入了新的错误。

  3. 使用 lint 工具：Lint 工具如 ESLint 可以帮助你发现代码中的潜在问题，包括语法错误、未使用的变量、不恰当的代码格式等。

  4. 使用类型检查：虽然 JavaScript 是一种动态类型语言，但你可以使用 TypeScript 或者 Flow 这样的静态类型检查工具来避免类型相关的错误。

  5. 使用进程管理器：进程管理器如 PM2 可以帮助你管理你的应用，当应用崩溃时自动重启，保持应用的稳定运行。

  6. 限制并发：Node.js 是单线程的，如果你的应用需要处理大量的并发请求，可能会导致性能问题。你可以使用适当的策略来限制并发，例如使用队列处理请求，或者使用集群模块来在多个 CPU 核心上运行应用。

  7. 监控和日志：通过监控应用的性能和记录日志，你可以及时发现并解决问题，防止应用崩溃。

以上就是一些提升 Node.js 代码运行稳定性的方法，希望对你有所帮助！

什么是单点登录？如何做单点登录？​

单点登录（Single Sign-On，SSO）是一种身份验证服务，用户只需要进行一次登录，就可以访问所有相关的、联合的系统或服务，无需对每个系统或服务进行单独登录。

实现单点登录的方法有很多，以下是一个基本的实现流程：

  1. 用户认证：用户首次访问任何一个系统时，都会被重定向到认证服务器进行登录。用户输入用户名和密码，认证服务器验证通过后，会创建一个包含用户信息的令牌（Token）。

  2. 令牌存储：认证服务器将令牌存储在用户的浏览器中，通常是以 Cookie 的形式。

  3. 服务访问：用户再次访问任何一个系统时，都会携带这个令牌。系统会将令牌发送到认证服务器进行验证。

  4. 令牌验证：认证服务器验证令牌的有效性。如果令牌有效，认证服务器会返回用户的登录信息，系统就可以根据这个信息提供个性化的服务。

  5. 注销：用户在任何一个系统中进行注销操作时，会通知认证服务器销毁令牌。这样，用户就需要重新登录才能访问任何系统。

这只是一个基本的单点登录实现流程，具体的实现可能会根据你的应用需求和安全需求进行调整。例如，你可能需要使用 OAuth、OpenID Connect、SAML 等协议来实现单点登录。希望这个解释对你有所帮助！

express和koa的区别​

Express 和 Koa 是两个流行的 Node.js 框架，它们有一些主要的区别：

  1. 中间件处理方式：Express 使用回调函数处理中间件，而 Koa 使用 ES6 的 Generator 函数和 async/await，这使得 Koa 的中间件处理更加优雅和易于理解。

  2. 错误处理：在 Express 中，错误需要通过回调函数或者错误处理中间件来处理。而在 Koa 中，由于使用了 async/await，可以直接使用 try/catch 来捕获和处理错误。

  3. 内置功能：Express 内置了路由系统、模板引擎等功能，而 Koa 更加轻量，只提供了最基础的功能，其他功能需要通过插件来实现。

  4. 社区支持：Express 的社区更加成熟，拥有更多的中间件和插件。而 Koa 是由 Express 的原团队开发的，虽然社区相对较小，但是由于其优雅的设计，正在逐渐获得更多的关注和支持。

总的来说，Express 更适合需要快速开发和部署的项目，而 Koa 更适合需要高度自定义和优雅代码的项目。选择哪一个，取决于你的项目需求和个人喜好。希望这个答案对你有所帮助！

说说怎么用纯粹的 Node.js 做一个服务端框架？谈谈 Node.js 服务端 MVC 的理解？​

要使用纯粹的 Node.js 构建一个服务端框架，你可以遵循以下步骤：

  1. 创建项目结构： 首先，创建一个空文件夹作为你的项目目录，并在其中初始化一个新的 Node.js 项目。可以通过运行 npm init 命令来初始化项目，并按照提示填写项目信息。

  2. 安装依赖： 在项目目录中，使用 npm 或 yarn 安装所需的依赖模块。对于服务端框架，你可能需要安装一些常用的 Node.js 模块，如 express（用于构建 Web 应用程序）和 body-parser（用于解析请求体数据）等。

  3. 创建服务器： 使用 Node.js 创建一个 HTTP 服务器，并监听指定的端口。你可以使用 Node.js 内置的 http 模块来创建服务器，或者选择使用一些流行的框架（如 express）来简化服务器的创建和管理。

  4. 定义路由和控制器： 在服务端框架中，路由用于将不同的 URL 请求映射到相应的控制器函数上。你可以创建一个路由模块，并在其中定义不同的路由规则。每个路由可以与一个或多个控制器函数相关联，用于处理请求并返回响应。

  5. 编写控制器逻辑： 在控制器函数中，处理相应的请求逻辑。这可以包括从数据库中获取数据、执行业务逻辑、处理请求参数等。控制器函数通常接收请求对象和响应对象作为参数，并使用它们来读取请求数据和发送响应。

  6. 视图渲染（可选）： 如果你的服务端框架需要支持视图层（如模板引擎），你可以将视图渲染的逻辑集成到控制器中。这可以包括将数据传递给视图模板，渲染模板并生成最终的 HTML 响应。

  7. 错误处理： 在服务端框架中，要考虑错误处理和异常情况。你可以定义全局的错误处理中间件，用于捕获并处理未被其他路由或控制器处理的错误。

这些步骤提供了一个基本的框架结构，你可以根据需求和项目的规模进行扩展和定制。Node.js 服务端 MVC（Model-View-Controller）是一种架构模式，用于组织和分离服务端应用程序的不同层。下面是对 Node.js 服务端 MVC 的简要理解：

  • Model（模型）：模型代表应用程序的数据层。它可以包含与数据库交互的代码，定义数据模型和业务逻辑。模型负责处理数据的访问、存储和验证等操作。

  • View（视图）：视图是用户界面的表示层。它负责将数据呈现给用户，并根据需要生成 HTML、JSON 或其他响应格式。视图通常与模板引擎集成，用于渲染动态内容。

  • Controller（控制器）：控制器是处理请求和响应的中间层。它接收用户请求，调用相应的模型来获取数据，然后将数据传递给视图进行渲染。控制器还负责处理表单验证、用户认证、路由规则等逻辑。

Node.js 服务端 MVC 的目标是将应用程序的不同关注点分离开来，使代码更易于管理和维护。模型负责数据处理，视图负责呈现界面，而控制器负责协调两者之间的交互。这种分层结构可以提高代码的可重用性、可测试性和可扩展性，以下是一个使用纯粹的 Node.js 构建的简单服务端框架的示例代码：

// 依赖模块
const http = require('http');
const url = require('url');
const fs = require('fs');

// 创建服务器
const server = http.createServer((req, res) => {
  // 解析请求的 URL
  const parsedUrl = url.parse(req.url, true);
  const path = parsedUrl.pathname;
  
  // 路由处理
  if (path === '/') {
    // 首页
    return handleHome(req, res);
  } else if (path === '/about') {
    // 关于页面
    return handleAbout(req, res);
  } else {
    // 404 页面
    return handleNotFound(req, res);
  }
});

// 定义首页处理逻辑
function handleHome(req, res) {
  // 读取首页模板文件
  fs.readFile('views/home.html', 'utf8', (err, content) => {
    if (err) {
      res.writeHead(500, { 'Content-Type': 'text/plain' });
      res.end('Internal Server Error');
    } else {
      res.writeHead(200, { 'Content-Type': 'text/html' });
      res.end(content);
    }
  });
}

// 定义关于页面处理逻辑
function handleAbout(req, res) {
  // 读取关于页面模板文件
  fs.readFile('views/about.html', 'utf8', (err, content) => {
    if (err) {
      res.writeHead(500, { 'Content-Type': 'text/plain' });
      res.end('Internal Server Error');
    } else {
      res.writeHead(200, { 'Content-Type': 'text/html' });
      res.end(content);
    }
  });
}

// 定义404页面处理逻辑
function handleNotFound(req, res) {
  res.writeHead(404, { 'Content-Type': 'text/plain' });
  res.end('Page Not Found');
}

// 监听端口
const port = 3000;
server.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

上述示例代码创建了一个简单的 Node.js 服务器，并根据不同的 URL 路径，使用路由处理不同的请求。handleHome 函数处理首页请求，handleAbout 函数处理关于页面请求，handleNotFound 函数处理 404 页面请求。在处理函数中，我们读取相应的 HTML 模板文件，并将其作为响应返回给客户端。

请注意，这只是一个简单的示例，实际的服务端框架可能包含更多功能和模块。你可以根据自己的需求和项目规模进行扩展和定制，例如添加数据库连接、身份验证、会话管理等功能。

跨域的解决方案有哪些？cors 是怎么处理跨域？​

跨域（Cross-Origin）是指在浏览器中，当一个网页的 JavaScript 代码正在向与当前页面不同域名（协议、端口号也不同）的服务器发送请求时，就会发生跨域请求。出于安全考虑，浏览器实施了同源策略（Same-Origin Policy），限制了跨域请求。

以下是几种常见的跨域解决方案：

  1. CORS（跨域资源共享）： CORS 是一种由浏览器实现的机制，用于允许跨域请求。它通过在服务器的响应中添加一些特定的 HTTP 头部信息来实现。当浏览器收到跨域请求的响应时，会检查响应头部中的 CORS 相关信息，如果符合规则，则返回给页面的 JavaScript 代码。

    CORS 解决跨域问题的关键是在服务器端设置合适的响应头部。常见的响应头部字段包括 Access-Control-Allow-Origin（指定允许跨域请求的源）、Access-Control-Allow-Methods（指定允许的请求方法）、Access-Control-Allow-Headers（指定允许的请求头部）、Access-Control-Allow-Credentials（指定是否允许发送身份凭证，如 Cookies）等。

  2. JSONP（JSON with Padding）： JSONP 是一种通过动态创建 <script> 标签来实现跨域请求的方法。它利用了 <script> 标签不受同源策略限制的特性，可以加载来自其他域的 JavaScript 代码。在跨域请求中，服务器返回的响应数据需要包裹在一个回调函数中，并在前端定义该回调函数，从而实现数据的获取和处理。

    JSONP 的原理是利用了脚本标签的 src 属性可以跨域加载资源的行为。但它只支持 GET 请求，并且需要服务器端的支持。

  3. 代理服务器： 可以设置一个位于同源的代理服务器，将跨域请求转发到目标服务器，并将得到的响应返回给前端页面。前端发送请求时，实际上是与同源的代理服务器进行通信，从而避免了跨域问题。

    代理服务器的实现可以借助于后端技术，如使用 Node.js、Nginx、Apache 等。前端代码只需要将请求发送到代理服务器，代理服务器再将请求转发到目标服务器，并将响应返回给前端。

  4. WebSocket： WebSocket 是一种全双工通信协议，它建立在 TCP 协议之上，可以在浏览器和服务器之间建立持久连接，实现双向实时通信。由于 WebSocket 是在 HTTP 握手阶段升级协议，而不是通过 XMLHttpRequest 发起请求，因此不受同源策略的限制。

    使用 WebSocket 可以实现跨域通信，但需要服务器端支持 WebSocket 协议。常见的 WebSocket 库有 Socket.IO、WebSocket API 等。

这些解决方案各有优劣，选择合适的方案取决于具体的需求和技术栈。CORS 是目前最常用和推荐的跨域解决方案，它通过在服务器端设置合适的响应头部来允许跨域请求。在 CORS 中，服务器通过响应头部告知浏览器请求是否被允许。以下是 CORS 处理跨域的基本流程：

  1. 客户端发起跨域请求，并在请求头中携带 Origin 字段，指示请求的源地址。

  2. 服务器接收到请求后，根据自身的设置判断是否允许该跨域请求。

  3. 如果服务器允许该跨域请求，会在响应头部中添加一些 CORS 相关的字段，如 Access-Control-Allow-Origin、Access-Control-Allow-Methods、Access-Control-Allow-Headers 等。

  4. 浏览器收到服务器的响应后，会检查响应头部中的 CORS 相关字段。

  5. 如果响应头部中的 CORS 字段符合规则，浏览器会将响应返回给前端 JavaScript 代码，并允许 JavaScript 代码访问响应数据。

  6. 如果响应头部中的 CORS 字段不符合规则，浏览器会阻止 JavaScript 代码访问响应数据，从而遵循同源策略的安全限制。

以下是一个示例的 CORS 响应头部的设置：

HTTP/1.1 200 OK
Access-Control-Allow-Origin: http://www.example.com
Access-Control-Allow-Methods: GET, POST
Access-Control-Allow-Headers: Content-Type

在上面的示例中，Access-Control-Allow-Origin 字段指定允许跨域请求的源地址为 http://www.example.com，Access-Control-Allow-Methods 字段指定允许的请求方法为 GET 和 POST，Access-Control-Allow-Headers 字段指定允许的请求头为 Content-Type。

请注意，CORS 是一种由浏览器实现的机制，只适用于浏览器环境下的跨域请求。如果是非浏览器环境，如服务器之间的跨域通信，需要使用其他方式来解决跨域问题。

问题参考链接

【1 月最新】前端 100 问：能搞懂 80% 的请把简历给我

🔥 连八股文都不懂还指望在前端混下去么

在阿里我是如何当面试官的

NodeJS有难度的面试题，你能答对几个？