lodash를 사용하여 객체를 배열로 변환

lodash로 어떻게 큰 object것을 array바꿀 수 있습니까?

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

// transform to 
var arr = [{name:"John", id:22...},{name:"Ivan", id:12...}]

넌 할 수있어

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": []
    }
  }
]"

누군가 관심이 있다면 현대적인 기본 솔루션 :

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

또는 (IE가 아님) :

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

나를 위해, 이것은 효과가 있었다 :

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

돌아서 다

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

으로

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

결과를 얻는 데는 몇 가지 방법이 있습니다. 카테고리로 분류하자 :

ES6 값만 :

이에 대한 주요 방법은 Object.values 입니다. 그러나 Object.keys 와 Array.map 을 사용 하면 예상 결과를 얻을 수 있습니다.

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

var obj = {
  A: {
    name: "John"
  },
  B: {
    name: "Ivan"
  }
}

console.log('Object.values:', Object.values(obj))
console.log('Object.keys:', Object.keys(obj).map(k => obj[k]))

ES6 키 및 가치 :

map 및 ES6 동적 / 계산 된 속성을 사용하고 파괴 하면 키를 유지하고 맵에서 객체를 반환 할 수 있습니다.

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

var obj = {
  A: {
    name: "John"
  },
  B: {
    name: "Ivan"
  }
}

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

Lodash 값만 :

_.values그러나 이를 위해 설계된 방법 은 "바로 가기"와 같은 _.map유틸리티 방법과 객체 의 값만_.toArray 포함하는 배열을 반환하는 유틸리티 방법 이 있습니다 . 당신은 할 수도 불구 하고 사용하여 개체의 값을 가져 표기합니다._.map_.keysobj[key]

참고 : _.map객체가 전달되면 baseMap기본적으로 forEach객체 속성에있는 핸들러를 사용 합니다.

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

var obj = {
  A: {
    name: "John"
  },
  B: {
    name: "Ivan"
  }
}

console.log('values:', _.values(obj))
console.log('map:', _.map(obj))
console.log('toArray:', _.toArray(obj))
console.log('keys:', _.map(_.keys(obj), k => obj[k]))

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.min.js"></script>

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이 사용됩니다 (화살표 기능 및 동적 속성). _.fromPairsES6이 문제인 경우 lodash 및 기타 방법을 사용 하여 객체를 작성할 수 있습니다 .

키 (이 경우 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

2017 업데이트 : Object.values , lodash 값 및 toArray 가 수행합니다. 그리고 키 맵 을 유지 하고 연산자를 멋지게 퍼 뜨리 려면 :

// import { toArray, map } from 'lodash'
const map = _.map

const input = {
  key: {
    value: 'value'
  }
}

const output = map(input, (value, key) => ({
  key,
  ...value
}))

console.log(output)
// >> [{key: 'key', value: 'value'}])

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js"></script>

일반 JavaScript ( ECMAScript-2016)를 사용 하여 객체를 배열로 변환 Object.values:

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

var values = Object.values(obj)

console.log(values);

키를 계속 사용하려면 다음 Object.entries과 Array#map같이 사용 하십시오.

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

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

console.log(values);

var arr = _.map(obj)

_.map함수와 ( lodash와 underscore)를 함께 사용할 수 있으며 object, 내부적으로 해당 경우를 처리하고 각 값과 키를 반복자와 반복하고 마지막으로 배열을 반환합니다. 실제로 _.map(obj)값의 배열을 원한다면 iteratee (just ) 없이 사용할 수 있습니다 . 좋은 부분은 중간에 변환이 필요한 경우 한 번에 수행 할 수 있다는 것입니다.

예:

var obj = {
    key1: {id: 1, name: 'A'},
    key2: {id: 2, name: 'B'},
    key3: {id: 3, name: 'C'}
};

var array1 = _.map(obj, v=>v);
console.log('Array 1: ', array1);

/*Actually you don't need the callback v=>v if you
are not transforming anything in between, v=>v is default*/

//SO simply you can use
var array2 = _.map(obj);
console.log('Array 2: ', array2);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js"></script>

그러나 객체를 변환하려면 키를 유지해야하더라도 _.map(obj, (v, k) => {...}추가 인수 map를 사용 하여 ( ) 작업을 수행 한 다음 원하는 방식으로 사용할 수 있습니다.

그러나 이것에 대한 다른 Vanilla JS 솔루션이 있습니다 (모든 lodash솔루션에는 순수한 JS 버전이 있어야 함).

• Object.keys그런 다음 map가치에
• Object.values (ES-2017에서)
• Object.entries그런 다음 map각 키 / 값 쌍 (ES-2017)
• for...in 페팅 값에 대해 각 키를 반복 사용

그리고 훨씬 더. 그러나이 질문은 lodash(그리고 이미 누군가 그것을 사용한다고 가정 할 때) 버전, 메소드 지원 및 오류 처리가 발견되지 않은 경우 오류 처리에 대해 많이 생각할 필요가 없습니다.

_.values(특정 perpose에 대해 더 읽기 쉬운) 또는 쌍을 얻은 다음 매핑하는 등 다른 lodash 솔루션이 있습니다 . 그러나 코드에 유연성이 필요한 경우 keys값을 조금 유지 하거나 변환 해야 할 때 나중에 업데이트 할 수 있는 가장 좋은 해결책은 _.map이 답변에서 추가 된대로 단일을 사용하는 것입니다. 그것은 가독성에 따라 그렇게 어렵지 않을 것입니다.

배열 할 객체

모든 답변 중에서 나는 이것이 최고라고 생각합니다.

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

그 변형 :

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

에:

[
  { 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).

Object에 대한 일부 사용자 정의 매핑 (예 : Original 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_.forEach의 문서 참조 https://lodash.com/docs/#forEach