WEB3全栈开发——面试专业技能点P1Node.js / Web3.js / Ethers.js

一、Node.js 事件循环

Node.js 的事件循环（Event Loop ）是其异步编程的核心机制，它使得 Node.js 可以在单线程中实现非阻塞 I/O 操作。

🔁 简要原理

Node.js 是基于 libuv 实现的，它使用事件循环来处理非阻塞操作。事件循环的主要作用是：

"不断检查任务队列（如回调、I/O、定时器），并按阶段执行回调。"

📊 事件循环的几个阶段

timers ：执行 setTimeout 和 setInterval 的回调。
pending callbacks：执行 I/O 操作失败的回调（如错误处理）。
idle, prepare：内部使用。
poll：等待新的 I/O 事件，如文件读写。
check ：执行 setImmediate() 的回调。
close callbacks ：如 socket.on('close', ...)。

🧪 示例代码：事件循环的顺序

复制代码

setTimeout(() => {
  console.log('setTimeout');
}, 0);

setImmediate(() => {
  console.log('setImmediate');
});

Promise.resolve().then(() => {
  console.log('Promise');
});

process.nextTick(() => {
  console.log('nextTick');
});

🧾 输出顺序可能是：

复制代码

nextTick
Promise
setTimeout
setImmediate

✅ 原因：

process.nextTick() 和 Promise.then() 是微任务（microtask），优先执行。
setTimeout 和 setImmediate 是宏任务（macrotask），排在后面。

📘 应用场景

高并发服务器（如 HTTP 服务器）
异步数据库访问
异步文件 I/O 操作
消息队列处理

🎯 总结

特性	描述
单线程	Node.js 本身是单线程的
非阻塞 I/O	借助事件循环与回调实现并发处理
微任务优先	`nextTick` > `Promise` > `setTimeout`

一、浏览器事件循环和 Node.js 的区别

浏览器和 Node.js 都使用事件循环（Event Loop）来处理异步任务，但由于运行环境不同，它们的事件循环机制在架构设计、宏任务与微任务处理、任务来源和模块支持等方面存在明显差异。

🌐 一、浏览器事件循环机制

浏览器的事件循环遵循 HTML5 标准，基本结构如下：

1. 执行顺序

同步任务（调用栈）
微任务队列（Microtasks） ：如 Promise.then、MutationObserver
宏任务队列（Macrotasks） ：如 setTimeout、setInterval、requestAnimationFrame

2. 典型任务来源

任务类型	示例
宏任务	`setTimeout`、`setInterval`、`message`、`UI 渲染`、`XHR onload`
微任务	`Promise.then`、`queueMicrotask`、`MutationObserver`

3. 特点

每执行一个宏任务，立即清空所有微任务。
浏览器事件循环中含有 UI 渲染阶段，微任务清空后才允许渲染。

⚙️ 二、Node.js 的事件循环机制

Node.js 基于 libuv 库实现自己的事件循环，主要包含 6 个阶段，不完全等同于浏览器模型。

1. Node.js 事件循环阶段

timers ：处理 setTimeout、setInterval
pending callbacks：处理某些 I/O 的回调
idle, prepare：仅内部使用
poll：检索 I/O 事件
check ：处理 setImmediate
close callbacks ：处理 close 事件，如 socket.on('close')

每个阶段之间都会执行微任务队列。

2. 微任务来源

process.nextTick()（优先级最高，不属于微任务队列，是独立队列）
Promise.then()（真正的微任务）

3. 特点

process.nextTick 比 Promise.then 更早执行。
没有 UI 渲染阶段（非浏览器）。
setImmediate 与 setTimeout(..., 0) 行为不同。

🔍 三、主要区别对比

项目	浏览器	Node.js
环境	有 UI 渲染	无 UI 渲染
宏任务示例	`setTimeout`, `setInterval`	`setTimeout`, `setImmediate`
微任务队列	`Promise`, `MutationObserver`	`Promise`, `process.nextTick`（优先）
微任务执行时机	每个宏任务后执行所有微任务	每个阶段后执行所有微任务（先执行 `nextTick`）
特殊队列	无 `nextTick`	`process.nextTick` 队列优先于微任务
底层实现	浏览器厂商自研	`libuv` 实现多平台 I/O

