TypeScript中的对象映射器

我喜欢像这样使用Object.fromEntries的示例，但它们仍然不太好用。使用Object.keys然后查找关键字的答案实际上是在进行可能不需要的多次查找。

我希望有一个Object.map函数，但我们可以创建自己的函数，并将其称为objectMap，同时可以修改键和值：

用法（JavaScript）：

const myObject = { 'a': 1, 'b': 2, 'c': 3 };

// keep the key and modify the value
let obj = objectMap(myObject, val => val * 2);
// obj = { a: 2, b: 4, c: 6 }


// modify both key and value
obj = objectMap(myObject,
    val => val * 2 + '',
    key => (key + key).toUpperCase());
// obj = { AA: '2', BB: '4', CC: '6' }

代码（TypeScript）：

interface Dictionary<T> {
    [key: string]: T;
}

function objectMap<TValue, TResult>(
    obj: Dictionary<TValue>,
    valSelector: (val: TValue, obj: Dictionary<TValue>) => TResult,
    keySelector?: (key: string, obj: Dictionary<TValue>) => string,
    ctx?: Dictionary<TValue>
) {
    const ret = {} as Dictionary<TResult>;
    for (const key of Object.keys(obj)) {
        const retKey = keySelector
            ? keySelector.call(ctx || null, key, obj)
            : key;
        const retVal = valSelector.call(ctx || null, obj[key], obj);
        ret[retKey] = retVal;
    }
    return ret;
}

如果您没有使用TypeScript，请在TypeScript Playground中复制上述代码以获取JavaScript代码。

此外，我在参数列表中将keySelector放在valSelector之后的原因是它是可选的。

*亚历山大·米尔斯的回答值得称赞。

您可以在返回的键数组上使用Object.keys和forEach：

var myObject = { 'a': 1, 'b': 2, 'c': 3 },
    newObject = {};
Object.keys(myObject).forEach(function (key) {
    var value = myObject[key];
    newObject[key] = value * value;
});

或者以更模块化的方式：

function map(obj, callback) {
    var result = {};
    Object.keys(obj).forEach(function (key) {
        result[key] = callback.call(obj, obj[key], key, obj);
    });
    return result;
}

newObject = map(myObject, function(x) { return x * x; });

请注意，Object.keys返回的数组只包含对象自己的可枚举财产，因此其行为类似于for。。在循环中使用hasOwnProperty检查。

公认的答案有两个缺点：

它误用了Array.prototype.reduce，因为reduce意味着改变复合类型的结构，这在这种情况下不会发生。它不是特别可重复使用

ES6/ES2015功能方法

请注意，所有函数都是以货币形式定义的。

//小型、可重复使用的辅助功能constkeys=o=>对象.keys（o）；constassign=（…o）=>对象.assign（｛｝，…o）；const-map=f=>xs=>xs.map（x=>f（x））；常量mul=y=>x=>x*y；常量sqr=x=>mul（x）（x）；//实际地图功能常量omap=f=>o=>{o=分配（o）；//A.映射（x=>o[x]=f（o[x]））（键（o））；//B返回o；};//模拟数据常量o={“a”：1，“b”：2，“c”：3}；//并运行控制台日志（omap（sqr）（o））；控制台日志（omap（mul（10））（o））；

在线A o被重新分配。由于Javascript通过共享传递引用值，因此生成了o的浅拷贝。我们现在能够在omap中突变o，而不在父作用域中突变o。在B行中，map的返回值被忽略，因为map执行了o的变异。由于此副作用仍在omap中，并且在父范围中不可见，因此完全可以接受。

这不是最快的解决方案，而是一个声明性和可重用的解决方案。以下是与单行相同的实现，简洁但可读性较差：

const omap = f => o => (o = assign(o), map(x => o[x] = f(o[x])) (keys(o)), o);

附录-为什么默认情况下对象不可迭代？

ES2015指定了迭代器和可迭代协议。但对象仍然不可迭代，因此不可映射。原因是数据和程序级别的混合。

var myObject=｛“a”：1，“b”：2，“c”：3｝；for（myObject中的var键）{if（myObject.hasOwnProperty（键））{myObject[key]*=2；}}console.log（myObject）；//｛“a”：2，“b”：4，“c”：6｝

var myObject=｛“a”：1，“b”：2，“c”：3｝；Object.keys（myObject）.filter（（item）=>myObject[item]*=2）console.log（myObject）

如果您不仅对值感兴趣，而且对键感兴趣，我已经编写了Object.map（valueMapper，keyMapper），其行为如下：

var source = { a: 1, b: 2 };
function sum(x) { return x + x }

source.map(sum);            // returns { a: 2, b: 4 }
source.map(undefined, sum); // returns { aa: 1, bb: 2 }
source.map(sum, sum);       // returns { aa: 2, bb: 4 }