TypeScript：用于A类型的索引键和用于B类型的保留键

Question

I need to define a type that allows predefined keys to be assigned to type A , and all other keys to be assigned to type B .

I've tried the below, but get the following errors:

type Foo = "foo";
type Bar = "bar";

interface Fuz {
  [key: string]: Foo
}

interface Qux {
  display?: Bar
}

type Bash = Qux & Fuz;

// ERROR: TS2322 -- Type '"bar"' is not assignable to '"foo"'
const a: Bash = {
  display: "bar"
};

// ERROR: TS2322 -- Type '"foo"' is not assignable to '"bar"'
const b: Bash = {
  display: "foo"
};

I guess this is fundamentally the same as writing:

interface Fuz {
  // ERROR: TS2411 -- property 'display' of type '"bar"' is not assignable to string index type '"foo"'
  display?: Bar
  [key: string]: Foo
}

Is there a way of achieving something like the above?

Answer 1

consider this case :

interface Fuz {
    // pretend this was valid for a moment
    display: 'bar';
    [k: string]: 'foo';
}


declare let x: Fuz; // lets say we have a variable of type Fuz


let index = 'display' // index is right now type string
let value = x[index]; // x[string] === 'foo' so `typeof value === 'foo'`
let value2 = x['display']; // x['display'] === 'bar' so `typeof value2 === 'bar'`

console.assert(value === value2);
// ERROR: This condition will always return 'false' since the types '"foo"' and '"bar"' have no overlap.
// which is obviously not correct, they are derived from the same property!

As you can see with the definition you are proposing value would obviously contain the string bar but as far as typescript could understand it would really be foo

as far as I know there isn't a way to give a "non explicitly defined keys" field so that x[string] would be the union of all applicable strings.

The only way I know to get the kind of behaviour you want is to specify that the values are either Foo or in the case of the string key bar it is Bar , so the string index must be a union:

interface CorrectFuz {
    bar: 'bar';
    [k: string]: 'bar' | 'foo';
}

It is possible there is a better solution to this that I would need more information about your actual use case to know how to help though.

Answer 2

I need to define a type that allows predefined keys to be assigned to type A, and all other keys to be assigned to type B

I think your expectations of Typescript are wrong. Types do not get "assigned" to anything. When you create a type union you are expanding the possible values of that variable by loosening the definition of the type, when you create a type intersection you are restricting the possible values of that variable by expanding the definition of the type.