TypeScript中为process定义类型化自定义事件的实现方法咨询

Absolutely! You can add type definitions for custom events to Node.js's process object in TypeScript, and there are also clean alternatives if you'd rather avoid modifying global types. Let's walk through both approaches:

Extending process with Custom Event Types #

If your custom event is tightly tied to the global process lifecycle (like your example of a domain-related rejection), extending the process type is totally valid. Here's how to do it:

1. Create a TypeScript declaration file (e.g., src/types/process.d.ts) to extend the global NodeJS.Process interface:

declare namespace NodeJS {
  interface Process {
    // Define the 'on' handler for your custom event
    on(
      event: 'domainHavenRejection',
      listener: (message: string, error: Error) => void
    ): this;

    // Define the 'emit' method for your custom event
    emit(
      event: 'domainHavenRejection',
      message: string,
      error: Error
    ): boolean;

    // Add 'once' if you need it too
    once(
      event: 'domainHavenRejection',
      listener: (message: string, error: Error) => void
    ): this;
  }
}

2. Make sure your tsconfig.json includes this declaration file so TypeScript picks it up:

{
  "compilerOptions": {
    // ... other options
  },
  "include": [
    "src/**/*",
    "src/types/**/*.d.ts" // Add this line
  ]
}

Now when you use process.emit('domainHavenRejection', ...) or process.on('domainHavenRejection', ...), TypeScript will enforce the correct argument types and give you proper autocompletion.

Using a Custom EventEmitter Instead #

If you want to avoid polluting the global process type (or if your event is specific to a module rather than the entire process), creating a custom EventEmitter instance is a great alternative. You can even add strict typing to it:

import { EventEmitter } from 'events';

// Define the shape of your events (maps event names to their argument tuples)
type DomainEvents = {
  domainHavenRejection: [message: string, error: Error];
  // Add other custom events here if needed
};

// Create a typed EventEmitter subclass for type safety
class TypedDomainEmitter extends EventEmitter {
  on<K extends keyof DomainEvents>(
    event: K,
    listener: (...args: DomainEvents[K]) => void
  ): this {
    return super.on(event, listener);
  }

  emit<K extends keyof DomainEvents>(
    event: K,
    ...args: DomainEvents[K]
  ): boolean {
    return super.emit(event, ...args);
  }

  // Add 'once' if required
  once<K extends keyof DomainEvents>(
    event: K,
    listener: (...args: DomainEvents[K]) => void
  ): this {
    return super.once(event, listener);
  }
}

// Initialize your emitter instance
const domainEmitter = new TypedDomainEmitter();

// Usage example:
domainEmitter.on('domainHavenRejection', (message, error) => {
  console.error(message, error.stack);
});

domainEmitter.emit(
  'domainHavenRejection',
  'unhandled rejection could not be pinned to a request/response.',
  new Error('Sample rejection error')
);

This approach keeps your events encapsulated, avoids global type changes, and still gives you full TypeScript type safety.

Which Should You Choose? #

• Use the process extension if your event is a global process-level event that makes sense to attach to the core process object.
• Use a custom EventEmitter if your event is module-specific or you want to keep your global scope clean.

内容的提问来源于stack exchange，提问作者Alexander Mills