Chcę uzyskać tablicę wartości każdego obiektu, jakie mam.

Mam to:

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}
    }
  ];

Chcę to:

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

Próbowałem tego:

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

Ale rzuca ten błąd:

Niepukliwy TypeError: array.map nie jest funkcją

4
Meta Code 4 czerwiec 2018, 22:15

8 odpowiedzi

Najlepsza odpowiedź

Możesz użyć Array.map, aby przekształcić każdy obiekt w tablicę tablic dwuetekiernych, a następnie zmniejszyć, aby spłaszczyć wynik:

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} }];

let result = numDataPoints.map(
    item => Object.values(item).map(({x, y})=> [x, y]))
              .reduce((arr, current) => [...arr, ...current], []);

  console.log(result);
5
mickl 4 czerwiec 2018, 19:27

Dzieje się tak, ponieważ to, co otrzymujesz, jest obiektem, a nie macierzy. Chociaż możesz spróbować (ES6):

numDataPoints
.map(_ => {
  return Object.values(_)
  .map(({x, y}) => [x, y]);
}).reduce((acc, elem) => [...acc, ...elem], []);
0
Vivick 4 czerwiec 2018, 19:24

Możesz użyć metody map za pomocą Object.values i Składnia rozprzestrzenia ....

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)
console.log(result)
7
Nenad Vracar 4 czerwiec 2018, 19:24

Zmniejsz się na to - poniżej będzie działać dla innych danych, ponieważ nie podkodujemy tutaj żadnych nazw kluczowych.

const res = numDataPoints.reduce((a, b) => a.concat(Object.keys(b).map(e => Object.values(b[e]))), []);
console.log(res);
<script>
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
        }
    }
];
</script>
4
baao 4 czerwiec 2018, 19:23

Nie masz tablic w tablicy numDataPoints, ale regularne obiekty, więc nie możesz użyć map.

Potrzebujesz to Object.values . Alternatywnie, aby gwarantują tę samą kolejność klawiszy x0, x1 i x2 , Destructure z {x0, x1, x2}, a następnie użyj [x0, x1, x2].

Sugeruje strukturę numDataPoints, że właściwie chcesz tablicę dwie tablic , każdy z trzy [x, y], a nie tylko sześć {{ X2}} punkty. Jeśli nadal chcesz spłaszczyć te podpunkty, użyj concat lub flatMap (obecnie kandydat na etap 3, prawdopodobnie stał się częścią edycji ECMAScript sfinalizowanej w czerwcu 2019 r.).

Oto wszystkie sześć możliwości:

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, same structure
console.log(numDataPoints.map((obj) => Object.values(obj).map(({x, y}) => [x, y])));

// Object.values, flattened with concat
console.log([].concat(...numDataPoints.map((obj) => Object.values(obj).map(({x, y}) => [x, y]))));

// Object.values, flattened with flatMap
console.log(numDataPoints.flatMap((obj) => Object.values(obj).map(({x, y}) => [x, y])));

// Destructuring, same structure
console.log(numDataPoints.map(({x0, x1, x2}) => [x0, x1, x2].map(({x, y}) => [x, y])));

// Destructuring, flattened with concat
console.log([].concat(...numDataPoints.map(({x0, x1, x2}) => [x0, x1, x2].map(({x, y}) => [x, y]))));

// Destructuring, flattened with flatMap
console.log(numDataPoints.flatMap(({x0, x1, x2}) => [x0, x1, x2].map(({x, y}) => [x, y])));
1
Sebastian Simon 4 czerwiec 2018, 19:47

Możesz użyć Object.keys, aby iterować przez kluczy w obiekcie, jak więc:

let 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
  }
}];

let result = data.map(obj => Object.keys(obj).map((key) => [obj[key].x, obj[key].y]));

console.log(result);

Możesz spłaszczyć wynik, nie jestem pewien.

0
user184994 4 czerwiec 2018, 19:22

Oto kilka różnych sposobów uzyskania dwóch różnych wyników (oryginalna struktura zagnieżdżania lub konstrukcji) - również zauważaj sortowanie, które może być dla Ciebie użytkowania dla Ciebie - klucze słownikowe są sortowane w sposób, w jaki są zadeklarowane (nie alfanumerycznie):

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} }];

// In case you need them sorted and in the original nesting:
console.log(
  numDataPoints
    .map(d => Object.keys(d).sort().map(k => [d[k].x, d[k].y]))
);

// In case you need them sorted and flattened:
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)); return a; }, [])
);

// In case you don't need them sorted and in the original nesting:
console.log(
  numDataPoints
    .map(d => Object.keys(d).map(k => [d[k].x, d[k].y]))
);

// In case you don't need them sorted and flattened:
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)); return a; }, [])
);
0
wiesion 4 czerwiec 2018, 19:50

Problem polega na tym, że array jest obiektem, więc musisz mapować klucze przed użyciem innego {x1}}.

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)
0
Alyson Maia 4 czerwiec 2018, 19:37