✅ 总结记忆口诀

浏览器关注 UI，先宏后微；Node 有 Tick，分阶段处理。

二、Node.js异步编程

下面是关于 Node.js 中异步编程的两种主要方式 ------ Promise 和 async/await 的示例与解释：

一、Promise 示例与解释

复制代码

function fetchData() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const success = true;
      if (success) {
        resolve("数据加载成功");
      } else {
        reject("数据加载失败");
      }
    }, 1000);
  });
}

fetchData()
  .then(data => {
    console.log(data); // 输出：数据加载成功
  })
  .catch(error => {
    console.error(error);
  });

✅ 说明：

Promise 表示一个异步操作的最终完成（或失败）及其结果值。
.then() 处理成功，.catch() 处理错误。
适合链式调用多个异步任务。

二、async/await 示例与解释

复制代码

function fetchData() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve("数据加载成功");
    }, 1000);
  });
}

async function getData() {
  try {
    const result = await fetchData();
    console.log(result); // 输出：数据加载成功
  } catch (error) {
    console.error(error);
  }
}

getData();

✅ 说明：

async 表示函数内部可能存在异步操作。
await 表示等待 Promise 处理完成，简化回调地狱。
语法更接近同步逻辑，可读性好，推荐使用。

如需讲解 回调函数 → Promise → async/await 的演进过程或应用在实际项目场景里，我也可以继续补充。

三、libuv 工作机制

libuv 是 Node.js 底层的核心库之一，负责 跨平台的异步 I/O 操作 。理解 libuv 的工作机制，有助于深入掌握 Node.js 的高性能和事件驱动模型。

✅ libuv 是什么？

libuv 是一个用 C 编写的跨平台异步 I/O 库，为 Node.js 提供以下能力：

事件循环（Event Loop）
异步文件系统操作
网络通信（TCP、UDP）
子进程管理
定时器（Timers）
DNS 查询
线程池

🔄 libuv 的工作机制（核心组成）

1. Event Loop 事件循环

libuv 实现了事件循环的机制，管理所有异步任务的执行时机。

2. 任务队列分阶段处理

libuv 的事件循环大致如下（简化版本）：

复制代码

while (循环运行中) {
  处理 timers 阶段（如 setTimeout、setInterval）
  处理 I/O callbacks（异步操作的回调）
  处理 idle, prepare 回调
  处理 poll 阶段（处理新的 I/O 事件）
  处理 check 阶段（setImmediate）
  处理 close callbacks（如 socket关闭）
  执行 microtask（如 Promise.then） → V8 控制
}

3. 线程池（Thread Pool）

对于 CPU 密集型或无法异步的操作（如 fs.readFile），libuv 使用线程池异步执行：

默认线程数：4
可以通过 UV_THREADPOOL_SIZE 环境变量配置

📌 举例说明（libuv 在线程池中运行 I/O）：

复制代码

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {
  console.log('文件内容:', data);
});

此处 readFile 实际由 libuv 在线程池中执行，不阻塞主线程，执行完回调被加入事件循环队列。

📊 总结图示（流程简化）

复制代码

JS 调用异步API（如 fs.readFile）
      ↓
libuv 将其交由线程池处理
      ↓
任务完成后，结果回调加入 Event Loop 的队列
      ↓
Event Loop 执行回调函数

如果你需要一张完整的图示来可视化这个执行流程，我可以画图说明（更详细展示与 V8、线程池、事件循环的协作）。是否需要？

四、Cluster 实现多进程

1. 概念

Node.js 是单线程运行的，但它的底层 libuv 使用线程池处理异步 I/O。单线程模型对 I/O 密集型应用非常高效，但在 CPU 密集型任务或者需要利用多核 CPU 的场景下，单线程的限制就明显了。

