你可以这样做

var arr = _.values(obj);

有关文档请参见这里。

_.toArray(obj);

输出为:

[
  {
    "name": "Ivan",
    "id": 12,
    "friends": [
      2,
      44,
      12
    ],
    "works": {
      "books": [],
      "films": []
    }
  },
  {
    "name": "John",
    "id": 22,
    "friends": [
      5,
      31,
      55
    ],
    "works": {
      "books": [],
      "films": []
    }
  }
]"

如果您希望键(在本例中为id)作为每个数组项的属性保留，您可以这样做

const arr = _(obj) //wrap object so that you can chain lodash methods
            .mapValues((value, id)=>_.merge({}, value, {id})) //attach id to object
            .values() //get the values of the result
            .value() //unwrap array of objects

一个现代的本地解决方案，如果有人感兴趣:

const arr = Object.keys(obj).map(key => ({ key, value: obj[key] }));

或(不是IE):

const arr = Object.entries(obj).map(([key, value]) => ({ key, value }));

Var arr = _.map(obj)

你可以使用_。Map函数(包括lodash和下划线)和object，它将在内部处理这种情况，迭代每个值和键与您的迭代对象，并最终返回一个数组。事实上，如果你只是想要一个值数组，你可以使用它而不需要任何迭代对象(只要_.map(obj))。好的部分是，如果你需要中间的任何变换，你可以一次完成。

例子:

Var obj = { key1: {id: 1, name: 'A'}， key2: {id: 2, name: 'B'}， key3: {id: 3，名称:'C'} }; Var array1 = _。地图(obj, v = > v); console.log('数组1:'，array1); /*实际上你不需要回调v=>v如果你 没有转换之间的任何东西，v=>v是默认*/ //如此简单，你可以使用 Var array2 = _.map(obj); console.log('数组2:'，array2); < script src = " https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js " > < /脚本>

