如何实现符合T接口的通用对象校验断言函数？

需要实现一个通用的TypeScript类型断言函数，校验传入对象是否严格匹配指定接口，解决现有实现的两大问题：

1. 手动传入必填字段的体验差
2. 因类型擦除导致的误判（比如无法从接口T中获取运行时字段信息）

• willObjectAdhereToInterface函数完全无效：TypeScript编译后类型信息会被擦除，Object.keys({} as T)返回的是空数组，导致expectedKeys.every(...)永远为true，无法真正校验字段是否存在，比如willObjectAdhereToInterface<A>(b)会误判为true。
• isGenericObject需要手动传必填字段，复用性差，且仅校验字段存在，不校验字段类型，存在类型安全隐患。

由于TypeScript类型是编译时概念，运行时无法直接获取接口的字段和类型信息，必须通过手动提供运行时元数据来实现准确校验。以下是两种可行方案：

方案1：基于类型校验器的严格断言函数 #

定义一个通用断言函数，配合接口对应的类型校验器，既校验字段存在，也校验字段类型：

类型定义与核心函数 #

// 定义接口的类型校验器结构，每个字段对应一个类型断言函数
type TypeGuard<T> = {
  [K in keyof T]: (value: any) => value is T[K];
};

/**
 * 校验对象是否符合指定接口
 * @param item 待校验对象
 * @param typeGuard 对应接口的类型校验器
 * @returns 是否匹配接口的类型断言
 */
export const assertConformsToInterface = <T>(
  item: any,
  typeGuard: TypeGuard<T>
): item is T => {
  if (item === null || item === undefined) return false;
  if (typeof item !== 'object') return false;

  // 校验所有接口字段存在且类型匹配
  const requiredKeys = Object.keys(typeGuard) as Array<keyof T>;
  return requiredKeys.every(key => {
    return key in item && typeGuard[key](item[key]);
  });
};

使用示例 #

interface A {
  a1: string;
  a2: string;
}

interface B {
  b1: string;
  b2: string;
  diffrence1: number;
  diffrence2: number;
}

// 为每个接口定义对应的类型校验器
const aTypeGuard: TypeGuard<A> = {
  a1: (val): val is string => typeof val === 'string',
  a2: (val): val is string => typeof val === 'string'
};

const bTypeGuard: TypeGuard<B> = {
  b1: (val): val is string => typeof val === 'string',
  b2: (val): val is string => typeof val === 'string',
  diffrence1: (val): val is number => typeof val === 'number',
  diffrence2: (val): val is number => typeof val === 'number'
};

// 校验示例
const a = { a1: 'a1', a2: 'a2' };
const b = { b1: 'b1', b2: 'b2', diffrence1: 0, diffrence2: 1 };

if (assertConformsToInterface(a, aTypeGuard)) {
  console.log(a.a1); // 类型安全，TS自动推断a为A类型
}

if (assertConformsToInterface(b, bTypeGuard)) {
  console.log(b.diffrence1); // 类型安全
}

// 此处会返回false，因为b没有A接口的字段
if (assertConformsToInterface(b, aTypeGuard)) {
  console.log(b.a1); // 不会执行到这里，TS也会提示类型错误
}

方案2：优化现有通用函数（轻量版） #

如果不需要严格的类型校验，仅需校验字段存在，可以优化现有函数，通过常量复用字段列表，提升体验：

优化后的函数 #

import { Dispatch, SetStateAction } from 'react';

// 用常量定义接口字段，避免重复输入
const A_FIELDS = ['a1', 'a2'] as const;
const B_FIELDS = ['b1', 'b2', 'diffrence1', 'diffrence2'] as const;

/**
 * 校验对象是否包含指定字段（可选校验类型）
 * @param object 待校验对象
 * @param requiredFields 必填字段列表
 * @param typeCheckers 可选的类型校验器
 * @returns 是否匹配的类型断言
 */
export const isGenericObject = <T extends Record<string, any>>(
  object: any,
  requiredFields: ReadonlyArray<keyof T>,
  typeCheckers?: Partial<TypeGuard<T>>
): object is T => {
  if (object === null || object === undefined) return false;
  if (typeof object !== 'object') return false;

  // 校验所有必填字段存在
  const hasAllFields = requiredFields.every(key => key in object);
  if (!hasAllFields) return false;

  // 可选：校验字段类型
  if (typeCheckers) {
    return Object.entries(typeCheckers).every(([key, checker]) => {
      return checker(object[key as keyof T]);
    });
  }

  return true;
};

/**
 * 校验setState是否符合指定类型
 * @param setState 待校验的setState函数
 * @param requiredStateFields 对应state接口的必填字段
 * @param stateTypeCheckers 可选的state类型校验器
 * @returns 是否匹配的类型断言
 */
const isGenericSetState = <T>(
  setState: any,
  requiredStateFields?: ReadonlyArray<keyof T>,
  stateTypeCheckers?: Partial<TypeGuard<T>>
): setState is Dispatch<SetStateAction<T>> => {
  if (setState === null || setState === undefined) return false;
  if (typeof setState !== 'function') return false;

  // 可选：如果需要校验初始state，可在这里添加逻辑
  return true;
};

使用示例 #

if (isGenericObject(a, A_FIELDS)) {
  console.log(a.a1);
}

// 带类型校验的使用
if (isGenericObject(b, B_FIELDS, {
  diffrence1: (val): val is number => typeof val === 'number'
})) {
  console.log(b.diffrence1);
}

TypeScript的类型信息仅存在于编译阶段，运行时会被完全擦除，因此不可能自动从接口T中获取运行时的字段或类型信息，必须手动提供元数据（字段列表、类型校验器）才能实现准确的断言校验。

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