Cluster 模块允许你创建多个 Node.js 进程（worker），这些进程共享同一个服务器端口，从而实现多核 CPU 的并行利用。每个 worker 进程是 Node.js 的一个单独实例，拥有自己的事件循环。

这样，Cluster 能让你充分利用多核 CPU，提升 Node.js 应用的性能和吞吐量。

2. 代码示例

下面是一个使用 Cluster 的简单示例，创建多个 worker，监听同一个端口：

复制代码

const cluster = require('cluster');
const http = require('http');
const os = require('os');

if (cluster.isMaster) {
  // 获取CPU核心数
  const cpuCount = os.cpus().length;

  console.log(`主进程 ${process.pid} 正在运行`);
  console.log(`启动 ${cpuCount} 个 worker`);

  // Fork 子进程
  for (let i = 0; i < cpuCount; i++) {
    cluster.fork();
  }

  // 监听 worker 退出事件
  cluster.on('exit', (worker, code, signal) => {
    console.log(`worker ${worker.process.pid} 已退出，启动新的 worker`);
    cluster.fork();
  });
} else {
  // Worker 进程运行 HTTP 服务器
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`由进程 ${process.pid} 处理请求\n`);
  }).listen(8000);

  console.log(`worker ${process.pid} 启动`);
}

3. 讲解

cluster.isMaster 判断当前进程是不是主进程。
主进程会根据 CPU 核数 fork 出对应数量的 worker 进程。
每个 worker 进程都执行同样的代码，但 cluster.isMaster 为 false，启动一个 HTTP 服务器监听同一端口。
Node.js Cluster 模块内部会将进入的请求分发给不同的 worker，负载均衡处理。
当某个 worker 进程退出时，主进程捕获 exit 事件，自动重启一个新的 worker，保证服务稳定。
每个 worker 进程拥有自己的进程 ID (process.pid)，方便区分请求是由哪个进程处理。

4. 总结

Cluster 允许 Node.js 程序多进程运行，充分利用多核 CPU。
主进程负责管理 worker 进程的生命周期。
Worker 进程独立运行同样的服务器代码，监听同一个端口。
请求会被均衡分发到不同的 worker，提高并发处理能力。
适合 CPU 密集型或高并发的 Node.js 服务。

如果需要，我还可以帮你写更完整的示例，或者介绍更高级的用法，比如 IPC 通信，欢迎告诉我！

五、V8 引擎原理

1. 概念

V8 引擎是 Google 开发的开源 JavaScript 引擎，主要用于 Chrome 浏览器和 Node.js 环境。它负责将 JavaScript 代码编译、优化并执行，极大提升了 JavaScript 的运行效率。

V8 的核心特点包括：

即时编译（JIT）：将 JavaScript 代码即时编译成机器码，而非先解释执行，提高性能。
隐藏类（Hidden Classes）和内联缓存（Inline Caches）：优化对象属性访问，减少动态查找的开销。
垃圾回收（Garbage Collection）：自动管理内存，回收不再使用的对象。
多阶段编译：先快速生成初步代码，再逐渐优化热代码。

2. V8 执行流程简述

解析阶段：V8 把 JavaScript 源代码解析成抽象语法树（AST）。
编译阶段：使用 Ignition 解释器将 AST 转换成字节码（intermediate representation）。
执行阶段：解释字节码运行程序，同时收集热点代码信息。
优化阶段：HotSpot 优化编译器将热点字节码编译为高效的机器码。
垃圾回收：定期回收无用对象释放内存。

3. 代码示例

V8 是底层引擎，运行时隐藏在 Node.js 或 Chrome 里。下面是一个用 Node.js 运行 JavaScript 的简单示例，展示 V8 执行 JavaScript：

复制代码

// demo.js
function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

console.log(fibonacci(10));

执行：

复制代码

node demo.js

背后 V8 会：

将这个函数编译成字节码。
解释执行，识别热点函数（递归调用频繁）。
对该函数进行优化编译，生成高效机器码。
最终输出结果。

4. 讲解

