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

一、Node.js 事件循环

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

🔁 简要原理

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

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

📊 事件循环的几个阶段

1. timers：执行 setTimeout 和 setInterval 的回调。

2. pending callbacks：执行 I/O 操作失败的回调（如错误处理）。

3. idle, prepare：内部使用。

4. poll：等待新的 I/O 事件，如文件读写。

5. check：执行 setImmediate() 的回调。

6. 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 的区别

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

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

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

1. 执行顺序

1. 同步任务（调用栈）

2. 微任务队列（Microtasks）：如 Promise.then、MutationObserver

3. 宏任务队列（Macrotasks）：如 setTimeout、setInterval、requestAnimationFrame

2. 典型任务来源

3. 特点

• 每执行一个宏任务，立即清空所有微任务。

• 浏览器事件循环中含有 UI 渲染阶段，微任务清空后才允许渲染。

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

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

1. Node.js 事件循环阶段

1. timers：处理 setTimeout、setInterval

2. pending callbacks：处理某些 I/O 的回调

3. idle, prepare：仅内部使用

4. poll：检索 I/O 事件

5. check：处理 setImmediate

6. close callbacks：处理 close 事件，如 socket.on('close')

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

2. 微任务来源

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

• Promise.then()（真正的微任务）

3. 特点

• process.nextTick 比 Promise.then 更早执行。

• 没有 UI 渲染阶段（非浏览器）。

• setImmediate 与 setTimeout(..., 0) 行为不同。

🔍 三、主要区别对比

✅ 总结记忆口诀

浏览器关注 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 执行流程简述

1. 解析阶段：V8 把 JavaScript 源代码解析成抽象语法树（AST）。

2. 编译阶段：使用 Ignition 解释器将 AST 转换成字节码（intermediate representation）。

3. 执行阶段：解释字节码运行程序，同时收集热点代码信息。

4. 优化阶段：HotSpot 优化编译器将热点字节码编译为高效的机器码。

5. 垃圾回收：定期回收无用对象释放内存。

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 代码无法直接控制，但可以通过编写大量对象生成与销毁来观察其效果。

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

js

复制编辑

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. 如何查阅使用手册

1. 首页快速入门
   先浏览 “Getting Started” 或 “Quick Start” 部分，了解如何安装 Web3.js 以及基本连接。

2. 模块导航
   文档页面左侧有目录，按模块分类，比如：

   • web3.eth：以太坊核心 API，如账户、交易、合约等。

   • web3.utils：工具函数，如单位转换、哈希计算。

   • web3.shh：点对点消息。

   • web3.net：网络相关接口。

3. 查找具体 API
   搜索你想用的功能，比如 “getBalance”、“sendTransaction”，查看参数、返回值和示例。

4. 示例代码
   结合文档里的示例代码，实际写代码测试，帮助理解。

5. 版本对应
   注意文档版本对应你使用的 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. 如何使用手册

1. 首页快速开始
   了解安装和基础用法，快速写出第一个查询余额或调用合约的代码。

2. 模块分类导航
   根据功能查找对应模块的使用方法，例如查 Provider 如何连接节点，查 Wallet 如何管理私钥。

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

4. 示例代码
   文档中大量示例，方便模仿和调试。

5. 版本匹配
   确保文档版本和你项目中安装的 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 的区别及作用概述

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);

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