Javascript 如何获取对象数组中对象的所有属性值的数组？

我想得到我拥有的每个对象的值的数组

我有这个：

const numDataPoints = [
    {
      x0: {x: 807, y: 625},
      x1: {x: 15, y: 20},
      x2: {x: 5, y: 20}
    },
    {
      x0: {x: 11, y: 6},
      x1: {x: 16, y: 21},
      x2: {x: 7, y: 22}
    }
  ];

我想要这个：

[
  [807, 625],
  [15, 20],
  [5, 20],
  [11, 6],
  [16, 21],
  [7, 22]
]

我试过这个：

numDataPoints.map((array) => array.map(axis => [axis.x, axis.y]));

但它抛出了一个错误：

未捕获的

TypeError

：

array.map

不是函数

---

您可以使用

Array.map

将每个对象转换为包含两个元素数组的数组，然后使用reduce将结果展平：

const numDataPoints=[{x0:{x:807，y:625}，x1:{x:15，y:20}，
x2:{x:5，y:20}，{x0:{x:11，y:6}，x1:{x:16，y:21}，x2:{x:7，y:22}]；
让结果=numDataPoints.map(
item=>Object.values（item.map）（{x，y}）=>[x，y]））
.减少（（arr，电流）=>[…arr，…电流]）；
控制台日志（结果）

您可以使用

Object.keys

在对象中的键上迭代，如下所示：

let数据=[{
x0:{
x:807，
y:625
},
x1:{
x:15，
y:20
},
x2：{
x:5，
y:20
}
}, {
x0:{
x:11,，
y:6
},
x1:{
x:16，
y:21
},
x2：{
x:7，
y:22
}
}];
让result=data.map（obj=>Object.keys（obj.map）（（key）=>obj[key].x，obj[key].y]）；
控制台日志（结果）使用reduce实现这一点-下面的代码也适用于其他数据，因为我们在此不硬编码任何键的名称


const res=numDataPoints.reduce（（a，b）=>a.concat（Object.keys（b.map）（e=>Object.values（b[e]）），[]）；
控制台日志（res）

常量numDataPoints=[
{
x0:{
x:807，
y:625
},
x1:{
x:15，
y:20
},
x2：{
x:5，
y:20
}
}, {
x0:{
x:11,，
y:6
},
x1:{
x:16，
y:21
},
x2：{
x:7，
y:22
}
}
];
您可以将
map
方法与
Object.values
和扩展语法
…
一起使用


const data=[{x0:{x:807，y:625}，x1:{x:15，y:20}，x2:{x:5，y:20}，{x0:{x:11，y:6}，x1:{x:16，y:21}，x2:{x:7，y:22}]；
const result=[].concat（…data.map（Object.values））.map（Object.values）
log（result）
这是因为您得到的是一个对象，而不是数组。尽管您可以尝试（Es6）：

在
numDataPoints
数组中没有数组，而是常规对象，因此不能使用
map

你需要的是。或者，为了保证键
x0
、
x1
和
x2
的顺序相同，使用
{x0，x1，x2}
，然后使用
[x0，x1，x2]

numDataPoints
的结构表明，实际上您需要一个由两个数组组成的数组，每个数组有三个
[x，y]
点，而不仅仅是六个
[x，y]
点。如果您仍然希望展平这些子数组，请使用or（目前是第3阶段候选，可能会成为2019年6月定稿的ECMAScript版本的一部分）

以下是所有六种可能性：


const numDataPoints=[
{
x0:{x:807，y:625}，
x1:{x:15，y:20}，
x2:{x:5，y:20}
},
{
x0:{x:11，y:6}，
x1:{x:16，y:21}，
x2:{x:7，y:22}
}
];
//Object.values，相同的结构
log（numDataPoints.map（（obj）=>Object.values（obj.map（{x，y}）=>[x，y]））；
//Object.values，用concat展平
log（[].concat（…numDataPoints.map（（obj）=>Object.values（obj.map（{x，y}）=>[x，y]））；
//Object.values，使用flatMap展平
log（numDataPoints.flatMap（（obj）=>Object.values（obj.map）（{x，y}）=>[x，y]））；
//解构，相同的结构
log（numDataPoints.map（{x0，x1，x2}）=>[x0，x1，x2].map（{x，y}）=>[x，y]）；
//分解结构，用concat展平
console.log（[].concat（…numDataPoints.map（{x0，x1，x2}）=>[x0，x1，x2].map（{x，y}=>[x，y]））；
//分解结构，使用flatMap展平
log（numDataPoints.flatMap（{x0，x1，x2}）=>[x0，x1，x2].map（{x，y}）=>[x，y]）
问题在于
array
是一个对象，因此在使用另一个
forEach
之前必须映射键

const numDataPoints =  [{ x0: {x: 807, y: 625}, x1: {x: 15, y: 20},x2: {x: 5, y: 20} }, { x0: {x: 11, y: 6}, x1: {x: 16, y: 21}, x2: {x:7, y: 22} }];
var foo = []
numDataPoints.forEach((points) => 
    Object.keys(points).forEach(point => 
        foo.push( [points[point].x, points[point].y] )
    )
);
console.log(foo)

这里有几种不同的方法可以获得两种不同的结果（原始嵌套结构或平面结构）-还要注意排序，这可能是您的一个用例-字典键按声明的方式排序（不是字母数字）：


const numDataPoints=[{x0:{x:807，y:625}，x1:{x:15，y:20}，
x2:{x:5，y:20}，{x0:{x:11，y:6}，x1:{x:16，y:21}，x2:{x:7，y:22}]；
//如果需要在原始嵌套中对其进行排序：
console.log(
numDataPoints
.map（d=>Object.keys（d）.sort（）.map（k=>[d[k].x，d[k].y]））
);
//如果需要对其进行排序和展平：
console.log(
numDataPoints
.map（d=>Object.keys（d）.sort（）.map（k=>[d[k].x，d[k].y]））
.reduce（（a，v）=>{v.forEach（value=>a.push（value））；返回a；}，[]
);
//如果不需要在原始嵌套中对其进行排序：
console.log(
numDataPoints
.map（d=>Object.keys（d）.map（k=>[d[k].x，d[k].y]））
);
//如果不需要对它们进行排序和展平：
console.log(
numDataPoints
.map（d=>Object.keys（d）.map（k=>[d[k].x，d[k].y]））
.reduce（（a，v）=>{v.forEach（value=>a.push（value））；返回a；}，[]
);
你没有数组，你不能使用
array.map
这里那么，我能做什么？或者我如何编辑我的问题？这些不是数组。那些是物体。现在还不清楚你想要什么样的订单。
[[807625]，[15,20]，[5,20]，[[11,6]，[16,21]，[7,22]。
你在这里不是需要什么吗？只是为了学究，你不能在这里第二次使用map：第一次
数点。map
很好。卢卡是正确的。看起来您有一个对象的数组。您可以
map
const numDataPoints =  [{ x0: {x: 807, y: 625}, x1: {x: 15, y: 20},x2: {x: 5, y: 20} }, { x0: {x: 11, y: 6}, x1: {x: 16, y: 21}, x2: {x:7, y: 22} }];
var foo = []
numDataPoints.forEach((points) => 
    Object.keys(points).forEach(point => 
        foo.push( [points[point].x, points[point].y] )
    )
);
console.log(foo)