我有下面的代码，代表两个接口和两个对象。然而，问题是如何创建一个通用的 predicate 函数，检查传递的对象是否符合上述接口。我尝试了 predicate 的其他实现，但它们显示了误报，因为在核心中，对象应该符合一个接口，而不是其他对象。

export const willObjectAdhereToInterface = <T>(item: any): item is T => {
  // Check for null and undefined only
  if (item === null || item === undefined) {
    return false;
  }
  // Check it is an object
  if (typeof item !== 'object') {
    return false;
  }

  // Get the expected keys of type T
  const expectedKeys: Array<keyof T> = Object.keys({} as T) as Array<keyof T>;

  // Check if all keys of T are present in the item
  return expectedKeys.every((key) => key in item);
};


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

interface B {
  b1: string;
  b2: string;
  diffrence1: number;
  diffrence2: number;
}
const a: A = {
  a1: 'a1',
  a2: 'a2',
 
};

const b: B = {
  b1: 'b1',
  b2: 'b2',
  diffrence1: 0,
  diffrence2: 1,
};

if(willObjectAdhereToInterface<A>(a)){
// a is deffinatly of A interface 
}

if(willObjectAdhereToInterface<B>(b)){
// a is deffinatly of B interface 
}

if(willObjectAdhereToInterface<A>(b)){
console.log(b.a1) // must show an error.
}

字符串
至于我目前所做的是这2个通用函数，一个将检查对象，但它必须有所需的键来检查（不太好），另一个是检查使用第一个函数的set State action。

// T will represent the interface of the state
export const isGenericObject = <T>(object: any, requiredFields: string[] /* Pass the keys */): object is Partial<T> | T => {
  // Check for null and undefined only
  if (object === null || object === undefined) {
    return false;
  }
  // Check if object
  if (typeof object !== 'object') {
    return false;
  }

  // Retrieve keys from the item
  const keys = Object.keys(object);

  // Check if all required fields are present
  const hasAllRequiredFields = requiredFields.every((field) => keys.includes(field));

  return hasAllRequiredFields;
};

const isGenericSetState = <T>(object: any, setState: any): setState is Dispatch<SetStateAction<T>> => {
  // Check for null or undefined
  if (setState === null || setState === undefined) {
    return false;
  }

  // Check if setState has the expected type
  if (typeof setState !== 'function') {
    return false;
  }

  if (object !== undefined && isGenericObject(object, Object.keys(object))) {
    return true;
  }

  return false;
};

型