以编程方式从另一个键创建一个类型化的记录/对象

Question

在我的打字稿程序（下面的代码）中，我定义了两个基本类型（Player、State），然后是一些嵌套的 Record 类型用作映射。

然后，我在一个类型化函数中根据嵌套记录的现有实例创建这些记录之一的实例。

type Player = "1" | "2";
type State = "A" | "B" | "C";
type StateMapping = Record<State, State>;
type PlayerStateMappings = Record<Player, StateMapping>
type PlayerStates = Record<Player, State>;

const playerStateMappings: PlayerStateMappings = {
    "1": {
        "A": "B",
        "B": "C",
        "C": "A"
    },
    "2": {
        "C": "B",
        "B": "A",
        "A": "C"
    },
}

function nextStates(currentState: State): PlayerStates {
    var nextStates = {};
    for(const player of Object.keys(playerStateMappings)){
        nextStates[player] = playerStateMappings[player][currentState]
    }
    return nextStates;
}

console.log(nextStates("A"))

此代码在 return 语句中引发以下类型错误，因为我创建了没有所需键的对象，并且之后才添加了这些： TS2739: Type '{}' is missing the following properties from type 'PlayerStates': 1, 2.

我的问题是，是否有一种方法可以避免满足以下要求的此类错误：

1. 类型系统并没有特别放松，它仍然强制nextStates 函数返回一个完整且有效的PlayerStates 对象。
2. nextStates 对象是基于playerStatesMapping 对象的键以编程方式创建的，这意味着我不必再次对所有播放器进行硬编码。

在对 SO 进行一些研究后，我发现了一些避免错误的选项，但所有这些选项都违反了上述两个要求之一：

违反条件 1 的方法：

1. 将 PlayerStates 类型设为局部：type PlayerStates = Partial<Record<Player, State>>;
2. 使用as关键字强制类型：var nextStates = {} as PlayerStates； （来自this问题）

违反条件 2 的方法：

1. 在对象创建中为每个玩家设置一个默认值：var nextStates = {"1": "A", "2": "B"}

我知道在上面的例子中整个打字有点过头了，但这是我在一个更复杂的项目中遇到的问题的高度简化/简化版本，上面的要求/期望更有意义。

PS：来自 python 背景，我想我正在寻找类似 @​​987654322@ 的东西，它允许我基于一些迭代来初始化一个新字典。

Answer 1

根据@hackape 的回答，我能够生成以下内容，但需要重新定义Object.fromEntries 和Object.entries：

type Player = "1" | "2";
type State = "A" | "B" | "C";
type StateMapping = Record<State, State>;
type PlayerStateMappings = Record<Player, StateMapping>
type PlayerStates = Record<Player, State>;

const playerStateMappings: PlayerStateMappings = {
    "1": {
        "A": "B",
        "B": "C",
        "C": "A"
    },
    "2": {
        "C": "B",
        "B": "A",
        "A": "C"
    },
}

// stricter version of Object.entries
const entries: <T extends Record<PropertyKey, unknown>>(obj: T) => Array<[keyof T, T[keyof T]]> = Object.entries

// stricter version of Object.fromEntries
const fromEntries: <K extends PropertyKey, V>(entries: Iterable<readonly [K, V]>) => Record<K, V> = Object.fromEntries

function nextStates(currentState: State): PlayerStates {
  return fromEntries(
    entries(playerStateMappings).map(([player, mapping]) =>
      [player, mapping[currentState]]
    )
  )
}

Playground link

Answer 2

尝试函数式编程方式。您可以完全避免使用 nextStates 变量。问题消失了。

function nextStates(currentState: State): PlayerStates {
  return Object.fromEntries(
    Object.entries(playerStateMappings).map(([player as Player, mapping]) =>
      [player, mapping[currentState]]
    )
  )
}

Answer 3

类型错误来自您的 nextStates 变量，因为您没有指定它的类型，因此当您将其定义为空对象时，它被推断为 {}。

您可以只为您的nextStates 变量使用Partial 类型以允许它从空开始，但是您需要一种方法来告诉编译器何时使用保护创建了完整的PlayerStates 对象。这是一个例子：

type Player = "1" | "2";
type State = "A" | "B" | "C";
type StateMapping = Record<State, State>;
type PlayerStateMappings = Record<Player, StateMapping>
type PlayerStates = Record<Player, State>;

const playerStateMappings: PlayerStateMappings = {
    "1": {
        "A": "B",
        "B": "C",
        "C": "A"
    },
    "2": {
        "C": "B",
        "B": "A",
        "A": "C"
    },
}

// Stricter version of keys which returns Array<keyof T> instead of string[]
const keys = <T extends Record<PropertyKey, unknown>>(obj: T): Array<keyof T> =>
  Object.keys(obj);

// Type guard to convert Partial<PlayerStates> to PlayerStates
const isCompletePlayerStatesObj = (
  obj: Partial<PlayerStates>
): obj is PlayerStates => 
  obj["1"] !== undefined && obj["2"] !== undefined;

function nextStates(currentState: State): PlayerStates {
    var nextStates: Partial<PlayerStates> = {};

    for(const player of keys(playerStateMappings)){
        nextStates[player] = playerStateMappings[player][currentState]
    }

    if (!isCompletePlayerStatesObj(nextStates)) {
      throw new Error("Whoops this function was badly implemented")
    }

    return nextStates;
}

console.log(nextStates("A"));