这可以通过TS类型 predicate （以前称为user-defined type guards）来实现。
为此，您需要定义一个返回类型 predicate 的函数，该类型 predicate 检查obj是否具有所需的元素。

interface MyInterface {
    idUser: string;
    idProducts: string[];
}

function isMyInterface(obj: Object): obj is MyInterface {
  return ("idUser" in obj && typeof obj.idUser === "string")   //obj.idUser exists and is a string
    && ("idProducts" in obj && Array.isArray(obj.idProducts)); //obj.idProducts exists and is an Array
}

const str: string = "{ \"idUser\": \"johndoe\", \"shadowKey\": \"myValue\" }";
const myObject: MyInterface = JSON.parse(str) as MyInterface;
if(isMyInterface(myObject)){ // will fail in this example
  console.log("myObject is MyInterface");
} else {
  console.log("myObject is not MyInterface");
}

这几乎是一个js解决方案，除了返回类型，我们可以只返回一个boolean结果（实际上这是js要处理的结果），但是有了这个设置，ts将能够解释结果，并能够给予你编译时的错误/问题。

if(isMyInterface(myObject)){
  console.log(myObject.idProducts); // works
} else {
  console.log(myObject.idProducts); // Error: Property 'idProducts' does not exist on type 'never'.
}

我建议使用Zod来验证对象。
示例对象：

const ZodResult = z.object({
  idUser: z.string(),
  idProducts: z.array(z.string()),
});

推断将其用作类型：

type Result = z.infer<typeof ZodResult>;

解析对象，

const parsed = JSON.parse(yourStringObject);
const result = ZodResult.safeParse(parsed);
if (!result.success) {
  // handle error then return
  result.error;
} else {
  // do something with data
  result.data; // data has type Result
}