V8不是简单的解释器，它通过多阶段编译和优化，极大提升 JS 代码性能。
传统的 JS 解释器逐行执行代码，而 V8 首先把代码编译成字节码，运行更快。
在运行过程中，V8 会分析哪些代码"热"（被频繁执行），并通过优化编译器将其转换成原生机器码，提高执行速度。
隐藏类和内联缓存是 V8 优化对象访问的关键技术，类似于为 JS 对象动态生成"类"，快速定位属性。
V8 使用分代垃圾回收，比如新生代和老生代，来高效管理内存，减少停顿时间。

如果你想，我还能帮你梳理 V8 的内存分配、垃圾回收机制，或者介绍 Node.js 如何通过 V8 实现高性能，随时告诉我！

六、V8 引擎内存分配与垃圾回收机制

1. 概念

V8 引擎内存分配

V8 引擎在执行 JavaScript 代码时，需要在内存中为对象、函数、变量等分配空间。它将内存划分为不同的区域，主要包括：

新生代（Young Generation）：存放新创建的对象，分配速度快，采用 Scavenge 算法进行垃圾回收。
老生代（Old Generation）：存放经过多次垃圾回收仍存活的长生命周期对象，采用标记-清除（Mark-Sweep）和标记-整理（Mark-Compact）算法回收。
代码区（Code Space）：存放编译后的机器码。
大对象空间（Large Object Space）：存放特别大的对象，避免影响新生代和老生代的内存管理。

垃圾回收机制

V8 使用自动垃圾回收，自动管理内存，释放不再被引用的对象。其核心算法包括：

Scavenge（新生代回收）：采用复制算法，将存活对象从一块内存区复制到另一块，快速清理内存。
标记-清除（Mark-Sweep）：标记所有存活对象，清除未标记对象。
标记-整理（Mark-Compact）：类似标记-清除，但会整理存活对象，避免内存碎片。

垃圾回收器根据对象的生命周期自动将其从新生代晋升到老生代，提高回收效率。

2. 代码示例

V8 的内存分配和垃圾回收是引擎内部行为，普通 JavaScript 代码无法直接控制，但可以通过编写大量对象生成与销毁来观察其效果。

示例：大量创建对象模拟内存使用

复制代码

复制编辑

function createObjects() { let arr = []; for (let i = 0; i < 1000000; i++) { arr.push({ index: i, time: Date.now() }); } return arr; } let objects = createObjects(); // 模拟释放内存 setTimeout(() => { objects = null; // 解除引用，等待垃圾回收 console.log('Objects dereferenced, eligible for GC'); }, 5000);

运行这段代码时，V8 会为 arr 分配大量内存。当 objects = null 后，数组及其包含的对象失去引用，V8 垃圾回收器会在合适时间回收这部分内存。

3. 讲解

新生代和老生代的设计是基于**大部分对象"朝生暮死"**的经验：新创建的对象大多数生命周期短暂，快速回收；存活较久的对象才进入老生代。
Scavenge 复制算法效率高，适合快速回收新生代内存，避免内存碎片。
老生代垃圾回收用 标记-清除 和标记-整理算法，后者减少碎片，保证大块内存连续，方便长寿命对象管理。
代码区内存存放编译后的机器码，方便函数和代码快速执行。
大对象空间独立分配，避免影响普通对象的内存回收策略。
JavaScript 代码中不能直接手动触发垃圾回收，但通过释放对象引用（如赋值 null），让垃圾回收器能回收无用内存。
V8 的垃圾回收是并发和增量式，尽量减少程序停顿，提高响应性能。

如果你想深入了解 V8 垃圾回收的算法细节、如何通过 --trace_gc 等命令行参数查看垃圾回收日志，我也可以帮你写具体说明！

七、V8 引擎定位性能瓶颈

1. 概念

V8 引擎在执行 JavaScript 代码时，通过多种机制定位和优化性能瓶颈，以提升代码执行效率。主要包括：

