如何在JavaScript中将Object {}转换为键值对的Array []

Question

我想转换这样的对象:

{"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}

成为一组键值对,如下所示:

[[1,5],[2,7],[3,0],[4,0]...].

如何在JavaScript中将对象转换为键值对数组？

Answer 1

您可以使用Object.keys()和map()执行此操作

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}
var result = Object.keys(obj).map(function(key) {
  return [Number(key), obj[key]];
});

console.log(result);

Answer 2

最好的方法是:

var obj ={"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10"??:0,"11":0,"12":0} 
Object.entries(obj);

entries如此处所示,呼叫将[key, value]按照提问者的要求返回对.

或者,你可以调用Object.values(obj),它只返回值.

Answer 3

Object.entries()返回一个数组,其元素是与[key, value]直接找到的可枚举属性对相对应的数组object.属性的顺序与手动循环对象的属性值所给出的顺序相同.

^{- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries#Description}

该Object.entries函数几乎返回您要求的确切输出,除了键是字符串而不是数字.

const obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0};

console.log(Object.entries(obj));

如果您需要键是数字,您可以将结果映射到具有回调函数的新数组,该函数用从中强制转换的数字替换每对中的键.

const obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0};

const toNumericPairs = input => {
    const entries = Object.entries(input);
    return entries.map(entry => Object.assign(entry, { 0: +entry[0] }));
}

console.log(toNumericPairs(obj));

我使用箭头函数和Object.assign上面示例中的映射回调,以便我可以通过利用Object.assign返回所分配对象的事实将其保留在一条指令中,并且单个指令箭头函数的返回值是指令的结果.

这相当于:

entry => {
    entry[0] = +entry[0];
    return entry;
}

正如@TravisClarke在评论中所提到的,地图功能可以缩短为:

entry => [ +entry[0], entry[1] ]

但是,这将为每个键值对创建一个新数组,而不是修改现有数组,从而使创建的键值对数组的数量加倍.虽然原始条目数组仍可访问,但它及其条目不会被垃圾回收.

现在,即使使用我们的就地方法仍然使用两个保存键值对的数组(输入和输出数组),数组的总数只会改变一个.输入和输出数组实际上并没有用数组填充,而是对数组的引用,这些引用在内存中占用的空间可以忽略不计.

• 在原地修改每个键值对会导致内存增长量可忽略不计,但需要输入更多字符.
• 为每个键值对创建一个新数组会导致所需的内存量翻倍,但需要输入少一些字符.

您可以更进一步,通过就地修改条目数组而不是将其映射到新数组来完全消除增长:

const obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0};

const toNumericPairs = input => {
  const entries = Object.entries(obj);
  entries.forEach(entry => entry[0] = +entry[0]);
  return entries;
}

console.log(toNumericPairs(obj));

Answer 4

您可以使用的另一种变体如果Object.entries不适合您.

const obj = {
      '1': 29,
      '2': 42
    };
const arr = Array.from(Object.keys(obj), k=>[`${k}`, obj[k]]);
console.log(arr);

Answer 5

现在在2018年以ES6为标准的总结一下这些答案。

从对象开始：

let const={"1":9,"2":8,"3":7,"4":6,"5":5,"6":4,"7":3,"8":2,"9":1,"10":0,"12":5};

• 只是盲目地获取数组中的值，不需要关心键：

const obj={"1":9,"2":8,"3":7,"4":6,"5":5,"6":4,"7":3,"8":2,"9":1,"10":0,"12":5};
console.log(Object.values(obj));
//[9,8,7,6,5,4,3,2,1,0,5]

• 简单地将对放在数组中：

const obj={"1":9,"2":8,"3":7,"4":6,"5":5,"6":4,"7":3,"8":2,"9":1,"10":0,"12":5};
console.log(Object.entries(obj));
//[["1",9],["2",8],["3",7],["4",6],["5",5],["6",4],["7",3],["8",2],["9",1],["10",0],["12",5]]

• 与先前相同，但每对上都有数字键：

const obj={"1":9,"2":8,"3":7,"4":6,"5":5,"6":4,"7":3,"8":2,"9":1,"10":0,"12":5};
console.log(Object.entries(obj).map(([k,v])=>[+k,v]));
//[[1,9],[2,8],[3,7],[4,6],[5,5],[6,4],[7,3],[8,2],[9,1],[10,0],[12,5]]

