看起來您希望Model保持跟蹤requiredFields和optionalFields元素中的實際文字值，這意味著Model在這些類型中可能是泛型的。所以可能類似于Model<R, O>，其中R是所有必需鍵的并集，O是所有可選鍵的并集。

但是您還希望Model<R, O>實際具有R和O類型的鍵。這就是我們在使用常規的class語句時遇到麻煩的地方。類和接口要求編譯器靜態地知道它們的鍵。它們不能是動態的，不能在以后填寫：

class Foo<T extends object > implements T {} // error!
// -----------------------------------> ~
// A class can only implement an object type or intersection 
// of object types with statically known members.

所以我們需要解決這個問題。

描述這樣的類構造函數類型很容易。應該是這樣的

type ModelConstructor = new <R extends string, O extends string>(
    params: ModelObject<R, O>
) => ModelObject<R, O> & {
    set(params: Partial<ModelObject<R, O>>): void,
    all_fields: Array<R | O>;
    required_fields: R[];
}

type ModelObject<R extends string, O extends string> =
    Record<R, string> & Partial<Record<O, string>>;

因此，ModelConstructor有一個構造簽名，它接受類型為ModelObject<R, O>的params。ModelObject<R, O>是一種對象類型，具有必需的鍵R和可選鍵O，其值均為string。構造的實例也是一個ModelObject<R, O>，它與Model類中的一組適當類型的屬性和方法相交。

不過，在繼續討論這個問題之前，考慮一下如何將Model子類化可能會很有用。由于您希望User的每個實例都具有相同的必填字段和可選字段，因此將Model設置為類工廠函數而不是class構造函數本身可能是有意義的。否則，您需要冗余地指定R和O：

class AnnoyingUser extends Model<"username", "email"> {
    _required_fields = ["username"] // redundant
    _optional_fields = ["email"] // redundant
}

寫下來可能會更好

class User extends Model(["username"], ["email"]) { }

其中Model(["username"], ["email"])生成一個類構造函數，其中這些字段已經存在。這取決于你是否想這樣做。我將假設工廠函數是可以接受的，并繼續使用它。

這里是工廠函數：

export const Model = <R extends string, O extends string>(
    requiredFields: R[], optionalFields: O[]
) => {

    type ModelObject =
        Record<R, string> & Partial<Record<O, string>> extends
        infer T ? { [K in keyof T]: T[K] } : never;

    class _Model {
        _required_fields: Array<R> = requiredFields;
        _optional_fields?: Array<O> = optionalFields;

        constructor(params: ModelObject) {
            this.set(params);
        }

        set(params: Partial<ModelObject>) {
            this.all_fields.forEach(key => {
                (this as any)[key] = (params as any)[key];
            });
        }

        get all_fields(): Array<R | O> {
            return [...this._required_fields,
            ...this._optional_fields ?? []];
        }

        get required_fields() {
            return this._required_fields;
        }
    }

    return _Model as any as new (params: ModelObject) =>
        ModelObject & {
            set(params: Partial<ModelObject>): void,
            all_fields: Array<R | O>;
            required_fields: R[];
        } extends infer T ? { [K in keyof T]: T[K] } : never;
}

注意，從Model返回的類構造函數關閉傳遞給它的requiredFields和optionalFields變量。

這些類型與以前類似，只是R和O現在是工廠函數上的泛型類型參數，而不是結果類。作用域略有不同，因此（例如）ModelObject不需要在R和O中是泛型的，因為R和O在該作用域中是已知的。還有一些拋出的extends infer T ? {[K in keyof T]: T[K]}: never類型，它們只是要求編譯器將類似Record<"username", string> & Partial<Record<"email", string>>的東西擴展成一個更好看的{username: string; email?: string}類型。

還要注意，由于編譯器不能將class表示為具有動態屬性，因此我需要使用類型斷言來告訴編譯器它可以將返回的構造函數視為正確的類型。

一旦使用工廠函數，您就可以決定進一步重構；也許您希望必需/可選字段僅為返回的類構造函數的static屬性，因為它們對于類的每個實例都應該相同。不過我不想麻煩了。只是一個想法。

讓我們測試一下。首先讓我們看看當我們調用Model時會出現什么結果：

const UserModel = Model(["username"], ["email"]);
/* const UserModel: new (params: {
    username: string;
    email?: string | undefined;
}) => {
    username: string;
    email?: string | undefined;
    set: (params: Partial<{
        username: string;
        email?: string | undefined;
    }>) => void;
    all_fields: ("username" | "email")[];
    required_fields: "username"[];
} */

看起來很合理，我想你想要什么。現在我們可以定義User：

export class User extends Model(["username"], ["email"]) {
    // static REQUIRED_FIELDS = ['username'];
    // static OPTIONAL_FIELDS = ['email'];
}

我注釋掉的那些static屬性來自您的示例，但它們不是我的解決方案所必需的。如果你想要它們，可以隨意添加，但我不知道它們有什么用途。

讓我們測試一下：

const u = new User({ username: "alice" });
console.log(u.required_fields) // ["username"]
console.log(u.all_fields) // ["username", "email"]
u.set({ email: "foo@example.com" })
console.log(u.email) // foo@example.com

Looks good!

操場連結至守則