首先，使用Object.entries（集合）转换您的HTMLCollection。然后，它是一个可迭代的，您现在可以在它上使用.map方法。

Object.entries(collection).map(...)

参考https://medium.com/@js_tut/calling-javascript-code-on-multiple-div-elements-without-the-id属性-97ff6a50f31

没有到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））

这真的很烦人，JS社区的每个人都知道。应该有这样的功能：

const obj1 = {a:4, b:7};
const obj2 = Object.map(obj1, (k,v) => v + 5);

console.log(obj1); // {a:4, b:7}
console.log(obj2); // {a:9, b:12}

这是一个幼稚的实现：

Object.map = function(obj, fn, ctx){

    const ret = {};

    for(let k of Object.keys(obj)){
        ret[k] = fn.call(ctx || null, k, obj[k]);
    });

    return ret;
};

总是要自己实现这一点非常令人讨厌；）

如果您想要一些更复杂的、不干扰Object类的东西，请尝试以下操作：

let map = function (obj, fn, ctx) {
  return Object.keys(obj).reduce((a, b) => {
    a[b] = fn.call(ctx || null, b, obj[b]);
    return a;
  }, {});
};


const x = map({a: 2, b: 4}, (k,v) => {
    return v*2;
});

但将此映射函数添加到Object是安全的，只是不要添加到Object.prototype。

Object.map = ... // fairly safe
Object.prototype.map ... // not ok

您可以在返回的键数组上使用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检查。

如果您不仅对值感兴趣，而且对键感兴趣，我已经编写了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 }

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