内置性能分析工具：V8 支持采样 CPU 和内存使用情况，帮助开发者找出代码热点（hot spots）。
优化编译器（TurboFan）：通过收集运行时信息，动态编译热点代码成机器码，提高性能。
内联缓存（Inline Cache）：加速属性访问，减少查找时间。
性能剖析（Profiler）：V8 可以生成性能分析数据，用于发现执行瓶颈。

通过这些手段，V8 能自动发现"慢代码"，并对其进行重点优化。

2. 代码示例

JavaScript 代码本身不直接控制 V8 的性能分析，但可以利用 Node.js 提供的性能工具，比如 --prof 选项开启 V8 性能分析。

示例：使用 Node.js 运行脚本并生成性能日志

复制代码

node --prof demo.js

假设 demo.js 内容：

复制代码

function slowFunction() {
  let sum = 0;
  for (let i = 0; i < 1e7; i++) {
    sum += i;
  }
  return sum;
}

console.log(slowFunction());

运行后，会生成 isolate-0x...-v8.log 文件，使用 node --prof-process 解析：

复制代码

node --prof-process isolate-0x...-v8.log > processed.txt

processed.txt 会包含函数执行时间、调用次数等性能数据，帮助定位性能瓶颈。

3. 讲解

V8 的性能优化基于采样分析，它不记录所有细节，而是定时采样调用栈，减少性能开销。
通过 --prof，V8 记录运行时的函数调用和时间分布，开发者可以找出耗时多的函数。
V8 识别"热点代码"，使用 TurboFan 优化编译器将其转为高效机器码。
内联缓存减少了属性访问的动态查找，是提升代码访问性能的关键。
在 Node.js 或 Chrome 开发者工具中，也能结合 V8 采集的性能数据，直观查看代码瓶颈。
通过定位性能瓶颈，开发者可以优化算法、减少不必要的循环、避免低效操作，从而提升整体性能。

如果你需要，我可以帮你写更详细的性能分析步骤，或者示范如何结合 Chrome DevTools 使用 V8 Profiler。

八、Web3.js使用手册在哪里看

1. 概念

Web3.js 的官方使用手册（文档）是学习和掌握该库的最佳途径。它详细介绍了 Web3.js 的安装、API 结构、常用功能、示例代码和进阶用法，帮助开发者快速上手与以太坊区块链交互。

2. 官方文档地址

Web3.js 官方文档网址：

web3.js - Ethereum JavaScript API --- web3.js 1.0.0 documentation

这里你可以找到：

安装和快速开始教程
主要模块和类的 API 说明（如 web3.eth、web3.utils）
示例代码和使用指南
常见问题和社区链接

3. 如何查阅使用手册

首页快速入门

先浏览 "Getting Started" 或 "Quick Start" 部分，了解如何安装 Web3.js 以及基本连接。
模块导航

文档页面左侧有目录，按模块分类，比如：
- web3.eth：以太坊核心 API，如账户、交易、合约等。
- web3.utils：工具函数，如单位转换、哈希计算。
- web3.shh：点对点消息。
- web3.net：网络相关接口。
查找具体 API

搜索你想用的功能，比如 "getBalance"、"sendTransaction"，查看参数、返回值和示例。
示例代码

结合文档里的示例代码，实际写代码测试，帮助理解。
版本对应

注意文档版本对应你使用的 Web3.js 版本，避免接口不兼容。

4. 额外资源

GitHub 主页：https://github.com/ChainSafe/web3.js
官方示例：https://github.com/ChainSafe/web3.js/tree/1.x/examples
社区论坛和问答（如 Stack Overflow）

八、Web3.js与以太坊等区块链交互

1. 概念

Web3.js 是一个 JavaScript 库，用于与以太坊区块链进行交互。它封装了以太坊的 JSON-RPC 接口，使开发者能够轻松调用智能合约、发送交易、查询账户余额等操作。

通过 Web3.js，前端或后端应用可以：

连接以太坊节点（如 Infura、Alchemy 或本地节点）
读取链上数据（账户信息、合约状态）
发送交易（转账、调用合约方法）
监听链上事件

2. 代码示例

以下是一个使用 Web3.js 连接以太坊节点、查询账户余额的示例：

