我有一个目标:

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

我正在寻找一个本地方法,类似于Array.prototype.map,可按如下方式使用:

newObject = myObject.map(function (value, label) {
    return value * value;
});

// newObject is now { 'a': 1, 'b': 4, 'c': 9 }

JavaScript是否有这样的对象映射函数?(我希望Node.JS使用这个,所以我不关心跨浏览器问题。)


当前回答

我只处理减少豁免的字符串:

Object.keys(params).map(k => typeof params[k] == "string" ? params[k] = params[k].trim() : null);

其他回答

常量orig={“a”:1,“b”:2,“c”:3}常量结果=_.变换(orig,(r,v,k)=>r[k.trim()]=v*2);console.log(结果);<script src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js“></script>

使用new_.transform()转换对象。

我来到这里是为了查找并回答将对象映射到数组的问题,结果得到了这个页面。如果你来这里寻找与我相同的答案,这里是如何映射和对象到一个数组。

您可以使用map从对象返回一个新数组,如下所示:

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


Object.prototype.map = function(fn){
    var oReturn = {};
    for (sCurObjectPropertyName in this) {
        oReturn[sCurObjectPropertyName] = fn(this[sCurObjectPropertyName], sCurObjectPropertyName);
    }
    return oReturn;
}
Object.defineProperty(Object.prototype,'map',{enumerable:false});





newObject = myObject.map(function (value, label) {
    return value * value;
});


// newObject is now { 'a': 1, 'b': 4, 'c': 9 }

这真的很烦人,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

我在谷歌搜索中发现了这一点,这是我试图学习如何做到这一点的第一个项目,我想我会与其他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/