以类型安全的方式迭代 object 属性

Question

I have an immutable class Settings containing tons of members and want to provide a simple way to create a modified copy. I started with something like

class Settings {
    private constructor(public readonly a: number, 
        public readonly b: number) {
    }

    static newSettings() {
        return new Settings(1, 2);
    }

    withA(a: number) {
        return new Settings(a, this.b);
    }

    withB(a: number) {
        return new Settings(this.a, b);
    }
}

which is exactly how I do it in Java (with Lombok generating all the boilerplate). This doesn't scale well, so I switched to

interface ISettings {
    readonly a?: number
    readonly b?: number
}

class Settings implements ISettings {
    readonly a: number = 1
    readonly b: number = 2

    private constructor(base?: ISettings, overrides?: ISettings) {
        for (const k of Object.keys(this)) {
            // @ts-ignore
            this[k] = overrides?.[k] ?? base?.[k] ?? this[k]; // <---- PROBLEM
        }
    }

    static newSettings() {
        return new Settings();
    }

    with(overrides: ISettings) {
        return new Settings(this, overrides);
    }
}

It works, but I had to use @ts-ignore for one line, which IMHO should work out of the box.

I know, I could use eg, immerjs (offering this and more), but how can I get the typings right ?

Answer 1

The source of the issue

First of all Object.keys will always return string type, because of the TS structural typing

The basic rule for TypeScript's structural type system is that x is compatible with y if y has at least the same members as x

Generally it means that TS allows for subtypes to be passed, in other words, value with more members/fields can be passed, what means Object.keys will have more keys than we think.

Example of such behavior:

type X = { a: string };
type Y = X & { b: string };

function f(x: X) {
  return Object.keys(x);
}

const y = { a: 'a', b: 'b' };
f(y); // no error - works but we have more keys then X has

Workaround

I would go into such approach:

private constructor(base?: ISettings, overrides?: ISettings) {
    const keys = Object.keys(this) as (keyof ISettings)[]
    for (const k of keys) {
      // k is a | b
      this[k] = overrides?.[k] ?? base?.[k] ?? this[k];
    }
  }

Because of the behavior of Object.keys the only way here is to make type assertion by as .