复制代码

const Web3 = require('web3');

// 连接到以太坊节点（这里用Infura的主网节点）
const web3 = new Web3('https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID');

async function getBalance(address) {
  try {
    const balanceWei = await web3.eth.getBalance(address);
    const balanceEth = web3.utils.fromWei(balanceWei, 'ether');
    console.log(`账户 ${address} 余额: ${balanceEth} ETH`);
  } catch (err) {
    console.error('查询余额出错:', err);
  }
}

const address = '0x742d35Cc6634C0532925a3b844Bc454e4438f44e'; // 示例地址
getBalance(address);

3. 智能合约交互示例

假设你有一个已部署的智能合约地址和ABI，调用合约的只读方法：

复制代码

const contractABI = [ /* 合约ABI数组 */ ];
const contractAddress = '0xYourContractAddressHere';

const contract = new web3.eth.Contract(contractABI, contractAddress);

async function callContractMethod() {
  try {
    const result = await contract.methods.yourMethodName().call();
    console.log('调用结果:', result);
  } catch (err) {
    console.error('调用合约方法失败:', err);
  }
}

callContractMethod();

4. 讲解

连接节点：Web3.js 需要连接一个以太坊节点，可以是远程公共节点（Infura、Alchemy）或者本地节点。
账户余额查询 ：通过 web3.eth.getBalance 查询某地址的以太币余额，返回单位为 Wei（以太坊最小单位），通常用 web3.utils.fromWei 转换成人类易读的 Ether。
智能合约交互 ：通过合约的 ABI 和地址实例化 web3.eth.Contract，调用 methods 中定义的函数。
- .call() 用于只读调用，不消耗 Gas，不产生交易。
- .send() 用于状态更改调用，需要签名并消耗 Gas。
交易发送 ：通过 web3.eth.sendTransaction 或 contract.methods.methodName().send() 发送交易，通常需要私钥或钱包签名。
事件监听：Web3.js 支持监听智能合约事件，方便前端实时响应链上变化。

如果你想，我还可以帮你写完整的发送交易示例、钱包集成示例，或者讲解 Web3.js 的更多高级用法。

九、Ethers.js 在哪里看使用手册，是干嘛的

1. 概念

Ethers.js 的使用手册（官方文档）是学习和掌握这个库的核心资源，提供详细的 API 说明、安装指南、示例代码和进阶用法。它帮助开发者理解如何用 Ethers.js 与以太坊区块链交互，比如连接节点、查询余额、调用合约、发送交易等。

2. 官方文档地址

Ethers.js 官方文档网址是：

https://docs.ethers.io/

这是 Ethers.js 官方维护的文档，内容覆盖：

快速开始
核心模块（Provider、Wallet、Contract 等）
API 详细说明
常用工具函数
进阶主题（事件监听、合约工厂、ENS 等）

3. 如何使用手册

首页快速开始

了解安装和基础用法，快速写出第一个查询余额或调用合约的代码。
模块分类导航

根据功能查找对应模块的使用方法，例如查 Provider 如何连接节点，查 Wallet 如何管理私钥。
API 参考

查看每个类和方法的参数、返回值和示例，便于正确调用。
示例代码

文档中大量示例，方便模仿和调试。
版本匹配

确保文档版本和你项目中安装的 Ethers.js 版本一致。

4. 额外资源

GitHub 仓库：https://github.com/ethers-io/ethers.js
社区问答（Stack Overflow）
教程视频和博客

九、Ethers.js 与以太坊等区块链交互

1. 概念

Ethers.js 是一个轻量级的 JavaScript 库，用于与以太坊区块链交互。它功能类似于 Web3.js，但设计更加模块化和简洁，且更注重安全性和易用性。

Ethers.js 支持：

连接以太坊节点（本地或远程，如 Infura）
查询账户余额和链上数据
构造、签名和发送交易
与智能合约进行交互
事件监听和解析
钱包管理（私钥、助记词）

2. 代码示例

安装 Ethers.js

复制代码

