您typedAction定义函数的方式工作正常：

export function typedAction<T extends string>(type: T): { type: T };
export function typedAction<T extends string, P extends any>(
  type: T,
  payload: P
): { type: T; payload: P };
export function typedAction(type: string, payload?: any) {
  return { type, payload };
}

您遇到的问题是由于您的减速器参数中的动作解构了：

export const tokenReducer = (
  state: IState["token"] = null,
  { type, payload }: AppAction
): typeof state => {
  // ...
};

解构和 TypeScript 的难点之一是，一旦你这样做了，变量的类型就会变得相互独立。将动作解构为{ payload, type }atype: 'LOGIN' | 'LOGOUT'和payload: string | undefined变量。即使您稍后细化 的值type，就像在您的 switch 语句中一样，payload仍然具有类型string | undefined; 细化后，TypeScript 不会自动细化payloadcase 块中的类型type；它们的类型是完全独立的。

因此，您可以使用的一个有点丑陋的 hack 是不解构：

export const tokenReducer = (
  state: IState['token'] = null,
  action: AppAction,
): typeof state => {
  switch (action.type) {
    case 'LOGIN':
      return action.payload;
    case 'LOGOUT':
      return null;
    default:
      return state;
  }
};

这是有效的，因为在您的 switch 语句中，它能够将action: AppAction类型细化为更具体的登录或注销类型，因此action.payload现在与特定于这些操作之一的有效负载类型密切相关。

这是我使用的 redux 操作的替代模式，您可能会在我的 fork中发现它更方便，它让您享受映射类型的强大功能，以使用更少的样板定义减速器。首先，您必须使用类型/有效负载映射定义一个类型，并定义一些从中派生的类型：

export type ActionPayloads = {
  LOGIN: string;
  LOGOUT: void;
};

export type ActionType = keyof ActionPayloads;

export type Action<T extends ActionType> = {
  type: T;
  payload: ActionPayloads[T];
};

现在可以根据该地图定义您的动作创建者：

export function typedAction<T extends ActionType>(
  type: T,
  payload: ActionPayloads[T]
) {
  return { type, payload };
}

接下来，您可以定义一个辅助函数来创建一个强类型的 reducer：

type ReducerMethods<State> = {
  [K in ActionType]?: (state: State, payload: ActionPayloads[K]) => State
};

type Reducer<State> = (state: State, action: AppAction) => State;

function reducer<State>(
  initialState: State,
  methods: ReducerMethods<State>
): Reducer<State> {
  return (state: State = initialState, action: AppAction) => {
    const handler: any = methods[action.type];
    return handler ? handler(state, action.payload) : state;
  };
}

（对于那个丑陋的: any演员，我还没有找到好的解决方法，但至少我们从逻辑上知道打字是从外面发出的声音）。

现在，您可以使用很好的隐式类型为您的操作处理程序定义您的减速器：

type TokenState = string | null;

export const tokenReducer = reducer<TokenState>(null, {
  LOGIN: (state, token) => token, // `token` is implicitly typed as `string`
  LOGOUT: () => null              // TS knows that the payload is `undefined`
});