然而，如果你想转换你的对象，你可以这样做，即使你需要保留键，你可以这样做(_。Map (obj， (v, k) =>{…})，在Map中添加额外的参数，然后按您想要的方式使用它。

然而，还有其他香草JS解决方案(每个lodash解决方案都应该有纯JS版本)，比如:

对象。键，然后将它们映射到值 对象。值(ES-2017) 对象。条目，然后映射每个键/值对(在ES-2017) 为…在循环中，并使用每个键feting值

还有更多。但是因为这个问题是针对lodash的(假设有人已经在使用它)，所以如果找不到这些，你就不需要考虑太多关于版本、方法支持和错误处理的问题。

还有其他lodash解决方案，如_。值(对于特定的目的更易于阅读)，或者获取对，然后映射等等。但如果你的代码需要灵活性，你可以在未来更新它，因为你需要保留键或转换值一点，那么最好的解决方案是使用单个_。映射在这个答案中。就可读性而言，这也不是那么难。

2017年更新:对象。valuevalues, lodash values和toArray。为了保存键映射和展开操作符，请注意:

//从'lodash'导入{toArray, map} Const map = _.map Const input = { 关键:{ 价值:“价值” ｝ ｝ Const输出= map(input， (value, key) => ({ 键, 价值…… })) console.log(输出) // >> [{key: 'key'， value: 'value'}]) < script src = " https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js " > < /脚本>

对我来说，这很有效:

_.map(_.toPairs(data), d => _.fromPairs([d]));

结果

{"a":"b", "c":"d", "e":"f"} 

into

[{"a":"b"}, {"c":"d"}, {"e":"f"}]

如果你想要一些对象到数组的自定义映射(比如原始的Array.prototype.map)，你可以使用_.forEach:

let myObject = {
  key1: "value1",
  key2: "value2",
  // ...
};

let myNewArray = [];

_.forEach(myObject, (value, key) => {
  myNewArray.push({
    someNewKey: key,
    someNewValue: value.toUpperCase() // just an example of new value based on original value
  });
});

// myNewArray => [{ someNewKey: key1, someNewValue: 'VALUE1' }, ... ];

参见lodash doc of _。forEach https://lodash.com/docs/ # forEach

将对象转换为数组与纯JavaScript的(ECMAScript-2016)对象。

Var obj = { 22:{名称:“约翰”,id: 22岁的朋友:[55]5日31日,工作原理:{书:[]、电影:[]}}, 12:{名称:“伊万”,id: 12,朋友:[2,44岁,12],工作原理:{书:[]、电影:[]}} ｝ var values = Object.values(obj) console.log(值);

如果你还想保留键，使用Object。entry和array# map像这样:

Var obj = { 22:{名称:“约翰”,id: 22岁的朋友:[55]5日31日,工作原理:{书:[]、电影:[]}}, 12:{名称:“伊万”,id: 12,朋友:[2,44岁,12],工作原理:{书:[]、电影:[]}} ｝ var values = Object.entries(obj)。Map (([k, v]) => ({[k]: v})) console.log(值);

有很多方法可以达到你想要的效果。让我们把它们分类:

ES6值:

主要的方法是Object.values。但是使用Object。键和数组。映射你也可以得到预期的结果:

Object.values(obj)
Object.keys(obj).map(k => obj[k])

var obj = A: ( 名称:“约翰” ), B: ( 名称:“伊万” ) ) log(’Object游戏机。价值观:',Object . values (obj)) log(’Object游戏机。群岛群岛(obj: ', Object)。地图(k => obj[k])

ES6键值:

使用map和ES6动态/计算属性和解构，你可以保留键并从map返回一个对象。

Object.keys(obj).map(k => ({[k]: obj[k]}))
Object.entries(obj).map(([k,v]) => ({[k]:v}))

Var obj = { 答:{ 名称:“约翰” }， B: { 名称:“伊万” ｝ ｝ console.log(“对象。钥匙:“种(obj)。Map (k => ({ [k]: obj [k] }))) console.log(“对象。条目:“Object.entries (obj)。Map (([k, v]) => ({ [k]: v })))

Lodash值:

为此设计的方法是_。值也有“快捷键”，比如_。地图和实用方法_。toArray也将返回一个仅包含该对象的值的数组。你也可以_。映射通过_。键，并使用obj[key]表示法从对象中获取值。

注意:_。map传递给对象时，会使用它的baseMap处理程序，基本上是对象属性上的forEach。

_.values(obj)
_.map(obj)
_.toArray(obj)
_.map(_.keys(obj), k => obj[k])

Var obj = { 答:{ 名称:“约翰” }， B: { 名称:“伊万” ｝ ｝ console.log(的价值观:_.values (obj)) console.log(地图:,_.map (obj)) console.log (toArray:, _.toArray (obj)) console.log('键:“_.map (_.keys (obj), k = > obj [k])) < script src = " https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.min.js " > < /脚本>

Lodash键值:

// Outputs an array with [[KEY, VALUE]]
_.entries(obj)
_.toPairs(obj)

// Outputs array with objects containing the keys and values
_.map(_.entries(obj), ([k,v]) => ({[k]:v}))
_.map(_.keys(obj), k => ({[k]: obj[k]}))
_.transform(obj, (r,c,k) => r.push({[k]:c}), [])
_.reduce(obj, (r,c,k) => (r.push({[k]:c}), r), [])

var obj = { A: { name: "John" }, B: { name: "Ivan" } } // Outputs an array with [KEY, VALUE] console.log('entries:', _.entries(obj)) console.log('toPairs:', _.toPairs(obj)) // Outputs array with objects containing the keys and values console.log('entries:', _.map(_.entries(obj), ([k, v]) => ({ [k]: v }))) console.log('keys:', _.map(_.keys(obj), k => ({ [k]: obj[k] }))) console.log('transform:', _.transform(obj, (r, c, k) => r.push({ [k]: c }), [])) console.log('reduce:', _.reduce(obj, (r, c, k) => (r.push({ [k]: c }), r), [])) <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.min.js"></script>

注意，在上面的例子中使用了ES6(箭头函数和动态属性)。 如果ES6有问题，可以使用lodash _.fromPairs和其他方法来组合对象。

对象到数组

在所有的答案中，我认为这个是最好的:

let arr = Object.entries(obj).map(([key, val]) => ({ key, ...val }))

转换:

{
  a: { p: 1, q: 2},
  b: { p: 3, q: 4}
}

to:

[
  { key: 'a', p: 1, q: 2 }, 
  { key: 'b', p: 3, q: 4 }
]

数组到对象

变回来:

let obj = arr.reduce((obj, { key, ...val }) => { obj[key] = { ...val }; return obj; }, {})

将键保留在值中进行反向转换:

let obj = arr.reduce((obj, { key, ...val }) => { obj[key] = { key, ...val }; return obj; }, {})

将:

{
  a: { key: 'a', p: 1, q: 2 },
  b: { key: 'b', p: 3, q: 4 }
}

对于最后一个例子，你也可以使用lodash _。keyBy(arr， 'key')或_。keyBy(arr, i => i.key)。