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)
);

为了获得最佳性能。

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

//示例对象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，它不起作用。

JS ES10/ES2019中的一行怎么样？

使用Object.entries（）和Object.fromEntries（）：

let newObj = Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, v * v]));

同样的东西写为函数：

function objMap(obj, func) {
  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, func(v)]));
}

// To square each value you can call it like this:
let mappedObj = objMap(obj, (x) => x * x);

此函数还使用递归对嵌套对象进行平方：

function objMap(obj, func) {
  return Object.fromEntries(
    Object.entries(obj).map(([k, v]) => 
      [k, v === Object(v) ? objMap(v, func) : func(v)]
    )
  );
}

// To square each value you can call it like this:
let mappedObj = objMap(obj, (x) => x * x);

对于ES7/ES2016，您不能使用Objects.fromEntries，但可以使用Object.assign结合排列运算符和计算的关键字名称语法实现相同的功能：

let newObj = Object.assign({}, ...Object.entries(obj).map(([k, v]) => ({[k]: v * v})));

ES6/ES2015不允许Object.entries，但可以改用Object.keys：

let newObj = Object.assign({}, ...Object.keys(obj).map(k => ({[k]: obj[k] * obj[k]})));

ES6还为。。。循环，允许更命令式的样式：

let newObj = {}

for (let [k, v] of Object.entries(obj)) {
  newObj[k] = v * v;
}

array.reduce（）

您也可以使用reduce代替Object.fromEntries和Object.assign：

let newObj = Object.entries(obj).reduce((p, [k, v]) => ({ ...p, [k]: v * v }), {});

继承的财产和原型链：

在一些罕见的情况下，您可能需要映射一个类类对象，该类对象在其原型链上保存继承对象的财产。在这种情况下，Object.keys（）和Object.entries（）将无法工作，因为这些函数不包括原型链。

如果需要映射继承的财产，可以使用for（myObj中的键）{…}。

以下是此类情况的示例：

const obj1 = { 'a': 1, 'b': 2, 'c': 3}
const obj2 = Object.create(obj1);  // One of multiple ways to inherit an object in JS.

// Here you see how the properties of obj1 sit on the 'prototype' of obj2
console.log(obj2)  // Prints: obj2.__proto__ = { 'a': 1, 'b': 2, 'c': 3}

console.log(Object.keys(obj2));  // Prints: an empty Array.
console.log(Object.entries(obj2));  // Prints: an empty Array.

for (let key in obj2) {
  console.log(key);              // Prints: 'a', 'b', 'c'
}

不过，请帮我一个忙，避免继承

我的回答主要基于这里的最高评分，希望每个人都能理解（在我的GitHub上也有同样的解释）。这就是为什么他对地图的实施有效：

Object.keys(images).map((key) => images[key] = 'url(' + '"' + images[key] + '"' +    
')');

该函数的目的是获取一个对象，并使用对所有对象（对象和数组都一样）可用的方法修改对象的原始内容，而不返回数组。JS中的几乎所有东西都是一个对象，因此，继承管道下游的元素在技术上可能会使用上游元素可用的对象（反之亦然）。

这之所以有效，是因为.map函数返回了一个数组REQUIRING，您可以提供一个数组的显式或隐式RETURN，而不是简单地修改现有对象。你本质上通过使用object.keys来欺骗程序，使其认为对象是一个数组，这将允许你使用map函数，并将其作用于各个键关联的值（我实际上意外返回了数组，但已修复）。只要没有正常意义上的返回，就不会创建原始对象仍然完整并按程序修改的数组。

这个特定的程序获取一个名为images的对象，并获取其键的值，并附加url标记以供在另一个函数中使用。原文如下：