• 使用object属性作为新数组的键（可以创建稀疏数组）：

const obj={"1":9,"2":8,"3":7,"4":6,"5":5,"6":4,"7":3,"8":2,"9":1,"10":0,"12":5};
console.log(Object.entries(obj).reduce((ini,[k,v])=>(ini[k]=v,ini),[]));
//[undefined,9,8,7,6,5,4,3,2,1,0,undefined,5]

最后一种方法，它还可以根据键的值重新组织数组顺序。有时这可能是所需的行为（有时不是）。但是现在的好处是，这些值被索引在正确的数组插槽上，这对于在数组插槽上进行搜索是必不可少的。

• 映射而不是数组

最后（不是完整性问题，而是完整性问题），如果您需要使用键或值轻松进行搜索，但又不想稀疏数组，不重复且无需重新排序而无需转换为数字键（甚至可以访问非常复杂的键），那么数组（或对象）就不是您所需要的。我将建议Map：

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Map

let r=new Map(Object.entries(obj));
r.get("4"); //6
r.has(8); //true

Answer 6

我建议使用这个最简单的解决方案 Object.entries()

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}
var result =Object.entries(obj)

console.log(result);

Answer 7

用法Object.keys和Array#map方法.

var obj = {
  "1": 5,
  "2": 7,
  "3": 0,
  "4": 0,
  "5": 0,
  "6": 0,
  "7": 0,
  "8": 0,
  "9": 0,
  "10": 0,
  "11": 0,
  "12": 0
};
// get all object property names
var res = Object.keys(obj)
  // iterate over them and generate the array
  .map(function(k) {
    // generate the array element 
    return [+k, obj[k]];
  });

console.log(res);

Answer 8

在Ecmascript 6中，

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0};

var res = Object.entries(obj);

console.log(res);

小提琴

Answer 9

使用Object.entries获取key & value格式的Object的每个元素，然后map像这样遍历它们：

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}

var res = Object.entries(obj).map(([k, v]) => ([Number(k), v]));

console.log(res);

但是，如果您确定密钥将以渐进顺序使用Object.values，Array#map则可以使用并执行以下操作：

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}; 

                        // idx is the index, you can use any logic to increment it (starts from 0)
let result = Object.values(obj).map((e, idx) => ([++idx, e]));

console.log(result);

Answer 10

使用 lodash，除了上面提供的答案之外，您还可以在输出数组中拥有键。

没有输出数组中的对象键

为了：

const array = _.values(obj);

如果 obj 如下：

{ “art”: { id: 1,  title: “aaaa” }, “fiction”: { id: 22,  title: “7777”} }

然后数组将是：

[ { id: 1, title: “aaaa” }, { id: 22, title: “7777” } ]

使用输出数组中的对象键

如果您改为编写（'genre' 是您选择的字符串）：

const array= _.map(obj, (val, id) => {
    return { ...val, genre: key };
  });

你会得到：

[ 
  { id: 1, title: “aaaa” , genre: “art”}, 
  { id: 22, title: “7777”, genre: “fiction” }
]

Answer 11

你可以使用Object.values([])，如果你还没有，你可能需要这个 polyfill：

const objectToValuesPolyfill = (object) => {
  return Object.keys(object).map(key => object[key]);
};
Object.values = Object.values || objectToValuesPolyfill;

/sf/answers/3837550741/

然后你可以这样做：

var object = {1: 'hello', 2: 'world'};
var array = Object.values(object);

请记住，js 中的数组只能使用数字键，因此如果您在对象中使用了其他东西，那么这些将变成 `0,1,2...x`

例如，如果您有一个唯一的键，则删除重复项会很有用。

var obj = {};
object[uniqueKey] = '...';

Answer 12

如果您使用lodash，它可能像这样简单：

var arr = _.values(obj);

Answer 13

var obj = { "1": 5, "2": 7, "3": 0, "4": 0, "5": 0, "6": 0, "7": 0, "8": 0, "9": 0, "10": 0, "11": 0, "12": 0 }
let objectKeys = Object.keys(obj);

let answer = objectKeys.map(value => {
    return [value + ':' + obj[value]]
});