TypeScript 定义合并对象，但防止对象属性中不同类型的合并

Question

我想编写一个函数，用另一个对象扩展一个对象。例如：我们将调用一个对象src 和另一个ext。该函数必须返回（一个副本）src 对象，但深度（递归地）使用ext 对象扩展该对象。如果ext 的一个（子）属性的数据类型与src（子）属性的类型不匹配，则函数必须忽略ext 值。 ext 中的新属性（src 中不存在）将添加到结果对象中。

为了更好地理解这里一个完整的例子：

/** A helper definition to build indexable objects */
interface indexObject<T> {
    [key: string]: T
}

type SafelyMergedObject<Src extends indexObject<any>, Ext extends indexObject<any>> = {
    // The searched type definition
}

const src= {
    a: "a",
    b: "b",
    c: false,
    d: {
        a: "Alice",
        b: "Bob",
    }
}
const ext = {
    a: ["a"],
    b: 1,
    c: true,
    d: {
        a: "Ann",
        c: "Clair",
    },
    e: "New value",
}
const result: SafelyMergedObject<typeof src, typeof ext> = {
    a: "a", /** Only string should be allowed here because
                it's the property type of the source (Src) type */
    b: "b", /** Same as above (`a` property) */
    c: true,/** Since `c` has the same data type the function
                should return the property value of the `ext`
                object */
    d: {    /** Same data type in both objects */
        a: "Ann",   /** new value from `ext` */
        b: "Bob",   /** copied value from `src` */
        c: "Clair", /** new property from `ext` */
    },
    e: "New Value", /** new property from `ext` */
}

TypeScript Playground Link

我知道如何编写函数。这很容易，但我不知道如何编写这种类型定义。这可能吗？

默认的 TypeScript 类型推断行为不适合我的问题，因为类型是递归的，并且比简单的 object 类型更复杂。例如，我将使用该功能将用户特定的配置加载到我的应用程序中。用户配置可能已损坏。所以我必须将默认配置与用户特定配置合并。

Answer 1

我将您的要求解释如下：对于对象类型T 和U，对象类型SafelyMergedObject<T, U> 应具有与T & U 相同的键，但与属性有一些差异类型。如果键 K 仅存在于 T 或 U 但不是两者都存在，则按原样使用属性（因此这与 T & U 相同）。如果K 键同时存在于T 和U 中，并且这两种属性类型中至少有一种不是对象，则使用T 中的属性类型并忽略U 中的属性。如果键 K 在 T 和 U 中都存在，并且 是 在 T 和 U 中的对象类型，则通过 SafelyMergedObject<T[K], U[K]> 向下递归到该属性。

这被翻译成类似的东西：

type SafelyMergedObject<T, U> = (
    Omit<U, keyof T> & { [K in keyof T]:
        K extends keyof U ? (
            [U[K], T[K]] extends [object, object] ?
            SafelyMergedObject<T[K], U[K]>
            : T[K]
        ) : T[K] }
) extends infer O ? { [K in keyof O]: O[K] } : never;

这里我们首先输出Omit<U, keyof T>，这是T中不存在的U的属性。然后我们遍历T 的键，如果属性不在U 中，或者如果它在U 但至少T[K] 或U[K] 中的一个不是目的。

这里唯一的“技巧”是extends infer O ? {[K in keyof O]: O[K]} : never。所有这些都是通过迭代所有键并将结果合并为单个对象类型来“美化”或“扩展”对象类型。

让我们看看你的 src 和 ext 值的作用：

type Result = SafelyMergedObject<typeof src, typeof ext>;

如果您使用 IntelliSense 将鼠标悬停在上面，您会看到：

type Result = {
    e: string;
    a: string;
    b: string;
    c: boolean;
    d: {
        c: string;
        a: string;
        b: string;
    };
}

我想这就是你想要的。请注意，如果我没有包含 extends infer O... 行，Result 类型将被评估为：

type Result = Pick<{
    a: string[];
    b: number;
    c: boolean;
    d: {
        a: string;
        c: string;
    };
    e: string;
}, "e"> & {
    a: string;
    b: string;
    c: boolean;
    d: SafelyMergedObject<{
        a: string;
        b: string;
    }, {
        a: string;
        c: string;
    }>;
}

虽然属于同一类型，但明显更难理解。

---

请注意，如果您在不同情况下使用上述SafelyMergedObject<T, U>，可能会出现各种边缘情况。您需要决定在这些情况下您希望输出看起来像什么，并可能调整定义以实现这些目标。所以要小心。

好的，希望对您有所帮助；祝你好运！

Playground link to code