Node.js跨进程传递类：序列化/反序列化及文件路径获取问题

一、怎么在父类Base.ts里拿到子类的文件路径？ #

你现在的serialize方法里path是空的，这很正常——父类本身不知道自己被哪个子类继承，所以没法直接获取子类的文件路径。咱们可以让子类主动“告知”父类自己的路径，有两种简单的实现方式：

方式1：给子类加个静态属性 #

这种方式最直观，让每个子类把自己的文件路径存在静态属性里，父类通过this.constructor就能拿到这个属性：

// src/Base.ts
export abstract class Base {
  // 强制子类必须定义这个静态属性
  public static readonly filePath: string;

  public serialize() {
    // 拿到当前子类的构造函数，进而获取文件路径
    const filePath = (this.constructor as typeof Base).filePath;
    return JSON.stringify({ path: filePath, obj: this });
  }

  public static deserialize(json: string) {
    const { path, obj } = JSON.parse(json) as { path: string; obj: Record<string, any> };
    // 注意ES模块和CommonJS的区别，ES模块建议用动态import替代require
    const classModule = require(path);
    // 如果是export default导出的类，记得取classModule.default
    const instance = new classModule();
    return Object.assign(instance, obj);
  }
}

// src/filter/A.ts
import { Base } from '../Base';

export class A extends Base {
  // CommonJS环境用__filename，ES模块用new URL(import.meta.url).pathname
  public static readonly filePath = __filename;

  public cat: string = 'meow';
  public sayHi() {
    return this.cat;
  }
}

// src/filter/B.ts和A.ts同理，添加静态filePath属性

方式2：构造函数传路径 #

要是你不想用静态属性，也可以在子类构造的时候把路径传给父类：

// src/Base.ts
export abstract class Base {
  protected filePath: string;

  constructor(filePath: string) {
    this.filePath = filePath;
  }

  public serialize() {
    return JSON.stringify({ path: this.filePath, obj: this });
  }

  // deserialize方法和上面一样
}

// src/filter/A.ts
export class A extends Base {
  constructor() {
    // 把当前文件路径传给父类
    super(__filename);
  }

  public cat: string = 'meow';
  public sayHi() {
    return this.cat;
  }
}

二、主进程传类给工作进程，有没有比序列化更好的办法？ #

你现在序列化整个实例的思路是可行的，但其实可以更轻量——不用序列化整个类，只传类的模块路径和实例的纯数据，让工作进程自己加载类并重建实例，这样能减少不必要的序列化开销。

优化后的代码示例 #

主进程（test.ts）：

import cp from 'child_process';
import path from 'path';
import { A } from './src/filter/A';
import { B } from './src/filter/B';

const aInstance = new A();
const bInstance = new B();

// 只传必要的信息：类的路径和实例数据
const sendData = {
  a: {
    classPath: A.filePath,
    instanceData: { ...aInstance }
  },
  b: {
    classPath: B.filePath,
    instanceData: { ...bInstance }
  }
};

const worker = cp.fork(path.join(__dirname, './worker'), [], { silent: true });
worker.send(sendData);

工作进程（worker.ts）：

import { Base } from './src/Base';

process.on('message', async (msg) => {
  // 加载A类并重建实例
  const AClass = require(msg.a.classPath);
  const classA = new AClass();
  Object.assign(classA, msg.a.instanceData);

  // 加载B类并重建实例
  const BClass = require(msg.b.classPath);
  const classB = new BClass();
  Object.assign(classB, msg.b.instanceData);

  console.log(classA.sayHi()); // 输出meow
  console.log(classB.sayHi()); // 输出woof
});

额外提示 #

• 如果你的项目用ES模块（package.json里设了"type": "module"），记得把require换成动态import()，比如const { A } = await import(msg.a.classPath);
• 一定要用绝对路径！不管是__filename还是import.meta.url转的路径，避免主进程和工作进程的相对路径不一致导致找不到模块
• 要是你做的是CPU密集型任务，worker_threads比child_process.fork更轻量，传递方式和这个思路一样，也是传路径和数据

内容的提问来源于stack exchange，提问作者Get Off My Lawn