npm install ethers

查询账户余额示例

复制代码

const { ethers } = require('ethers');

// 连接到以太坊主网节点
const provider = new ethers.providers.InfuraProvider('mainnet', 'YOUR_INFURA_PROJECT_ID');

async function getBalance(address) {
  const balance = await provider.getBalance(address);
  console.log(`账户余额: ${ethers.utils.formatEther(balance)} ETH`);
}

const address = '0x742d35Cc6634C0532925a3b844Bc454e4438f44e';
getBalance(address);

调用智能合约只读方法示例

复制代码

const contractABI = [ /* 合约 ABI 数组 */ ];
const contractAddress = '0xYourContractAddressHere';

const contract = new ethers.Contract(contractAddress, contractABI, provider);

async function callContractMethod() {
  try {
    const result = await contract.yourMethodName();
    console.log('调用结果:', result);
  } catch (err) {
    console.error('调用合约方法失败:', err);
  }
}

callContractMethod();

3. 讲解

Provider（提供者） ：Ethers.js 使用 Provider 对象连接以太坊节点，用于读取区块链数据（余额、交易、合约状态）。支持多种类型节点，如 JSON-RPC、Infura、Alchemy 等。
Wallet（钱包）：管理私钥和签名交易，支持从助记词、私钥或硬件钱包创建。
Contract（合约） ：实例化合约后，可以调用智能合约中的函数，call 方法用于只读调用，send（需要 Wallet 签名）用于发送交易。
工具函数：Ethers.js 包含很多实用工具，如单位转换（Wei 和 Ether）、哈希计算、编码解码等。
Ethers.js API 设计更现代、易用，类型定义完善，适合 TypeScript 开发。
它更注重安全性，默认不会暴露用户私钥，必须显式创建 Wallet 进行签名。

如果需要，我也可以帮你写发送交易、事件监听等更复杂的示例，或者给你对比 Web3.js 和 Ethers.js 的优缺点。

十、Web3.js和Ethers.js区别，各自的作用

Web3.js和Ethers.js一般来说只用其中一个库就够了，因为 Web3.js 和 Ethers.js 都能完成和以太坊区块链的主要交互功能，比如：

查询余额
发送交易
调用智能合约
监听事件

它们功能大部分重叠，没必要同时用两个，避免增加项目复杂度和包体积。

选哪个合适？

想用更轻量、现代、TypeScript 支持好、钱包管理方便 ，建议选 Ethers.js。
需要兼容老项目或已有依赖，或者用的生态比较多是 Web3.js ，就用 Web3.js。

如果你只做一个项目，学会用一个库就足够高效，没必要混着用。

1. Web3.js 和 Ethers.js 的区别及作用概述

特性/方面	Web3.js	Ethers.js
定位和设计	以太坊官方较早的 JS 库，功能全面但较庞大	轻量级、模块化设计，更加现代和易用
体积大小	较大，功能丰富但包体积较重	更小，适合前端项目，对资源有限环境友好
API 风格	API 设计相对复杂，有些冗余	API 更简洁，链式调用方便，类型定义更好（TS 友好）
钱包支持	通常与外部钱包配合使用，钱包管理较弱	内置 Wallet 支持，私钥、助记词管理方便
社区支持与生态	更成熟，很多教程和项目使用	发展迅速，社区活跃，越来越多项目青睐
功能覆盖	功能全面，涵盖所有链交互需求	功能齐全但更注重核心，扩展性好
文档和易用性	文档较丰富，但入门门槛稍高	文档结构清晰，示例丰富，更容易上手
事件监听	支持事件监听，使用起来稍复杂	事件监听使用简洁，支持过滤器
性能和稳定性	稳定性好，广泛使用，但有些接口较旧	性能优化好，设计现代，支持最新以太坊特性

2. 各自作用

Web3.js

主要用于和以太坊区块链进行交互，功能涵盖账户管理、交易、智能合约调用、事件监听等。
适合需要全面功能，已有成熟项目或依赖 Web3.js 生态的开发者。
常用于 DApp 前端与以太坊节点通信。

