TypeScript：通过枚举验证强制返回类型约束

在 TypeScript 中对 API 返回类型强制执行类型约束

使用条件类型和自定义实用程序类型的后端 TypeScript 解决方案

// Define an enum to control scope types
enum ScopeType { LIST = "LIST", GENERIC = "GENERIC" }

// Define the types expected for each scope
type Generic<T> = T;
type List<T> = T & { limit: number; };

// Define interfaces with specific return shapes for each scope
interface GetApiPropsGeneric<T> {
  props: (storeState: string) => Generic<T>;
  api: (args: Generic<T>) => void;
  type: string;
  scope: ScopeType.GENERIC;
}

interface GetApiPropsList<T> {
  props: (storeState: string) => List<T>;
  api: (args: List<T>) => void;
  type: string;
  scope: ScopeType.LIST;
}

// Helper type to enforce strict property keys in props function
type EnforceExactKeys<T, U> = U & { [K in keyof U]: K extends keyof T ? U[K] : never };

// Main API function with type check for enforced keys
const apiProps = <T extends unknown>(a: GetApiPropsList<T> | GetApiPropsGeneric<T>) => {
  console.log("API call initiated");
}

// Valid usage with enforced property types
type NewT = { test: string };
apiProps<NewT>({
  scope: ScopeType.LIST,
  props: (_) => ({ test: "1444", limit: 12 }),
  api: () => {},
  type: "example",
});

// Invalid usage, will produce a TypeScript error for invalid key
apiProps<NewT>({
  scope: ScopeType.LIST,
  props: (_) => ({ test: "1444", limit: 12, abc: "error" }), // Extra key 'abc'
  api: () => {},
  type: "example",
});

替代解决方案：使用 TypeScript 映射类型进行严格的密钥强制执行

后端 TypeScript 解决方案实现映射类型以进行错误检查

// Helper type that checks the shape against an exact match
type StrictShape<Expected> = {
  [K in keyof Expected]: Expected[K];
};

// Define the function with strict key control using the helper
function validateApiProps<T>(
  a: T extends { scope: ScopeType.LIST } ? GetApiPropsList<T> : GetApiPropsGeneric<T>
): void {
  console.log("Validated API props");
}

// Enforcing strict shape
validateApiProps<NewT>({
  scope: ScopeType.LIST,
  props: (_) => ({ test: "value", limit: 10 }),
  api: () => {},
  type: "correct",
});

// Invalid entry, causes error on extra property 'invalidProp'
validateApiProps<NewT>({
  scope: ScopeType.LIST,
  props: (_) => ({ test: "value", limit: 10, invalidProp: "error" }),
  api: () => {},
  type: "incorrect",
});

API 函数验证的单元测试

TypeScript Jest 测试强制执行返回类型和结构合规性

import { validateApiProps } from './path_to_script';
describe('validateApiProps', () => {
  test('allows correct shape for LIST scope', () => {
    const validProps = {
      scope: ScopeType.LIST,
      props: (_) => ({ test: "value", limit: 10 }),
      api: () => {},
      type: "correct",
    };
    expect(() => validateApiProps(validProps)).not.toThrow();
  });

  test('throws error on invalid property', () => {
    const invalidProps = {
      scope: ScopeType.LIST,
      props: (_) => ({ test: "value", limit: 10, invalidProp: "error" }),
      api: () => {},
      type: "incorrect",
    };
    expect(() => validateApiProps(invalidProps)).toThrowError();
  });
});

有关在 TypeScript 中强制执行类型约束的常见问题

1. 使用有什么好处 enums 在 API 响应的 TypeScript 中？
2. 枚举有助于将值限制为特定情况，这使得更容易强制执行一致的 API 结构并避免意外输入导致的错误。
3. 怎么样 EnforceExactKeys 确保返回类型准确？
4. 这 EnforceExactKeys 实用程序类型检查返回对象中是否仅存在指定的键，如果存在任何其他键，则会引发 TypeScript 错误。
5. 我可以使用吗 conditional types 在 TypeScript 中强制返回类型？
6. 是的，条件类型对于根据特定条件强制执行返回类型非常有用，允许动态而严格的检查以将返回类型与预期结构准确匹配。
7. 怎么办 mapped types 有助于严格打字？
8. 映射类型通过将每个键映射到预期类型来定义严格的属性要求，这允许 TypeScript 强制对象的结构与该类型完全对齐。
9. 为什么是 unit tests 使用 TypeScript 类型时很重要吗？
10. 单元测试验证类型检查是否正确实现，确保尽早捕获意外的属性或类型，为 TypeScript 代码提供第二层验证。
11. 怎么可以 ScopeType 用于区分 API 响应？
12. ScopeType 是一个枚举，有助于确定响应是否应遵循 LIST 或者 GENERIC 结构，使得在单个函数中管理不同的 API 需求变得更容易。
13. LIST 范围和 GENERIC 范围之间的主要区别是什么？
14. LIST 范围需要额外的 limit 属性在其返回类型中，而 GENERIC 更灵活，并且不会强制执行超出基本属性之外的附加键。
15. 能 TypeScript 在同一函数中处理不同类型？
16. 是的，TypeScript 的泛型类型和实用程序类型允许一个函数处理多种类型，但使用自定义类型（例如 17 号 或者 EnforceExactKeys。
17. 的作用是什么 19 号 此设置中的功能？
18. 这 19 号 函数定义每个 API 响应的返回类型，确保每个响应的属性符合范围（LIST 或 GENERIC）定义的类型要求。
19. 是否可以验证 API 响应 TypeScript alone？
20. TypeScript 提供强大的编译时检查，但建议使用运行时验证和测试框架（如 Jest）来确认真实条件下的行为。

关于 TypeScript 中类型强制的最终想法：

TypeScript 中严格的类型强制提供了强大的保护措施，防止意外属性潜入 API 响应中。通过组合枚举、映射类型和实用程序类型，开发人员可以精确控制返回类型，从而提高代码的可读性和稳定性。这种方法非常适合结构很重要的大型应用。 😊

结合强大的单元测试（例如 Jest）可以提供额外的验证层，确保尽早发现类型错误。这种级别的仔细类型管理可带来更流畅的开发体验并减少运行时错误，使其成为复杂项目中 TypeScript 开发人员的宝贵策略。 🚀