将枚举转换为具有值的对象

Question

我想创建一个可以返回类似对象/枚举值的助手，这样我们就不会重复模式：

enum ActionTypes {
    Find,
    Update,
    Create
}
enum RequestTypes {
    Request,
    Success,
    Failure

}

如果我在这里开始使用这个枚举，我需要一个可以将其转换为以下内容的辅助方法：

const actions = createActions(ActionTypes);
// actions.Find.Request -> 'FindRequest'
// actions.Find.Success -> 'FindSuccess'

甚至不知道从哪里开始我对打字稿很陌生

actions 的完整预期输出应该是：

{
    Find: {
        Request: 'FindRequest',
        Success: 'FindSuccess',
        Failure: 'FindFailure'
    },
    Create: {
        Request: 'CreateRequest',
        Success: 'CreateSuccess',
        Failure: 'CreateFailure'
    },
    Update: {
        Request: 'UpdateRequest',
        Success: 'UpdateSuccess',
        Failure: 'UpdateFailure'
    }
}

Answer 1

这是一个类型安全的功能解决方案，它接受两个 string enums 作为参数（因此您可以在其他情况下重用它）：

TS Playground link

type StringEnum = Record<string, string>;

type NestedCombinedStringEnum<
  P extends StringEnum,
  C extends StringEnum,
> = {
  [KP in keyof P]: {
    [KC in keyof C]: KP extends string ? KC extends string ? `${KP}${KC}` : never : never;
  };
};

function nestAndCombineStringEnums <
  P extends StringEnum,
  C extends StringEnum,
>(enumParent: P, enumChild: C): NestedCombinedStringEnum<P, C> {
  const result: any = {};

  for (const keyP of Object.keys(enumParent)) {
    result[keyP] = {};
    for (const keyC of Object.keys(enumChild)) {
      result[keyP][keyC] = `${keyP}${keyC}`;
    }
  }

  return result;
}

// Use:

enum RequestType {
  Request = 'Request',
  Success = 'Success',
  Failure = 'Failure',
}

// Overloaded function declaration (classic)

// function createActions <
//   P extends StringEnum,
//   C extends StringEnum,
// >(enumParent: P, enumChild: C): NestedCombinedStringEnum<P, C>;
// function createActions <P extends StringEnum>(enumParent: P): NestedCombinedStringEnum<P, typeof RequestType>;
// function createActions <
//   P extends StringEnum,
//   C extends StringEnum,
// >(enumParent: P, enumChild?: C) {
//   return nestAndCombineStringEnums(enumParent, enumChild ?? RequestType);
// }

// Overloaded function expression (you'll see this style less often, but the two are equivalent)

const createActions: {
  <P extends StringEnum, C extends StringEnum>(enumParent: P, enumChild: C): NestedCombinedStringEnum<P, C>;
  <P extends StringEnum>(enumParent: P): NestedCombinedStringEnum<P, typeof RequestType>;
} = <C extends StringEnum, P extends StringEnum>(
  enumParent: P,
  enumChild?: C,
) => nestAndCombineStringEnums(enumParent, enumChild ?? RequestType);

enum ActionType {
  Find = 'Find',
  Update = 'Update',
  Create = 'Create',
}

const actions = createActions(ActionType); // same as createActions(ActionType, RequestType);
console.log(actions.Create.Success); // "CreateSuccess"
console.log(actions); // the expected result object in your question

Answer 2

您可以从Object.values 方法中获取枚举字符串，然后根据需要进行迭代和连接。

enum ActionTypes {
  Find,
  Update,
  Create
}
enum RequestTypes {
  Request,
  Success,
  Failure

}


function createActions(actionTypes) {


  let actionTypeStrings = Object.values(actionTypes).filter(e => typeof e == 'string');
  let requestTypeStrings = Object.values(RequestTypes).filter(e => typeof e == 'string');

  let actions = actionTypeStrings.reduce((a, c) => {

    let anAction: any = {};
    requestTypeStrings.forEach((e: any) => anAction[e] = c + e)

    a[c] = anAction;

    return a;
  }, < any > {})

  return actions;
}


const actions = createActions(ActionTypes);
console.log(actions);

Answer 3

这是你可以做的：

enum ActionTypes {
    Find = 'Find',
    Update = 'Update',
    Create = 'Create'
}

enum RequestTypes {
    Request = 'Request',
    Success = 'Success',
    Failure  = 'Failure'

}

type combination = {
  [k in  ActionTypes]: {
    [k1 in  RequestTypes]: `${k}${k1}`
  }
}


function createActions(): combination {
  return Object.keys(ActionTypes).reduce((cum, k) => {
     cum[k] = Object.keys(RequestTypes).reduce((cum1, k1) => {
       cum1[k1] = `${k}${k1}`
       return cum1;
     }, {} as any)
     return cum;
  } , {} as any)
}


console.log(createActions().Create.Failure)
// CreateFailure

TS 游乐场：https://tsplay.dev/WG6bkm

Answer 4

为此编写了一个简单的函数。

function mixEnumsToObject(e1: any, e2: any) {
  const keys1: string[] = Object.keys(e1).filter((key) => isNaN(Number(key)));
  const keys2: string[] = Object.keys(e2).filter((key) => isNaN(Number(key)));
  const mixEnumMap = new Map();

  keys1.forEach((key1) => {
    const valueObject = new Map();
    keys2.forEach((key2) => {
      valueObject.set(key2, key1 + key2);
    });
    mixEnumMap.set(key1, valueObject);
  });
  return mixEnumMap;
}

const mixedEnumObject = mixEnumsToObject(ActionTypes, RequestTypes);
console.log(mixedEnumObject);