Ethers.js

设计更轻量且模块化，强调安全和易用，支持钱包管理（私钥、助记词）。
适合希望代码体积小、使用现代 JS/TS 特性、方便钱包集成的项目。
也适合后端脚本和服务，提供简洁且强大的链交互能力。

3. 总结建议

如果你是新项目，注重代码质量和易用性，推荐用 Ethers.js。
如果需要兼容大量现有教程或项目，或者使用的库/框架依赖 Web3.js，则用 Web3.js。

需要的话，我可以帮你写一份两者的对比示例代码，或者帮你快速上手其中任意一个。

十一、账户管理（Account Management）

功能点：

创建账号
从私钥导入
查询余额

Web3.js 示例：

复制代码

const Web3 = require('web3');
const web3 = new Web3('https://mainnet.infura.io/v3/你的API_KEY');

// 创建新账户
const newAccount = web3.eth.accounts.create();
console.log(newAccount);

// 从私钥导入
const account = web3.eth.accounts.privateKeyToAccount('0x你的私钥');
console.log(account.address);

// 查询余额
web3.eth.getBalance(account.address).then(balance => {
  console.log('ETH余额:', web3.utils.fromWei(balance, 'ether'));
});

Ethers.js 示例：

复制代码

import { ethers } from 'ethers';

const provider = new ethers.InfuraProvider('mainnet', '你的API_KEY');

// 创建钱包
const wallet = ethers.Wallet.createRandom();
console.log(wallet.address);

// 导入私钥
const walletFromPK = new ethers.Wallet('0x你的私钥', provider);

// 查询余额
provider.getBalance(walletFromPK.address).then(balance => {
  console.log('ETH余额:', ethers.utils.formatEther(balance));
});

十二、交易构造与签名（Transaction Creation & Signing）

功能点：

构造交易（to、value、gas等）
签名交易
广播交易

Web3.js 示例：

复制代码

const tx = {
  to: '0x接收方地址',
  value: web3.utils.toWei('0.01', 'ether'),
  gas: 21000,
};

web3.eth.accounts.signTransaction(tx, '0x你的私钥')
  .then(signed => web3.eth.sendSignedTransaction(signed.rawTransaction))
  .then(receipt => console.log('交易成功:', receipt.transactionHash));

Ethers.js 示例：

复制代码

const tx = {
  to: '0x接收方地址',
  value: ethers.utils.parseEther('0.01'),
};

walletFromPK.sendTransaction(tx).then(txResponse => {
  console.log('发送中:', txResponse.hash);
  return txResponse.wait();
}).then(receipt => {
  console.log('交易成功:', receipt.transactionHash);
});

十三、调用智能合约（Call Smart Contract）

功能点：

加载合约 ABI 和地址
调用读取函数（call）
调用修改函数（send/写交易）

Web3.js 示例：

复制代码

const abi = [ /* 合约ABI */ ];
const contractAddress = '0x合约地址';
const contract = new web3.eth.Contract(abi, contractAddress);

// 读取数据（不会上链）
contract.methods.name().call().then(console.log);

// 写数据（需要签名+发交易）
contract.methods.setValue(123).send({ from: account.address, gas: 100000 });

Ethers.js 示例：

复制代码

const abi = [ /* 合约ABI */ ];
const contractAddress = '0x合约地址';
const contract = new ethers.Contract(contractAddress, abi, walletFromPK);

// 读取
contract.name().then(console.log);

// 写入（需要签名）
contract.setValue(123).then(tx => tx.wait()).then(console.log);

账户管理、交易构造与签名、调用智能合约------知识总结表

功能	Web3.js	Ethers.js
创建/导入账户	`web3.eth.accounts`	`ethers.Wallet`
查询余额	`web3.eth.getBalance`	`provider.getBalance`
构造交易	手动构造 + sign/send	`wallet.sendTransaction()`
调用合约函数	`contract.methods.fn`	`contract.fn()`
签名交易/消息	`signTransaction`	`wallet.signMessage()`