使用映射器对象的Typescript通用对象映射

我正在尝试创建一个通用的对象映射函数，它允许我将一个实体对象映射到一个数据传输对象。映射规则将在mapper对象中给出

例如，在以下情况下

类用户实体{
身份证号码
用户名：string
}
类CustomerDto{
customerNumber:编号
名称：string
鼻涕虫：字符串
}
常量映射器={
customerNumber:'id'，
名称：“用户名”，
slug：（userEntity:userEntity）=>(
userEntity.userName.toLowerCase（）.replace（/\s/g，“-”）
)
}

UserEntity

的属性

id

将映射到

Customer

上的

customerNumber

，

userName

到

name

，并且将使用给定函数设置属性

slug

这是我的密码：

type FilteredKeys={
[P in keyof T]：T[P]扩展U？P：从不
}[keyof T]
类型映射器={
[DK-in-keyof D]？：（FilteredKeys）|（（来源：S）=>D[DK]）
}
功能图(
资料来源：S，
制图员：制图员
) {
常量目标：D={}作为D
for（映射器中的常量键）{
const val=映射器[键]
if（typeof val==‘function’）{
目的地[键]=val（源）
}else if（val的类型！=“未定义”）{
目标[键]=源[值]
}
}
返回目的地
}

关于

至少有两种类型的问题我不确定如何解决：

• 映射器对象属性值不能用作源对象的键
• 这种类型的防护显然是不够的

仅支持映射器中的函数的简化版本（）似乎可以工作：

类型映射器={
[D中的DK]？：（来源：S）=>D[DK]
}

您可以使用类型保护并像这样断言类型

function isFunction(val: any): val is () => string {
  return typeof val === "function";
}

function isUndefined(val: any): val is string {
  return typeof val !== "undefined";
}

function map<S, D>(source: S & { [key: string]: any }, mapper: Mapper<S, D>) {
  const destination: any = {};
  for (const key in mapper) {
    const val = mapper[key];
    if (isFunction(val)) {
      destination[key] = val(source);
    } else if (isUndefined(val)) {
      destination[key] = source[val];
    }
  }
  return destination;
}

像这样使用它

function isFunction(val: any): val is () => string {
  return typeof val === "function";
}

function isUndefined(val: any): val is string {
  return typeof val !== "undefined";
}

function map<S, D>(source: S & { [key: string]: any }, mapper: Mapper<S, D>) {
  const destination: any = {};
  for (const key in mapper) {
    const val = mapper[key];
    if (isFunction(val)) {
      destination[key] = val(source);
    } else if (isUndefined(val)) {
      destination[key] = source[val];
    }
  }
  return destination;
}

函数映射（源代码：S&{[key:string]：any}，映射器：映射器）{
const destination:any={}；
for（映射器中的常量键）{
const val=映射器[键]；
if（isFunction（val））{
目的地[键]=val（源）；
}否则如果（未定义（val））{
目的地[键]=源[值]；
}
}
返回目的地；
}

您可以使用类型保护并像这样断言类型

function isFunction(val: any): val is () => string {
  return typeof val === "function";
}

function isUndefined(val: any): val is string {
  return typeof val !== "undefined";
}

function map<S, D>(source: S & { [key: string]: any }, mapper: Mapper<S, D>) {
  const destination: any = {};
  for (const key in mapper) {
    const val = mapper[key];
    if (isFunction(val)) {
      destination[key] = val(source);
    } else if (isUndefined(val)) {
      destination[key] = source[val];
    }
  }
  return destination;
}

像这样使用它

function isFunction(val: any): val is () => string {
  return typeof val === "function";
}

function isUndefined(val: any): val is string {
  return typeof val !== "undefined";
}

function map<S, D>(source: S & { [key: string]: any }, mapper: Mapper<S, D>) {
  const destination: any = {};
  for (const key in mapper) {
    const val = mapper[key];
    if (isFunction(val)) {
      destination[key] = val(source);
    } else if (isUndefined(val)) {
      destination[key] = source[val];
    }
  }
  return destination;
}

函数映射（源代码：S&{[key:string]：any}，映射器：映射器）{
const destination:any={}；
for（映射器中的常量键）{
const val=映射器[键]；
if（isFunction（val））{
目的地[键]=val（源）；
}否则如果（未定义（val））{
目的地[键]=源[值]；
}
}
返回目的地；
}