业务广泛依赖JavaScript来开发Web开发项目，以提高效率并实现目标。技术发展迅猛，有多个框架可供选择，但由于每个框架都有特定功能，因此选择合适的框架可能是一个挑战。

Express.js和Next.js是最先进的Web开发框架，因此我们希望突出这两个框架的特点、优缺点，以帮助企业做出更好的选择。

## 什么是框架？

框架是构建块，也称为预定义代码，开发人员用于设计软件或应用程序。这些代码提供指令以解决问题，并修改基本功能以获得所需组件的输出。

有工具集、支持程序、代码库和编译器，支持数据管理、路由等功能。Next.js和Express.js是[最佳JavaScript框架](https://technostacks.com/blog/best-javascript-frameworks/)，易于使用，即使初学者也能高效地设计有益于业务运营的实用软件。现在，让我们来看一下Next.js vs. Express.js的完整指南。

## 什么是Next.js？

大多数企业倾向于使用开源Web框架，这就是为什么Next.js变得非常受欢迎，因为它还提供了自由添加功能，如服务器端渲染和静态Web生成，使应用程序开发对移动端和Web端都可行。

代码是通过React编写的，这使得在不复杂的配置下轻松配置客户端和服务器端应用程序。

## Next.js的主要特点

当谈到这个JavaScript开发平台提供的功能时，强调这是构建现代和功能性Web或移动应用的最佳选择是至关重要的。以下是使其成为开发人员理想选择的特点。

- Next.js允许互操作性，这意味着系统可以轻松连接并交换关键信息，因为ES6支持系统支持它。
- 该框架下载了网页的重要代码，使加载速度快：这是每个企业的目标。
- Next.js基于热模块替换，允许在运行中的应用程序中进行所需更改；因此，开发人员无需重新加载应用程序，节省了大量时间和精力。
- 服务器端渲染是一项功能，可以加快服务器上的内容加载速度。
- 该框架可以快速将保存在HTML服务器上的文件转换为客户端的HTML页面。

## Next.js的优缺点

尽管Next JavaScript在开发人员中很受欢迎，但仍然存在一些与之相关的缺点。以下是一些优点和缺点：

### 优点

- 该框架使用TypeScript使应用程序构建更容易。
- 使用Next.js开发的应用程序确保数据安全。
- 该框架允许企业提供具有吸引力和实用功能的最佳用户体验的应用程序。
- 静态站点生成功能允许在构建时编译和渲染网页。
- 允许客户端平稳地浏览页面，提升体验。

### 缺点

- 开发人员只能使用有限数量的插件。
- 组织需要有内部团队来开发和管理应用程序。
- 由于缺乏内置状态管理器，需要下载状态管理器应用程序，如MobX或Redux。
- 静态Web开发也意味着开发时间更长。
- 使用Next.js的开发人员必须自行设计应用程序的前端页面，因为这些内容不包含在框架中。

## 何时使用Next.js？

当您需要开发支持服务器端渲染的应用程序时，Next.js框架是最佳选择。开发人员可以设计具有静态和动态页面组合的应用程序。以下是Next.js被证明有用的一些产品：

- 单个网页
- JAMstack网站
- SaaS应用程序
- 仪表板
- 交互式用户界面
- Web门户
- 电子商务网站

## 什么是Express.js？

[Express.js](https://expressjs.com/)也是一个开源框架，开发人员广泛使用它来设计API和Web应用程序。它在Node.js上运行，并允许在客户端和服务器端构建现代、功能丰富的应用程序。该框架的显著特点是开发人员可以将其与其他框架结合使用，提供最佳的开发解决方案。

## Express.js的主要特点

以下是Express JavaScript的特点，广受设计师和开发人员欢迎：

- 该框架允许在客户端接收响应之前或路由处理程序获取HTTP请求之前执行代码。
- JavaScript可以同时为不同的URL定义路由。
- 该框架具有Google V8支持，使其可扩展且可靠，适用于实时应用程序功能。
- Express.js通过MEAN堆栈提供可扩展的数据管理系统。
- 使用该框架开发的应用程序具有高端数据保护。

## Express.js的优缺点

Express.js作为一个框架被广泛应用于各行业，用于开发应用程序以改善业务产出。以下是与之相关的一些主要优缺点：

### 优点

- 具有用于决策的中间件。
- 与MongoDB、Redis、MySQL等数据库兼容。
- 对开发人员灵活且方便。
- 通过使用Jade、Vash等模板进行轻松集成。
- 开发人员可以使用相同的语言进行服务器和移动应用程序开发。

### 缺点

- 代码复杂
- 对初学者来说使用起来困难。
- 无效的错误报告使调试更加困难。
- 需要持续修补以处理安全漏洞。
- 缺乏同步回调功能。

## 何时使用Express.js？

Express.js可用于根据业务需求开发移动和Web应用程序。开发人员可以设计具有所需功能的多页、单页或混合Web应用程序。与Next.js不同，Express.js框架具有支持顶层设计的功能，使路由和服务器管理变得简单。

## Express.js和Next.js之间有什么区别？

尽管开发人员使用这两个框架来设计Web和移动应用程序，但next.js和express.js之间存在差异，它们满足不同的业务需求。以下是开发人员应该了解的主要区别，以便根据需要选择其中一个框架。

- **路由过程的差异：**  Express通过正则表达式匹配URL，而Next将URL映射为处理程序的对象。
- **接口的差异：**  Express使用基于回调的API，具有额外的功能，如中间件。另一方面，Next使用服务器端渲染的页面。
- **插件的使用：**  Next.js使用外部工具，而Express.js允许开发人员通过事件订阅使用网关插件。
- **速度：**  Express.js比Next.js更快，因为它使用最小功能和工具，而Next使用静态目标。
- **可扩展性：**  Express灵活，可以轻松扩展以设计具有多个页面的大型应用程序。Next可用于设计多个页面。

## Express.js vs. Next.js：你应该选择哪一个？

现在我们已经详细比较了next.js和express.js，开发人员和企业在计划使用特定目标设计应用程序时，将更容易选择其中一个。这两个框架都是完整的JavaScript包，具有类似的功能和性能。

对于需要具有前端库的框架的开发人员来说，Next.js是一个合适的选择，而对于只希望使用JavaScript进行后端设计的开发人员来说，Express是一个实用的选择。使用Next.js时，无需安装CSS和JavaScript，这导致页面加载速度更快。Express利用URL和HTTP方法来确保更快的响应。

因此，没有好坏框架之分，选择完全取决于项目需求和开发人员的专业知识。在选择框架之前评估项目目标是至关重要的，以确保输出没有任何不规则性。

## 主要观点

通过这份全面的Next.js vs. Express.js比较，我们旨在与对技术世界了解有限的初学者分享关键信息，并希望在没有任何错误的情况下提供最佳结果。

选择错误的框架只会导致无效的应用程序开发。在完成项目后因结果不尽如人意而切换到另一个框架会消耗时间、金钱和精力，这只会对业务产生负面影响。

## 常见问题

### 1. Express.js和Next.js哪个更好？

不可能将一个框架评为比另一个更好，因为每个框架都满足特定的项目需求。Express.js是一个灵活且快速的平台，用于构建服务器端应用程序或API。它拥有庞大且经验丰富的开发人员社区，可以在专业人员遇到问题时提供支持。还有额外的插件，使应用程序开发变得简单快捷。另一方面，Next.js适用于SEO优化、自动代码拆分或设计静态网页。

### 2. Next.js能否取代Express？

Next.js不能取代Express，因为这两个框架都具有帮助设计不同项目类型的特定功能。Express基于Node.js，开发人员广泛使用它来设计API和后端框架。Next.js基于React框架，适用于SEO优化和静态网站。

### 3. Next.js比Express.js更好吗？

开发人员根据要开发的应用程序类型选择框架，因此没有特定的平台可以被认为比其他更好。这两个框架的功能不同，这直接影响输出。对于前端开发任务，Next.js是最佳选择，对于后端开发，Express.js是一个实用的选择。

### 4. Express.js是前端还是后端框架？

Express.js主要是一个后端框架，使用Node.js设计服务器端应用程序和API；但它不适用于处理静态网页和SEO优化，这是前端框架的关键方面，因此它依赖于Next.js。

### 5. Next.js和Express.js有什么区别？

Express.js和Next.js之间的主要区别在于开发人员使用它们设计的开发项目类型不同，因为这两者满足两个不同的类别。Next.js的亮点是它基于React，并且是Web和移动端的服务器端应用程序设计和静态网页的首选框架。另一方面，Express.js更受开发人员欢迎，用于设计Web应用程序和API。

### 6. 我可以使用Next.js进行后端开发吗？

Next.js不适合后端开发，因此开发人员应该考虑使用Express.js进行此类业务项目。Next.js框架便于设计前端项目，如静态网页和简单但功能性的服务器端应用程序。

### 7. Express.js是否适合创建API？

Express.js允许开发人员和设计师编写服务器端应用程序和API，通过服务器和客户端之间的通信处理请求和响应。这种系统允许无缝地整合外部附加组件和接口，使其轻松与其他操作合并。

### 8. Next.js与Express.js有何不同？

Next和Express都是开发人员用于设计和开发移动和Web应用程序的JavaScript框架。在编码领域，Next框架使用React简化整个编程过程，这是许多开发人员青睐的一个引人注目的因素。另一方面，Express.js基于NodeJS库，帮助设计API和后端框架。

### 9. 你会在哪些情况下选择 Next.js 而不是 Express.js？

对于需要进行 SEO 优化、仪表板设计、Web 门户开发、JAMstack 网站以及其他静态网站开发任务的项目开发者来说，应该优先选择 Next.js 而不是 Express.js。通过扩展你的视野，使用基于 React 的服务器端渲染工具 Next，无需深入理解即可使用，这使其成为一个吸引人的选择。因此，初学者可以轻松理解并适应这个框架，以最小的努力提供最佳的输出。


在本文中，探索Next.js和Express.js之间的差异，包括它们的特性、优点、缺点和使用案例。

Next.js 与 Express.js：它们有什么不同？

简单而廉价的单板计算机（SBC）的出现是[物联网](https://dzone.com/guides/the-internet-of-things-1)世界的一个重要推动因素，为工业、家庭、医疗等领域的控制系统和设备的开发提供了可能性。现在，每个人都可以为自己的需求开发所需的东西，为公共项目的发展做出贡献，并使用他人开发的产品。

在本文中，我们将开发一个控制系统，用于管理基本的园艺活动，如浇水、照明等。为了使我们的应用程序更加灵活和可扩展，我们将其开发为一个分层的分布式系统，由松散耦合的组件通过标准（在我们的情况下是REST）协议进行通信。我们将使用广为人知的企业技术Node.js和[React.js](https://dzone.com/refcardz/reactjs-essentials)，以及树莓派Zero设备作为我们应用程序的传感器层。

我们的传感器层组件的主要功能是控制我们花园中执行主要活动的设备。假设我们需要控制浇水电路和照明电路，即打开/关闭水泵和室外灯。首先，我们连接所有硬件单元，然后开发必要的软件来使硬件运行起来。

## **硬件设置：继电器板连接，电路组装**

对于我们的两个设备，我们可以使用[Raspberry Pi Zero W](https://www.raspberrypi.com/products/raspberry-pi-zero-w/) SBC和[SB Components Zero Relay](https://learn.sb-components.co.uk/Zero-Relay)继电器HAT（‘Hardware Attached on Top’）。每个HAT继电器都有NC（常闭）和NO（常开）接点。我们需要我们的浇水和照明电路仅在需要打开水泵和灯时才关闭（打开），因此我们将电路端连接到NO和COM接点，如图1.1所示。

![](https://cdn.iokks.com/art/3d4e5df01d73/7836689a6e884d4fa7fc730254ce80e9.jpg)

## **软件设置：操作系统和库安装，控制软件开发**

提供所有硬件组件连接后，我们可以添加软件使系统运行。首先，我们需要在树莓派设备上安装操作系统。有几种方法可以做到这一点；可能最舒适的方法是使用[Raspberry Pi Imager](https://www.raspberrypi.com/software/)。使用此应用程序，我们可以下载适当的操作系统并将其写入SD卡以启动SBC；我们可以从安装菜单中使用Raspberry Pi OS（32位）。

假设您的树莓派装备有适当的操作系统并且可以访问命令行，我们可以准备所有必要的软件。我们的组件有两个任务：暴露一个API以接受控制继电器的命令并将这些命令传递给继电器。让我们从实现API开始，这是大多数现代企业应用程序的常见任务。

### **控制API的实现**

正如我们之前讨论的，我们将使用REST协议在我们的组件之间进行通信，因此我们需要为控制接口暴露REST端点。考虑到我们的树莓派Zero计算机的受限配置，我们应该尽可能轻量地实现API。对于这种情况，一个合适的技术是[Node.js](https://nodejs.org/en)框架。本质上，它是一个JavaScript引擎，提供了在服务器端运行JavaScript代码的可能性。由于其设计，Node.js特别适用于构建Web应用程序，即处理互联网上的请求并返回处理后的数据和视图的应用程序。我们将在我们的Node.js应用程序中使用[Express](https://expressjs.com/) Web框架来简化请求处理。假设我们的系统中已经运行了Node.js，我们可以开始实现控制API。让我们创建一个Web控制器，它将是我们组件的主要控制单元。我们可以为每个设备继电器实现三个端点 - 打开、关闭和状态端点。为我们的应用程序创建一个Node包是个好主意，因此我们在树莓派根目录下创建一个新目录“smartgarden”，并在该目录中运行以下命令，以安装所有必要的依赖项并创建包描述符：

`pi@raspberrypiZero:~/smartgarden $ npm install express --save`

`pi@raspberrypiZero:~/smartgarden $ npm install http --save`

我们从以下基本脚本开始，并逐渐添加所有必要的功能。

**清单2.1. smartgarden/outdoorController.js：组件Web API**

```javascript
const express = require("express");
const http = require("http");

var app = express();

app.use((req, res, next) => {
    res.append('Access-Control-Allow-Origin', ['*']);
    res.append('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE');
    res.append('Access-Control-Allow-Headers', 'Content-Type');
    next();
});

var server = new http.Server(app);

  app.get("/water/on", (req, res) => {
    console.log("Watering switched on");
  });
  app.get("/water/off", (req, res) => {
    console.log("Watering switched off");
  });

  app.get("/water/status", (req, res) => {
    console.log("TODO return the watering relay status");
  });

  app.get("/light/on", (req, res) => {
    console.log("Light switched on");
  });

  app.get("/light/off", (req, res) => {
    console.log("Light switched off");
  });

  app.get("/light/status", (req, res) => {
    console.log("TODO return the light relay status");
  });

 server.listen(3030, () => {console.log("Outdoor controller listens to port 3030")});
```

我们可以使用以下命令运行应用程序：

`pi@raspberrypiZero:~ $ node smartgarden/outdoorController.js`

终端中应该显示以下消息：

`Outdoor controller listens to port 3030`

当访问定义的端点时，我们应该看到相应的输出，例如，“Light switched off”对于/light/off端点。如果是这种情况，那就意味着我们的控制API正在工作！这很好，但实际上，它现在并没有做任何有用的工作。让我们通过添加内容来修复它，以便将命令传递给物理设备，即继电器。

### **将命令传递给物理设备**

从JavaScript应用程序内部与物理设备通信有几种方法。在这里，我们将使用[Johnny-Five](http://johnny-five.io/) JavaScript库。

Johnny-Five是JavaScript机器人和物联网平台，适用于许多平台，包括树莓派。它支持各种设备，如继电器、传感器、舵机等。

假设您的树莓派上已安装了Node和npm工具，您可以使用以下命令安装Johnny-Five库：

`pi@raspberrypiZero:~/smartgarden $ npm install johnny-five --save`

此外，我们需要安装raspi-io包。Raspi IO是Johnny-Five Node.js机器人平台的I/O插件，它使Johnny-Five能够控制树莓派上的硬件。

`pi@raspberrypiZero:~/smartgarden $ npm install raspi-io --save`

为了测试安装，我们可以运行以下脚本：

```javascript
const Raspi = require('raspi-io').RaspiIO;
const five = require('johnny-five');

const board = new five.Board({
  io: new Raspi()
});

board.on('ready', () => {

  // Create an Led on pin 7 (GPIO4) on P1 and strobe it on/off
  // Optionally set the speed; defaults to 100ms
  (new five.Led('P1-7')).strobe();

});
```

由于Raspbian中与GPIO交互的权限较为保守，您需要使用sudo来执行此脚本。如果我们的安装成功，我们应该看到LED以默认频率100毫秒闪烁。

现在，我们可以像清单2.2中所示那样为我们的控制器添加Johnny-Five支持。

**清单2.2. 启用继电器控制的smartgarden/outdoorController.js**

```javascript
const express = require("express");
const http = require("http");
const five = require("johnny-five");
const { RaspiIO } = require('raspi-io');

var app = express();

app.use((req, res, next) => {
    res.append('Access-Control-Allow-Origin', ['*']);
    res.append('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE');
    res.append('Access-Control-Allow-Headers', 'Content-Type');
    next();
});

var server = new http.Server(app);

const board = new five.Board({io: new RaspiIO(), repl: false});

board.on("ready", function() {

  var relay1 = new five.Relay({pin:"GPIO22",type: "NO"});
  var relay2 = new five.Relay({pin:"GPIO5",type: "NO"});
    
   app.get("/water/:action", (req, res) => {

        switch(req.params.action) {

           case 'on':
                relay1.close();
                res.send(relay1.value.toString());
                break;
           case 'off':
                relay1.open();
                res.send(relay1.value.toString());
                break;
           case 'status':
                res.send(relay1.value.toString());
                break;
           default:
                console.log('Unknown command: ' + req.params.action);
                res.sendStatus(400);
        }   
  });

  app.get("/light/:action", (req, res) => {

        switch(req.params.action) {

          case 'on':
                relay2.close();
                res.send(relay2.value.toString());
                break;
          case 'off':
                relay2.open();
                res.send(relay2.value.toString());
                break;
          case 'status':
                res.send(relay2.value.toString());
                break;
          default:
                console.log('Unknown command: ' + req.params.action);
                res.sendStatus(400);
        }   
  });

  server.listen(3030, () => {
    console.log('Outdoor controller listens to port 3030');
  });
});
```

我们可以使用以下命令运行更新后的应用程序：

`pi@raspberrypiZero:~ $ sudo node smartgarden/outdoorController.js`

如果我们现在访问端点，我们应该看到相应的继电器打开和关闭。如果是这种情况，那就意味着我们的控制器组件正常工作！

干得好！但是通过在http客户端中键入[REST](https://dzone.com/refcardz/rest-foundations-restful)请求发送命令并不是很方便。为此，提供一个GUI将是个不错的选择。

### **命令用户界面的开发**

有各种选项可用于实现控制界面，我们将使用React.js来完成这项任务。React.js是一个轻量级的JavaScript框架，专注于创建基于组件的Web UI，这对于我们这种分布式组件应用程序的情况是一个正确的选择。为了充分利用React，我们可以安装create-react-app工具：

`npm install -g create-react-app`

然后，我们可以为我们的前端内容创建一个JavaScript应用程序。假设我们在项目根目录中，我们可以运行以下命令：

`.../project-root>create-react-app smartgarden`

这个命令将创建一个新的文件夹（'smartgarden'），其中包含一个准备就绪的原型React应用程序。现在，我们可以进入该目录并运行以下命令：

`.../project-root>cd smartgarden`

`.../project-root/smartgarden>npm start`

这将在http://localhost:3000上的新浏览器中启动应用程序。这是一个简单但完全功能的前端应用程序，我们可以将其用作创建我们的UI的原型。React支持组件层次结构，其中每个组件都可以有一个状态，并且状态可以在相关组件之间共享。此外，可以通过向组件传递属性来自定义每个组件的行为。因此，我们可以开发主组件，它作为显示屏或表单的占位符，用于执行相应操作。此外，为了加快开发速度并使我们的UI看起来更加常用和用户友好，我们将使用MUI组件库，这是最受欢迎的React组件库之一。我们可以使用以下命令安装该库：
npm install @mui/material @emotion/react @emotion/styled

````

为了将所有配置设置放在一个地方，我们创建了一个配置类，并将其放在特定的配置目录中：

**清单 2.3. configuration.js：包含所有应用程序设置的配置类。** 

```javascript
class Configuration {

    WATERING_ON_PATH = "/water/on";
    WATERING_OFF_PATH = "/water/off";
    WATERING_STATUS_PATH = "/water/status";
    LIGHT_ON_PATH = "/light/on";
    LIGHT_OFF_PATH = "/light/off";
    LIGHT_STATUS_PATH = "/light/status";
    
    CONTROLLER_URL = process.env.REACT_APP_CONTROLLER_URL ? process.env.REACT_APP_CONTROLLER_URL :
        window.CONTROLLER_URL ? window.CONTROLLER_URL : "http://localhost:3030";
}

export default Configuration;
````

配置类包含控制器服务器的URL和控制端点的路径。对于控制器URL，我们提供了两种外部配置的可能性和一个默认值，在我们的情况下是http://localhost:3030。您可以将其替换为您的控制器服务器的相应URL。

将所有相关功能放在一个地方是个好主意。将我们的功能放在一个服务后面，该服务公开了某些API，可以确保我们的应用程序更灵活和可测试。因此，我们创建了一个控制服务类，该类实现了与控制器服务器进行数据交换的所有基本操作，并将这些操作公开为所有React组件的方法。为了使我们的UI更具响应性，我们将方法实现为异步的。只要API不变，我们就可以自由更改实现，而不会影响任何消费者。我们的服务可以如下所示。

**清单 2.4. services/ControlService.js – 用于与传感器层通信的API。**

```javascript
import Configuration from './configuration';

class ControlService {

  constructor() {
    this.config = new Configuration();
  }

  async switchWatering(switchOn) {
    console.log("ControlService.switchWatering():");
    let actionUrl = this.config.CONTROLLER_URL
                  + (switchOn ? this.config.WATERING_ON_PATH : this.config.WATERING_OFF_PATH);

    return fetch(actionUrl ,{
        method: "GET",
        mode: "cors"
      })
      .then(response => {
        if (!response.ok) {
            this.handleResponseError(response);
        }
        return response.text();
      }).then(result => {
        return result;
      }).catch(error => {
        this.handleError(error);
      });
  }

  async switchLight(switchOn) {
    console.log("ControlService.switchLight():");
    let actionUrl = this.config.CONTROLLER_URL
                  + (switchOn ? this.config.LIGHT_ON_PATH : this.config.LIGHT_OFF_PATH);

    return fetch(actionUrl ,{
        method: "GET",
        mode: "cors"
      })
      .then(response => {
        if (!response.ok) {
            this.handleResponseError(response);
        }
        return response.text();
      }).then(result => {
        return result;
      }).catch(error => {
        this.handleError(error);
      });
  }

   handleResponseError(response) {
      throw new Error("HTTP error, status = " + response.status);
  }

  handleError(error) {
      console.log(error.message);
  }

}

export default ControlService;
```

为了封装控制功能，我们创建了控制面板组件，如清单 2.5 所示。为了保持代码结构化，我们将组件放入“components”文件夹中。

**清单 2.5. components/ControlPanel.js：包含用于控制花园设备的UI元素的React组件。**

```javascript
import React, { useEffect, useState } from 'react';
import Switch from '@mui/material/Switch';
import ControlService from '../ControlService';
import Configuration from '../configuration';

function ControlPanel() {

    const controlService = new ControlService();

    const [checked1, setChecked1] = useState(false);
    const [checked2, setChecked2] = useState(false);

    useEffect(() => {

        const config = new Configuration();
        const fetchData = async () => {
            try {
                let response = await fetch(config.CONTROLLER_URL + config.WATERING_STATUS_PATH);
                const isWateringActive = await response.text();
                setChecked1(isWateringActive === "1" ? true : false);
                response = await fetch(config.CONTROLLER_URL + config.LIGHT_STATUS_PATH);
                const isLightActive = await response.text();
                setChecked2(isLightActive === "1" ? true : false);
            } catch (error) {
                console.log("error", error);
            }
        };

        fetchData();
    }, []);

    const handleWatering = (event) => {
        controlService.switchWatering(event.target.checked).then(result => {
            setChecked1(result === "1" ? true : false);
        });
    };

    const handleLight = (event) => {
        controlService.switchLight(event.target.checked).then(result => {
            setChecked2(result === "1" ? true : false);
        });
    };

    return(

        <React.Fragment>
            <div>
                <label htmlFor='device1'>
                    <span>Watering</span>
                <Switch id="1" name="device1" checked={checked1}         onChange={handleWatering} />
                </label>
                <label htmlFor='device2'>
                    <span>Light</span>
                <Switch id="2" name="device2" checked={checked2} onChange={handleLight}/>
                </label>
            </div>
        </React.Fragment>
        
    );
}

export default ControlPanel;
```

使用create-react-app工具生成的内容，我们可以将app.js的内容更改如下。

**清单 2.6. 基本UI组件**

```javascript
import './App.css';
import React from 'react';
import AppBar from '@mui/material/AppBar';
import Toolbar from '@mui/material/Toolbar';
import Typography from '@mui/material/Typography';
import ControlPanel from './components/ControlPanel';
import { createTheme, ThemeProvider } from '@mui/material/styles';

function App() {

  const theme = createTheme(
    {
      palette: {
        primary: {
          main: '#1b5e20',
        },
        secondary: {
          main: '#689f38',
        },
      },
    });

  return (

    <div className="App">
      <ThemeProvider theme={theme}>
       <AppBar position="static">
        <Toolbar>
          <Typography variant="h5">Smart Garden</Typography>
        </Toolbar>
       </AppBar>
          <ControlPanel/>
      </ThemeProvider>
    </div>
 );
}
export default App;
```

现在，是时候测试我们的UI应用程序了。可能需要将CONTROLLER_URL配置参数设置为Raspberry Pi设备的IP地址，该设备运行着室外控制器后端应用程序，类似于“[http://](http://localhost:3000/)[192.168.nn.nn](http://localhost:3000/)[:30](http://localhost:3000/)[3](http://localhost:3000/)[0](http://localhost:3000/)”。启动应用程序后，它将在新的浏览器选项卡中打开。

![图 2.1. 控制UI前端应用程序](https://cdn.iokks.com/art/3d4e5df01d73/bd6dd5f9cc654212b5b119981359f952.png)

如果我们的室外控制器应用程序运行在连接到控制电路的Raspberry Pi设备上（参见图 1.1），现在我们可以打开和关闭浇水和照明电路。我们应该看到类似于图 2.1 所示的屏幕。

如果是这种情况，那么你成功了！恭喜你！现在，您拥有一个可用于各种设备和设备的远程控制系统。此外，我们可以将传感器层控制器包集成到任何系统中，并从UI和业务逻辑组件与其REST端点进行通信。

本文的源代码可在\*[GitHub](https://github.com/spylypets/smartgarden)\*上找到。


我们将开发一个远程控制系统，该系统能够使用流行的企业技术和树莓派平台，以扩展至各种设备和设备。

使用 Node.js、React.js 和 Raspberry Pi 进行远程控制

NodeJS是由Ryan Dahl于2009年创建的开源、跨平台工具，主要为JavaScript提供了一个在浏览器之外执行的运行环境。它采用了异步编程。

NodeJS基于JavaScript V8引擎，可以在各种浏览器上运行，如Chrome，也可以作为独立应用程序运行。NodeJS Web开发能够轻松处理服务器请求。

简而言之，NodeJS Web开发扩展了JavaScript的功能。NodeJS Web开发有助于将编程语言与API、其他语言和各种第三方库集成。它专门用于Web应用程序开发中的“JavaScript无处不在”范式，并且可以管理服务器端脚本和客户端编程。

## **NodeJS功能**

以下是NodeJS的工作原理：

- 收集表单数据。
- 添加、删除和更改数据库中的数据。
- 创建动态页面内容，以及读取、写入、删除和关闭服务器文件。

## **NodeJS的8个显著特点**

我们已经了解了NodeJS Web开发的前8个特点，这些特点使其在后端Web应用程序开发的竞争解决方案中脱颖而出。

### **跨平台**

NodeJS可以在多种平台上运行，包括Windows、Unix、Linux、Mac OS X和移动设备。它可以与适当的软件包一起使用，创建自包含的应用程序。

### 使用一种编程语言

那些已经熟悉JavaScript的人可以很快掌握NodeJS。NodeJS允许开发人员在同一框架中编写前端和后端代码。因此，JavaScript是全栈开发的首选语言。

因此，程序员受益于不必在多种编程语言之间切换，并且可以处理更小的数据。

### **可扩展性**

NodeJS解决了软件开发中最紧迫的问题之一：可扩展性。如今，大多数组织都希望拥有可扩展的软件。

首先，NodeJS处理并发请求。NodeJS中的集群模块管理所有活动CPU核心的负载平衡，这是它受欢迎的第二个原因。

NodeJS的第三个最引人注目的特点是能够水平分割软件。它通过使用子进程来实现这一点。这意味着公司可以为不同的目标群体提供不同的应用程序版本，以满足客户对定制化的偏好。

### **V8引擎**

V8引擎最初是为Chrome设计的，现在已经转换为用于Web应用程序开发。V8引擎是将JavaScript转换为广泛的计算机编程语言（使用C++）的最佳引擎之一。因此，V8引擎对服务器和所有基于机器语言的产品都是有益的。

### 快速部署和微服务开发

NodeJS是一个快速应用程序开发和部署的极简框架。大多数成功的公司如今选择它，因为他们的产品可以更快地发布到市场上。

它还有助于创建微服务。这是因为NodeJS能够快速分析数据并提供非阻塞算法，这两点在构建微服务中特别有用。

### **数据处理能力**

NodeJS的数据处理机制是异步的。因此，这有助于同时处理查询。其次，NodeJS使用基于事件驱动的软件开发技术，其中提供的输出完全取决于用户的输入，没有固定的输出顺序。

### **开源社区**

NodeJS拥有一个庞大的全球社区，因为它是一个开源解决方案。实施更大的社区的好处是，开发人员可以向社区成员请求帮助，并立即得到问题的解决方案。社区成员之间自由交换工具、模块、软件包和框架。

### **最快和最强大**

当数据以多个流传输时，处理它们需要很长时间。因此，通过在上传文件时同时分析文件，NodeJS在处理信息时减少了时间。因此，NodeJS提高了数据和视频流的整体速度。

## **结语**

现在你明白了为什么NodeJS Web开发是开发真正的Web应用程序的最佳选择，而不是其他后端开发工具。它具有许多功能，可以帮助开发人员创建各种跨平台兼容的程序。与JavaScript一起使用的能力是NodeJS最重要的特点，这也是程序员选择它的原因，因为它允许他们在前端和后端开发中使用相同的编程语言。


寻找NodeJS网页开发服务？看看这八大特性让它如此受欢迎，以及为什么你应该考虑在下一个项目中使用它。

NodeJS Web开发的8大特性

网站可以利用IP地理定位为网站用户提供各种功能。这些功能包括根据国家进行网页重定向、以本地语言显示内容，或者根据用户的地理位置定制内容。

[React](https://react.dev/)是一个开源的JavaScript库，它使得网页开发人员可以基于组件轻松创建引人入胜的用户界面。它被设计为在前端（客户端）运行，这意味着它只能在浏览器端渲染页面。

与此同时，[Next.js](https://nextjs.org/)是由Vercel开发的开源React Web开发框架。Next.js使得React Web应用程序可以执行服务器端渲染、代码拆分等功能。该框架由[Node.js](https://nodejs.org/en)提供支持，Node.js提供了JavaScript运行环境。

在本教程中，我将介绍如何使用React和Next.js搭建一个基本的网站。然后，我将演示如何通过检查访问者的IP地址来获取IP地理定位数据。这涉及与[IP2Location.io](https://www.ip2location.io/#dzone)进行简单集成，这是IP2Location.com提供的IP地理定位数据的下一代API。

我将使用Debian 12实例进行演示。

先决条件：[IP2Location.io免费API密钥](https://www.ip2location.io/pricing#dzone)。请记下您的API密钥，它将在下面的步骤中使用。

## 1. 安装Node.js

在撰写本文时，Next.js所需的最低Node.js版本为18或更高。请参考[next.js设置](https://nextjs.org/learn/basics/create-nextjs-app/setup)以了解最新所需版本。

按照您的平台在[node.js](https://nodejs.org)上安装。

对于Debian，请使用以下命令进行安装：

`sudo apt install nodejs npm`

安装完成后，请验证两者的版本。

`nodejs --version && npm --version`

![](https://cdn.iokks.com/art/7cb926bf920f/73f2d8f765ad4beea400d7c518909b80.png)

好的，我的版本符合要求。接下来，让我们进入下一步。

## 2. 创建基本的Next.js应用程序

使用下面的命令行自动生成基本的Next.js应用程序，基于默认模板。导航到您想要创建应用程序的文件夹，然后运行以下命令。

`npx create-next-app@latest`

![](https://cdn.iokks.com/art/7cb926bf920f/b19c6539776b490bbd0c44a6af1d29dd.png)

我将使用默认项目名称“my-app”，并且不会在此演示中使用TypeScript。选择ESLint为Yes，Tailwind为No，src director为No，App Router为No，import alias为No。

运行上述命令后，您应该看到名为“my-app”的文件夹已经创建，并且包含了默认模板的骨架代码。让我们进入“my-app”文件夹，看看创建了哪些文件和文件夹。

![](https://cdn.iokks.com/art/7cb926bf920f/715d7656c85e4823b5598b68bfa5aaec.png)

查看package.json文件，您会发现它已自动包含了与React和Next.js一起使用所需的依赖项。

![](https://cdn.iokks.com/art/7cb926bf920f/67d87349650b4ae8ace26e78df840f65.png)

## 3. 安装IP2Location.io Node.js SDK

运行以下命令以安装IP2Location.io Node.js SDK。

`npm install ip2location-io-nodejs`

![](https://cdn.iokks.com/art/7cb926bf920f/1bb945405fc845c9ab0dc6b01438ecd8.png)

运行上述命令后，您会看到package.json已更新，包含了IP2Location.io Node.js SDK。

## 4. 修改Pages文件夹中的Index.js以添加IP2Location.io代码

导航到pages文件夹，让我们使用文本编辑器查看index.js文件。我假设您已经熟悉React，因此我在这里不会涵盖它。

![](https://cdn.iokks.com/art/7cb926bf920f/bdd774244f6046cb994e6c5b6a208e0b.png)

现在，让我们用下面的代码替换整个页面，以简化演示目的的页面。在粘贴下面的简化代码后保存页面。

```javascript
import Head from 'next/head'
import Image from 'next/image'
import { Inter } from 'next/font/google'
import styles from '@/styles/Home.module.css'
import ip2locationio from 'ip2location-io-nodejs'

const inter = Inter({ subsets: ['latin'] })

export async function getServerSideProps(context) {
  let ip
  const { req } = context

  if (req.headers['x-forwarded-for']) {
	ip = req.headers['x-forwarded-for'].split(',')[0]
  } else if (req.headers['x-real-ip']) {
	ip = req.connection.remoteAddress
  } else {
	ip = req.connection.remoteAddress
  }

  // Configures IP2Location.io API key
  let mykey = 'YOUR_API_KEY'
  let config = new ip2locationio.Configuration(mykey)
  let ipl = new ip2locationio.IPGeolocation(config)
  let lang = 'fr' // translation language, only supported in Plus and Security plans so use blank if not needed

  // Lookup ip address geolocation data
  const ipldata = await ipl.lookup(ip, lang)
  return { props: { ipldata: ipldata } }
}

export default function Home({ ipldata }) {
  return (
	<>
  	<Head>
    	<title>Create Next App</title>
    	<meta name="description" content="Generated by create next app" />
    	<meta name="viewport" content="width=device-width, initial-scale=1" />
    	<link rel="icon" href="/favicon.ico" />
  	</Head>
  	<main className={`${styles.main} ${inter.className}`}>
    	<div className={styles.description}>
      	IP: {ipldata.ip} <br />
      	Country: {ipldata.country_name} ({ipldata.country_code}) <br />
      	Country translation: {ipldata.country.translation.value} ({ipldata.country.translation.lang}) <br />
      	Region: {ipldata.region_name} <br />
      	City: {ipldata.city_name} <br />
      	Latitude: {ipldata.latitude} <br />
      	Longitude: {ipldata.longitude} <br />
      	Continent: {ipldata.continent.name} <br />
      	Continent translation: {ipldata.continent.translation.value} ({ipldata.continent.translation.lang}) <br />
    	</div>
  	</main>
	</>
  )
}
```

现在，让我们分解一下将允许我们检索网站访问者IP地址的IP地理位置的重要部分。

首先，我们需要导入IP2Location.io Node.js SDK，以便我们可以使用它的功能。

`import ip2locationio from 'ip2location-io-nodejs'`

接下来，添加另一个名为“getServerSideProps”的函数，这是一个Next.js函数，允许我们在每次页面请求时设置动态属性。在这里，我们检索调用者的IP地址，并将其传递给IP2Location.io API以获取地理位置数据。

```javascript
export async function getServerSideProps(context) {
  let ip
  const { req } = context

  if (req.headers['x-forwarded-for']) {
	ip = req.headers['x-forwarded-for'].split(',')[0]
  } else if (req.headers['x-real-ip']) {
	ip = req.connection.remoteAddress
  } else {
	ip = req.connection.remoteAddress
  }

  // Configures IP2Location.io API key
  let mykey = 'YOUR_API_KEY'
  let config = new ip2locationio.Configuration(mykey)
  let ipl = new ip2locationio.IPGeolocation(config)
  let lang = 'fr' // translation language, only supported in Plus and Security plans so use blank if not needed

  // Lookup ip address geolocation data
  const ipldata = await ipl.lookup(ip, lang)
  return { props: { ipldata: ipldata } }
}
```

最后，我们可以在Home函数中使用我们上面设置的属性，该函数将渲染我们的索引页面。我们将ipldata传递给函数，然后IP地理位置字段如country_code、country_name、region_name和其他字段将被显示。

```jsx
export default function Home({ ipldata }) {
  return (
	<>
  	<Head>
    	<title>Create Next App</title>
    	<meta name="description" content="Generated by create next app" />
    	<meta name="viewport" content="width=device-width, initial-scale=1" />
    	<link rel="icon" href="/favicon.ico" />
  	</Head>
  	<main className={`${styles.main} ${inter.className}`}>
    	<div className={styles.description}>
      	IP: {ipldata.ip} <br />
      	Country: {ipldata.country_name} ({ipldata.country_code}) <br />
      	Country translation: {ipldata.country.translation.value} ({ipldata.country.translation.lang}) <br />
      	Region: {ipldata.region_name} <br />
      	City: {ipldata.city_name} <br />
      	Latitude: {ipldata.latitude} <br />
      	Longitude: {ipldata.longitude} <br />
      	Continent: {ipldata.continent.name} <br />
      	Continent translation: {ipldata.continent.translation.value} ({ipldata.continent.translation.lang}) <br />
    	</div>
  	</main>
	</>
  )
}
```

## 5. 运行Next.js应用程序

运行以下命令以启动Next.js应用程序。

`npm run dev`

![](https://cdn.iokks.com/art/7cb926bf920f/5429a0c61b9646559361075319bf5cf9.png)

它会告诉您可以在本地主机的3000端口访问Web服务器。

## 6. 打开浏览器并测试页面

由于IP地理定位需要公共IP地址，我们将通过互联网从客户端机器访问我们的测试服务器，以便它可以读取我们的公共IP地址。

在客户端机器上打开浏览器，然后导航到您在端口3000上使用的服务器。

查看下面的页面输出。

注意：我的示例使用了API的Security计划，因此我能够检索更多的数据，比如大洲信息以及翻译。

![](https://cdn.iokks.com/art/7cb926bf920f/8db365d3cbfa4e69a53b9e7b68a1dd76.png)

## 结论

希望上述指南能够帮助您轻松地将IP地理定位集成到您的Next.js Web应用程序中。现代网站确实依赖于IP地理定位来实现许多功能，而这是很容易实现的。


 在Next.js中简单实现IP地理定位功能，以使用IP地址确定用户的物理位置。

如何在Next.js中获取IP地理位置数据

在充满活力的云计算领域中，无服务器架构以其革命性的应用开发方法脱颖而出。无服务器计算的利用使开发人员能够专注于编码，消除了服务器基础架构管理的复杂性。谷歌云平台（[GCP](https://dzone.com/refcardz/getting-to-know-google-compute-engine-and-how-to-u)）提供了一个弹性的无服务器环境，与Node.js集成后，形成了一个强大的联盟，用于创建可扩展和流畅的应用程序。

在本文中，我将深入探讨Node.js在谷歌云无服务器计算中的重要性，详细介绍部署无服务器Node.js函数的顺序过程。

## 了解Node.js在谷歌云无服务器计算中的作用

Node.js以其快速和高效而闻名，与无服务器计算完美地配合在一起。其事件驱动、非阻塞的架构与无服务器范式完美契合，使其成为开发人员中备受青睐的选择。与谷歌云函数结合时，[Node.js](https://dzone.com/refcardz/nodejs)为开发人员提供了创建流畅、模块化和轻松部署的函数的能力。

谷歌云函数充当无服务器执行环境，使开发人员能够执行专门的函数，无需进行服务器的预配或管理。这个事件驱动的无服务器计算平台旨在根据需求自动扩展，确保最佳性能和成本效益。

## **在谷歌云上实现无服务器Node.js函数的步骤**

### **1. 设置谷歌云项目**

在深入研究无服务器函数之前，请确保您拥有谷歌云账户并创建一个新项目。激活Cloud Functions API并在本地机器上安装谷歌云SDK。

```markdown
# 安装谷歌云SDK

curl https://sdk.cloud.google.com | bash



# 与谷歌云进行身份验证

gcloud auth login



# 设置默认项目

gcloud config set project <your-project-id>
```

### **2. 安装Node.js和npm**

确保您的计算机上安装了Node.js和npm。谷歌云函数支持Node.js 10、12、14和更高版本。

```markdown
# 安装Node.js和npm（以Node.js 14为例）

curl -sL https://deb.nodesource.com/setup_14.x | sudo -E bash -

sudo apt-get install -y nodejs
```

### **3. 创建一个简单的Node.js函数**

为您的项目创建一个新目录并进入其中。在其中，创建一个名为index.js的文件，用于您的Node.js函数。

```javascript
// index.js

exports.myFunction = (event, context) => {

  console.log("Hello, Serverless World!");

  // 其他逻辑在这里

};
```

### **4. 将函数部署到谷歌云**

使用以下命令将您的函数部署到谷歌云。

```markdown
# 部署函数

gcloud functions deploy myFunction \

  --runtime nodejs14 \

  --trigger-http
```

### **5. 触发函数**

部署后，您可以通过HTTP请求触发函数。从部署输出中获取提供的URL，并使用cURL或Postman等工具发出请求。

```markdown
# 使用cURL触发函数

curl <your-function-url>
```

## 总结

在谷歌云平台上实现无服务器Node.js函数为开发人员提供了一种流畅、可扩展和成本效益的构建应用程序的方法。Node.js与谷歌云函数之间的协同作用促进了个别函数的流畅开发和部署，动态响应事件并优化资源使用。

通过遵循本指南中概述的步骤，您可以开始涉足无服务器计算，利用Node.js和谷歌云的潜力建立多才多艺、响应灵活的应用架构。随着深入研究，您将发现更多丰富谷歌云无服务器计算功能和集成，使您能够构建强大而富有创意的解决方案。


本指南将展示在使用Google Cloud时node.js的作用，以及使用Google Cloud进行无服务器node.js实现的步骤。

使用Google Cloud的Serverless Node.js函数指南

文章深入探讨了每种框架的优缺点，有助于理解在何种情况下使用Flutter或React Native更为合适。

Flutter 与 React Native 开发对比及性能检测

构建一个与RDS数据库通信的REST API对于许多开发人员来说是一项基本任务，使应用程序能够通过互联网与数据库进行交互。本文将指导您完成创建一个与Amazon关系型数据库服务（RDS）实例通信的RESTful API的过程，并附有示例。我们将使用一个流行的框架和编程语言进行演示：[Node.js](https://dzone.com/refcardz/nodejs)和Express，因为它们被广泛应用并支持构建Web服务。

## 先决条件

在开始之前，请确保您具备以下条件：

- AWS账户和已设置的RDS实例：在本示例中，假设我们使用的是[MySQL](https://dzone.com/refcardz/essential-mysql)数据库，但对于RDS支持的其他数据库引擎，方法类似。
- 在开发机器上安装了Node.js和npm（Node包管理器）
- 对[JavaScript](https://dzone.com/refcardz/object-oriented-javascript)和SQL有基本的了解

## 步骤1：设置项目

首先，为您的项目创建一个新目录并初始化一个新的Node.js应用程序：

```powershell
mkdir my-api

cd my-api

npm init -y
```

安装Express和MySQL数据库连接器：

```powershell
npm install express mysql
```

## 步骤2：创建数据库连接

在项目目录中创建一个名为**database.js** 的新文件。该文件将建立与您的RDS数据库的连接。请用您实际的RDS实例详细信息替换占位符：

```javascript
const mysql = require('mysql');

const pool = mysql.createPool({
  connectionLimit: 10,
  host: '<RDS_HOST>',
  user: '<RDS_USERNAME>',
  password: '<RDS_PASSWORD>',
  database: '<RDS_DATABASE>'
});

module.exports = pool;
```

使用连接池是推荐的，可以有效地管理多个并发数据库连接。

## 步骤3：构建REST API

创建一个名为**app.js** 的新文件。该文件将定义您的API端点以及它们如何与RDS数据库交互。

```javascript
const express = require('express');
const pool = require('./database');
const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.json());

// 用于获取所有项目的端点
app.get('/items', (req, res) => {
  pool.query('SELECT * FROM items', (error, results) => {
    if (error) throw error;
    res.status(200).json(results);
  });
});

// 用于添加新项目的端点
app.post('/items', (req, res) => {
  const { name, description } = req.body;
  pool.query('INSERT INTO items (name, description) VALUES (?, ?)', [name, description], (error, results) => {
    if (error) throw error;
    res.status(201).send(`Item added with ID: ${results.insertId}`);
  });
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});
```

在这个示例中，我们创建了两个端点：一个用于从`items`表中检索所有项目，另一个用于向表中添加新项目。请确保您的RDS数据库中有一个`items`表，至少包含`name`和`description`列。

## **步骤4：运行您的API**

要启动您的API，请在项目目录中运行以下命令：

```powershell
node app.js
```

您的API现在正在运行，并且可以与您的RDS数据库进行交互。您可以使用Postman或cURL等工具测试端点。

## **测试API**

要测试从数据库检索项目，请使用：

```powershell
curl http://localhost:3000/items
```

要测试添加新项目，请使用：

```powershell
curl -X POST http://localhost:3000/items -H "Content-Type: application/json" -d '{"name": "NewItem", "description": "This is a new item."}'
```

## 结论

您现在已经设置了一个基本的REST API，可以与AWS RDS数据库通信。这个设置是可扩展的，可以通过更复杂的查询、额外的端点和更复杂的数据库操作进行扩展。请记住在部署应用程序到生产环境时，确保保护好您的API和数据库连接。有了这些基础，您就可以有效地将AWS RDS数据库集成到您的Web应用程序中。


本指南详细介绍了创建一个与Amazon关系型数据库服务（RDS）实例通信的RESTful API的过程，包括示例。

使用Nodejs构建并整合REST APIs与AWS RDS数据库

Electron是一个使用HTML、CSS和JavaScript等Web技术构建厚客户端应用程序的框架。Electron提供了灵活性，可以维护一个JavaScript代码库来创建支持Windows、macOS和Linux的跨平台应用程序。基本上，您只需编写一次代码，就可以在各个平台上运行。

JavaScript几乎可以很好地满足应用程序中几乎所有所需的功能，但当需要与特定操作系统的本机API进行交互时，问题就会出现。在使用基于Electron的浏览器时，我遇到了这样的问题。有一个特定的需求，需要在Mac上特定时间间隔（几秒钟）内找到打开的应用程序窗口列表。Node或JavaScript没有提供任何接口来从操作系统层访问这些信息，因此我不得不想出一个自定义解决方案。

## **初始解决方案**

最初，我通过编写[OSAScript](https://ss64.com/osx/osascript.html)来解决这个问题。OSAScript能够提供Mac上打开窗口的列表，但在测试过程中我们发现的主要问题是CPU使用率。由于OSAScript在间隔期间运行，导致CPU使用率飙升了40%至50%，因此这个解决方案是不可接受的。

## **接下来呢？**

在搜索后，我偶然发现了各种解决方案，比如：

1. **使用[Python Cocoa库](https://pypi.org/project/PyCocoa/)（PyCocoa）：**  这提供了Python和Cocoa之间的接口，可以在JavaScript中使用。
2. **JsCocoa库：**  我尝试集成了它，但没有成功。
3. **自定义Flask服务器：**  有一些帖子建议在浏览器中运行自定义Flask服务器，并从JavaScript中使用API。

所有这些方法要么太麻烦，要么会导致更高的延迟和增加的应用程序大小。

## **解决方案**

**使用SWIFT和`child_process.exec()`:**  最后，我决定使用Cocoa编写一个本机SWIFT脚本来识别进程窗口，并使用Xcode Playground进行测试。SWIFT脚本将输出一个JSON，可以轻松地进行消耗和解析。测试完成后，我将其编译为可执行文件，使用以下命令：

```swift
swiftc sample.swift -o sample
```

这为我提供了一个可执行文件`sample`，可以使用`./sample`来执行，并输出JSON。

接下来的步骤是将其打包到Electron中，并在`child_process.exec()`方法中使用。为了打包，我将此文件放在一个文件夹中，假设为`executable`，并更新了复制脚本以在打包代码时包含此文件的内容。一旦可执行文件存在于捆绑包中，我将可执行文件路径提供给`[child_process.exec()](https://nodejs.org/api/child_process.html#child_processexeccommand-options-callback)`命令。使用此命令的回调，我成功地能够检索SWIFT输出的JSON，以便在Electron应用程序中做出决定。

## **结果**

这导致CPU开销由OSAScript引入的几乎40%降低到了几乎0%。

## **结论**

1. 为Mac等特定操作系统创建类似SWIFT的二进制文件
2. 将此可执行文件打包到您的Electron应用程序中
3. 使用`child_process`命令来执行打包的二进制可执行文件
4. 在您的Electron应用程序中使用响应来做出决定！


Electron 提供了灵活性，可以维护一个 JavaScript 代码库来创建支持 Windows、macOS 和 Linux 的跨平台应用程序。

如何在Electron浏览器中本地使用Swift脚本

便携文档格式（PDF）是一种文件格式，包含了文档的全面表示，包括文本、字体、图形和其他组件。由于其固有的安全功能，PDF通常被认为是一种安全的文档格式。这些功能使得文件能够加入密码保护、加密和数字签名。

PDF安全对于多种原因都很重要。信息经常在互联网上共享，确保在这种交换过程中敏感数据的隐私和完整性至关重要。无论PDF文件包含法律合同、机密商业报告还是个人信息，适当的PDF安全性可以确保只有授权人员可以访问或修改这些文件的内容。PDF安全不仅可以保护知识产权，还可以帮助您遵守法律和监管要求。这使得它成为当今互联世界中不可或缺的工具。

在本文中，您将通过探索可能影响PDF文件的常见安全威胁，并深入了解各种编程技术来保护PDF文件，了解有关PDF的基本安全措施。

## 可能影响PDF文件的常见安全威胁

以下部分讨论了可能影响PDF文件的一些最常见的安全威胁，探讨了攻击者如何利用风险和机制进行攻击。了解这些威胁是实施强大安全措施的第一步，以保护PDF内容。

### 恶意JavaScript

嵌入在PDF文件中的恶意[JavaScript](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/First_steps/What_is_JavaScript)是一个经常被忽视的主要安全问题。一方面，PDF中的JavaScript可以用于合法目的，如创建交互式表单或增强文档功能。另一方面，PDF中的JavaScript可能会被网络犯罪分子利用。

当黑客将恶意JavaScript代码插入PDF中时，威胁就出现了。当用户打开被感染的PDF文件时，恶意JavaScript代码可以自动执行。这可能导致各种有害活动，包括：

- **窃取个人信息** ：恶意代码可以用于从打开PDF文件的用户计算机中提取个人或敏感信息。这些敏感信息可能包括登录凭据、信用卡号码或个人身份信息。
- **安装恶意软件** ：恶意JavaScript可以触发下载和安装恶意软件、间谍软件或勒索软件到用户的系统，从而导致进一步的利用。
- **控制计算机** ：在某些情况下，代码甚至可能授予用户系统的远程访问权限，使黑客可以完全控制计算机。这可能包括访问文件、监视活动，甚至利用计算机进行其他网络犯罪活动。

### 钓鱼攻击

PDF也可以用于[钓鱼攻击](https://www.imperva.com/learn/application-security/phishing-attack-scam/)。黑客可以创建外观与合法发票或银行对账单非常相似的PDF文件。这样，网络犯罪分子可以利用人们普遍对PDF的信任，诱使毫无戒心的用户打开这些看似无害的文件。PDF中可能嵌入了链接，将用户重定向到专门设计的仿真真实网站的欺诈性网站。这些仿真网站随后会提示用户输入诸如登录凭据或财务详情等敏感信息。黑客可以收集这些信息，用于身份盗窃或金融欺诈等恶意目的。

### 嵌入对象

PDF文件中的嵌入对象可以包括图像或视频。一方面，这些对象提供了内容展示的多样性，但另一方面，它们也为安全漏洞引入了潜在途径。网络犯罪分子可以偷偷地在这些对象中植入恶意软件。当用户打开包含这些受损对象的PDF文件时，嵌入的恶意软件可能会默默执行，导致各种网络安全问题。这些问题包括未经授权访问个人数据到对受害者计算机系统的完全控制。因此，看似无害的打开PDF文件的行为可能成为严重的安全问题。隐藏在这些嵌入对象中的恶意软件的检测和防御的复杂性使得这是一个特别令人担忧的威胁。

### 文档元数据利用

PDF文件中元数据的利用经常被忽视，但却是一个值得关注的安全问题。PDF文件中的元数据包括作者姓名、创建日期和修订历史等详细信息。乍一看，这些信息可能看似无害。然而，网络犯罪分子可以利用这些信息收集有关个人或组织的情报。

通过分析这些元数据，他们可以发现模式、关系和潜在的漏洞。例如，了解用于创建或修改文档的软件版本可能会导致他们发现可以利用的未修补的安全漏洞。特别是在企业环境中，包含作者姓名和文档历史等信息的元数据可能会揭示可用于更有针对性的利用或网络攻击的内部结构、角色和流程。

### 嵌入脚本

虽然PDF中的嵌入链接可能是一个安全问题，如钓鱼部分所述，但嵌入脚本也代表着可能让用户措手不及的高级威胁。与简单的链接不同，这些嵌入脚本可以在用户打开PDF时直接在用户的计算机上执行代码。这可能导致一系列恶意活动，包括：

- **未经授权的文件访问** ：脚本可以设计为在用户不知情的情况下访问用户计算机上的文件。这可能导致数据窃取。
- **键盘记录** ：恶意脚本可以启动键盘记录活动，捕获密码和信用卡号等敏感信息。
- **远程控制** ：在极端情况下，脚本甚至可以启用对计算机的远程控制。这可以为网络犯罪分子提供对系统的无限制访问。
- **利用漏洞** ：脚本可以利用PDF阅读器软件或操作系统中已知或零日漏洞，导致系统进一步受损。
- **勒索软件** ：恶意代码可以加密用户计算机上的文件，并要求用户支付赎金以释放文件。

### 密码破解

当PDF文件受到密码保护时，它增加了一层安全防护，以防止未经授权的访问。然而，如果所选密码较弱、容易猜测或遵循常见模式，它可能容易被攻击者破解。不同的工具和技术，包括暴力破解或字典攻击，可以用于猜测或破解密码。一旦密码被破解，攻击者就可以未经授权地访问PDF文件。这可能会暴露文档中包含的敏感信息、知识产权或个人数据。

## 如何通过编程方式保护PDF文件

### 启用安全密码保护

安全密码保护是PDF安全的重要方面。它作为防止未经授权访问的第一道防线。然而，这种安全措施的有效性取决于其正确实施。例如，Adobe在其PDF软件的第8版中使用了AES-128加密，而在第9版中转换为了AES-256。具有讽刺意味的是，[Adobe后来宣布第9版实际上比第8版更不安全](http://lukenotricks.blogspot.ie/2008/12/spin-on-passwords-and-aes.html)，对于暴力破解攻击来说。问题并不在于AES加密本身，AES是一种强大的加密标准，而是在于它的实施方式。这里的教训是，即使像AES这样的强加密算法也只有在正确实施时才能发挥作用。

### 设置正确的权限

设置正确的权限是保护PDF文件的重要步骤。默认权限通常会赋予用户对PDF文件的广泛控制权。通过仔细配置这些权限，PDF作者可以限制其他用户对文档的操作。这可以包括阻止打印、复制、编辑或从PDF中提取内容。将权限减少到用户所需的内容，显著限制了对文档的恶意利用或意外处理的潜力。

您应该审查并调整每个PDF文件的权限，而不是依赖于广泛的默认设置。您的审查应考虑文档内部内容的敏感性。此外，必须考虑所需的特定用户操作。应避免依赖广泛的默认设置，因为它们可能无法为文件的特定内容和用途提供足够的保护。

### 使用数字签名

[数字签名](https://kb.foxit.com/hc/en-us/articles/4412321902740-Electronic-Signatures-vs-Digital-Signatures-What-s-the-Difference-)是保护PDF文件的有效方法。数字签名提供了一个加密印章，验证了作者的身份，并确认文档自签名以来未被更改。通过使用数字签名，用户可以防止未经授权对文档的修改，并向接收者保证内容来自经过验证的来源。这个过程涉及创建一个唯一的数字ID，通常与受信任的证书颁发机构相关联，然后将此签名应用到PDF文件上。对文档的任何后续更改都将使签名无效。这将清楚地表明PDF文件被篡改。

### 添加水印以指示状态和所有权

向PDF文件添加[水印](https://www.mediavalet.com/blog/watermarks-are-important/)是指示PDF状态和所有权的战略方法，可以进一步增强文档的安全性。水印可以是自定义文本或图像，叠加在页面上。水印通常显示公司名称、标志或类似“机密”等声明。

水印基本上充当了一个视觉威慑，防止未经授权的复制或分发PDF，因为它明确将文档与特定所有者关联起来。此外，它可以提供有关文档状态的上下文信息，例如它是草稿还是最终版本。在PDF中包含水印不仅可以更好地控制文档，同时也能够阻止滥用。

### 使用PDF库进行内容消除

PDF文件中的内容消除是指永久删除或模糊敏感信息的过程。简单地使用视觉PDF编辑器在PDF文件中重叠内容并不安全。这种方法可能会在视觉上隐藏信息，但可以使底层数据保持完整并且可以被懂得提取的人访问。因此，建议您使用专门设计用于处理安全删除敏感内容的PDF库。这些库提供了程序化的方法来消除内容，确保信息被完全删除且无法检索。
原文输出


学习PDF文件的基本安全措施。探索影响PDF文件的常见安全威胁，并深入研究以编程方式保护PDF的各种技术。

PDF文档的基本安全措施

教孩子编程不仅仅是关于技术或计算机，它更是关于释放他们的潜力并灌输一些最关键的生活技能，帮助他们在不断发展的技术世界中生存。在本文中，我们将了解教授编程对孩子的重要性，以及列出一些可以在孩子早期学习的最佳编程语言。

## 为什么要教孩子编程？

在21世纪，编程已经成为最关键的技能之一。它不再被视为专业人士或专家的技能。以下是教孩子编程可能带来的一些主要优势：

- **逻辑思维：** 编程不仅涉及解决问题或开发想法，还鼓励质疑、假设和列出逐步行动计划。它促进了逻辑思维过程，以处理任何情况或挑战。
- **创造力：** 编程为孩子提供了一个通过数字平台探索和表达想象和想法的机会。孩子们可以在解决问题或构建游戏时自由选择任何功能和无限的可能性。
- **问题解决：** 编程通常要求孩子们分解复杂问题或项目，分析它们，找到可能的解决方案并实施。这使孩子们成为寻找最佳解决方案的系统化思考者。
- **未来保障：** 编程技能无疑为许多令人兴奋的职业机会打开了大门。从开发人员到数据科学家，分析师到网络安全专家，机器学习到人工智能，职场机会无穷无尽。

## 最适合孩子的编程语言

今天有数百种编程语言可供选择，选择最佳编程语言可能是一项具有挑战性的任务。以下是2024年推荐给孩子学习的4种顶尖编程语言的列表。

### 1. JavaScript（脚本编程语言）

[JavaScript](https://dzone.com/javascript) 是最常用的编程语言之一。

- **交互性：** JavaScript使网页和应用程序的交互成为可能。它允许用户采取实时行动，并通过创建动画、按钮等增强功能，提供用户友好的体验。
- **现实应用：** JavaScript具有广泛的现实应用，大多数网站和应用程序都在使用，包括[Facebook](https://en.wikipedia.org/wiki/Meta_Platforms)、Google Maps和Gmail。
- **易于入门：** JavaScript没有难以理解的语法和专门的平台来掌握。孩子们甚至可以从一个简单的文本编辑器开始，用相对简单的代码行开发令人兴奋的项目。

### 2. Python编程语言

Python是当今最受欢迎的编程语言之一。它是一种高级且多才多艺的语言，用于Web开发、数据分析、机器学习、自动化等。

- **清晰易读：** 使用Python的主要优势在于它没有复杂的语法。语法非常易于阅读和书写，大大减少了编码错误，并使其成为初学者核心编程语言的理想选择。
- **教育资源：** Python是一种开源语言，拥有自己的社区。它还有一个庞大的库和足够的资源可供使用，无论是教程、指南还是示例项目，都可以让新学习者创建、解决疑惑并获得开始的想法。
- **问题解决：** 与任何其他编程语言一样，Python使解决或开发各种令人兴奋的项目变得轻而易举。

### 3. CSS（层叠样式表）

CSS代表层叠样式表。它是一种包含有关网页布局、颜色、字体和视觉呈现的样式表：

- CSS负责使网页对用户具有吸引力和吸引力。它允许设计师尝试并实验网页的不同美学。
- CSS为孩子们提供了一个绝佳的机会，通过开发配色方案、动画和更具吸引力的用户界面来探索他们的创造力。
- CSS负责使网页内容能够适应不同的屏幕尺寸和设备，而不会影响质量和用户体验。

### 4. HTML（超文本标记语言）

HTML代表超文本标记语言。它是一种非常易于学习和使用的轻量级编码语言。

- **结构：** 它负责在网页上结构化和组织各种内容或元素，例如标题、标题、段落、正文、表格等。
- **语义：** HTML使用标签来识别或标记网页上的内容。这些标签帮助搜索引擎理解内容并使其对用户可访问。

例如：

```html
<header>, <nav>, <article>, <footer>
```

**集成：** HTML允许在网页上轻松地整合各种功能或组件。这基本上是网页的支撑，例如CSS、小部件、CMS等。

上述提到的顶尖编程语言经过精心挑选，掌握它们将使孩子们接触到广泛的编程领域。这是因为该列表包括有助于开发完全可工作的网站或应用程序的语言，包括设计、演示、功能和可访问性。此外，这些语言对初学者非常友好，使它们成为新手的绝佳选择。


在这篇文章中，我们将发现教授孩子们编程的重要性，并列出一些可以在早期介绍的最佳编程语言。

儿童最佳编程语言

在这篇文章中，我将逐步演示如何使用Typescript和OceanBase作为数据库来构建一个无头CMS。

使用OceanBase和TypeScript创建无头CMS

JSON对象是什么？

JSON代表JavaScript对象表示法，是一种基于JavaScript对象语法的结构化数据的标准文本格式。JSON仅定义了两种数据结构：对象和数组。JSON对象是由花括号括起来的键/值对组成的数据类型。JSON数组是值的列表。当数据从服务器发送到网页或数据存储在文件或数据库中时，通常会使用JSON对象。JSON与JavaScript对象文字语法非常相似，但可以独立于JavaScript使用。许多编程环境支持读取和生成JSON。

JSON对象的特点

- 它们以逗号分隔的键/值对形式编写。键是用双引号括起来的字符串，值必须是以下JSON数据类型
  - 字符串
  - 数字
  - 对象
  - 数组
  - 布尔值
  - 空值
- 它们由花括号{}括起来。花括号也可以用于在对象内部嵌套对象，从而创建分层结构。
- 数组用方括号\[\]括起来，它们的值用逗号(,)分隔。数组中的每个值可以是不同类型，包括另一个数组或对象。
- 它们区分大小写，这意味着键和值在拼写和大小写上必须完全匹配。
- 它们不允许尾随逗号。简单来说，花括号外部或双引号内部不应有任何不属于键/值对的文本。
- 它们不允许注释。

JSON提供了几个优点，使其成为表示结构化数据的流行选择：

- 简单易读：JSON简单直观，易于理解。与XML等更冗长的格式不同，JSON相对容易阅读。其简洁的语法允许高效的数据表示。
- 解析简便：JSON比XML更简单、更快速。
- 灵活性：JSON支持各种数据类型和对象层次结构，并且关系可以在传输过程中保持并在接收端适当地重新组装。
- 广泛应用：大多数现代API接受JSON请求并发出JSON响应，使其成为系统之间数据交换的通用格式。

JSON对象示例

|  |
| --- |
| 基本JSON对象：`{"name": "Natalie", "married": false, "age": 21, "city": "New York", "zip" : "10001", "awards": null}` |
| 嵌套JSON对象：这是一种由名称/值对列表组成的数据类型，其中一个或多个值是另一个JSON对象。`{"person": {"name": "Natalie", "age": 21}, "address": {"street": "123 XYZ Street", "City": "New York", "State" : "NY", "zip": "10001"}}` |
| JSON对象数组：`[ { "name": "Natalie", "age": 21 }, { "name": "David", "age": 37 }, { "name": "Mark", "age": 43 } ]` |

解析JSON对象

解析是将JSON对象转换为本机JavaScript对象的方法。

`JSON.parse()`方法：`JSON.parse()`方法解析字符串并返回一个JavaScript对象。字符串必须是JSON格式。

语法：`JSON.parse(string, function)`

| 参数 | 必需/可选 | 描述 |
| --- | --- | --- |
| 字符串 | 必需 | 以JSON格式编写的字符串 |
| Reviver函数 | 可选 | 一个接受键和值作为参数并返回修改后的值或undefined以删除属性的函数。对每个项目调用该函数。任何嵌套对象在父对象之前转换。 |

示例

```json
var text = '{"name": "Natalie", "married": false, "age": 21, "city": "New York", "zip" : "10001", "awards": null}';
var obj = JSON.parse(text, function (key, value) {
     if (key === "name") {
       return value.toUpperCase();
     } else {
       return value;
     }
});
console.log(obj);
```

输出

```json
{
     name: 'NATALIE',
     married: false,
     age: 21,
     city: 'New York',
     zip: '10001',
     awards: null
}
```

`JSON.stringify()`方法

该方法将JavaScript对象转换为字符串。在将数据发送到Web服务器时，数据必须是字符串。`JSON.stringify()`也适用于数组。

语法：`JSON.stringify(obj, replacer, space)`

| 参数 | 必需/可选 | 描述 |
| --- | --- | --- |
| Obj | 必需 | 要转换为字符串的值 |
| Replacer | 可选 | 用于转换结果的函数或数组。对每个项目调用replacer。 |
| Space | 可选 | 用作空格的字符串（最多10个字符）或数字，从0到10，表示要用作空格的空格字符数。 |

示例

```json
var obj = {"name": "Natalie", "married": false, "age": 21, "city": "New York", "zip" : "10001", "awards": null};
var text = JSON.stringify(obj, function (key, value) {
     if (key === "name") {
       return value.toUpperCase();
     } else {
       return value;
     }
});
console.log(text);
```

输出

`{"name":"NATALIE","married":false,"age":21,"city":"New York","zip":"10001","awards":null}`

```json
/*为每个空格插入单词SPACE：*/
var newText = JSON.stringify(obj, null, "space");
console.log(“Text with the word space “+ newText);
```

输出

```json
Text with the word space {
space"name": "Natalie",
space"married": false,
space"age": 21,
space"city": "New York",
space"zip": "10001",
space"awards": null
}
```

JSON对象导航

可以使用点(.)或方括号(\[\])表示法导航到其属性并访问它们的值。

```json
// 使用点表示法访问名称
var obj = {"name": "Natalie", "married": false, "age": 21, "city": "New York", "zip" : "10001", "awards": null};
console.log(obj.name);                      输出：Natalie
```

```json
// 使用点表示法访问城市
console.log(obj["city"];                      输出：New York
```

```json
var obj_array = [ { "name": "Natalie", "age": 21 }, { "name": "David", "age": 37 }, { "name": "Mark", "age": 43 } ]
```

```json
// 使用点和方括号表示法访问第一个成员的名称
console.log(obj_array[0].name);       输出：Natalie
```

```json
// 使用点和方括号表示法访问第二个成员的年龄
console.log(obj_array[1][ "age"]);     输出：37
```

`Object.keys()`方法

`keys()`方法返回给定对象的自身可枚举字符串键属性的数组。作为静态方法的`keys()`方法使用Object类名调用。

语法：`Object.keys(obj)`

| 参数 | 必需/可选 | 描述 |
| --- | --- | --- |
| obj | 必需 | 要返回其可枚举属性的对象 |

`Object.values()`方法

`values()`方法返回给定对象的自身可枚举字符串键属性值的数组。作为静态方法的`values()`方法使用Object类名调用。

语法：`Object.values(obj)`

| 参数 | 必需/可选 | 描述 |
| --- | --- | --- |
| obj | 必需 | 要返回其可枚举属性的对象 |

`Object.entries()`方法

该方法返回对象的可枚举属性的键值对数组。作为静态方法的`entries()`方法使用Object类名调用。

语法：`Object.entries(obj)`

| 参数 | 必需/可选 | 描述 |
| --- | --- | --- |
| obj | 必需 | 要返回其可枚举属性的对象 |

示例

```json
var obj = {"name": "Natalie", "married": false, "age": 21, "city": "New York", "zip" : "10001", "awards": null};
var keys = Object.keys(obj);
var values = Object.values(obj);
var entries = Object.entries(obj);
console.log("Array of keys :");
console.log(keys);
console.log("Array of values :");
console.log(values);
console.log("Array of entries :");
console.log(entries);
```

输出

```json
Array of keys :
[ 'name', 'married', 'age', 'city', 'zip', 'awards' ]
Array of values :
[ 'Natalie', false, 21, 'New York', '10001', null ]
Array of entries :
[
     [ 'name', 'Natalie' ],
     [ 'married', false ],
     [ 'age', 21 ],
     [ 'city', 'New York' ],
     [ 'zip', '10001' ],
     [ 'awards', null ]
]
```

`for`循环

`for`循环重复执行，直到指定的条件评估为false。

语法：`for (初始化; 条件; 表达式) {要执行的代码块}`

| 参数 | 必需/可选 | 描述 |
| --- | --- | --- |
| 初始化 | 必需 | 在执行代码块之前执行一次 |
| 条件 | 必需 | 执行代码块的条件 |
| 表达式 | 必需 | 在执行代码块后每次执行 |

示例

```json
var obj = [ { "name": "Natalie", "age": 21, "married": true }, { "name": "David", "age": 37, "married": false }, { "name": "Mark", "age": 43, "married": true } ];
for(var i=0; i<obj.length; i++) {
           console.log("Name:  " + obj[i]["name"]); //使用方括号表示法
           console.log("Married Status:     " + obj[i].married); //使用点表示法
}
```

输出

```json
输出
Name:     Natalie
Married Status:  true
Name:     David
Married Status:  false
Name:     Mark
Married Status:  true
```

`for…in`循环

`for...in`语句遍历对象的所有可枚举字符串非符号属性，包括继承的可枚举属性。循环内的代码块对每个属性执行一次。

语法：`for (item in object) {要执行的代码块}`

| 参数 | 必需/可选 | 描述 |
| --- | --- | --- |
| item | 必需 | 用于遍历属性的变量 |
| object | 必需 | 要遍历的对象 |

示例

```json
var obj = [ { "name": "Natalie", "age": 21, "married": true }, { "name": "David", "age": 37, "married": false }, { "name": "Mark", "age": 43, "married": true } ];
for(item in obj) {
           console.log("Name:  " + obj[item]["name"]); //使用方括号表示法
           console.log("Married Status:     " + obj[item].married); //使用点表示法
}
```

输出

```json
Name:     Natalie
Married Status:  true
Name:     David
Married Status:  false
Name:     Mark
Married Status:  true
```

`for…of`循环

`for..of`循环按顺序操作来自可迭代对象的值。

语法：`array.forEach(iterable object中的变量) {语句}`

| 参数 | 必需/可选 | 描述 |
| --- | --- | --- |
| 变量 | 必需 | 对于每次迭代，下一个属性的值被赋给变量。变量可以使用const、let或var声明。 |
| 可迭代对象 | 必需 | 循环操作的值的来源。 |

Name:     Natalie
Married Status:  true
Name:     David
Married Status:  false
Name:     Mark
Married Status:  true

````

## `forEach()`**方法** 

`forEach()`方法对数组中的每个元素调用一个函数。它必须至少接受一个参数，该参数表示数组的元素。

*语法:*`array.forEach(function(currentValue, index, array), thisValue)`

|  |  |  |
| --- | --- | --- |
| **参数**  | **必需/可选**  | **描述**  |
| Function  | 必需 | 用于对数组每个元素运行的函数 |
| currentvalue | 必需 | 当前元素的值 |
| index | 可选 | 当前元素的索引 |
| Array | 可选 | 当前元素的数组 |
| Thisvalue | 可选 | 作为this值传递给函数的值。默认为undefined。 |

### 示例

```json
var obj = [ { "name": "Natalie", "age": 21, "married": true }, { "name": "David", "age": 37, "married": false }, { "name": "Mark", "age": 43, "married": true } ];
obj.forEach((item, index, arr) => {
       console.log("元素详情:     " +index);
       console.log("姓名:      "+arr[index]["name"]);
       console.log("年龄:      "+item.age);
});
````

### 输出

```json
元素详情:  0
姓名:      Natalie
年龄:      21
元素详情:  1
姓名:      David
年龄:      37
元素详情:  2
姓名:      Mark
年龄:      43
```

## **结论**

JSON通常用于服务器和Web应用程序之间传输数据。JSON的灵活性、易解析性和简单性使软件开发人员能够在各种编程环境中高效地处理结构化数据。


本教程涵盖了在JavaScript中使用JSON对象所需了解的所有内容。它包括创建、解析和操作JSON数据等主题。

JavaScript中如何正确处理JSON

SELECT '随着越来越多的开发人员采用TypeScript，我精心挑选了一些**你应该在下一个项目中使用TypeScript的原因** 。尽管它在早期遇到了一些阻力，但在过去的十年里，它迅速成为了一种广泛使用的编程语言。' AS translation
`npm install –save-dev TypeScript`

### 如何卸载 TypeScript

要卸载它，你可以使用与安装相同的命令。只需将 install 替换为 uninstall，如下所示：

`npm uninstall –global TypeScript`

![如何卸载 TypeScript: npm uninstall --global TypeScript](https://cdn.iokks.com/art/8da54f8afa2f/93d0bcd3805d425d9d9c967519e8aa60.png "如何卸载 TypeScript")

## 如何使用 TypeScript

安装完成后，就可以开始使用了。你需要一个像 Visual Code Studio 这样的代码编辑器。如果你没有它，你需要下载并安装 VS Code。安装完成后，下面是如何使用 TypeScript：

**步骤 1：** 让我们创建一个简单的 Hello World 项目。这将帮助你了解如何使用 TypeScript。

**步骤 2：** 在安装完成后运行以下命令以创建一个项目目录：

`mkdir HelloWorld`

然后进入新目录：

`cd HelloWorld`

**步骤 3：** 启动 Visual Studio Code（或你喜欢的代码编辑器）。我们将在这里使用 VS Code。

**步骤 4：** 导航到文件资源管理器并创建一个名为 helloworld.ts 的新文件。文件名并不重要；你可以随意命名。但是，重要的是这些文件以 .ts 扩展名结尾。

![](https://cdn.iokks.com/art/8da54f8afa2f/fae123dd3faa44389877a1f96e68d05b.png)

**步骤 5：** 接下来，添加以下 TypeScript 代码。

`let message: string = ‘Hello, World!’; console.log(message);`

你会注意到关键字 let 和字符串类型声明。

**步骤 6：** 要编译 TypeScript 代码，只需打开集成终端（Ctrl+\`）并输入：

`tsc helloworld.ts`

![这将编译并创建一个新的 helloworld.js JavaScript 文件。](https://cdn.iokks.com/art/8da54f8afa2f/67a6d516a865493793e62cabaae2b690.png)

这将编译并创建一个新的 helloworld.js JavaScript 文件。

当你打开 helloworld.js 时，你会发现它看起来与 helloworld.ts 并没有太大的不同。你会看到类型信息现在已被移除，let 已被替换为 var。

## 结论

最终，使用 TypeScript 将取决于你的项目以及所需的时间和精力。你的团队需要评估实施的优势和劣势。因此，使用 TypeScript 将立即显现出来，从更好的代码补全到错误预防，它将使你的团队在编写代码时更加轻松。


TypeScript的主要目的是在开发复杂应用程序时提高生产力，它将使你的团队在编写代码时的工作变得更加轻松。

为什么要在你的项目中使用TypeScript？

你做到了！当然，也许已经晚了四周，而且是在周五晚上，但你终于完成了长期期待的网页应用程序的更新部署。然而，你的庆祝活动被打断了，因为你的手机在桌子上不停地震动。拿起手机，你面对着开发者的噩梦。你接到了大量消息，说登录不再起作用了。难道是你的部署出了问题吗？这太糟糕了。如果用户无法登录，那么就无法使用网站。

你匆匆回到电脑前，手颤抖着输入密码。你导航到生产网站，点击“登录”按钮，然后在控制台中看到以下错误：

![](https://cdn.iokks.com/art/77df86052a69/230de989435f4366a3a696d7ddbaea91.png) 你茫然地盯着它。`main.d1589c82.js`？这个文件在代码库中根本不存在。而且错误出现在第2行？第2行几乎总是一个导入语句。这是怎么回事？为什么它告诉你错误发生在一个不存在的文件中？这肯定是个错误……

为了解决这个谜团，理解源映射的威力，我们需要回到很久以前，一直回到数字革命的开始。

## 让编程成为可能的魔法

没有人能怀疑计算机在根本改变世界方面所起的作用。实际上，从儿童玩具到烤面包机，几乎所有东西都由某种形式的计算机驱动。然而，也许会让人感到惊讶的是，计算机是愚蠢的。事实上，非常愚蠢。它们需要被准确地告知该做什么以及何时做。此外，它们只能看到一和零，并且只能进行基本的数学运算。这与我们作为人类的思维和操作方式相去甚远。如果每个程序都必须用二进制编写，数字革命很可能永远不会发生。

这就是为什么几乎在第一台计算机被发明的同时，第一批[编程语言](https://raygun.com/blog/programming-languages/)也被发明出来。这些语言允许程序员以更符合人类习惯和理解的格式编写代码，然后再由[编译器](https://en.wikipedia.org/wiki/Compiler)将其转换为机器码（一种对一和零的花哨称呼）。这就是所谓的抽象，它使现代通用计算机成为可能。

随着时间的推移，编程语言变得越来越抽象，以使软件工程师的工作变得更加容易。许多语言甚至不直接编译为机器码；它们将另一种语言视为机器码，并编译为该语言。更高级的方法是创建两种编程语言：第一种是供程序员交互使用的友好可读语言，然后将其编译为第二种不太可读的语言，以便计算机更容易地进行优化速度或内存使用等操作。然后，这种语言最终被编译为机器码。这种第二种语言被称为[中间表示](https://en.wikipedia.org/wiki/Intermediate_representation)。

这就把我们带回了JavaScript。JavaScript就是这样一种不直接编译为机器码的语言。当用户访问您的网站时，浏览器会向托管网站的服务器发送后台请求，然后服务器会响应所需的HTML和JavaScript，以在您的浏览器中呈现页面。然后，浏览器的引擎将此JavaScript编译为中间表示，当运行时再转换为机器码。

这听起来可能很复杂，但大多数情况下，编写JavaScript代码时，您无需担心任何这些复杂性。您所要做的就是编写和部署您的代码，它就像魔术一样工作。

然而，这种抽象已经在您编写的代码和实际执行的代码之间产生了差距。开发环境会尽最大努力为您弥合这一差距，以便您无需考虑它。然而，在生产环境中，您通常不会得到那种帮助。这就是我们示例中发生的情况——浏览器位于差距的一侧，而您位于另一侧。它报告的错误代码位置是正确的，但仅适用于它正在执行的代码。正如我们所探讨的那样，这不一定是*您*编写的相同代码。

所以现在我们知道为什么错误指向“不存在”的代码，但我们该如何处理呢？我们如何跨越这个差距呢？

## 通过源映射跨越差距

好吧，当我说有一个单一的差距时，我是在简化。实际上，有许多差距；每个抽象级别都包含自己需要跨越的差距。不过，现在让我们专注于导致我们看到难以理解错误的与JavaScript相关的差距。由于需要通过互联网获取代码，这个过程越快，您的网站就能更快地加载给用户。因此，大部分的[JS都是“被压缩的”](https://www.freecodecamp.org/news/javascript-minify-minifying-js-with-a-minifier-or-jsmin/)，这基本上意味着所有不必要的空格和换行都被移除，以尽可能减小文件大小，以便尽可能快速、便宜地发送。这就是我们问题的关键所在。浏览器报告的错误是在被压缩的代码中，但我们正在处理未被压缩的源代码。我们该如何解决这个问题呢？

最终，这就是我们要谈到的[源映射](https://web.dev/source-maps/)的话题。源映射是一种至关重要的调试工具，它提供了从编译或压缩代码到原始源代码的映射。正如我们所见，编译代码中的错误可能是一场追溯到原始代码根源的噩梦。让我们深入了解源映射是如何做到这一点的。

## 源映射的解剖

所以我们知道源映射解决了什么问题，但它是如何做到的呢？源映射是一个包含信息的JSON文件，用于将处理后的代码映射回原始源文件。以下是一个源映射的示例，以及每个字段的解释：

```json
{
  "version": 3,
  "file": "minified.js",
  "sourceRoot": "",
  "sources": ["original.js"],
  "names": ["myFunction", "x", "y"],
  "mappings": "AAAA,0BAA0B;AAC1B,UAAU,EAAC;AACV,MAAM,EAAC,WAAW,GAAG,IAAI,CAAC"
}
```

- **Version** ：指示源映射的版本，`3`是当前版本。这个版本不是特定于您的应用程序，而是源映射标准的版本。
- **File** ：指定此源映射对应的被压缩或编译文件的名称。
- **SourceRoot** ：一个可选属性，可以指定所有源文件的根URL（这里为空）。
- **Sources** ：原始源文件的路径或URL数组。在这种情况下，只有一个名为`original.js`的源文件。
- **Names** ：列出在压缩或编译过程中可能被更改的一些符号。
- **Mappings** ：包含编码映射信息，这是源映射的核心部分。它可能看起来像一组随机字母，但实际上这是一个\[可变长度数量（VLQ）\](https://en.wikipedia.org/wiki/Variable-length_quantity#:~:text=A%20variable%2Dlength%20quantity%20(VLQ,to%20mark%20continuation%20of%20bytes)编码的信息，解释了如何将代码中的特定符号映射到被压缩或编译的代码中。

这只是一个简单的示例，实际的源映射可能会复杂得多。特别是映射信息通常是由构建工具自动生成的，并且可能非常复杂，对应于应用于代码的具体转换。

## 如何生成源映射

许多现代处理JavaScript的工具和编译器，比如[Webpack](https://webpack.js.org/)、[Babel](https://babeljs.io/)或[UglifyJS](https://www.npmjs.com/package/uglify-js)，都可以生成源映射。以下是您可能会这样做的一般示例：

1. **配置您的构建工具** ：大多数构建工具都有特定的配置或插件，可以启用源映射生成。通常，您会设置特定选项，比如在Webpack中设置`devtool: 'source-map'`来启用此功能。一些构建工具和项目模板可能默认启用了此功能，请检查您的构建目录是否有任何“.map”文件，以确定是否是这种情况。如果您没有使用构建工具，您可以使用前面提到的UglifyJS。
2. **确保服务器配置** ：确保您的服务器配置为提供源映射（如果需要），因为某些配置可能会阻止访问这些文件。这一点很重要，因为这是让浏览器将一开始看到的令人困惑的错误转换为有用信息的关键。

## 如何使用源映射

在开发代码时，您通常无需考虑源映射，因为现代开发环境可以自动使用源映射来帮助[调试](https://raygun.com/blog/javascript-debugging-major-browsers/)。然而，在部署到生产环境时，情况就不同了。回想一下我在文章开头提出的例子：在更新网页应用程序后，当您尝试登录时，控制台中出现了错误。我们该如何解决这个问题呢？一旦源映射生成并链接到处理后的代码，现代浏览器的开发者工具就可以自动使用源映射。就是这样！确保源映射已生成并可用，浏览器将处理剩下的事情。

然而，这只是故事的一部分。错误很少会如此容易被捕捉到。对于[复杂的软件，错误可能会在](https://raygun.com/blog/errors-and-exceptions/)由许多因素的组合导致的各种情况中出现，这使得它们更难以自己捕捉。毕竟，您只能找到您自己遇到的错误。那么，您如何找到您的用户遇到的错误呢？这就是错误监控工具可以将源映射提升到另一个层次的地方。

崩溃报告工具允许您查看用户遇到的所有错误，为您提供了对网站性能的最佳可见性。在没有错误监控服务的情况下监控网站就像在黑暗中导航一样。您可能熟悉布局，但没有灯光，您很可能会错过细节，绊倒在看不见的障碍上，并且需要更长时间才能找到您要找的东西。

使用崩溃报告工具就像打开灯一样。您将获得详细的实时问题概述，这些问题在其他情况下可能会隐藏起来。这些见解不仅仅是关于定位问题；它们还涉及了解问题的上下文和影响。集成源映射增加了透明度的另一层，将被压缩的代码转换回原始源代码。这使得调试过程更加高效，并且使开发环境更贴近实际用户体验。就像浏览器一样，这些工具可以自动获取您的源映射（如果它们是公开可访问的，可以通过URL访问）。大多数工具还支持手动上传源映射，以处理源映射无法公开的情况。如果您在本地开发，或者希望您的源映射保密，您可以手动上传它们。

在我们的源映射可用之后，浏览器控制台中的错误现在给了我们有用的信息，可以带回我们的原始代码，更好地理解问题所在以及我们可能如何解决它。请注意，原始堆栈跟踪现在告诉我们错误发生在`App.js`的第18行。这比`main.d1589c82.js`的第2行要有用得多。

![](https://cdn.iokks.com/art/77df86052a69/b22f82cb0ca842cc8af825085852c441.png)

## 其他语言呢？

我们编写的代码与实际执行的代码之间的差距是各种编程语言都面临的共同挑战。虽然本文主要关注JavaScript，但重要的是要认识到大多数语言都实现了类似“源映射”的概念。无论是通过[调试符号](https://encyclopedia.kaspersky.com/glossary/debug-symbol/)、调试信息还是其他专门的工具，它们都以类似的方式解决了相同的问题。


源映射是不可或缺的，它揭开了压缩和编译代码的神秘面纱。掌握它们，调试就变得轻而易举。

为什么每个开发者现在都需要了解源代码映射

便携文档格式（PDF）被广泛用于在各种平台上共享文档。PDF之所以受欢迎，是因为它以一种方式保持文档的格式和布局，使得任何操作系统或PDF查看器都不会显示任何修改的迹象。PDF是通过称为PDF查看器的软件工具来显示的，这些工具具有许多与文档交互的功能，如导航、放大和缩小以及跳转到特定页面。

每个PDF查看器都有特定的功能，这限制了新功能的可能性。因此，开发人员可能希望创建自己的PDF查看器软件，以满足其特定的需求和偏好，比如文档分析或数据提取。创建自定义PDF查看器有许多优势，其中一些如下：

- **定制化** ：开发自己的PDF查看器可以让您定制其界面、功能和功能，以满足您特定的需求。
- **集成** ：构建自定义PDF查看器可以让您无缝集成到您的平台或应用程序中，而不会牺牲任何功能。
- **安全和隐私** ：自定义PDF查看器可以让您控制加密和访问控制等安全措施，以确保PDF文件中敏感内容的保密性。

在本文中，您将使用PDF.js库构建一个简单的自定义PDF查看器。[PDF.js](https://mozilla.github.io/pdf.js/)是Mozilla开发的基于HTML5的开源PDF查看器库，用于呈现和解析PDF文档。

## 使用PDF.js库开发PDF查看器

在开始之前，您需要选择一个代码编辑器和PDF.js库，可以通过CDN（本教程中使用）连接，也可以从[GitHub下载](https://github.com/adarshchimnani/PDF-Viewer)。

### 设置环境

首先，您将设置一个包含HTML、CSS和JavaScript功能的简单网页的Vanilla JS项目。

在文件夹中设置一个名为**PDF Viewer** 的项目文件夹，并在文件夹中创建以下三个文件：

1. index.html
2. styles.css
3. viewer.js

项目文件夹结构应如下所示：

![项目结构](https://cdn.iokks.com/art/a1d32299be5e/aaea78566879425599cc92730ad49a74.png)

*项目结构*

## 为PDF查看器创建用户界面

下一步是创建一个界面来使用PDF查看器。

打开`index.html`文件，然后输入以下代码并保存：

```html
<!DOCTYPE html>

<html lang="en">

<head>

  <meta charset="UTF-8">

  <meta name="viewport" content="width=device-width, initial-scale=1.0">

  <title>Simple PDF Viewer</title>

  <link rel="stylesheet" href="styles.css">

</head>

<body>

  <h1>Simple PDF Viewer</h1>

  <div id="pdf-container"></div>

  <div id="page-controls">

    <button id="prev-page">Previous</button>

    <span id="page-num">Page 1</span>

    <button id="next-page">Next</button>

    <input type="number" id="go-to-page-input" placeholder="Go to Page">

    <button id="go-to-page-btn">Go</button>

  </div>

  <div>

    <button id="zoom-out">Zoom Out</button>

    <button id="zoom-in">Zoom In</button>

  </div>

  <input type="file" id="file-input" accept=".pdf">

</body>

</html>
```

上述代码创建了一个简单的界面，包括以下元素：

- 用于显示PDF文件的容器
- “上一页”和“下一页”按钮，用于导航PDF文件的页面
- 用于跳转到PDF文件指定页面编号的输入字段
- “放大”和“缩小”按钮
- 用于从用户本地文件资源管理器中选择PDF文件的按钮

除了创建用户界面外，还有两个用于外部JavaScript文件的脚本标签，用于向网页添加功能。

第一个脚本标签`https://cdnjs.cloudflare.com/ajax/libs/pdf.js/2.11.338/pdf.min.js`是用于呈现PDF文档的PDF.js库的链接。这将把PDF.js库集成到您的项目中。

第二个脚本标签`viewer.js`是用于实现PDF查看器功能的自定义JavaScript文件的链接。

这样，HTML文件中的代码就结束了。生成的网页应如下所示：

![PDF查看器](https://cdn.iokks.com/art/a1d32299be5e/bd5130b46e0f44f3a4146de0dc975b80.png)

*PDF查看器*

## 使用CSS为界面添加样式

虽然本教程不侧重于为用户界面添加样式，但您可以使其看起来更加美观。将以下代码保存在`styles.css`中：

```css
/* styles.css */

body {

    display: flex;

    flex-direction: column;

    align-items: center;

    justify-content: center;

    height: 100vh;

    margin: 0;

    font-family: Arial, sans-serif;

  }



  #pdf-container {

    border: 1px solid #ccc;

    overflow: auto;

    width: 80%;

    max-width: 800px;

    height: 70vh;

  }



  .button-group, #zoom-controls, #file-controls {

    display: flex;

    align-items: center;

    margin-top: 10px;

  }



  .button-group button, #zoom-controls button, #file-controls button, #file-controls input[type="file"] {

    margin: 0 5px;

    padding: 5px 10px;

    border: none;

    background-color: #007bff;

    color: #fff;

    cursor: pointer;

    border-radius: 4px;

    font-size: 14px;

    transition: background-color 0.3s ease;

  }



  .button-group button:hover, #zoom-controls button:hover, #file-controls button:hover, #file-controls input[type="file"]:hover {

    background-color: #0056b3;

  }



  #go-to-page-input, #go-to-page-btn {

    margin-left: 5px;

  }
```

上述代码将元素居中，为显示PDF的空间进行了组织，并对所有按钮和输入字段进行了对齐。

生成的网页现在应如下所示：

![带有CSS样式的PDF查看器](https://cdn.iokks.com/art/a1d32299be5e/6816f776ea924cc49c91e80c070a3686.png)

*带有CSS样式的PDF查看器*

## 使用JavaScript和PDF.js添加功能

现在，您已经使用CSS组织了PDF查看器的界面。最后一步是使用JavaScript和PDF.js库添加功能。

首先，为了向PDF查看器添加功能，您需要将所有相关代码放入名为`DOMContentLoaded`的事件侦听器中。这样可以确保在HTML文档完全加载后执行JavaScript代码：

```javascript
document.addEventListener('DOMContentLoaded', function() {

    // 所有代码在此处

});
```

您还需要通过JavaScript启用与HTML（DOM）元素的交互，例如按钮和输入字段。`document.getElementById()`函数允许访问文档对象模型（DOM）元素，从而可以为稍后使用的每个元素创建变量：

```javascript
const pdfContainer = document.getElementById('pdf-container');

const prevPageBtn = document.getElementById('prev-page');

const nextPageBtn = document.getElementById('next-page');

const pageNumSpan = document.getElementById('page-num');

const goToPageInput = document.getElementById('go-to-page-input'); 

const goToPageBtn = document.getElementById('go-to-page-btn'); 

const zoomOutBtn = document.getElementById('zoom-out');

const zoomInBtn = document.getElementById('zoom-in');

const fileInput = document.getElementById('file-input');
```

然后，您将初始化以下三个变量：`pdfDoc`、`pageNum`和`scale`。`pdfDoc`变量存储加载的PDF文档实例，`pageNum`变量跟踪当前显示的页面编号，`scale`变量用于跟踪缩放比例，以实现放大和缩小功能：

```javascript
let pdfDoc = null;

let pageNum = 1;

let scale = 1.0;
```

接下来，`renderPage()`函数呈现加载的PDF文件的特定页面。它获取PDF页面，调整画布尺寸以匹配页面，清除容器，并将页面内容呈现到画布上，从而在容器内有效地显示页面：

```javascript
async function renderPage(num) {
  const page = await pdfDoc.getPage(num);

  const viewport = page.getViewport({ scale: scale });

  const canvas = document.createElement('canvas');

  const canvasContext = canvas.getContext('2d');


  canvas.height = viewport.height;

  canvas.width = viewport.width;

  pdfContainer.innerHTML = '';

  pdfContainer.appendChild(canvas);

  const renderContext = {

    canvasContext,

    viewport,

  };

  await page.render(renderContext);
}
```

`loadPDF()`函数从给定的URL加载PDF文档，使用`pdfjsLib.getDocument()`方法。然后调用`renderPage()`来显示初始页面并更新页面计数：

```javascript
async function loadPDF(url) {
  const loadingTask = pdfjsLib.getDocument(url);

  pdfDoc = await loadingTask.promise;

  renderPage(pageNum);

  pageNumSpan.textContent = `Page ${pageNum} of ${pdfDoc.numPages}`;
}
```

接下来，您将为多个按钮添加点击功能的事件侦听器，例如：

- `prevPageBtn`和`nextPageBtn`按钮用于页面导航，同时更新要显示的页面编号
- `goToPageBtn`按钮，用于跳转到`goToPageInput`字段中输入的值（页面编号），以跳转到PDF文件的特定页面
- `zoomOutBtn`和`zoomInBtn`按钮，用于放大和缩小显示的页面

```javascript
prevPageBtn.addEventListener('click', () => {

  if (pageNum > 1) {

    pageNum--;

    renderPage(pageNum);

    pageNumSpan.textContent = `Page ${pageNum} of ${pdfDoc.numPages}`;

  }

});



nextPageBtn.addEventListener('click', () => {

  if (pageNum < pdfDoc.numPages) {

    pageNum++;

    renderPage(pageNum);

    pageNumSpan.textContent = `Page ${pageNum} of ${pdfDoc.numPages}`;

  }

});



goToPageBtn.addEventListener('click', () => { // Event listener for the "Go to Page" button

  const targetPage = parseInt(goToPageInput.value);

  if (targetPage >= 1 && targetPage <= pdfDoc.numPages) {

    pageNum = targetPage;

    renderPage(pageNum);

    pageNumSpan.textContent = `Page ${pageNum} of ${pdfDoc.numPages}`;

  }

});



zoomOutBtn.addEventListener('click', () => {

  if (scale > 0.25) {

    scale -= 0.25;

    renderPage(pageNum);

  }

});



zoomInBtn.addEventListener('click', () => {

  if (scale < 3) {

    scale += 0.25;

    renderPage(pageNum);

  }

});
```

最后一部分是`fileInput`侦听器，用于检查`change`事件以加载和呈现用户从本地文件资源管理器中选择的任何文件：

```javascript
fileInput.addEventListener('change', async (event) => {

  const selectedFile = event.target.files[0];

  if (selectedFile) {

    const fileURL = URL.createObjectURL(selectedFile);

    loadPDF(fileURL);

  }
});
```

以下是添加功能的完整代码。打开已创建的`viewer.js`文件，然后输入以下代码并保存：

```javascript
document.addEventListener('DOMContentLoaded', function() {

    const pdfContainer = document.getElementById('pdf-container');

    const prevPageBtn = document.getElementById('prev-page');

    const nextPageBtn = document.getElementById('next-page');

    const pageNumSpan = document.getElementById('page-num');

    const goToPageInput = document.getElementById('go-to-page-input'); // Added input element

    const goToPageBtn = document.getElementById('go-to-page-btn'); // Added button element

    const zoomOutBtn = document.getElementById('zoom-out');

    const zoomInBtn = document.getElementById('zoom-in');

    const fileInput = document.getElementById('file-input');

 

    let pdfDoc = null;

    let pageNum = 1;

    let scale = 1.0;

 

    async function renderPage(num) {

      const page = await pdfDoc.getPage(num);

      const viewport = page.getViewport({ scale: scale });

 

      const canvas = document.createElement('canvas');

      const canvasContext = canvas.getContext('2d');

 

      canvas.height = viewport.height;

      canvas.width = viewport.width;

      pdfContainer.innerHTML = '';

      pdfContainer.appendChild(canvas);

 

      const renderContext = {

        canvasContext,

        viewport,

      };

      await page.render(renderContext);

    }

 

    async function loadPDF(url) {

      const loadingTask = pdfjsLib.getDocument(url);

      pdfDoc = await loadingTask.promise;

      renderPage(pageNum);

      pageNumSpan.textContent = `Page ${pageNum} of ${pdfDoc.numPages}`;

    }

 

    prevPageBtn.addEventListener('click', () => {

      if (pageNum > 1) {

        pageNum--;

        renderPage(pageNum);

        pageNumSpan.textContent = `Page ${pageNum} of ${pdfDoc.numPages}`;

      }

    });

 

    nextPageBtn.addEventListener('click', () => {

      if (pageNum < pdfDoc.numPages) {

        pageNum++;

        renderPage(pageNum);

        pageNumSpan.textContent = `Page ${pageNum} of ${pdfDoc.numPages}`;

      }

    });

 

    goToPageBtn.addEventListener('click', () => { // Event listener for the "Go to Page" button

      const targetPage = parseInt(goToPageInput.value);

      if (targetPage >= 1 && targetPage <= pdfDoc.numPages) {

        pageNum = targetPage;

        renderPage(pageNum);

        pageNumSpan.textContent = `Page ${pageNum} of ${pdfDoc.numPages}`;

      }

    });

 

    zoomOutBtn.addEventListener('click', () => {

      if (scale > 0.25) {

        scale -= 0.25;

        renderPage(pageNum);

      }

    });

 

    zoomInBtn.addEventListener('click', () => {

      if (scale < 3) {

        scale += 0.25;

        renderPage(pageNum);

      }

    });

 

    fileInput.addEventListener('change', async (event) => {

      const selectedFile = event.target.files[0];

      if (selectedFile) {

        const fileURL = URL.createObjectURL(selectedFile);

        loadPDF(fileURL);

      }

    });

});
```

这标志着使用PDF.js开发自定义PDF查看器的开发工作已经完成。

## 测试PDF查看器

使用PDF.js完成PDF查看器项目后，现在让我们尝试渲染一些PDF并看看它的效果。

如果你渲染一个PDF文件，它会看起来像这样：

![PDF查看器测试](https://cdn.iokks.com/art/a1d32299be5e/5c14c94f39194a2db7550cfbfd70e336.png)

*PDF查看器测试*

放大：

![PDF查看器：放大](https://cdn.iokks.com/art/a1d32299be5e/b9757e85ee9b4d77b62ba8f182494c6d.png)

*PDF查看器：放大*

缩小：

![PDF查看器：缩小](https://cdn.iokks.com/art/a1d32299be5e/d9d86789685e438f9aaec3fb31199a01.png)

*PDF查看器：缩小*

下一页：

![PDF查看器：下一页](https://cdn.iokks.com/art/a1d32299be5e/476a4b00be4f4b74be90de1e882d43ba.png)

*PDF查看器：下一页*

上一页：

![PDF查看器：上一页](https://cdn.iokks.com/art/a1d32299be5e/2789d83ea2484bea83749f32b94f7dfc.png)

*PDF查看器：上一页*

## 结论

在本文中，您了解了如何使用PDF.js库从头开始开发自定义PDF查看器。您可以在这些步骤的基础上构建许多不同版本的PDF查看器，并添加您需要的任何功能。

您可以在这个[GitHub存储库](https://github.com/adarshchimnani/PDF-Viewer.git)中找到本文中使用的所有代码。


如何使用PDF.js库构建一个简单的自定义PDF查看器。PDF.js是Mozilla开发的一个开源PDF查看器库，使用HTML5构建，可以渲染和解析PDF文件。

从零开始使用PDF.js构建PDF阅读器

你是否觉得现有的视频通话应用有所限制？如果是的话，为什么不自己制作一个视频通话应用，可以用于任何用途呢？借助[Video SDK](https://www.videosdk.live/)的帮助，很容易集成并构建自己的视频通话应用，具备聊天、投票、白板等功能。

Video SDK是一个平台，允许开发人员创建丰富的应用内体验，如嵌入实时视频、语音、实时录制、直播流和实时消息传递。Video SDK可在JavaScript、React.js、React-Native、iOS、Android和Flutter中无缝集成。Video SDK还提供预构建的SDK，可让您在短短10分钟内将实时通信集成到您的应用程序中。

在本教程中，您将探索Video SDK的群组通话功能。您将逐步了解如何使用React Video SDK集成视频通话。

本指南将帮助您在几分钟内运行Video SDK视频和音频通话。

让我们使用React.js和Video SDK创建一个视频通话应用。

## 先决条件

在继续之前，请确保您的开发环境满足以下要求：

- Video SDK开发者帐户
- 基本的React理解
- React Video SDK
- 在您的设备上安装了Node和NPM
- 基本的Hooks理解（useState、useRef、useEffect）
- React Context API（可选）

> 需要有Video SDK帐户来生成令牌。访问Video SDK仪表板生成令牌。

## 开始编码！

按照以下步骤创建必要的环境以向您的应用程序添加视频通话。

### 创建新的React应用

使用以下命令创建一个新的React应用

```markdown
$ npx create-react-app videosdk-rtc-react-app
```

### 安装Video SDK

使用下面提到的npm命令安装Video SDK。在运行此命令之前，请确保您在React应用程序目录中。

```markdown
$ npm install "@videosdk.live/react-sdk"

//对于参与者视频
$ npm install "react-player"
```

### 项目结构

在使用create-react-app创建应用程序后，您的项目结构应如下所示

```markdown
root   
   ├── node_modules
   ├── public
   ├── src
   │    ├── api.js
   │    ├── App.js
   │    ├── App.css
   │    ├── index.js
   │    ├── index.js
   .    .
```

我们将使用功能组件来利用React的可重用组件架构。将为用户、视频和控件（麦克风、摄像头、离开）创建组件。

### 应用程序架构

该应用程序将包含一个`MeetingView`组件，其中包括`ParticipantView`，用于呈现参与者的名称、视频、音频等。我们还将有一个Controls组件，允许用户执行离开和切换媒体等操作。

我们将在两个文件上工作：

- API.js：负责处理API调用，如生成唯一的`meetingId`和令牌
- App.js：负责渲染`MeetingView`并加入会议。

## 构建React视频通话应用的五个步骤

### 步骤1：开始使用API.js

在继续之前，我们必须创建一个API请求来生成唯一的`meetingId`。您将需要一个身份验证令牌，您可以通过[videosdk-rtc-api-server-examples](https://github.com/videosdk-live/videosdk-rtc-api-server-examples)或直接从Video SDK Dashboard for developers创建它。

```markdown
//我们将使用此身份验证令牌来生成会议并连接到它
export const authToken = "<Generated-from-dashbaord>";
// 创建会议的API调用
export const createMeeting = async ({ token }) => {  const res = await fetch(`https://api.videosdk.live/v2/rooms`, {    method: "POST",    headers: {      authorization: `${authToken}`,      "Content-Type": "application/json",    },    body: JSON.stringify({}),  });  //从响应中解构roomId  const { roomId } = await res.json();  return roomId;
}
```

### 步骤2：使用所有组件的App.js框架

为了构建App.js的框架，我们将使用Video SDK Hooks和Context Providers。Video SDK提供`MeetingProvider`、`MeetingConsumer`、`useMeeting`和`useParticipant` hooks。让我们了解每一个。

首先，我们将探索Context Provider和Consumer。当一些数据需要在不同嵌套级别的许多组件中访问时，主要使用Context。

- `MeetingProvider`：它是一个Context Provider。它接受值配置和令牌作为props。Provider组件接受一个值prop，传递给此Provider的后代消费组件。一个Provider可以连接到多个消费者。Providers可以嵌套以在树的更深处覆盖值。
- `MeetingConsumer`：它是Context Consumer。所有作为Provider后代的消费者将在Provider的值prop更改时重新渲染。
- `useMeeting`：这是一个会议React hook API。它包括与会议相关的所有信息，如参与者、流等。
- `useParticipant`：这是参与者hook API。`useParticipant` hook负责处理与一个特定参与者相关的所有事件和属性，如加入、离开、静音等。

Meeting Context有助于监听参与者加入会议或更改麦克风或摄像头等的所有更改。

让我们开始在App.js中更改几行代码。

```markdown
import "./App.css";
import React, { useEffect, useRef, useState } from "react";
import {  MeetingProvider,  MeetingConsumer,  useMeeting,  useParticipant,
} from "@videosdk.live/react-sdk";
import { authToken, createMeeting } from "./API";

function JoinScreen() {  return null;
}

function VideoComponent(props) {  return null;
}

function Controls(props) {  return null;
}

function Container(props) {  return null;
}

function App() {  const [meetingId, setMeetingId] = useState(null);
  const getMeetingAndToken = async (id) => {    const meetingId =      id == null ? await createMeeting({ token: authToken }) : id;    setMeetingId(meetingId);  };
  return authToken && meetingId ? (    <MeetingProvider      config={{        meetingId,        micEnabled: true,        webcamEnabled: false,        name: "C.V. Raman",      }}      token={authToken}    >      <MeetingConsumer>        {() => <Container meetingId={meetingId} />}
      </MeetingConsumer>
    </MeetingProvider>
  ) : (    <JoinScreen getMeetingAndToken={getMeetingAndToken} />
  );
}

export default App;
```

### 步骤3：实现加入屏幕

加入屏幕将作为一个介质，用于安排新会议或加入现有会议。

```markdown
function JoinScreen({ getMeetingAndToken }) {  const [meetingId, setMeetingId] = useState(null);  const onClick = async () => {    await getMeetingAndToken(meetingId);  };  return (    <div>      <input        type="text"        placeholder="Enter Meeting Id"        onChange={(e) => {          setMeetingId(e.target.value);        }}      />
      <button onClick={onClick}>Join</button>
      {" or "}      <button onClick={onClick}>Create Meeting</button>
    </div>
  );
}
```

### 步骤4：实现Container和Controls

下一步是创建`MeetingView`和`Controls`组件，以管理加入、离开、静音和取消静音等功能。

```markdown
function MeetingView(props) {  const [joined, setJoined] = useState(null);  //获取用于加入会议的方法。  //我们还将获取参与者列表，以显示所有参与者  const { join, participants } = useMeeting({    //当会议成功加入时的回调    onMeetingJoined: () => {      setJoined("JOINED");    },    //当会议离开时的回调    onMeetingLeft: () => {      props.onMeetingLeave();    },  });  const joinMeeting = () => {    setJoined("JOINING");    join();  };
  return (    <div className="container">      <h3>Meeting Id: {props.meetingId}</h3>
      {joined && joined == "JOINED" ? (        <div>          <Controls />          //用于呈现会议中的所有参与者          {[...participants.keys()].map((participantId) => (            <ParticipantView              participantId={participantId}              key={participantId}            />
          ))}        </div>
      ) : joined && joined == "JOINING" ? (        <p>Joining the meeting...</p>
      ) : (        <button onClick={joinMeeting}>Join</button>
      )}    </div>
  );
}
```

除此之外，需要一个Control组件来处理用户操作。

```markdown
function Controls() {  const { leave, toggleMic, toggleWebcam } = useMeeting();  return (    <div>      <button onClick={leave}>Leave</button>
      <button onClick={toggleMic}>toggleMic</button>
      <button onClick={toggleWebcam}>toggleWebcam</button>
    </div>
  );
}
```

### 步骤5：实现Participant View

在实现视频组件之前，我们需要了解一些概念。

#### 1. 用于麦克风和摄像头的Ref转发

Ref转发是一种自动将ref通过组件传递给其子组件的技术。我们将使用Refs将音频和视频轨道与组件连接起来。

```markdown
const webcamRef = useRef(null);
const micRef = useRef(null);
```

#### **2. `useParticipant` Hook**

`useParticipant` hook负责处理加入会议的一个特定参与者的所有属性和事件。它将参与者作为参数。

```markdown
const { webcamStream, micStream, webcamOn, micOn } = useParticipant(  props.participantId
);
```

#### **3. `MediaStream` API**

`MediaStream`对于将`MediaTrack`添加到音频/视频标签以播放音频或视频非常有用。

```markdown
const webcamRef = useRef(null);
const mediaStream = new MediaStream();
mediaStream.addTrack(webcamStream.track);

webcamRef.current.srcObject = mediaStream;
webcamRef.current  .play()  .catch((error) => console.error("videoElem.current.play() failed", error));
```

现在，让我们使用所有这些API来创建`ParticipantView`。

```markdown
function ParticipantView(props) {  const micRef = useRef(null);  const { webcamStream, micStream, webcamOn, micOn, isLocal, displayName } =    useParticipant(props.participantId);
  const videoStream = useMemo(() => {    if (webcamOn && webcamStream) {      const mediaStream = new MediaStream();      mediaStream.addTrack(webcamStream.track);      return mediaStream;    }  }, [webcamStream, webcamOn]);
  useEffect(() => {    if (micRef.current) {      if (micOn && micStream) {        const mediaStream = new MediaStream();        mediaStream.addTrack(micStream.track);
        micRef.current.srcObject = mediaStream;        micRef.current          .play()          .catch((error) =>            console.error("videoElem.current.play() failed", error)          );      } else {        micRef.current.srcObject = null;      }    }  }, [micStream, micOn]);
  return (    <div>      <p>        Participant: {displayName} | Webcam: {webcamOn ? "ON" : "OFF"} | Mic:{" "}        {micOn ? "ON" : "OFF"}      </p>
      <audio ref={micRef} autoPlay playsInline muted={isLocal} />
      {webcamOn && (        <ReactPlayer          //          playsinline // very very imp prop          pip={false}          light={false}          controls={false}          muted={true}          playing={true}          //          url={videoStream}          //          height={"300px"}          width={"300px"}          onError={(err) => {            console.log(err, "participant video error");          }}        />
      )}    </div>
  );
}
```

我们已经成功使用React.js和Video SDK实现了一个定制的视频通话应用。

## 结论

我们已成功使用React.js完成了视频通话应用。如果您希望添加诸如聊天消息、屏幕共享、投票等功能，您可以随时查看我们的[文档](https://docs.videosdk.live/)。如果您在实施过程中遇到任何困难，可以查看我们在GitHub上的[示例](https://github.com/videosdk-live/videosdk-rtc-react-sdk-example)，或在我们的[Discord社区](https://discord.gg/Gpmj6eCq5u)上与我们联系。
抱歉，我无法完成你的要求。


本教程展示了如何使用React和Video SDK构建一个视频通话应用 —— 设置环境、集成视频通话以及实现会议控制功能。

如何使用Video SDK构建React视频通话应用

在 JavaScript 的浩瀚宇宙中，某些功能不仅因其功能而脱颖而出，还因其引入的范式转变而引人注目。其中之一就是 `Proxy` 对象。在其核心，Proxy 提供了一种定制对象上基本操作行为的方式。可以将其视为一个中间人，位于您的代码和一个对象之间，拦截并可能改变对象的交互方式。这提供了前所未有的控制，允许开发人员为诸如读取属性、赋值或甚至确定属性是否存在等操作定义自定义行为。除了机制之外，Proxy 的真正魅力在于其潜在应用，从数据验证和属性监视到对象虚拟化等更高级模式。随着我们深入研究 Proxy，我们将揭开它们所打开的可能性层，重新定义我们曾经认为 JavaScript 能够实现的边界。

## **第一部分：Proxy 的基础**

### **1.1 什么是 Proxy？**

在 JavaScript 领域，`Proxy` 对象类似于一个保护盾或代理人，包裹在另一个我们称之为“目标”的对象周围。这种包裹允许 Proxy 拦截和控制对目标对象执行的各种基本操作。就像有一个监护人监督我们如何与数据交互一样，赋予我们重新定义或定制这些交互的权力。

### **1.2 创建 Proxy**

创建 Proxy 很简单，但理解其结构对于有效利用至关重要。`Proxy` 构造函数需要两个主要组成部分：

- **目标：**  要包裹的原始对象。
- **处理器：**  包含称为“陷阱”的方法的对象，用于定义目标对象上操作的自定义行为。

以下是一个基本表示：

```javascript
const target = {};
const handler = {
    get: function(target, property) {
        return property in target ? target[property] : 'Not Found';
    }
};
const proxy = new Proxy(target, handler);
```

### **1.3 与 Proxy 交互**

当与 Proxy 交互时，就好像直接与目标对象交互一样。但不同之处在于，现在操作经过处理器进行过滤和控制。在上面的例子中，如果您尝试通过代理访问目标上不存在的属性，您将收到 `Not Found` 而不是 `undefined`。

```javascript
console.log(proxy.name); // 输出："Not Found"

```

#### 

### **1.4 Proxy vs. 目标**

区分 Proxy 和目标是至关重要的。对 Proxy 进行的更改会影响目标，反之亦然，除非处理器明确控制。但是，在进行身份检查时，Proxy 和目标是不同的实体：

```javascript
console.log(proxy === target); // 输出：false
```

## **第二部分：深入处理器**

### **2.1 处理器的本质**

在 Proxy 的上下文中，处理器是包含“陷阱”的对象。这些陷阱是专门设计用于拦截并可能重新定义目标对象上特定操作的方法。处理器的职责是指定哪些操作被拦截以及如何修改它们。

### **2.2 通用陷阱一瞥**

- `get` **：**  当读取属性时调用此陷阱。它可用于返回自定义值或动态计算值。

```javascript
{
    get: function(target, property) {
        return property in target ? target[property] : 'Default';
    }
}
```

- `set` **：**  在设置属性时调用。除了分配值之外，它还可以验证或转换数据。

```javascript
{
    set: function(target, property, value) {
        if (value < 0) {
            throw new Error('Invalid value');
        }
        target[property] = value;
    }
}
```

- `has` **：**  由 `in` 运算符触发，此陷阱可以自定义行为以隐藏或公开特定属性。

```javascript
{
    has: function(target, property) {
        if (property.startsWith('_')) return false; // 隐藏私有属性
        return property in target;
    }
}
```

- `deleteProperty` **：**  顾名思义，它拦截属性删除，提供了阻止操作或执行副作用的机会。

```javascript
{
    deleteProperty: function(target, property) {
        if (property.startsWith('_')) {
            throw new Error('Cannot delete private properties');
        }
        delete target[property];
    }
}
```

### **2.3 高级陷阱**

除了通用陷阱外，还有像 `getPrototypeOf`、`setPrototypeOf`、`isExtensible`、`ownKeys` 等高级陷阱，它们可以对微妙的对象行为进行精细控制。这些允许开发人员微调与 Proxy 的交互，确保它在各种场景中表现如期。

### **2.4 处理器的灵活性**

处理器的美妙之处之一在于其多样性。您不受限于使用所有陷阱。如果处理器仅定义了 `get` 陷阱，那么代理上的其他操作将默认为标准行为。这种选择性定制允许开发人员专注于特定操作，而无需定义所有可能的交互的开销。

## **第三部分：高级用例**

### **3.1 数据绑定和可观察性**

Proxy 最引人注目的用途之一是观察对象中的更改，使其成为响应式编程范式的关键组成部分。

```javascript
function createObserver(target, callback) {
    return new Proxy(target, {
        set: function(obj, prop, value) {
            const oldValue = obj[prop];
            obj[prop] = value;
            callback(prop, oldValue, value);
            return true;
        }
    });
}

const data = createObserver({}, (prop, oldValue, newValue) => {
    console.log(`Property ${prop} changed from ${oldValue} to ${newValue}`);
});

data.age = 25;  // 输出：Property age changed from undefined to 25
```

### **3.2 验证和约束**

Proxy 可以强制执行约束，确保数据一致性和有效性。

```javascript
const schema = {
    age: 'number',
    name: 'string'
};

const validator = new Proxy({}, {
    set: function(obj, prop, value) {
        if (schema[prop] && typeof value !== schema[prop]) {
            throw new Error(`Expected ${prop} to be a ${schema[prop]}`);
        }
        obj[prop] = value;
    }
});

validator.age = "twenty";  // 抛出：Expected age to be a number
```

### **3.3 虚拟化对象**

Proxy 可以创建可能不存在的属性的幻觉，使其非常适合诸如延迟加载等任务。

```javascript
const fetchData = id => ({ id, name: 'John Doe' });  // 模拟数据获取

const dbProxy = new Proxy({}, {
    get: function(obj, prop) {
        return prop in obj ? obj[prop] : fetchData(prop);
    }
});

console.log(dbProxy[123].name);  // 输出：John Doe（并在幕后获取数据）
```

### **3.4 方法链接和流畅 API**

Proxy 可以通过在某些操作后返回代理对象来促进方法链接。

```javascript
const chainable = target => {
    return new Proxy(target, {
        get: function(obj, prop) {
            if (prop in obj) {
                return (...args) => {
                    obj[prop](...args);
                    return proxy;  // 返回代理以进行链接
                };
            }
            return () => proxy;  // 默认返回代理
        }
    });
};

const obj = chainable({
    print: msg => console.log(msg)
});

obj.print('Hello').print('World');
```

## **第四部分：限制和注意事项**

### **4.1 性能开销**

每个硬币都有两面，动态的 Proxy 功能带来了轻微的性能成本。处理器添加的间接性可能会引入开销，特别是在广泛使用时。虽然现代 JavaScript 引擎对此进行了良好优化，但在性能关键的应用程序中，意识到潜在影响至关重要。

### 4.2 不透明的非可配置属性

虽然 Proxy 通常充当透明包装器，但它们可能会表现出不透明的行为，特别是对于非可配置属性。例如，如果目标具有非可配置属性，则 Proxy 无法报告其不同的值。

### **4.3 与某些内置对象的不兼容性**

某些内置对象，如 `Date` 或 `Map`，具有内部槽和特定行为，可能不总是与 Proxy 很好地配合。开发人员在包装这些对象时需要小心，确保它们不会意外地破坏其预期行为。

### **4.4 内存考虑**

Proxy 不会阻止其目标被垃圾回收。但是，处理器可能对目标有引用，间接地阻止垃圾回收。了解这些引用至关重要，以避免潜在的内存泄漏。

### **4.5 可撤销的 Proxy**

JavaScript 提供了 `Proxy.revocable()`，它创建一个可撤销（关闭）的 Proxy。一旦撤销，对 Proxy 的任何操作都将抛出错误。虽然此功能在某些场景中很有用，如安全性或资源管理，但这是开发人员应该注意的另一层复杂性。

## **结论**

在 JavaScript 广阔的领域中，`Proxy` 对象的引入无疑标志着一个重要的里程碑。为开发人员提供了一种独特的机制来干预和重新定义基本对象操作，Proxy 已经重塑了我们思考现代 Web 中数据交互方式的方式。它们的功能，从简单的数据验证到复杂的虚拟化和可观察性模式，都证明了它们的多才多艺。

然而，对于所有强大的工具来说，理解和尊重同样重要。了解它们的优势和认识到它们的局限性同样重要。在审慎开发人员的手中，Proxy 可以成为将挑战转化为优雅解决方案的魔术棒。

随着我们在不断发展的 Web 开发世界中继续前行，像 Proxy 这样的工具提醒我们未来的无限可能性。它们邀请我们探索、创新，并推动可能性的边界，同时又保持着语言基础原则。

### **参考资料**

1. **MDN Web 文档** ：MDN 上关于 Proxy 的全面文档是任何开发人员的宝贵资源。

   - [Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy)

2. **JavaScript.info** ：涵盖与 Proxy 相关的基础知识和高级主题的详细指南。

   - [Proxy and Reflect](https://javascript.info/proxy)

3. **ECMAScript 6 – 新特性** ：此指南提供了关于 ES6 中引入的新特性的见解，包括 Proxy。

   - [ECMAScript 6 特性概述](http://es6-features.org/#Proxying)

4. **Google Developers** ：深入探讨 Proxy 的实际应用，提供了真实世界的示例。

   - [ES6 中的元编程：第 2 部分 - Reflect](https://developers.google.com/web/updates/2016/02/es2015-proxies)


JavaScript的Proxy对象重新定义了对象交互，转变了数据操作。探索它的魔力和多功能性。

JavaScript的秘密武器：揭开代理（Proxy）的神秘面纱

React，一个用于构建用户界面的JavaScript库，自问世以来就备受欢迎。其成功的原因之一是其高效的状态管理系统。React Context是该系统的一个重要组成部分，它简化了在组件树中传递数据的过程，无需进行属性钻取。在这份全面的指南中，我们将深入探讨`useContext`钩子，这是处理React Context的关键工具。通过本文，您将全面了解如何在React中使用`useContext`来有效地管理状态和属性。

## 什么是React Context？

在深入了解`useContext`之前，让我们先了解一下React Context是什么。React Context是在React应用程序中在组件之间共享数据的一种方式，无需通过组件树的每个级别显式传递属性。它提供了一种机制，可以使某些数据（如主题、用户身份验证或语言偏好）可在树的不同级别的许多组件中访问。

在典型的React应用程序中，数据是通过从父组件传递给其子组件的方式进行传递的。然而，当您有深度嵌套的组件或者组件之间没有直接关联时，通过每个中间组件传递属性可能会变得繁琐，并导致“属性钻取”，即属性在多个级别传递，使代码难以维护和理解。

React Context通过允许您创建一个持有要共享的数据的上下文对象来解决了这个问题，并提供了一种让子组件访问该数据的方式，无论它们在组件树中嵌套多深。

## 何时使用React Context？

React Context是一个强大的功能，但并非在每种情况下都是最佳解决方案。以下是一些使用React Context有益的情况：

1. 主题和样式：如果您有需要被多个组件访问的主题或样式信息，React Context是一个很好的选择。
2. 用户身份验证：在构建需要用户身份验证的应用程序时，React Context可以帮助管理用户的身份验证状态，并使其在整个应用程序中可用。
3. 语言偏好：如果您的应用程序支持多种语言，并且希望将用户的语言偏好可用于所有组件，React Context可以简化此任务。
4. 全局状态管理：在某些情况下，您可能需要一个多个组件可以读取和写入的全局状态。React Context可以作为应用程序的全局状态管理器。

## 创建上下文

要使用React Context，首先需要使用`React.createContext`函数创建一个上下文对象。该函数返回一个具有两个属性的对象：`Provider`和`Consumer`。

以下是如何创建上下文：

```javascript
import React from 'react'; 
const MyContext = React.createContext();
```

在这个例子中，我们创建了一个名为`MyContext`的上下文。现在，这个上下文可以用于在组件之间共享数据。

## 使用`useContext`钩子

`useContext`钩子是React的内置钩子，允许您访问上下文对象中存储的数据。要使用`useContext`，您需要从`react`库中导入它，并将您创建的上下文对象作为其参数传递。

以下是如何使用`useContext`：

```javascript
import React, { useContext } from 'react'; 
const MyContext = React.createContext(); 
function MyComponent() { 
  const contextData = useContext(MyContext); 
  // 现在，contextData包含了MyContext上下文中的数据。
  // 您可以在组件中使用这些数据。
  return ( 
    <div> 
      {/* 使用contextData渲染您的组件 */}
    </div> 
  ); 
}
```

在这个例子中，`contextData`将包含`MyContext`上下文中存储的数据。然后，您可以根据需要在组件中使用这些数据。

## 提供者和消费者组件

要使上下文中的数据对子组件可用，您需要使用`Provider`组件。`Provider`组件接受一个`value`属性，这是您要共享的数据。任何作为`Provider`的子组件都可以使用`useContext`钩子来访问这些数据。

以下是如何使用`Provider`组件：

```javascript
import React from 'react'; 
const MyContext = React.createContext(); 
function MyComponent() { 
  return ( 
    <MyContext.Provider value={/* 在这里提供您的数据 */}> 
      {/* 子组件可以在这里访问上下文数据 */}
    </MyContext.Provider> 
  ); 
}
```

您还可以使用`Consumer`组件来访问上下文数据，但在现代React应用程序中，这种方法不太常见，因为`useContext`钩子提供了更简洁的方式来实现相同的结果。

## 现实世界的例子

让我们探索一个真实世界的例子，以说明如何有效地使用`useContext`。假设我们正在构建一个多语言博客应用程序，用户可以在不同语言之间切换。我们希望将用户选择的语言存储在一个上下文中，并使其对所有组件可用。

首先，我们将创建上下文并提供必要的语言数据：

```javascript
import React, { createContext, useContext, useState } from 'react'; 
// 为用户选择的语言创建一个上下文
const LanguageContext = createContext();
// 创建一个提供者组件来管理语言状态
function LanguageProvider({ children }) { 
  const [language, setLanguage] = useState('en'); // 默认语言是英语
  // 更改语言的函数
  const changeLanguage = (newLanguage) => { 
    setLanguage(newLanguage); 
  }; 
  return ( 
    <LanguageContext.Provider value={{ language, changeLanguage }}> 
      {children} 
    </LanguageContext.Provider> 
  ); 
}
// 自定义钩子，简化访问语言上下文
function useLanguage() { 
  return useContext(LanguageContext); 
}
export { LanguageProvider, useLanguage };
```

在这个例子中，我们创建了一个`LanguageContext`上下文和一个`LanguageProvider`组件，使用`useState`钩子来管理语言状态。还定义了`useLanguage`钩子，以简化访问语言上下文。

现在，让我们在一个组件中使用`useLanguage`钩子，允许用户在不同语言之间切换：

```javascript
import React from 'react';
import { useLanguage } from './LanguageContext'; 
function LanguageSwitcher() { 
  const { language, changeLanguage } = useLanguage(); 
  const handleLanguageChange = (newLanguage) => { 
    changeLanguage(newLanguage); 
  }; 
  return ( 
    <div> 
      <button onClick={() => handleLanguageChange('en')}>English</button> 
      <button onClick={() => handleLanguageChange('fr')}>French</button> 
      <button onClick={() => handleLanguageChange('es')}>Spanish</button> 
    </div> 
  ); 
}
export default LanguageSwitcher;
```

在这个组件中，我们使用`useLanguage`钩子来访问上下文中的`language`和`changeLanguage`函数。用户可以点击按钮来更改语言，`changeLanguage`函数会更新上下文，从而导致依赖语言数据的任何组件重新渲染为新语言。

## 性能考虑

虽然React Context是一个强大的工具，但重要的是要注意潜在的性能影响，特别是在使用它来管理全局状态时。每当上下文数据发生变化时，所有消费该上下文的组件都将重新渲染。

为了优化性能：

- 明智地使用上下文：避免在上下文中存储过大或频繁变化的数据。只将真正需要在多个组件之间共享的数据放入上下文中。
- 记忆化：使用`React.memo`函数或`useMemo`钩子来记忆化组件，以防止不必要的重新渲染。
- 分割上下文：考虑将上下文分成多个较小的上下文，以最小化数据变化时需要更新的组件数量。
- 使用React内置的上下文：在某些情况下，考虑使用Redux或Mobx等库来进行复杂状态管理，而不是使用React Context，因为它们提供了更高级的优化。

## 结论

React Context结合`useContext`钩子，为在React应用程序中的组件之间管理和共享数据提供了一种便利的方式。通过在适当级别的组件树中创建上下文并提供它们，您可以简化应用程序的状态管理，并避免属性钻取。

了解何时以及如何使用[React中的useContext](https://www.cronj.com/blog/react-context-how-to-use-the-usecontext-hook/)，以及考虑性能影响，对于构建[可扩展的](https://dzone.com/refcardz/scalability)和可维护的React应用程序至关重要。通过本指南所获得的知识，您将能够充分利用`useContext`在您的React项目中，并改善您的整体开发体验。


标签：JavaScript