我有一个结构非常大的JSON对象,如下所示:
{A : 1, B : 2, C : 3, D : 4}
我需要一个可以与对象中的键交换值的函数,但我不知道该怎么做。我需要这样的输出:
{1 : A, 2 : B, 3 : C, 4 : D}
有什么办法可以手动创建一个交换所有内容的新对象?
谢谢
function swap(obj) {return new Map(Object.entries(x).map([k, v] => [v, k]))}
我有一个结构非常大的JSON对象,如下所示:
{A : 1, B : 2, C : 3, D : 4}
我需要一个可以与对象中的键交换值的函数,但我不知道该怎么做。我需要这样的输出:
{1 : A, 2 : B, 3 : C, 4 : D}
有什么办法可以手动创建一个交换所有内容的新对象?
谢谢
function swap(obj) {return new Map(Object.entries(x).map([k, v] => [v, k]))}
Answers:
function swap(json){
var ret = {};
for(var key in json){
ret[json[key]] = key;
}
return ret;
}
这里的示例FIDDLE不要忘记打开控制台以查看结果。
ES6版本:
static objectFlip(obj) {
const ret = {};
Object.keys(obj).forEach(key => {
ret[obj[key]] = key;
});
return ret;
}
或使用Array.reduce()和Object.keys()
static objectFlip(obj) {
return Object.keys(obj).reduce((ret, key) => {
ret[obj[key]] = key;
return ret;
}, {});
}
或使用Array.reduce()和Object.entries()
static objectFlip(obj) {
return Object.entries(obj).reduce((ret, entry) => {
const [ key, value ] = entry;
ret[ value ] = key;
return ret;
}, {});
}
您可以使用lodash函数_.invert它也可以使用multivlaue
var object = { 'a': 1, 'b': 2, 'c': 1 };
_.invert(object);
// => { '1': 'c', '2': 'b' }
// with `multiValue`
_.invert(object, true);
// => { '1': ['a', 'c'], '2': ['b'] }
使用ES6:
const obj = { a: "aaa", b: "bbb", c: "ccc", d: "ddd" };
Object.assign({}, ...Object.entries(obj).map(([a,b]) => ({ [b]: a })))
在ES6 / ES2015中,您可以结合使用Object.keys并通过新的Object.assign函数,arrow函数和简化的单语句解决方案的计算属性名称来简化操作。
const foo = { a: 1, b: 2, c: 3 };
const bar = Object.keys(foo)
.reduce((obj, key) => Object.assign({}, obj, { [foo[key]]: key }), {});
如果使用对象散布运算符(在撰写本文时为第3阶段)进行转译,则会进一步简化操作。
const foo = { a: 1, b: 2, c: 3 };
const bar = Object.keys(foo)
.reduce((obj, key) => ({ ...obj, [foo[key]]: key }), {});
最后,如果有Object.entries可用(撰写本文时为第4阶段),则可以多做一些清理(IMO)的逻辑。
const foo = { a: 1, b: 2, c: 3 };
const bar = Object.entries(foo)
.reduce((obj, [key, value]) => ({ ...obj, [value]: key }), {});
作为@joslarson和@jPO答案的补充:
无需ES6,您可以使用和逗号运算符:Object.keys
Array.reduce
Object.keys(foo).reduce((obj, key) => (obj[foo[key]] = key, obj), {});
某些人可能会发现它很丑陋,但是它的“种类”更快,因为reduce
它不会obj
在每个循环中传播的所有属性。
forEach
,map
或reduce
方法。我做出此响应是为了获得无需es6的单线解决方案,并且在速度/效果方面仍然很重要。
我认为最好通过使用npm模块来完成此任务invert-kv
。
invert-kv:反转对象的键/值。示例:{foo:'bar'}→{bar:'foo'}
https://www.npmjs.com/package/invert-kv
const invertKv = require('invert-kv');
invertKv({foo: 'bar', unicorn: 'rainbow'});
//=> {bar: 'foo', rainbow: 'unicorn'}
采用纯Ramda的纯净无点样式:
const swapKeysAndValues = R.pipe(
R.toPairs,
R.map(R.reverse),
R.fromPairs,
);
或者,使用复杂得多的ES6版本,仍可以使用纯功能:
const swapKeysAndValues2 = obj => Object
.entries(obj)
.reduce((newObj, [key, value]) => ({...newObj, [value]: key}), {})
var data = {A : 1, B : 2, C : 3, D : 4}
var newData = {};
Object.keys(data).forEach(function(key){newData[data[key]]=key});
console.log(newData);
object
是哪里来的?
map
应该做的,您正在这里使用它,例如forEach
这里是翻转的纯功能的实现keys
,并values
在ES6:
const flipKeyValues = (originalObj: {[key: string]: string}): {[key: string]: string} => {
if(typeof originalObj === "object" && originalObj !== null ) {
return Object
.entries(originalObj)
.reduce((
acc: {[key: string]: string},
[key, value]: [string, string],
) => {
acc[value] = key
return acc;
}, {})
} else {
return {};
}
}
const flipKeyValues = (originalObj) => {
if(typeof originalObj === "object" && originalObj !== null ) {
return Object
.entries(originalObj)
.reduce((acc, [key, value]) => {
acc[value] = key
return acc;
}, {})
} else {
return {};
}
}
const obj = {foo: 'bar'}
console.log("ORIGINAL: ", obj)
console.log("FLIPPED: ", flipKeyValues(obj))
function swapKV(obj) {
const entrySet = Object.entries(obj);
const reversed = entrySet.map(([k, v])=>[v, k]);
const result = Object.fromEntries(reversed);
return result;
}
这可以使您的对象{A : 1, B : 2, C : 3, D : 4}
类似于数组,因此您可以
const o = {A : 1, B : 2, C : 3, D : 4}
const arrayLike = swapKV(o);
arrayLike.length = 5;
const array = Array.from(arrayLike);
array.shift(); // undefined
array; // ["A", "B", "C", "D"]
这是一个将键与值交换但不会丢失重复项的选项,如果您的对象是:{a:1,b:2,c:2},它将始终在输出中返回一个数组:
function swapMap(map) {
const invertedMap = {};
for (const key in map) {
const value = map[key];
invertedMap[value] = invertedMap[value] || [];
invertedMap[value].push(key);
}
return invertedMap;
}
swapMap({a: "1", b: "2", c: "2"})
// Returns => {"1": ["a"], "2":["b", "c"]}