Async，有人吗？

尽管有大量的评论，但我没有找到使用异步映射器的解决方案。这是我的。

使用p-map，一个受信任的（@sindresorhus）和小的依赖关系。

（注意，没有选项传递给p-map。如果需要调整并发/错误处理，请参阅文档）。

字体：

import pMap from "p-map";

export const objectMapAsync = async <InputType, ResultType>(
  object: { [s: string]: InputType } | ArrayLike<InputType>,
  mapper: (input: InputType, key: string, index: number) => Promise<ResultType>
): Promise<{
  [k: string]: ResultType;
}> => {
  const mappedTuples = await pMap(
    Object.entries(object),
    async ([key, value], index) => {
      const result = await mapper(value, key, index);
      return [key, result];
    }
  );

  return Object.fromEntries(mappedTuples);
};

普通JS：

import pMap from "p-map";

export const objectMapAsync = async (
  object,
  mapper
) => {
  const mappedTuples = await pMap(
    Object.entries(object),
    async ([key, value], index) => {
      const result = await mapper(value, key, index);
      return [key, result];
    }
  );

  return Object.fromEntries(mappedTuples);
};

};

用法示例：

（精心设计，无错误处理，无类型）

// Our object in question.
const ourFavouriteCharacters = {
  me: "luke",
  you: "vader",
  everyone: "chewbacca",
};

// An async function operating on the object's values (in this case, strings)
const fetchCharacter = (charName) =>
  fetch(`https://swapi.dev/api/people?search=${charName}`)
    .then((res) => res.json())
    .then((res) => res.results[0]);

// `objectMapAsync` will return the final mapped object to us
//  (wrapped in a Promise)
objectMapAsync(ourFavouriteCharacters, fetchCharacter).then((res) =>
  console.log(res)
);

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之后的原因是它是可选的。

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

为了获得最佳性能。

如果您的对象不经常更改，但需要经常迭代，我建议使用本地映射作为缓存。

//示例对象var obj={a:1，b:2，c:'something'}；//缓存映射var objMap=新映射（Object.entries（obj））；//Map对象上的快速迭代objMap.forEach（（项，键）=>{//用一件物品做点什么console.log（键，项）；});

Object.entries已经在Chrome、Edge、Firefox和beta Opera中运行，因此它是一个经得起未来考验的功能。这是ES7的，所以用塑料填充https://github.com/es-shims/Object.entries对于IE，它不起作用。

我在谷歌搜索中发现了这一点，这是我试图学习如何做到这一点的第一个项目，我想我会与其他folsk分享我最近发现的解决方案，它使用了npm包不可变。

我觉得分享很有趣，因为不可变在他们自己的文档中使用了OP的EXACT情况——以下不是我自己的代码，而是从当前不可变的js文档中提取的：

const { Seq } = require('immutable')
const myObject = { a: 1, b: 2, c: 3 }
Seq(myObject).map(x => x * x).toObject();
// { a: 1, b: 4, c: 9 } 

这并不是说Seq有其他财产（“Seq描述了一个惰性操作，允许它们通过不创建中间集合来高效地链接所有高阶集合方法（如map和filter）的使用”），也不是说其他一些不可变js数据结构也可以非常有效地完成这项工作。

任何使用此方法的人都必须npm安装不可变，并且可能需要阅读文档：

https://facebook.github.io/immutable-js/

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

根据@Amberlamps的回答，这里有一个实用函数（作为评论，它看起来很难看）

function mapObject(obj, mapFunc){
    return Object.keys(obj).reduce(function(newObj, value) {
        newObj[value] = mapFunc(obj[value]);
        return newObj;
    }, {});
}

其用途是：

var obj = {a:1, b:3, c:5}
function double(x){return x * 2}

var newObj = mapObject(obj, double);
//=>  {a: 2, b: 6, c: 10}