var images = { 
snow: 'https://www.trbimg.com/img-5aa059f5/turbine/bs-md-weather-20180305', 
sunny: 'http://www.cubaweather.org/images/weather-photos/large/Sunny-morning-east-   
Matanzas-city- Cuba-20170131-1080.jpg', 
rain: 'https://i.pinimg.com/originals/23/d8
/ab/23d8ab1eebc72a123cebc80ce32b43d8.jpg' };

…并修改为：

var images = { 
snow: url('https://www.trbimg.com/img-5aa059f5/turbine/bs-md-weather-20180305'),     
sunny: url('http://www.cubaweather.org/images/weather-photos/large/Sunny-morning-   
east-Matanzas-city- Cuba-20170131-1080.jpg'), 
rain: url('https://i.pinimg.com/originals/23/d8
/ab/23d8ab1eebc72a123cebc80ce32b43d8.jpg') 
};

对象的原始结构保持不变，只要没有返回，就可以正常访问属性。不要让它像正常一样返回数组，一切都会好起来。目标是将原始值（图像[key]）重新设计为所需的值，而不是其他值。据我所知，为了防止数组输出，必须有图像的重新分配[key]，并且没有返回数组的隐式或显式请求（变量赋值完成了这一点，并且对我来说来回出现问题）。

编辑：

要解决他关于创建新对象的另一个方法，以避免修改原始对象（为了避免意外创建数组作为输出，似乎仍然需要重新分配）。这些函数使用箭头语法，如果您只是想创建一个新对象以供将来使用，则可以使用。

const mapper = (obj, mapFn) => Object.keys(obj).reduce((result, key) => {
                result[key] = mapFn(obj)[key];
                return result;
            }, {});

var newImages = mapper(images, (value) => value);

这些功能的工作方式如下：

mapFn接受稍后要添加的函数（在这种情况下（value）=>value），并简单地返回存储在那里的任何内容，

然后在result[key]=mapFn（obj）[key]中重新定义与键关联的原始值

并返回对结果执行的操作（位于括号中的累加器在reduce函数结束时启动）。

所有这些都是在所选对象上执行的，但仍然不能对返回的数组进行隐式请求，只有在我所知的重新分配值时才有效。这需要一些心理体操，但减少了所需的代码行，如上文所示。输出完全相同，如下所示：

{snow: "https://www.trbimg.com/img-5aa059f5/turbine/bs-   
md-weather-20180305", sunny: "http://www.cubaweather.org/images/weather-
photos/l…morning-east-Matanzas-city-Cuba-20170131-1080.jpg", rain: 
"https://i.pinimg.com/originals/23/d8
/ab/23d8ab1eebc72a123cebc80ce32b43d8.jpg"}

请记住，这适用于非数字。通过在mapFN函数中简单地返回值，可以复制任何对象。

没有到Object对象的本机映射，但这如何：

var myObject=｛“a”：1，“b”：2，“c”：3｝；Object.keys（myObject）.forEach（函数（键，索引）{myObject[key]*=2；});console.log（myObject）；//=>｛“a”：2，“b”：4，“c”：6｝

但是您可以使用for。。。在：

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｝；//返回一个新对象，其中每个键的值都使用mapFn（value）映射函数objectMap（对象，mapFn）{return Object.keys（Object）.reduce（function（result，key）{result[key]=mapFn（对象[key]）返回结果}, {})}var newObject=对象映射（myObject，函数（值）{返回值*2})console.log（newObject）；//=>｛“a”：2，“b”：4，“c”：6｝console.log（myObject）；//=>｛“a”：1，“b”：2，“c”：3｝

Array.prototype.reduce通过将前一个值与当前值进行某种程度的合并，将数组缩减为单个值。链由空对象｛｝初始化。每次迭代时，都会添加myObject的一个新键，该键的值是该键的两倍。

使现代化

有了新的ES6特性，有了一种更优雅的方式来表达objectMap。

常量对象映射=（obj，fn）=>对象.fromEntries(对象条目（obj）.map(（[k，v]，i）=>[k，fn（v，k，i）]))常量myObject=｛a:1，b:2，c:3｝console.log（objectMap（myObject，v=>2*v））

编辑：使用较新JavaScript功能的规范方法是-

const identity = x =>
  x

const omap = (f = identity, o = {}) =>
  Object.fromEntries(
    Object.entries(o).map(([ k, v ]) =>
      [ k, f(v) ]
    )
  )

其中o是某个对象，f是映射函数。或者我们可以说，给定一个a->b的函数和一个值为a的对象，生成一个值类型为b的对象。作为伪类型签名-

// omap : (a -> b, { a }) -> { b }

最初的答案是为了演示一个强大的组合子mapReduce，它允许我们以不同的方式思考我们的转换

m、 映射函数–让您有机会在…r、 reduce函数–此函数将累加器与映射元素的结果组合

直观地说，mapReduce创建了一个新的reduce，我们可以直接插入Array.prototype.reduce中。但更重要的是，我们可以通过使用对象幺半群、object.assign和{}来简单地实现我们的对象函子实现omap。

常量标识=x=>x（x）常量mapReduce=（m，r）=>（a，x）=>r（a，m（x））常量omap=（f=身份，o={}）=>对象.键（o）减少（mapReduce（k=>（{[k]：f（o[k]）}），对象分配), {})常量平方=x=>x×x常量数据=｛a:1，b:2，c:3｝console.log（omap（方形，数据））//｛a:1，b:4，c:9｝

请注意，我们实际需要编写的程序的唯一部分是映射实现本身——

k => ({ [k]: f (o[k]) })

也就是说，给定已知对象o和某个键k，构造一个对象，其计算属性k是对键的值o[k]调用f的结果。

如果我们首先抽象oreduce，我们就可以一窥mapReduce的测序潜力

// oreduce : (string * a -> string * b, b, { a }) -> { b }
const oreduce = (f = identity, r = null, o = {}) =>
  Object
    .keys (o)
    .reduce
      ( mapReduce
          ( k => [ k, o[k] ]
          , f
          )
      , r
      )

// omap : (a -> b, {a}) -> {b}
const omap = (f = identity, o = {}) =>
  oreduce
    ( mapReduce
        ( ([ k, v ]) =>
            ({ [k]: f (v) })
        , Object.assign
        )
    , {}
    , o
    )

一切都是一样的，但现在可以在更高级别上定义omap。当然，新的Object.entries让这看起来很愚蠢，但练习对学习者来说仍然很重要。

你不会在这里看到mapReduce的全部潜力，但我分享这个答案，因为看到它可以应用到多少地方很有趣。如果您对它的派生方式和其他有用的方式感兴趣，请查看此答案。