```typescript
interface wtf {
id: string;
[k: string]: number;
}

```

这种?

```ts
interface Obj {
id: string
}
interface Somebody extends Obj {
key?: number
}
```

interface A{
[key: string]: number;
}

interface B {
id: string;
}

type C = A | B;

@MRG0

const data: IData = {
id: 'xxx-xxx-xxx', // id 只能是 string
cid: 123123123,
name: 233233,
...//任意属性，但值必须是 number 不能是其他的或者 string
}

#3 是对的

```
interface IData {
id: string
[k: string]: number | string
}
```

我解开了

interface NumO {
[k: string]: number;
}

type WithID<T> = {
id: string;
} & T;
type WTF = WithID<NumO>;

const v = {
id: 'wtf'
} as WTF;

// OK
v.id = 'str';
v.a = 3;
v.b = 4;
// Not OK
v.c = 'sr';

interface A {
id: string;
}

interface B {
[k: string]: number
}

type AB = A & B

function sample(arg: AB) {
arg.id = 'aaa'
arg.bcd = 1234
}

```
type CustomType = {
[key: string]: number | string;
} & {
id: string;
};

// 通过映射类型和条件类型来移除 id 属性外的 string 类型
type StrictCustomType = {
[K in keyof CustomType]: CustomType[K] extends string ? (K extends 'id' ? string : never) : number;
};
```

对于初始化来说，如果可以加个 helper 函数的话，倒是有一种办法：

type CoercedItem<T> = {
[K in keyof T]: K extends 'id' ? string : number
}

type ValidItem<T> = T extends CoercedItem<T> ? 'id' extends keyof T ? T : never : never

function makeItem<T>(item: ValidItem<T>): T {
return item
}

const a = makeItem({ id: 'x', no: 1 })

a.id = 'y'
a.no = 2

const b = makeItem({ id: 'z' })

// 报错
const c = makeItem({ id: 1, no: 1 })

// 报错
const d = makeItem({ no: 1 })

好奇什么场景需要这么复杂的类型定义呢？

或者说类似问题的类型约束的严谨性和代码简洁应该如何取舍？

我个人是把 TS 当作一个不太完美的类型约束工具，更倾向于代码简洁性。

```ts
type Others = Record<string, number>;

type T<O = Others> = {
id: string;
} & {
[K in keyof O]: K extends "id" ? string : number;
};

const obj: T<{ id: string; aaa: number }> = {
id: "1",
aaa: 123,
bbb: 1, // error
};
```

使用的时候泛型传入对应的类型就行，但是和 #28 说的一样，泛型中没有定义的的字段会报错

const id = ()=> ('i' + 'd ').trim();

const n:number = obj[id()];

如果有这样的类型你这样操作那 TS 该不该报错？ key 是运行时决定，所以有可能是 string 也有可能是 number 。