Angular可注入类只读属性类型安全获取属性名方法咨询

Great question! This is a super common pain point when building libraries—hardcoding property names as strings creates fragile code that breaks silently when refactoring. Luckily, TypeScript gives us several type-safe ways to reference property names without relying on magic strings. Let's break down the best solutions for your Angular injectable class scenario:

1. Quick Win: Use satisfies for Simple Property References #

If you're only dealing with individual properties, TypeScript's satisfies operator (available in TS 4.9+) is the easiest way to enforce type safety. It lets you assert that a string matches a key of your class, while keeping the string as a literal type:

@Injectable({ providedIn: 'root' })
export class MyLibService {
  readonly id!: string;
  readonly name!: string;
}

// Inside your library's initialization logic
const service = inject(MyLibService);

// This is type-safe—if you rename 'id' to 'identifier', TS will throw an error
const idProperty = 'id' satisfies keyof MyLibService;
Reflect.set(service, idProperty, 'lib-123'); // Or your special assignment trick

2. Enforce Readonly-Only Access with a Utility Type #

If you want to make sure you only ever reference readonly properties (since those are the ones you're managing internally), create a utility type to extract just the readonly keys from your class:

// Utility type to get all readonly keys of a type
type ReadonlyKeys<T> = {
  [K in keyof T]: T extends { readonly [P in K]: T[K] } ? K : never;
}[keyof T];

// Your injectable class
@Injectable({ providedIn: 'root' })
export class MyLibService {
  readonly id!: string;
  readonly name!: string;
  public mutableValue = ''; // Example non-readonly property
}

// Type-safe function to get a readonly property name
function getReadonlyProp<T, K extends ReadonlyKeys<T>>(key: K): K {
  return key;
}

// Usage in your library
const service = inject(MyLibService);
const nameProp = getReadonlyProp<MyLibService, 'name'>('name');
// ❌ This will throw a TS error because 'mutableValue' isn't readonly
// const badProp = getReadonlyProp<MyLibService, 'mutableValue'>('mutableValue');

Reflect.set(service, nameProp, 'My Awesome Library');

This ensures you can't accidentally reference a mutable property, adding an extra layer of safety for your library's internal logic.

3. Generic Helper for Bulk Operations #

If you need to assign multiple properties at once, you can create a generic function that accepts a record of type-safe property names and values:

type ReadonlyPartial<T> = {
  [K in ReadonlyKeys<T>]?: T[K];
};

function assignReadonlyProps<T>(instance: T, props: ReadonlyPartial<T>) {
  for (const [key, value] of Object.entries(props)) {
    Reflect.set(instance, key as ReadonlyKeys<T>, value);
  }
}

// Usage
assignReadonlyProps(service, {
  id: 'lib-456',
  name: 'Updated Library Name'
  // ❌ TS error if you try to include 'mutableValue' here
});

Why This Works #

Instead of hardcoding strings like 'id', we're leveraging TypeScript's type system to tie our property references directly to the class's type definition. When you rename a property in MyLibService, TypeScript will immediately flag any references to the old name across your library code—no silent runtime errors.

Since you can't control the class's initialization logic, these approaches work seamlessly with Angular's DI system: you just grab the injected instance and use these type-safe property references to apply your special assignment logic.

内容的提问来源于stack exchange，提问作者stephan.peters