很好的问题...在这个相当长的答案的结尾有两个可行的选择。你问了两个问题，我分别回答。
问题一：
有没有办法让 Reducer 类型更严格地要求两个参数...
这将很难实现，因为 TypeScript 函数存在两个障碍。
障碍1：丢弃函数参数
您已经注意到一个障碍，is documented here 在标题“比较两个函数”下。它说“我们允许'丢弃'参数。”也就是说，参数较少的函数可以分配给参数较多的函数。 rationale is in the FAQ。简而言之，下面的赋值是安全的，因为参数较少的函数“可以安全地忽略多余的参数”。
const add: (x: number, y: number) =
(x: number) => { return x; }; // works and is safe
障碍2：函数参数双方差
第二个障碍是function parameters are bivariant。那
意味着我们无法使用用户定义的类型参数来解决这个问题。在某些语言中，我们可以定义Pair 以及一个接受Pair 的函数。
class Pair {
x: number;
y: number;
}
let addPair: (p: Pair) => number;
在具有协变函数的语言中，上述内容会将参数限制为 Pair 的子类型。
在 TypeScript 中，简单类型分配遵循预期的substitutability rules，但函数遵循双变量规则。在其简单的类型分配中，TypeScript 允许我们将类型 Pair 分配给类型 Single，但不能将类型 Single 分配给类型 Pair。这是预期的替换。
class Single {
x: number;
}
let s: Single = new Pair(); // works
let p: Pair = new Single(); // fails because of a missing property.
不过，TypeScripts 函数是双变量的，并且不受相同的限制。
let addSingle: (s: Single) => number;
addSingle = (p: Pair) => p.x + p.y; // as expected, Pair is assignable to Single.
let addPair: (p: Pair) => number;
addPair = (s: Single) => s.x; // surprise, Single is assignable to Pair!
结果是期望Pair 的函数将接受Single。
对Reducers 的影响
以下两种技术都不会强制Reducer 实现必须接受的参数（或类属性）的数量。
class Action { }
// no restriction - TypeScript allows discarding function parameters
type Reducer01<S> = (state: S, action: Action) => S;
const reducer01: Reducer01<number> = (state: number) => 0; // works
// no restriction - TypeScript functions have parameter bivariance
class ReducerArgs<S> {
state: S;
action: Action;
}
type Reducer02<S> = (args: ReducerArgs<S>) => S;
const reducer02 = (args: { state: number }) => 0; // works
这实际上可能不会成为问题，因为让ReducersMapObject 接受具有较少参数的Reducer 是安全的。编译器仍将确保：
- 对
Reducer 的每次调用都包含所有 Reducer 参数，以及
-
Reducer 的每个实现仅对其（可能很短）参数列表进行操作。
问题2：
...或者另一种方法来让 ReducersMapObject 实际上包含 reducer 函数更有信心？
我们正在尝试做的一件事是使reducerCreator 函数（以及其他形状不寻常的函数）与Reducer<S> 函数类型不兼容。这里有两个可行的选择。
可行的选项1：用户定义的参数类型
上面的第二种技术，使用称为ReducerArgs<S> 的用户定义类型，将给我们更多信心。它不会提供完全的信心，因为我们仍然会有双变量，但它会确保编译器拒绝reducerCreator。以下是它的外观：
interface Action {
type: any;
}
// define an interface as the parameter for a Reducer<S> function
interface ReducerArgs<S> {
state: S;
action: Action
}
type Reducer<S> = (args: ReducerArgs<S>) => S;
const reducer: Reducer<string> = (args: ReducerArgs<string>) => args.state;
const reducerCreator = (n: number): Reducer<string> => reducer;
interface ReducersMapObject {
[key: string]: Reducer<any>;
}
const reducerMap: ReducersMapObject = {
test: reducer,
test2: reducerCreator // error!
}
可行的选项 2：泛型和联合类型
另一种选择是使用通用的ReducerMapObject<T>，如下所示：
interface ReducersMapObject<T> {
[key: string]: Reducer<T>;
}
然后用a union type 参数化它，列出所有reducer 的类型。
const reducer: Reducer<string> = (state: string, action: Action) => state;
const reducer1: Reducer<number> = (state: number, action: Action) => state;
const reducerMap: ReducersMapObject<string | number> = {
test: reducer,
test1: reducer1,
test2: reducerCreator // error!
}
结果将是any => any 变为T => T，其中T 是联合中列出的类型之一。 （顺便说一句，最好有一个类型说，“x 可以是任何类型，只要它与 y 的类型相同。”）
虽然上述两种方法都涉及更多代码并且有点笨拙，但它们确实可以达到您的目的。这是一个有趣的研究项目。谢谢你的提问！